Merge branch 'master' of http://bore.pub:10439/r/ERP_override

廖井涛

2025-03-25 768e16999a8ce4bb500490ee76c659aa61ea1783

 north-glass-erp/src/main/java/com/example/erp/service/pp/ReportingWorkService.java

@@ -4,63 +4,72 @@
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.example.erp.common.Constants;
import com.example.erp.entity.pp.DamageDetails;
import com.example.erp.entity.pp.FlowCard;
import com.example.erp.entity.pp.ReportingWork;
import com.example.erp.entity.pp.ReportingWorkDetail;
import com.example.erp.dto.pp.OrderNumberTransferDTO;
import com.example.erp.entity.pp.*;
import com.example.erp.entity.sd.Order;
import com.example.erp.entity.sd.OrderDetail;
import com.example.erp.entity.sd.OrderProcessDetail;
import com.example.erp.entity.userInfo.Log;
import com.example.erp.entity.userInfo.SysError;
import com.example.erp.exception.ServiceException;
import com.example.erp.mapper.mm.FinishedOperateLogMapper;
import com.example.erp.mapper.pp.*;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.example.erp.mapper.sd.OrderDetailMapper;
import com.example.erp.mapper.sd.OrderGlassDetailMapper;
import com.example.erp.mapper.sd.OrderMapper;
import com.example.erp.mapper.sd.OrderProcessDetailMapper;
import com.example.erp.mapper.userInfo.LogMapper;
import com.example.erp.service.sd.OrderProcessDetailService;
import com.example.erp.service.userInfo.LogService;
import com.example.erp.service.userInfo.SysErrorService;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.client.RestTemplate;

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.util.*;

@Service
@DS("pp")
@RequiredArgsConstructor
public class ReportingWorkService {
    final
    ReportingWorkMapper reportingWorkMapper;
    final
    BasicDateProduceMapper basicDateProduceMapper;
    final
    DamageDetailsMapper damageDetailsMapper;
    final
    OrderProcessDetailMapper orderProcessDetailMapper;
    final
    ReportingWorkDetailMapper
            reportingWorkDetailMapper;
    final OrderMapper
            orderMapper;
    private final ReportingWorkTransferMapper reportingWorkTransferMapper;
    private final ReportingWorkMapper reportingWorkMapper;
    private final BasicDateProduceMapper basicDateProduceMapper;
    private final DamageDetailsMapper damageDetailsMapper;
    private final OrderProcessDetailMapper orderProcessDetailMapper;
    private final ReportingWorkDetailMapper reportingWorkDetailMapper;
    private final OrderMapper  orderMapper;
    private final OrderDetailMapper orderDetailMapper;

    final
    FlowCardMapper flowCardMapper;
    private final FlowCardMapper flowCardMapper;

    final
    OrderProcessDetailService orderProcessDetailService;
    private final OrderProcessDetailService orderProcessDetailService;

    final
    LogService logService;
    private final LogService logService;

    final LogMapper logMapper;
    private final LogMapper logMapper;
    private final OrderGlassDetailMapper orderGlassDetailMapper;
    private final SysErrorService sysErrorService;
    private final FinishedOperateLogMapper finishedOperateLogMapper;
    private final RestTemplate restTemplate;


    public ReportingWorkService(ReportingWorkMapper reportingWorkMapper, BasicDateProduceMapper basicDateProduceMapper, DamageDetailsMapper damageDetailsMapper, ReportingWorkDetailMapper reportingWorkDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, OrderProcessDetailService orderProcessDetailService, OrderMapper orderMapper, FlowCardMapper flowCardMapper, LogService logService, LogMapper logMapper, OrderGlassDetailMapper orderGlassDetailMapper) {
    /*public ReportingWorkService(ReportingWorkMapper reportingWorkMapper, BasicDateProduceMapper basicDateProduceMapper, DamageDetailsMapper damageDetailsMapper, ReportingWorkDetailMapper reportingWorkDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, OrderProcessDetailService orderProcessDetailService, OrderMapper orderMapper, FlowCardMapper flowCardMapper, LogService logService, LogMapper logMapper, OrderGlassDetailMapper orderGlassDetailMapper, SysErrorService sysErrorService, OrderDetailMapper orderDetailMapper, FinishedOperateLogMapper finishedOperateLogMapper, ReportingWorkTransferMapper reportingWorkTransferMapper) {
        this.reportingWorkMapper = reportingWorkMapper;
        this.basicDateProduceMapper = basicDateProduceMapper;
        this.damageDetailsMapper = damageDetailsMapper;
@@ -72,10 +81,16 @@
        this.logService = logService;
        this.logMapper = logMapper;
        this.orderGlassDetailMapper = orderGlassDetailMapper;
    }
        this.sysErrorService = sysErrorService;
        this.orderDetailMapper = orderDetailMapper;
        this.finishedOperateLogMapper = finishedOperateLogMapper;
        this.reportingWorkTransferMapper = reportingWorkTransferMapper;
    }*/

    public Map<String, Object> AddSelectLastWorkSv(String processIdStr, String technologyStr, String process, String reportType) {
        Map<String, Object> map = new HashMap<>();
        //获取报工工序是否为复合工程
        String laminating = reportingWorkMapper.getProcessLaminating(process);
        //查询流程卡工艺流程
        String technologicalProcess = reportingWorkMapper.SelectTechnologicalProcess(processIdStr,technologyStr);

@@ -119,38 +134,62 @@
            map.put("device", reportingWorkMapper.SelectWorkBasicDeviceMp(process));
            //班组下拉框
            map.put("teams", reportingWorkMapper.SelectWorkBasicTeamsMp(process));

            //次破类型
            map.put("breakageType", reportingWorkMapper.selectBasicNameByType("breakagetype"));
            //次破原因
            map.put("breakageReason", reportingWorkMapper.selectBasicNameByType("breakagereason"));

            //查询本工序报工需要哪几层，上工序是什么
            String obtainTechnology = reportingWorkMapper.SelectWorkTechnologyMp(processIdStr);

            map.put("numberList", flowCardMapper.getGlassNumber(Integer.valueOf(technologyStr),processIdStr));
            map.put("numberList", flowCardMapper.getGlassNumber(technologyStr,processIdStr));

            //判断本工序是不是第一道工序
            if (interceptProcess.equals(process)) {
                //是第一道工序，查询流程卡数据
                map.put("Detail", reportingWorkMapper.SelectTechnologicalNumMp(processIdStr, technologyStr, process,reportType));
            } else {
                //不是第一道工序，查询报工数据
                List<Map<String,String>>  details = reportingWorkMapper.SelectReworlDetailMp(processIdStr, technologyStr, process,previousProcess);
                if(process.equals("中空")){
                    String orderId = processIdStr.substring(0,10);
                    details.forEach( detail -> {
                        Integer glassId = orderGlassDetailMapper.
                                getMinIdByGroup(orderId,
                                        String.valueOf(detail.get("order_number")),
                                        String.valueOf(detail.get("group")));
                        int listGlassId = Integer.parseInt(String.valueOf(detail.get("glassId")));
                        if(listGlassId  !=glassId){
                            detail.put("rowClass","latter");
                ReportingWork retrievedData = (ReportingWork) map.get("data");
                if (retrievedData!=null){
                    Integer reviewedState = retrievedData.getReviewedState();
                    //根据审核状态查询未审核数据
                    if (reviewedState==1){//已审核
                        //不是第一道工序，查询报工数据
                        List<Map<String,String>>  details = reportingWorkMapper.SelectReworlDetailMp(processIdStr, technologyStr, process,previousProcess,laminating);
                        if(process.equals("中空")){
                            //获取该流程卡订单号
                            String orderId = reportingWorkMapper.selectOrderid(processIdStr);
                            details.forEach( detail -> {
                                Integer glassId = orderGlassDetailMapper.
                                        getMinIdByGroup(orderId,
                                                String.valueOf(detail.get("order_number")),
                                                String.valueOf(detail.get("group")));
                                int listGlassId = Integer.parseInt(String.valueOf(detail.get("glassId")));
                                if(listGlassId  !=glassId){
                                    detail.put("rowClass","latter");
                                }
                            });
                        }
                    });
                        map.put("Detail",details );
                    }else {
                        //不是第一道工序，查询报工数据
                        List<Map<String,String>>  details = reportingWorkMapper.SelectReworlDetailMpReview(processIdStr, technologyStr, process,previousProcess,laminating);
                        if(process.equals("中空")){
                            String orderId = reportingWorkMapper.selectOrderid(processIdStr);
                            details.forEach( detail -> {
                                Integer glassId = orderGlassDetailMapper.
                                        getMinIdByGroup(orderId,
                                                String.valueOf(detail.get("order_number")),
                                                String.valueOf(detail.get("group")));
                                int listGlassId = Integer.parseInt(String.valueOf(detail.get("glassId")));
                                if(listGlassId  !=glassId){
                                    detail.put("rowClass","latter");
                                }
                            });
                        }
                        map.put("Detail",details );
                    }
                }


                map.put("Detail",details );
            }

            // 第一道工序（流程卡数+补片数量-完工数-次破数-返工未完成数-禁用数量）
@@ -166,15 +205,26 @@
            //历史工序
            map.put("historyProcess", reportingWorkMapper.SelectHistoryProcessMp(historyProcess, process));
        }


        return map;
    }

    //查询工序
    public Map<String, Object> SelectProcessSv() {
    public Map<String, Object> SelectProcessSv(String userId) {
        Map<String, Object> map = new HashMap<>();
        map.put("process", reportingWorkMapper.SelectProcessMp());
        String process = reportingWorkMapper.selectUserProcess(userId);
        if (process==null) {
            map.put("process", reportingWorkMapper.SelectProcessMp());
        }
        else {
            //对指定工序单独查询
            if (process.equals("夹胶")){
                map.put("process",reportingWorkMapper.getSelectProcessJiajiao() );
            }
            if (process.equals("技术部多曲")){
                map.put("process",reportingWorkMapper.getSelectProcessDuoqu() );
            }
        }

        return map;
    }

@@ -193,27 +243,28 @@
        String formattedDate = dateFormat.format(currentDate);
        String reportingWorkId = "BG" + formattedDate + formattedNumber;
        reportingWork.setReportingWorkId(reportingWorkId);
        reportingWork.setProcessId(reportingWork.getProcessId().substring(0, 14));
        String[] processIdStr = reportingWork.getProcessId().split("/");
        reportingWork.setProcessId(processIdStr[0]);

        int reviewState = (int) reportingWorkJson.get("type");
        if (reviewState == 1) {
        if (reviewState == 1) {//审核通过
            reportingWork.setReviewed(reportingWork.getCreator());
            reportingWork.setReviewedState(1);
        } else {
            reportingWork.setReviewedState(0);
        }
        if(reportingWork.getReportingWorkTime()==null){
            LocalDateTime localDateTime = LocalDateTime.now();
            reportingWork.setReportingWorkTime(localDateTime);
        }
        //是否线补 1现补 0未现补
        int isPatch = (reportingWorkJson.get("isPatch") != null) ? (int) reportingWorkJson.get("isPatch") : 0;

        reportingWork.setNextProcess(orderProcessDetailMapper.selectNextProcess(processIdStr[0],processIdStr[1],reportingWork.getThisProcess()));
        //主表插入
        reportingWorkMapper.insert(reportingWork);
        //副表循环插入，并且插入次破信息表。再根据次破信息修改订单玻璃流程表的完工数量与刺破数量
        reportingWorkDetails.forEach(reportingWorkDetail -> {
//            reportingWork.setThisProcessQuantity(
//                    reportingWork.getThisProcessQuantity()
//                            +reportingWorkDetail.getCompletedQuantity()
//                            +reportingWorkDetail.getBreakageQuantity());
//            reportingWork.setThisCompletedQuantity(
//                    reportingWork.getThisCompletedQuantity()+reportingWorkDetail.getCompletedQuantity());
//            reportingWork.setThisWornQuantity(
//                    reportingWork.getThisWornQuantity()+reportingWorkDetail.getBreakageQuantity());

            int qualityInsStatus = (int) reportingWorkJson.get("qualityInsStatus");
            reportingWorkDetail.setReportingWorkId(reportingWorkId);
@@ -228,6 +279,9 @@
                    //跨工序次破修改质检状态
                    if (!damageDetail.getResponsibleProcess().equals(reportingWork.getThisProcess()) && qualityInsStatus==2) {
                        damageDetail.setQualityInsStatus(1);
                    }
                    if (isPatch == 1){
                        damageDetail.setQualityInsStatus(2);
                    }
                    damageDetailsMapper.insert(damageDetail);
                });
@@ -281,17 +335,21 @@
            orderProcessDetail.setReportingWorkNum(reportingWorkDetail.getCompletedQuantity());
            orderProcessDetail.setReportingWorkNumCount(reportingWorkDetail.getCompletedQuantity());

            //根据订单id，订单序号，以及小片序号 更新小片流程的完工数量以及刺破数量
            LambdaUpdateWrapper<OrderProcessDetail> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(OrderProcessDetail::getOrderNumber, reportingWorkDetail.getOrderNumber())
                    .eq(OrderProcessDetail::getProcessId, reportingWork.getProcessId().substring(0, 14))
                    .eq(OrderProcessDetail::getOrderId, reportingWork.getOrderId())
                    .eq(OrderProcessDetail::getProcess, reportingWork.getThisProcess())
                    .eq(OrderProcessDetail::getTechnologyNumber, reportingWorkDetail.getTechnologyNumber())
                    .setSql("reporting_work_num_count = reporting_work_num_count +" + orderProcessDetail.getReportingWorkNum())
                    .setSql("reporting_work_num =reporting_work_num +" + orderProcessDetail.getReportingWorkNum())
                    .setSql("broken_num =broken_num +" + orderProcessDetail.getBrokenNum());
            orderProcessDetailMapper.update(null, updateWrapper);

            if (isPatch == 0){//未现补
                //根据订单id，订单序号，以及小片序号 更新小片流程的完工数量以及刺破数量
                LambdaUpdateWrapper<OrderProcessDetail> updateWrapper = new LambdaUpdateWrapper<>();
                updateWrapper.eq(OrderProcessDetail::getOrderNumber, reportingWorkDetail.getOrderNumber())
                        .eq(OrderProcessDetail::getProcessId, reportingWork.getProcessId())
                        .eq(OrderProcessDetail::getOrderId, reportingWork.getOrderId())
                        .eq(OrderProcessDetail::getProcess, reportingWork.getThisProcess())
                        .eq(OrderProcessDetail::getTechnologyNumber, reportingWorkDetail.getTechnologyNumber())
                        .setSql("reporting_work_num_count = reporting_work_num_count +" + orderProcessDetail.getReportingWorkNum())
                        .setSql("reporting_work_num =reporting_work_num +" + orderProcessDetail.getReportingWorkNum())
                        .setSql("update_time = now()")
                        .setSql("broken_num =broken_num +" + orderProcessDetail.getBrokenNum());
                orderProcessDetailMapper.update(null, updateWrapper);
            }

            //判断完工数量和刺破数量是否为0，为0则不插入到数据库
            if (!(reportingWorkDetail.getCompletedQuantity() == 0 && reportingWorkDetail.getBreakageQuantity() == 0)) {
@@ -299,7 +357,7 @@
            }

            //更新流程卡表的报工数量
            if (Objects.equals(reportingWork.getNextProcess(), "")) {
            if (Objects.equals(reportingWork.getNextProcess(), "")|| Objects.equals(reportingWork.getNextProcess(), null)) {
                LambdaUpdateWrapper<FlowCard> flowCardLambdaUpdateWrapper =
                        new LambdaUpdateWrapper<>();
                flowCardLambdaUpdateWrapper
@@ -328,21 +386,28 @@

        String processId = reportingWork.get("processId");
        String thisProcess = reportingWork.get("thisProcess");
        String userName=reportingWork.get("userName");
        int index = processId.lastIndexOf("/") + 1;
        String result = processId.substring(index);
        String technologyStr = reportingWork.get("technologyStr");

if (thisProcess.equals("夹胶") || thisProcess.equals("中空") || thisProcess.equals("包装")){
        String[] processIdStr = processId.split("/");
        String nowDate = LocalDate.now().toString();
        //获取报工工序是否为复合工程
        String laminating = reportingWorkMapper.getProcessLaminating(thisProcess);
//合片工序
if (laminating.equals("laminating")){
    LambdaUpdateWrapper
                <ReportingWork> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper
                .eq(ReportingWork::getProcessId, processId.substring(0, 14))
                .eq(ReportingWork::getProcessId, processIdStr[0])
                .eq(ReportingWork::getThisProcess, reportingWork.get("process"))
                .eq(ReportingWork::getReviewedState, 0)
                .setSql("reviewed_state =1");
                .setSql("reviewed_state =1")
                .set(ReportingWork::getReviewed, userName)
                .set(ReportingWork::getExamineTime, nowDate);
        reportingWorkMapper.update(null, updateWrapper);
}else {
    reportingWorkMapper.ReviewReportingWorkMp(processId.substring(0, 14),reportingWork.get("process"),technologyStr);
    reportingWorkMapper.ReviewReportingWorkMp(processIdStr[0],reportingWork.get("process"),technologyStr,userName);

}
        return true;
@@ -374,13 +439,16 @@
        });

        Map<String, Object> map = new HashMap<>();
        //报工主表
        map.put("reportingWork", reportingWork);
        //报工明细
        map.put("reportingWorkDetails", reportingWorkDetails);
        //报工下拉框数据
        map.put("basic", getReportingWorkBase(reportingWork.getProcessId(), reportingWork.getThisProcess()));
        //根据报工编号获取层
        map.put("layer", reportingWorkMapper.selectLayerByReportingWorkId(reportingWorkId));
        map.put("numberList", flowCardMapper.getGlassNumber(reportingWorkMapper.selectLayerByReportingWorkId(reportingWorkId),reportingWork.getProcessId()));

        map.put("title", "补片状态");
        return map;

    }
@@ -392,8 +460,9 @@
        map.put("deviceType", reportingWorkMapper.SelectWorkBasicDeviceMp(thisProcess));
        //班组下拉框
        map.put("teamsType", reportingWorkMapper.SelectWorkBasicTeamsMp(thisProcess));

        //次破类型
        map.put("breakageType", reportingWorkMapper.selectBasicNameByType("breakagetype"));
        //次破原因
        map.put("breakageReason", reportingWorkMapper.selectBasicNameByType("breakagereason"));

        //获取该流程卡号历史报工工序
@@ -429,7 +498,8 @@
                .delete(new LambdaQueryWrapper<ReportingWorkDetail>()
                        .eq(ReportingWorkDetail::getReportingWorkId, reportingWork.getReportingWorkId()));

        //更细报工主表
        //更新报工主表
        int qualityInsStatus = (int) reportingWorkJson.get("qualityInsStatus");
        reportingWorkMapper.updateById(reportingWork);
        reportingWorkDetails.forEach(reportingWorkDetail -> {
            reportingWorkDetail.setReportingWorkId(reportingWork.getReportingWorkId());
@@ -437,7 +507,12 @@
            //每一条报工数据循环插入次破明细表
            if (damageDetails != null && !damageDetails.isEmpty()) {
                damageDetails.forEach(damageDetail -> {
                    if (!Objects.equals(reportingWork.getThisProcess(), damageDetail.getResponsibleProcess())) {
                    damageDetail.setReportingWorkId(reportingWork.getReportingWorkId());
                    damageDetail.setProcessId(reportingWork.getProcessId());
                    damageDetail.setOrderNumber(reportingWorkDetail.getOrderNumber());
                    damageDetail.setTechnologyNumber(reportingWorkDetail.getTechnologyNumber());
                    //是否修改质检状态
                    if (!Objects.equals(reportingWork.getThisProcess(), damageDetail.getResponsibleProcess()) && qualityInsStatus==2) {
                        damageDetail.setQualityInsStatus(1);
                    }
                    if (Objects.equals(reviewState, "review")) {
@@ -488,6 +563,7 @@
        Map<String, Object> map = new HashMap<>();
        map.put("data", reportingWorkMapper.selectReportingWorkMp(offset, pageSize, selectTime1, selectTime2, orderId, reportingWork));
        map.put("total", reportingWorkMapper.getPageTotal(offset, pageSize, selectTime1, selectTime2, orderId, reportingWork));
        map.put("footSum" ,reportingWorkMapper.getFootSum(selectTime1, selectTime2, orderId,reportingWork));
        return map;
    }

@@ -612,67 +688,326 @@
        String count=reportingWorkMapper.getPatchConditionMp(reportingWorkId);
        return count;
    }
    @Transactional(rollbackFor = Exception.class)
    @Transactional(rollbackFor = Exception.class , noRollbackFor = ServiceException.class)
    public Boolean mesReportingWorkSv(Map<String,Object> reportingWorkMap) {
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try{
            //接收解析主附表信息
            JSONObject reportingWorkJson = new JSONObject(reportingWorkMap);
            ReportingWork reportingWork = JSONObject.parseObject(JSONObject.toJSONString(reportingWorkJson.get("title")), ReportingWork.class);
            ReportingWorkDetail reportingWorkDetail =JSON.parseObject(JSONObject.toJSONString(reportingWorkJson.get("detail")), ReportingWorkDetail.class);

        //接收解析主附表信息
        JSONObject reportingWorkJson = new JSONObject(reportingWorkMap);
        ReportingWork reportingWork = JSONObject.parseObject(JSONObject.toJSONString(reportingWorkJson.get("title")), ReportingWork.class);
        ReportingWorkDetail reportingWorkDetail =JSON.parseObject(JSONObject.toJSONString(reportingWorkJson.get("detail")), ReportingWorkDetail.class);
            //查询流程卡工艺流程
            String technologicalProcess = reportingWorkMapper.SelectTechnologicalProcess(reportingWork.getProcessId(), reportingWorkDetail.getTechnologyNumber());

        int processNum = reportingWorkMapper.selectGlassProcessNum(
                reportingWorkDetail.getOrderNumber(),
                reportingWorkDetail.getTechnologyNumber(),
                reportingWork.getProcessId(),
                reportingWork.getThisProcess()
        );
        //判断是否大于当前数量并且抛出异常
        if (processNum < (reportingWorkDetail.getBreakageQuantity() + reportingWorkDetail.getCompletedQuantity())) {
            int index = technologicalProcess.indexOf("-");
            String interceptProcess = "";
            if (index <0){
                interceptProcess = technologicalProcess;
            }
            else {
                //获取工艺流程第一个工序
                interceptProcess = technologicalProcess.substring(0, index);
            }
            int processNum =0;
            if (interceptProcess.equals(reportingWork.getThisProcess())) {
                processNum = reportingWorkMapper.selectFlowCardNum(
                        reportingWorkDetail.getOrderNumber(),
                        reportingWorkDetail.getTechnologyNumber(),
                        reportingWork.getProcessId(),
                        reportingWork.getThisProcess()
                );
            }else{
                 processNum = reportingWorkMapper.selectGlassProcessNum(
                        reportingWorkDetail.getOrderNumber(),
                        reportingWorkDetail.getTechnologyNumber(),
                        reportingWork.getProcessId(),
                        reportingWork.getThisProcess()
                );
            }

            //获取可报数量

            //判断是否大于当前数量并且抛出异常
            if (processNum < (reportingWorkDetail.getBreakageQuantity() + reportingWorkDetail.getCompletedQuantity())) {
                return false;
            }
            //查询报工数据
            List<ReportingWork> ReportingWorks = reportingWorkMapper.selectJoinList(ReportingWork.class,
                    new MPJLambdaWrapper<ReportingWork>()
                            .select(ReportingWork::getReportingWorkId)
                            .leftJoin(ReportingWorkDetail.class, ReportingWorkDetail::getReportingWorkId, ReportingWork::getReportingWorkId)
                            .eq(ReportingWork::getProcessId,reportingWork.getProcessId())
                            .eq(ReportingWork::getThisProcess,reportingWork.getThisProcess())
                            .eq(ReportingWork::getDeviceName,reportingWork.getDeviceName())
                            .eq(ReportingWork::getReviewedState,0)//审核状态等于0，未删除
                            .eq(ReportingWork::getThisWornQuantity,0)
                            .eq(ReportingWorkDetail::getTechnologyNumber,reportingWorkDetail.getTechnologyNumber())
                            .orderByDesc(ReportingWork::getId)

            );


            //判断报工表是否存在，不存在则新增报工主副表数据，存在则修改副表数据
            if(ReportingWorks.isEmpty()){
                //获取当前最大报工单号生成报工单号
                String formattedNumber = String.format("%04d", reportingWorkMapper.selectMaxReportingWorkId() + 1);
                //格式化当前日期
                Date currentDate = new Date();
                SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
                String formattedDate = dateFormat.format(currentDate);
                String reportingWorkId = "BG" + formattedDate + formattedNumber;

                reportingWork.setReportingWorkId(reportingWorkId);
                reportingWorkDetail.setReportingWorkId(reportingWorkId);

                reportingWorkMapper.insert(reportingWork);
                reportingWorkDetailMapper.insert(reportingWorkDetail);
            }else{

                ReportingWorkDetail reportingWorkDetail1 = reportingWorkDetailMapper.selectOne(
                        new LambdaQueryWrapper<ReportingWorkDetail>()
                                .eq(ReportingWorkDetail::getReportingWorkId,ReportingWorks.get(0).getReportingWorkId())
                                .eq(ReportingWorkDetail::getOrderNumber,reportingWorkDetail.getOrderNumber())
                                .eq(ReportingWorkDetail::getTechnologyNumber,reportingWorkDetail.getTechnologyNumber())
                );

                if(reportingWorkDetail1 == null){
                    reportingWorkDetail.setReportingWorkId(ReportingWorks.get(0).getReportingWorkId());
                    reportingWorkDetailMapper.insert(reportingWorkDetail);
                }else{
                    LambdaUpdateWrapper<ReportingWorkDetail> detailLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
                    detailLambdaUpdateWrapper.eq(ReportingWorkDetail::getReportingWorkId, ReportingWorks.get(0).getReportingWorkId() )
                            .eq(ReportingWorkDetail::getOrderNumber,reportingWorkDetail.getOrderNumber())
                            .eq(ReportingWorkDetail::getTechnologyNumber,reportingWorkDetail.getTechnologyNumber())
                            .setSql("completed_quantity = completed_quantity+" + reportingWorkDetail.getCompletedQuantity());
                    reportingWorkDetailMapper.update(null, detailLambdaUpdateWrapper);
                }




                LambdaUpdateWrapper<ReportingWork> reportingWorkLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
                reportingWorkLambdaUpdateWrapper
                        .eq(ReportingWork::getReportingWorkId, ReportingWorks.get(0).getReportingWorkId() )
                        .setSql("this_completed_quantity = this_completed_quantity+" + reportingWorkDetail.getCompletedQuantity());
                reportingWorkMapper.update(null, reportingWorkLambdaUpdateWrapper);

            }



            OrderProcessDetail orderProcessDetail = new OrderProcessDetail();
            orderProcessDetail.setBrokenNum(reportingWorkDetail.getBreakageQuantity());
            orderProcessDetail.setReportingWorkNum(reportingWorkDetail.getCompletedQuantity());
            orderProcessDetail.setReportingWorkNumCount(reportingWorkDetail.getCompletedQuantity());

            //根据订单id，订单序号，以及小片序号 更新小片流程的完工数量以及刺破数量
            LambdaUpdateWrapper<OrderProcessDetail> updateWrapper = new LambdaUpdateWrapper<>();
            updateWrapper.eq(OrderProcessDetail::getOrderNumber, reportingWorkDetail.getOrderNumber())
                    .eq(OrderProcessDetail::getProcessId, reportingWork.getProcessId())
                    .eq(OrderProcessDetail::getOrderId, reportingWork.getOrderId())
                    .eq(OrderProcessDetail::getProcess, reportingWork.getThisProcess())
                    .eq(OrderProcessDetail::getTechnologyNumber, reportingWorkDetail.getTechnologyNumber())
                    .setSql("reporting_work_num_count = reporting_work_num_count +" + orderProcessDetail.getReportingWorkNum())
                    .setSql("reporting_work_num =reporting_work_num +" + orderProcessDetail.getReportingWorkNum());

            orderProcessDetailMapper.update(null, updateWrapper);
            return true;
         } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            throw new ServiceException(Constants.Code_600, "上工序已完工数量小于本工序报工数量，请检查");
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e +Arrays.toString(e.getStackTrace()));
            sysError.setFunc("汉玻mes报工");
            sysErrorService.insert(sysError);
            throw new ServiceException(Constants.Code_500, "数据请求异常，请检查");

        }
    }

    @Transactional(rollbackFor = Exception.class)
    public Object reportingWorkTransferSv(Map<String, String> reportingWork) {
        Order oldOrder = orderMapper.selectOrderId(reportingWork.get("oldOrderId"));
        OrderDetail oldOrderDetail = orderDetailMapper.selectOne(
                new QueryWrapper<OrderDetail>()
                        .eq("order_id", reportingWork.get("oldOrderId"))
                        .eq("order_number", reportingWork.get("oldOrderNumber"))
        );

        Order newOrder = orderMapper.selectOrderId(reportingWork.get("newOrderId"));
        OrderDetail newOrderDetail = orderDetailMapper.selectOne(
                new QueryWrapper<OrderDetail>()
                        .eq("order_id", reportingWork.get("newOrderId"))
                        .eq("order_number", reportingWork.get("newOrderNumber"))
        );
        if(!Objects.equals(oldOrder.getCustomerId(), newOrder.getCustomerId())){
            return "新旧订单客户不一致";
        }
        if(!Objects.equals(oldOrderDetail.getProductId(), newOrderDetail.getProductId())){
            return "新旧订单产品不一致";
        }
        if (!Objects.equals(oldOrderDetail.getWidth(), newOrderDetail.getWidth())
                || !Objects.equals(oldOrderDetail.getHeight(), newOrderDetail.getHeight())){
            return "新旧订单尺寸不一致";
        }


        //获取当前最大报工单号生成报工单号
        String formattedNumber = String.format("%04d", reportingWorkMapper.selectMaxReportingWorkId() + 1);
        //格式化当前日期
        Date currentDate = new Date();
        SimpleDateFormat dateFormat = new SimpleDateFormat("yyMMdd");
        String formattedDate = dateFormat.format(currentDate);
        String reportingWorkId = "BG" + formattedDate + formattedNumber;
        //获取旧订单是否流程卡是否存在
        List<OrderProcessDetail> oldOrderProcessDetailList = orderProcessDetailMapper
                .selectList(new QueryWrapper<OrderProcessDetail>()
                        .eq("order_id", reportingWork.get("oldOrderId"))
                        .eq("order_number", reportingWork.get("oldOrderNumber"))
                );
        if(oldOrderProcessDetailList.isEmpty()){
            return "旧订单未分流程卡";
        }
        //获取新订单是否流程卡是否存在
        List<OrderProcessDetail> newOrderProcessDetailList = orderProcessDetailMapper
                .selectList(new QueryWrapper<OrderProcessDetail>()
                        .eq("order_id", reportingWork.get("newOrderId"))
                        .eq("order_number", reportingWork.get("newOrderNumber"))
                );
        if(newOrderProcessDetailList.isEmpty()){
            return "新订单未分流程卡";
        }
        //新订单是否存在已经排版序号
        List<FlowCard> newFlowCardLayoutStatus = flowCardMapper.selectList(new QueryWrapper<FlowCard>()
                .eq("order_id", reportingWork.get("newOrderId"))
                .eq("order_number", reportingWork.get("newOrderNumber"))
                .gt("layout_status",0)
        );
        if(!newFlowCardLayoutStatus.isEmpty()){
            return "新订单此序号存在排版";
        }
        //获取旧订单报工数据汇总
        List<OrderProcessDetail> oldOrderProcessDetailForReport = orderProcessDetailMapper
                .selectList(new QueryWrapper<OrderProcessDetail>()
                        .eq( "order_id", reportingWork.get("oldOrderId"))
                        .eq("order_number", reportingWork.get("oldOrderNumber"))
                        .gt("reporting_work_num",0)
        );

        reportingWork.setReportingWorkId(reportingWorkId);
        reportingWorkDetail.setReportingWorkId(reportingWorkId);
        Map<String,Object> log = new HashMap<>();
        log.put("oldOrderBeforeChange",oldOrderProcessDetailForReport);

        reportingWorkMapper.insert(reportingWork);
        reportingWorkDetailMapper.insert(reportingWorkDetail);
        Map<String,Object> newOrderLog = new HashMap<>();
        newOrderLog.put("newOrderBeforeChange",newOrderProcessDetailList);

        //传给mes流程卡数量集合
        List<OrderNumberTransferDTO> orderNumberTransferList = new ArrayList<>();

        oldOrderProcessDetailForReport.forEach(oldOrderProcessDetail -> {
            int maxNum = 0;
            for(OrderProcessDetail newOrderProcessDetail : newOrderProcessDetailList){
                if(oldOrderProcessDetail.getReportingWorkNum() == 0){
                    break;
                }
                //判断小片是否一致，工序是否一致
                if(newOrderProcessDetail.getProcess().equals(oldOrderProcessDetail.getProcess()) &&
                        Objects.equals(newOrderProcessDetail.getTechnologyNumber(), oldOrderProcessDetail.getTechnologyNumber())){
                    //判断是否为第一道工序，给可转移最大值赋值
                    if(oldOrderProcessDetail.getProcess().equals("切割")){
                        FlowCard  thisFlowCard = flowCardMapper.selectOne(new QueryWrapper<FlowCard>()
                                .eq("process_id", newOrderProcessDetail.getProcessId())
                                .eq("order_number", newOrderProcessDetail.getOrderNumber())
                                .eq("technology_number",newOrderProcessDetail.getTechnologyNumber())
                        );
                        maxNum = thisFlowCard.getQuantity();
                    }else{
                        //当不是第一道工序则，拿上一道工序作为最大值
                        maxNum = orderProcessDetailMapper.selectById(newOrderProcessDetail.getId()-1).getReportingWorkNum();
                    }
                    //判断被转移的数量是否大于可转移的数量最大值
                    int transferNum = 0;
                    if(oldOrderProcessDetail.getReportingWorkNum() > maxNum){
                        transferNum = maxNum;
                        oldOrderProcessDetail.setReportingWorkNum(oldOrderProcessDetail.getReportingWorkNum()-maxNum);
                        oldOrderProcessDetail.setReportingWorkNumCount(oldOrderProcessDetail.getReportingWorkNumCount()-maxNum);
                    }else{
                        transferNum = oldOrderProcessDetail.getReportingWorkNum();
                        oldOrderProcessDetail.setReportingWorkNum(0);
                        oldOrderProcessDetail.setReportingWorkNumCount(0);
                    }
                    //更新旧订单小片流程表的报工数量
                    orderProcessDetailMapper.update(null,new UpdateWrapper<OrderProcessDetail>()
                            .set("reporting_work_num",oldOrderProcessDetail.getReportingWorkNum())
                            .set("reporting_work_num_count",oldOrderProcessDetail.getReportingWorkNumCount())
                            .eq("id",oldOrderProcessDetail.getId())
                    );
                    //更新新订单小片流程表的报工数量
                    orderProcessDetailMapper.update(null,new UpdateWrapper<OrderProcessDetail>()
                            .set("reporting_work_num",transferNum)
                            .set("reporting_work_num_count",transferNum)
                            .eq("id",newOrderProcessDetail.getId())
                    );
                    if(oldOrderProcessDetail.getProcess().equals("切割")){
                        //更新旧订单流程卡转出数量
                        flowCardMapper.update(null,new UpdateWrapper<FlowCard>()
                                .setSql("export_number = export_number + "+transferNum)
                                .eq("process_id", oldOrderProcessDetail.getProcessId())
                                .eq("order_number", oldOrderProcessDetail.getOrderNumber())
                                .eq("technology_number",oldOrderProcessDetail.getTechnologyNumber())
                        );
                        //更新新订单流程卡转出数量
                        flowCardMapper.update(null,new UpdateWrapper<FlowCard>()
                                .setSql("import_number = import_number + "+transferNum)
                                .eq("process_id", newOrderProcessDetail.getProcessId())
                                .eq("order_number", newOrderProcessDetail.getOrderNumber())
                                .eq("technology_number",newOrderProcessDetail.getTechnologyNumber())
                        );

                        //传给mes数据赋值
                        OrderNumberTransferDTO orderNumberTransfer = new OrderNumberTransferDTO();
                        orderNumberTransfer.setChangeNumber(transferNum);
                        orderNumberTransfer.setOldProcessId(oldOrderProcessDetail.getProcessId());
                        orderNumberTransfer.setNewProcessId(newOrderProcessDetail.getProcessId());
                        orderNumberTransfer.setOldOrderNumber(oldOrderProcessDetail.getOrderNumber());
                        orderNumberTransfer.setNewOrderNumber(newOrderProcessDetail.getOrderNumber());
                        orderNumberTransfer.setOldTechnologyNumber(oldOrderProcessDetail.getTechnologyNumber());
                        orderNumberTransfer.setNewTechnologyNumber(newOrderProcessDetail.getTechnologyNumber());
                        orderNumberTransferList.add(orderNumberTransfer);

                    }

                }
            }
        });


        //把旧订单数据和新订单数据传到日志表当中
        log.put("oldOrderChange",JSON.toJSONString(oldOrderProcessDetailForReport));

        OrderProcessDetail orderProcessDetail = new OrderProcessDetail();
        orderProcessDetail.setBrokenNum(reportingWorkDetail.getBreakageQuantity());
        orderProcessDetail.setReportingWorkNum(reportingWorkDetail.getCompletedQuantity());
        orderProcessDetail.setReportingWorkNumCount(reportingWorkDetail.getCompletedQuantity());
        newOrderLog.put("newOrderChange",orderProcessDetailMapper
                .selectList(new QueryWrapper<OrderProcessDetail>()
                        .eq("order_id", reportingWork.get("newOrderId"))
                        .eq("order_number", reportingWork.get("newOrderNumber"))
                ));
        //旧订单信息传入日志
        ReportingWorkTransfer reportingWorkTransfer = new ReportingWorkTransfer();
        reportingWorkTransfer.setOldOrder(reportingWork.get("oldOrderId"));
        reportingWorkTransfer.setOldOrderNumber(Integer.valueOf(reportingWork.get("oldOrderNumber")));
        reportingWorkTransfer.setOldReportContent(JSON.toJSONString(log));

        //根据订单id，订单序号，以及小片序号 更新小片流程的完工数量以及刺破数量
        LambdaUpdateWrapper<OrderProcessDetail> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper.eq(OrderProcessDetail::getOrderNumber, reportingWorkDetail.getOrderNumber())
                .eq(OrderProcessDetail::getProcessId, reportingWork.getProcessId().substring(0, 14))
                .eq(OrderProcessDetail::getOrderId, reportingWork.getOrderId())
                .eq(OrderProcessDetail::getProcess, reportingWork.getThisProcess())
                .eq(OrderProcessDetail::getTechnologyNumber, reportingWorkDetail.getTechnologyNumber())
                .setSql("reporting_work_num_count = reporting_work_num_count +" + orderProcessDetail.getReportingWorkNum())
                .setSql("reporting_work_num =reporting_work_num +" + orderProcessDetail.getReportingWorkNum());
        //新订单信息传入日志
        reportingWorkTransfer.setNewOrder(reportingWork.get("newOrderId"));
        reportingWorkTransfer.setNewOrderNumber(Integer.valueOf(reportingWork.get("newOrderNumber")));
        reportingWorkTransfer.setNewReportContent(JSON.toJSONString(newOrderLog));
        reportingWorkTransferMapper.insert(reportingWorkTransfer);
        //restTemplate.postForObject("http://localhost:8086/order/test",orderNumberTransferList,String.class);

        orderProcessDetailMapper.update(null, updateWrapper);
        //向mes发送http请求
        ResponseEntity<String> response =restTemplate.exchange(
                "http://localhost:88/api/loadGlass/order/order/orderChange",
                HttpMethod.POST,
                new HttpEntity<>(orderNumberTransferList),
                String.class);




        //String thisProcess = reportingWork.getThisProcess();
        //reportingWorkMapper.
        return true;
        if(response.getStatusCode() == HttpStatus.OK){
            return true;
        }else{
            return "mes响应超时";
        }
    }
}