blame | 历史 | 补丁 | 提交 | 提交对比 | ignore whitespace
guoyuji
2025-02-19 3d66a05e01b17a57f80a422b19fbbff92a69c080 
 north-glass-erp/src/main/java/com/example/erp/service/pp/ReportingWorkService.java


@@ -13,6 +13,7 @@


import com.example.erp.entity.sd.Order;


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.pp.*;


import com.baomidou.dynamic.datasource.annotation.DS;


@@ -22,6 +23,8 @@


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 org.springframework.stereotype.Service;


import org.springframework.transaction.annotation.Transactional;


import org.springframework.transaction.interceptor.TransactionAspectSupport;


@@ -58,9 +61,10 @@




    final LogMapper logMapper;


    private final OrderGlassDetailMapper orderGlassDetailMapper;


    private final SysErrorService sysErrorService;






    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) {


        this.reportingWorkMapper = reportingWorkMapper;


        this.basicDateProduceMapper = basicDateProduceMapper;


        this.damageDetailsMapper = damageDetailsMapper;


@@ -72,10 +76,13 @@


        this.logService = logService;


        this.logMapper = logMapper;


        this.orderGlassDetailMapper = orderGlassDetailMapper;


        this.sysErrorService = sysErrorService;


    }




    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 +126,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 +197,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 +235,26 @@


        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);


        }




        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);


@@ -284,7 +325,7 @@


            //根据订单id，订单序号，以及小片序号 更新小片流程的完工数量以及刺破数量


            LambdaUpdateWrapper<OrderProcessDetail> updateWrapper = new LambdaUpdateWrapper<>();


            updateWrapper.eq(OrderProcessDetail::getOrderNumber, reportingWorkDetail.getOrderNumber())


                    .eq(OrderProcessDetail::getProcessId, reportingWork.getProcessId().substring(0, 14))


                    .eq(OrderProcessDetail::getProcessId, reportingWork.getProcessId())


                    .eq(OrderProcessDetail::getOrderId, reportingWork.getOrderId())


                    .eq(OrderProcessDetail::getProcess, reportingWork.getThisProcess())


                    .eq(OrderProcessDetail::getTechnologyNumber, reportingWorkDetail.getTechnologyNumber())


@@ -292,14 +333,13 @@


                    .setSql("reporting_work_num =reporting_work_num +" + orderProcessDetail.getReportingWorkNum())


                    .setSql("broken_num =broken_num +" + orderProcessDetail.getBrokenNum());


            orderProcessDetailMapper.update(null, updateWrapper);




            //判断完工数量和刺破数量是否为0，为0则不插入到数据库


            if (!(reportingWorkDetail.getCompletedQuantity() == 0 && reportingWorkDetail.getBreakageQuantity() == 0)) {


                reportingWorkDetailMapper.insert(reportingWorkDetail);


            }




            //更新流程卡表的报工数量


            if (Objects.equals(reportingWork.getNextProcess(), "")) {


            if (Objects.equals(reportingWork.getNextProcess(), "")|| Objects.equals(reportingWork.getNextProcess(), null)) {


                LambdaUpdateWrapper<FlowCard> flowCardLambdaUpdateWrapper =


                        new LambdaUpdateWrapper<>();


                flowCardLambdaUpdateWrapper


@@ -328,21 +368,24 @@




        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");




        String[] processIdStr = processId.split("/");


//合片工序


if (thisProcess.equals("夹胶") || thisProcess.equals("中空") || thisProcess.equals("包装")){


    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);


        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 +417,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 +438,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 +476,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 +485,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")) {


@@ -612,67 +665,117 @@


        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);


            //获取可报数量


            int 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)




        //接收解析主附表信息


        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);


            );




        int processNum = reportingWorkMapper.selectGlassProcessNum(


                reportingWorkDetail.getOrderNumber(),


                reportingWorkDetail.getTechnologyNumber(),


                reportingWork.getProcessId(),


                reportingWork.getThisProcess()


        );


        //判断是否大于当前数量并且抛出异常


        if (processNum < (reportingWorkDetail.getBreakageQuantity() + reportingWorkDetail.getCompletedQuantity())) {




            //判断报工表是否存在，不存在则新增报工主副表数据，存在则修改副表数据


            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, "数据请求异常，请检查");




        }






        //获取当前最大报工单号生成报工单号


        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);








        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().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());




        orderProcessDetailMapper.update(null, updateWrapper);










        //String thisProcess = reportingWork.getThisProcess();


        //reportingWorkMapper.


        return true;


    }


}