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

guoyuji

2024-08-28 412392f2fe6317d0b7fef67e566aac6d5ce7dd48

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

@@ -22,9 +22,9 @@
import com.example.erp.mapper.userInfo.LogMapper;
import com.example.erp.service.sd.OrderProcessDetailService;
import com.example.erp.service.userInfo.LogService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
@@ -74,98 +74,100 @@
        this.orderGlassDetailMapper = orderGlassDetailMapper;
    }

    public Map<String, Object> AddSelectLastWorkSv(String processIdStr, String technologyStr, String process) {
    public Map<String, Object> AddSelectLastWorkSv(String processIdStr, String technologyStr, String process, String reportType) {
        Map<String, Object> map = new HashMap<>();
        //查询流程卡工艺流程
        String technologicalProcess = reportingWorkMapper.SelectTechnologicalProcess(processIdStr,technologyStr);

        if (technologicalProcess!=null || !technologicalProcess.equals("")){
            String[] processList = technologicalProcess.split("->");
            //获取工艺流程第一个工序
            String interceptProcess = processList[0];
            int length = processList.length;

            //定义当前工序上下工序
            String previousProcess = "";
            String nextProcess = "";

        String[] processList = technologicalProcess.split("->");
        //获取工艺流程第一个工序
        String interceptProcess = processList[0];
        int length = processList.length;

        //定义当前工序上下工序
        String previousProcess = "";
        String nextProcess = "";

        //循环该流程卡工艺流程
        for (int i = 0; i < length; i++) {
            //当到当前工序时
            if (processList[i].equals(process)) {
                //获取当前工序的上一道工序
                if (i - 1 < 0) {
                    previousProcess = "";
                } else {
                    previousProcess = processList[i - 1];
                }
                //获取当前工序的下一道工序
                if (i + 1 > length - 1) {
                    nextProcess = "";
                } else {
                    nextProcess = processList[i + 1];
                }
                //查询当前工序的表头数据
                map.put("data", reportingWorkMapper.AddSelectLastWorkMp(processIdStr, technologyStr, previousProcess, nextProcess, process));
                map.put("thisProcess", processList);
                break;
            }
        }

        //工艺流程
        map.put("technologicalProcess", technologicalProcess);

        //设备下拉框
        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));

        //判断本工序是不是第一道工序
        if (interceptProcess.equals(process)) {
            //是第一道工序，查询流程卡数据
            map.put("Detail", reportingWorkMapper.SelectTechnologicalNumMp(processIdStr, technologyStr, process));
        } else {
            //不是第一道工序，查询报工数据
            List<Map<String,String>>  details = reportingWorkMapper.SelectReworlDetailMp(processIdStr, technologyStr, process);
            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("id")));
                    if(listGlassId  !=glassId){
                        detail.put("rowClass","latter");
            //循环该流程卡工艺流程
            for (int i = 0; i < length; i++) {
                //当到当前工序时
                if (processList[i].equals(process)) {
                    //获取当前工序的上一道工序
                    if (i - 1 < 0) {
                        previousProcess = "";
                    } else {
                        previousProcess = processList[i - 1];
                    }
                });
                    //获取当前工序的下一道工序
                    if (i + 1 > length - 1) {
                        nextProcess = "";
                    } else {
                        nextProcess = processList[i + 1];
                    }
                    //查询当前工序的表头数据
                    map.put("data", reportingWorkMapper.AddSelectLastWorkMp(processIdStr, technologyStr, previousProcess, nextProcess, process,reportType));
                    map.put("thisProcess", processList);
                    break;
                }
            }

            //工艺流程
            map.put("technologicalProcess", technologicalProcess);

            map.put("Detail",details );
            //设备下拉框
            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));

            //判断本工序是不是第一道工序
            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");
                        }
                    });
                }


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

            // 第一道工序（流程卡数+补片数量-完工数-次破数-返工未完成数-禁用数量）

            // 后续工序（上工序报工数-完工数-次破数-返工未完成数）

            //获取该流程卡号历史报工工序
            String historyProcess = reportingWorkMapper.historyProcessMp(processIdStr);
            //历史报工工序设备
            map.put("historyDevice", reportingWorkMapper.historyDeviceMp(historyProcess, process));
            //历史报工工序班组
            map.put("historyTeams", reportingWorkMapper.historyTeamsMp(processIdStr, process));
            //历史工序
            map.put("historyProcess", reportingWorkMapper.SelectHistoryProcessMp(historyProcess, process));
        }

        // 第一道工序（流程卡数+补片数量-完工数-次破数-返工未完成数-禁用数量）

        // 后续工序（上工序报工数-完工数-次破数-返工未完成数）

        //获取该流程卡号历史报工工序
        String historyProcess = reportingWorkMapper.historyProcessMp(processIdStr);
        //历史报工工序设备
        map.put("historyDevice", reportingWorkMapper.historyDeviceMp(historyProcess, process));
        //历史报工工序班组
        map.put("historyTeams", reportingWorkMapper.historyTeamsMp(processIdStr, process));
        //历史工序
        map.put("historyProcess", reportingWorkMapper.SelectHistoryProcessMp(historyProcess, process));
        return map;
    }

@@ -213,7 +215,7 @@
//            reportingWork.setThisWornQuantity(
//                    reportingWork.getThisWornQuantity()+reportingWorkDetail.getBreakageQuantity());


            int qualityInsStatus = (int) reportingWorkJson.get("qualityInsStatus");
            reportingWorkDetail.setReportingWorkId(reportingWorkId);
            List<DamageDetails> damageDetails = reportingWorkDetail.getDamageDetails();
            //次破明细表插入数据
@@ -223,7 +225,8 @@
                    damageDetail.setOrderNumber(reportingWorkDetail.getOrderNumber());
                    damageDetail.setProcessId(reportingWork.getProcessId());
                    damageDetail.setTechnologyNumber(reportingWorkDetail.getTechnologyNumber());
                    if (!damageDetail.getResponsibleProcess().equals(reportingWork.getThisProcess())) {
                    //跨工序次破修改质检状态
                    if (!damageDetail.getResponsibleProcess().equals(reportingWork.getThisProcess()) && qualityInsStatus==2) {
                        damageDetail.setQualityInsStatus(1);
                    }
                    damageDetailsMapper.insert(damageDetail);
@@ -327,8 +330,9 @@
        String thisProcess = reportingWork.get("thisProcess");
        int index = processId.lastIndexOf("/") + 1;
        String result = processId.substring(index);
        String technologyStr = reportingWork.get("technologyStr");

if (thisProcess.equals("夹胶") || thisProcess.equals("中空") || thisProcess.equals("仓储")){
if (thisProcess.equals("夹胶") || thisProcess.equals("中空") || thisProcess.equals("包装")){
    LambdaUpdateWrapper
                <ReportingWork> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper
@@ -338,7 +342,7 @@
                .setSql("reviewed_state =1");
        reportingWorkMapper.update(null, updateWrapper);
}else {
    reportingWorkMapper.ReviewReportingWorkMp(processId.substring(0, 14),reportingWork.get("process"),result);
    reportingWorkMapper.ReviewReportingWorkMp(processId.substring(0, 14),reportingWork.get("process"),technologyStr);

}
        return true;
@@ -449,7 +453,7 @@
            //修改包装时修改库存数量
            if (reportingWork.getNextProcess()==null || reportingWork.getNextProcess().isEmpty()){
                //获取该报工修改后的可入库数量
                Integer  inventory = reportingWorkDetailMapper.selectInventory(reportingWork.getProcessId(),Integer.parseInt(reportingWorkDetail.getOrderNumber()),Integer.parseInt(reportingWorkDetail.getTechnologyNumber()));
                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);
            }
@@ -608,4 +612,67 @@
        String count=reportingWorkMapper.getPatchConditionMp(reportingWorkId);
        return count;
    }
    @Transactional(rollbackFor = Exception.class)
    public Boolean mesReportingWorkSv(Map<String,Object> reportingWorkMap) {
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();

        //接收解析主附表信息
        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())) {
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            throw new ServiceException(Constants.Code_600, "上工序已完工数量小于本工序报工数量，请检查");
        }


        //获取当前最大报工单号生成报工单号
        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;
    }
}