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

廖井涛

2025-03-26 d33a7f7c7e7c218a4cb71cb039249b75bcfeef42

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

@@ -485,73 +485,79 @@
        JSONObject reportingWorkJson = new JSONObject(reportingWorkMap);
        ReportingWork reportingWork = JSONObject.parseObject(JSONObject.toJSONString(reportingWorkJson.get("title")), ReportingWork.class);
        List<ReportingWorkDetail> reportingWorkDetails = JSONArray.parseArray(JSONObject.toJSONString(reportingWorkJson.get("detail")), ReportingWorkDetail.class);
        //查询该报工是否为报工转移订单
        Integer transferState = reportingWorkMapper.selectReviewedState(reportingWork.getReportingWorkId());
        if (transferState !=3){
            //删除刺破明细表刺破数据
            damageDetailsMapper.delete(
                    new LambdaQueryWrapper<DamageDetails>()
                            .eq(DamageDetails::getReportingWorkId, reportingWork.getReportingWorkId())
            );
            //修改小片流程表数量
            orderProcessDetailMapper.updateQuantity(reportingWork.getReportingWorkId(), reportingWork.getThisProcess(), "delete");
            //删除报工明细表数据
            reportingWorkDetailMapper
                    .delete(new LambdaQueryWrapper<ReportingWorkDetail>()
                            .eq(ReportingWorkDetail::getReportingWorkId, reportingWork.getReportingWorkId()));

        //删除刺破明细表刺破数据
        damageDetailsMapper.delete(
                new LambdaQueryWrapper<DamageDetails>()
                        .eq(DamageDetails::getReportingWorkId, reportingWork.getReportingWorkId())
        );
        //修改小片流程表数量
        orderProcessDetailMapper.updateQuantity(reportingWork.getReportingWorkId(), reportingWork.getThisProcess(), "delete");
        //删除报工明细表数据
        reportingWorkDetailMapper
                .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());
            List<DamageDetails> damageDetails = reportingWorkDetail.getDamageDetails();
            //每一条报工数据循环插入次破明细表
            if (damageDetails != null && !damageDetails.isEmpty()) {
                damageDetails.forEach(damageDetail -> {
                    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")) {
                        damageDetail.setQualityInsStatus(2);
                    }

                    damageDetailsMapper.insert(damageDetail);
                });
            }
            //插入报工数据
            reportingWorkDetailMapper.insert(reportingWorkDetail);
            orderProcessDetailMapper.insertByReportingWorkDetail(reportingWorkDetail,reportingWork.getProcessId(),reportingWork.getThisProcess());
            //修改包装时修改库存数量
            if (reportingWork.getNextProcess()==null || reportingWork.getNextProcess().isEmpty()){
                //获取该报工修改后的可入库数量
                Integer  inventory = reportingWorkDetailMapper.selectInventory(reportingWork.getProcessId(),Integer.parseInt(reportingWorkDetail.getOrderNumber()),Integer.parseInt(reportingWorkDetail.getTechnologyNumber()),reportingWork.getThisProcess());
                //修改流程卡表库存数量
                flowCardMapper.updateInventory(reportingWork.getProcessId(),reportingWorkDetail.getOrderNumber(),reportingWorkDetail.getTechnologyNumber(),inventory);
            }
        });
        //获取质检时间
        if (Objects.equals(reviewState, "review")) {
            LocalDateTime
                    currentDate = LocalDateTime.now();
            reportingWork.setQualityInsTime(currentDate);
            //更新报工主表
            int qualityInsStatus = (int) reportingWorkJson.get("qualityInsStatus");
            reportingWorkMapper.updateById(reportingWork);
            reportingWorkDetails.forEach(reportingWorkDetail -> {
                reportingWorkDetail.setReportingWorkId(reportingWork.getReportingWorkId());
                List<DamageDetails> damageDetails = reportingWorkDetail.getDamageDetails();
                //每一条报工数据循环插入次破明细表
                if (damageDetails != null && !damageDetails.isEmpty()) {
                    damageDetails.forEach(damageDetail -> {
                        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")) {
                            damageDetail.setQualityInsStatus(2);
                        }

                        damageDetailsMapper.insert(damageDetail);
                    });
                }
                //插入报工数据
                reportingWorkDetailMapper.insert(reportingWorkDetail);
                orderProcessDetailMapper.insertByReportingWorkDetail(reportingWorkDetail,reportingWork.getProcessId(),reportingWork.getThisProcess());
                //修改包装时修改库存数量
                if (reportingWork.getNextProcess()==null || reportingWork.getNextProcess().isEmpty()){
                    //获取该报工修改后的可入库数量
                    Integer  inventory = reportingWorkDetailMapper.selectInventory(reportingWork.getProcessId(),Integer.parseInt(reportingWorkDetail.getOrderNumber()),Integer.parseInt(reportingWorkDetail.getTechnologyNumber()),reportingWork.getThisProcess());
                    //修改流程卡表库存数量
                    flowCardMapper.updateInventory(reportingWork.getProcessId(),reportingWorkDetail.getOrderNumber(),reportingWorkDetail.getTechnologyNumber(),inventory);
                }
            });
            //获取质检时间
            if (Objects.equals(reviewState, "review")) {
                LocalDateTime
                        currentDate = LocalDateTime.now();
                reportingWork.setQualityInsTime(currentDate);
                reportingWorkMapper.updateById(reportingWork);
            }

            //修改小片流程表数量为报工明细表数量
            //orderProcessDetailMapper.updateQuantity(reportingWork.getReportingWorkId(), reportingWork.getThisProcess(), "add");
            //保存日志
            Log log = new Log();
            log.setContent(reportingWorkMap.toString());
            log.setFunction("updateReportingWork报工修改");
            log.setOperatorId((String) reportingWorkJson.get("userId"));
            log.setOperator((String) reportingWorkJson.get("userName"));
            logService.saveLog(log);

            return true;
        } else {
            return false;
        }

        //修改小片流程表数量为报工明细表数量
        //orderProcessDetailMapper.updateQuantity(reportingWork.getReportingWorkId(), reportingWork.getThisProcess(), "add");
        //保存日志
        Log log = new Log();
        log.setContent(reportingWorkMap.toString());
        log.setFunction("updateReportingWork报工修改");
        log.setOperatorId((String) reportingWorkJson.get("userId"));
        log.setOperator((String) reportingWorkJson.get("userName"));
        logService.saveLog(log);

        return true;
    }

    //报工管理查询
@@ -578,38 +584,65 @@
            String lastProcess = reportingWorkMapper.selectLastProcess(processId);
            //获取是否有已补片或返工
            Integer countStates= Integer.valueOf(reportingWorkMapper.getPatchConditionMp(reportingWorkId));
            //判断是否有补片返工数据
            if (countStates==0){
                //判断是否是入库工序
                if (lastProcess.equals(thisProcess)) {//是入库工序
                    //查询该流程卡数量、可入库数量、已入库数量
                    Map<String, Object> list = reportingWorkMapper.selectReceiptQuantity(processId);
                    if (list.get("quantity") == list.get("receiptQuantity")) {
                        return false;
                    } else {
                        //转换类型:已入库数量
                        Integer receiptQuantity = Integer.parseInt(list.get("receivedQuantity").toString());
                        //转换类型:可入库数量
                        Integer inventoryQuantity = Integer.parseInt(list.get("inventoryQuantity").toString());
                        //查询该报工编号本工序完工数量
                        Integer completedQuantity = reportingWorkMapper.selectCompletedQuantity(reportingWorkId);
                        //当该工序完工数量小于等于已入库数量时
                        //可入库数量-已入库数量>=报工编号本工序完工数量
                        if (inventoryQuantity - receiptQuantity >= completedQuantity) {
            //查询该报工是否为报工转移订单
            Integer transferState = reportingWorkMapper.selectReviewedState(reportingWorkId);
            if (transferState !=3){
                //判断是否有补片返工数据
                if (countStates==0){
                    //判断是否是入库工序
                    if (lastProcess.equals(thisProcess)) {//是入库工序
                        //查询该流程卡数量、可入库数量、已入库数量
                        Map<String, Object> list = reportingWorkMapper.selectReceiptQuantity(processId);
                        if (list.get("quantity") == list.get("receiptQuantity")) {
                            return false;
                        } else {
                            //转换类型:已入库数量
                            Integer receiptQuantity = Integer.parseInt(list.get("receivedQuantity").toString());
                            //转换类型:可入库数量
                            Integer inventoryQuantity = Integer.parseInt(list.get("inventoryQuantity").toString());
                            //查询该报工编号本工序完工数量
                            Integer completedQuantity = reportingWorkMapper.selectCompletedQuantity(reportingWorkId);
                            //当该工序完工数量小于等于已入库数量时
                            //可入库数量-已入库数量>=报工编号本工序完工数量
                            if (inventoryQuantity - receiptQuantity >= completedQuantity) {
                                //查询当前报工编号完工次破数量的数据
                                List<Map<String, Object>> workDateList = reportingWorkMapper.reportingWorkDate(reportingWorkId);
                                for (Map<String, Object> item : workDateList) {
                                    //更新流程卡可入库数量
                                    reportingWorkMapper.updateInventoryQuantity(processId, item.get("order_number"), item.get("technology_number"), item.get("completed_quantity"));
                                    //更新报工流程表数据
                                    reportingWorkMapper.updateWorkProcess(processId, item.get("order_number"), item.get("technology_number"), item.get("completed_quantity"), item.get("breakage_quantity"), thisProcess);
                                }
                                //删除报工，将审核状态改为-1
                                reportingWorkMapper.deleteWork(reportingWorkId);
                                //保存日志
                                Log log = new Log();
                                log.setContent(reportingWorkId+"-"+processId+"-"+thisProcess);
                                log.setFunction("deleteWork报工入库删除");
                                log.setOperatorId(userId);
                                log.setOperator(userName);
                                logService.saveLog(log);
                                return true;
                            } else {
                                return false;
                            }
                        }

                    } else {//不是入库工序
                        if (count == 0) {
                            //查询当前报工编号完工次破数量的数据
                            List<Map<String, Object>> workDateList = reportingWorkMapper.reportingWorkDate(reportingWorkId);
                            for (Map<String, Object> item : workDateList) {
                                //更新流程卡可入库数量
                                reportingWorkMapper.updateInventoryQuantity(processId, item.get("order_number"), item.get("technology_number"), item.get("completed_quantity"));
                                //更新报工流程表数据
                                reportingWorkMapper.updateWorkProcess(processId, item.get("order_number"), item.get("technology_number"), item.get("completed_quantity"), item.get("breakage_quantity"), thisProcess);
                            }
                            //删除报工，将审核状态改为-1
                            reportingWorkMapper.deleteWork(reportingWorkId);

                            //保存日志
                            Log log = new Log();
                            log.setContent(reportingWorkId+"-"+processId+"-"+thisProcess);
                            log.setFunction("deleteWork报工入库删除");
                            log.setFunction("deleteWork报工删除");
                            log.setOperatorId(userId);
                            log.setOperator(userName);
                            logService.saveLog(log);
@@ -618,34 +651,14 @@
                            return false;
                        }
                    }

                } else {//不是入库工序
                    if (count == 0) {
                        //查询当前报工编号完工次破数量的数据
                        List<Map<String, Object>> workDateList = reportingWorkMapper.reportingWorkDate(reportingWorkId);
                        for (Map<String, Object> item : workDateList) {
                            //更新报工流程表数据
                            reportingWorkMapper.updateWorkProcess(processId, item.get("order_number"), item.get("technology_number"), item.get("completed_quantity"), item.get("breakage_quantity"), thisProcess);
                        }
                        //删除报工，将审核状态改为-1
                        reportingWorkMapper.deleteWork(reportingWorkId);

                        //保存日志
                        Log log = new Log();
                        log.setContent(reportingWorkId+"-"+processId+"-"+thisProcess);
                        log.setFunction("deleteWork报工删除");
                        log.setOperatorId(userId);
                        log.setOperator(userName);
                        logService.saveLog(log);
                        return true;
                    } else {
                        return false;
                    }
                }
            }
            else {
                else {
                    return false;
                }
            } else {
                return false;
            }


        } else {
            return false;
@@ -829,12 +842,24 @@

    @Transactional(rollbackFor = Exception.class)
    public Object reportingWorkTransferSv(Map<String, String> reportingWork) {
        Map<String, Object> result = new HashMap<>();

        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"))
        );
        if(oldOrder == null){
            result.put("msg","旧订单不存在");
            result.put("data",false);
            return result;
        }
        if(oldOrderDetail == null){
            result.put("msg","旧订单次序号不存在");
            result.put("data",false);
            return result;
        }

        Order newOrder = orderMapper.selectOrderId(reportingWork.get("newOrderId"));
        OrderDetail newOrderDetail = orderDetailMapper.selectOne(
@@ -842,15 +867,37 @@
                        .eq("order_id", reportingWork.get("newOrderId"))
                        .eq("order_number", reportingWork.get("newOrderNumber"))
        );
        if (newOrder == null){
            result.put("msg","新订单不存在");
            result.put("data",false);
            return result;
        }
        if(newOrderDetail == null){
            result.put("msg","新订单次序号不存在");
            result.put("data",false);
            return result;
        }
        if(Objects.equals(oldOrder.getOrderId(), newOrder.getOrderId())){
            result.put("msg","新旧订单号一致");
            result.put("data",false);
            return result;
        }

        if(!Objects.equals(oldOrder.getCustomerId(), newOrder.getCustomerId())){
            return "新旧订单客户不一致";
            result.put("msg","新旧订单客户不一致");
            result.put("data",false);
            return result;
        }
        if(!Objects.equals(oldOrderDetail.getProductId(), newOrderDetail.getProductId())){
            return "新旧订单产品不一致";
            result.put("msg","新旧订单产品不一致");
            result.put("data",false);
            return result;
        }
        if (!Objects.equals(oldOrderDetail.getWidth(), newOrderDetail.getWidth())
                || !Objects.equals(oldOrderDetail.getHeight(), newOrderDetail.getHeight())){
            return "新旧订单尺寸不一致";
            result.put("msg","新旧订单尺寸不一致");
            result.put("data",false);
            return result;
        }


@@ -861,7 +908,9 @@
                        .eq("order_number", reportingWork.get("oldOrderNumber"))
                );
        if(oldOrderProcessDetailList.isEmpty()){
            return "旧订单未分流程卡";
            result.put("msg","旧订单未分流程卡");
            result.put("data",false);
            return result;
        }
        //获取新订单是否流程卡是否存在
        List<OrderProcessDetail> newOrderProcessDetailList = orderProcessDetailMapper
@@ -870,7 +919,9 @@
                        .eq("order_number", reportingWork.get("newOrderNumber"))
                );
        if(newOrderProcessDetailList.isEmpty()){
            return "新订单未分流程卡";
            result.put("msg","新订单未分流程卡");
            result.put("data",false);
            return result;
        }
        //新订单是否存在已经排版序号
        List<FlowCard> newFlowCardLayoutStatus = flowCardMapper.selectList(new QueryWrapper<FlowCard>()
@@ -879,7 +930,9 @@
                .gt("layout_status",0)
        );
        if(!newFlowCardLayoutStatus.isEmpty()){
            return "新订单此序号存在排版";
            result.put("msg","新订单此序号存在排版");
            result.put("data",false);
            return result;
        }
        //获取旧订单报工数据汇总
        List<OrderProcessDetail> oldOrderProcessDetailForReport = orderProcessDetailMapper
@@ -1015,9 +1068,12 @@
                String.class);

        if(response.getStatusCode() == HttpStatus.OK){
            return true;
            result.put("data",true);
            return result;
        }else{
            return "连接mes响应超时";
            result.put("msg","连接mes响应超时");
            result.put("data",false);
            return result;
        }
        
    }