Merge branch 'master' of http://10.153.19.25:10101/r/ERP_override

guoyuji

2025-02-19 3d66a05e01b17a57f80a422b19fbbff92a69c080

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

@@ -25,7 +25,6 @@
import com.example.erp.service.userInfo.LogService;
import com.example.erp.service.userInfo.SysErrorService;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
@@ -82,6 +81,8 @@

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

@@ -125,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 );
            }

            // 第一道工序（流程卡数+补片数量-完工数-次破数-返工未完成数-禁用数量）
@@ -172,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;
    }

@@ -199,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);
@@ -290,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())
@@ -298,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
@@ -334,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;
@@ -380,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;

    }
@@ -398,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"));

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

        //更细报工主表
        //更新报工主表
        int qualityInsStatus = (int) reportingWorkJson.get("qualityInsStatus");
        reportingWorkMapper.updateById(reportingWork);
        reportingWorkDetails.forEach(reportingWorkDetail -> {
@@ -448,6 +489,7 @@
                    damageDetail.setProcessId(reportingWork.getProcessId());
                    damageDetail.setOrderNumber(reportingWorkDetail.getOrderNumber());
                    damageDetail.setTechnologyNumber(reportingWorkDetail.getTechnologyNumber());
                    //是否修改质检状态
                    if (!Objects.equals(reportingWork.getThisProcess(), damageDetail.getResponsibleProcess()) && qualityInsStatus==2) {
                        damageDetail.setQualityInsStatus(1);
                    }
@@ -653,11 +695,12 @@
                            .eq(ReportingWork::getDeviceName,reportingWork.getDeviceName())
                            .eq(ReportingWork::getReviewedState,0)//审核状态等于0，未删除
                            .eq(ReportingWork::getThisWornQuantity,0)
                            .eq(ReportingWorkDetail::getOrderNumber,reportingWorkDetail.getOrderNumber())
                            .eq(ReportingWorkDetail::getTechnologyNumber,reportingWorkDetail.getTechnologyNumber())
                            .orderByDesc(ReportingWork::getId)

            );


            //判断报工表是否存在，不存在则新增报工主副表数据，存在则修改副表数据
            if(ReportingWorks.isEmpty()){
                //获取当前最大报工单号生成报工单号
@@ -674,20 +717,34 @@
                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);



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

            }

@@ -701,7 +758,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())