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

guoyuji

2024-07-18 09897d2adec822b398c652bc3b8e6b6cfd6a6b2b

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

@@ -5,14 +5,12 @@
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
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.entity.sd.Order;
import com.example.erp.entity.sd.OrderDetail;
import com.example.erp.entity.sd.OrderProcessDetail;
import com.example.erp.exception.ServiceException;
import com.example.erp.mapper.pp.*;
@@ -20,7 +18,6 @@
import com.example.erp.mapper.sd.OrderMapper;
import com.example.erp.mapper.sd.OrderProcessDetailMapper;
import com.example.erp.service.sd.OrderProcessDetailService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

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



@@ -102,6 +99,9 @@
            }
        }

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

        //设备下拉框
        map.put("device", reportingWorkMapper.SelectWorkBasicDeviceMp(process));
        //班组下拉框
@@ -112,6 +112,8 @@

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

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

        //判断本工序是不是第一道工序
        if (interceptProcess.equals(process)) {
@@ -191,18 +193,25 @@
                    damageDetail.setOrderNumber(reportingWorkDetail.getOrderNumber());
                    damageDetail.setProcessId(reportingWork.getProcessId());
                    damageDetail.setTechnologyNumber(reportingWorkDetail.getTechnologyNumber());
                    if (damageDetail.getResponsibleProcess() != reportingWork.getThisProcess()) {
                    if (!damageDetail.getResponsibleProcess().equals(reportingWork.getThisProcess())) {
                        damageDetail.setQualityInsStatus(1);
                    }
                    damageDetailsMapper.insert(damageDetail);
                });
            }
            //查询流程卡工艺流程
            String technologicalProcess = reportingWorkMapper.SelectTechnologicalProcess(reportingWork.getProcessId());
            String technologicalProcess = reportingWorkMapper.SelectTechnologicalProcess(reportingWork.getProcessId(), reportingWorkDetail.getTechnologyNumber());

            int index = technologicalProcess.indexOf("-");
            //获取工艺流程第一个工序
            String interceptProcess = technologicalProcess.substring(0, index);
            String interceptProcess = "";
            if (index <0){
                 interceptProcess = technologicalProcess;
            }
            else {
                //获取工艺流程第一个工序
                 interceptProcess = technologicalProcess.substring(0, index);
            }


            //判断当前工序是否为第一道工序工序，使用流程卡表数量或者小片流程表上工序数量
            int processNum = 0;
@@ -278,8 +287,12 @@
    public boolean ReviewReportingWorkSv(Map<String, String> reportingWork) {

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

        LambdaUpdateWrapper
if (thisProcess.equals("夹胶") || thisProcess.equals("中空") || thisProcess.equals("仓储")){
    LambdaUpdateWrapper
                <ReportingWork> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper
                .eq(ReportingWork::getProcessId, processId.substring(0, 14))
@@ -287,8 +300,10 @@
                .eq(ReportingWork::getReviewedState, 0)
                .setSql("reviewed_state =1");
        reportingWorkMapper.update(null, updateWrapper);
}else {
    reportingWorkMapper.ReviewReportingWorkMp(processId.substring(0, 14),reportingWork.get("process"),result);


}
        return true;
    }

@@ -303,6 +318,8 @@
                        .eq(Order::getOrderId, reportingWork.getOrderId())));
        reportingWork.setFlowCard(new FlowCard());



        List<Map<String, Object>> reportingWorkDetails = reportingWorkMapper.selectByReportingWorkId(reportingWorkId, reportingWork.getNextProcess());
        reportingWorkDetails.forEach(reportingWorkDetail -> {
            List<DamageDetails> damageDetailsList = new ArrayList<>();
@@ -312,14 +329,16 @@
                    .eq(DamageDetails::getTechnologyNumber, reportingWorkDetail.get("technology_number"))
            );
            reportingWorkDetail.put("damageDetails", damageDetailsList);
        });

        });

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

        return map;

@@ -432,27 +451,47 @@
            Integer count = reportingWorkMapper.selectCountByProcessId(processId, nextProcess);
            //获取最后一道工序
            String lastProcess = reportingWorkMapper.selectLastProcess(processId);
            //判断是否是入库工序
            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 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) {
                            //查询当前报工编号完工次破数量的数据
                            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);
                            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);
                        }
@@ -463,23 +502,10 @@
                        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);
                    return true;
                } else {
                    return false;
                }
            }

            else {
                return false;
            }

        } else {
            return false;
@@ -517,4 +543,9 @@

        return map;
    }

    public String getPatchConditionSv(String reportingWorkId) {
        String count=reportingWorkMapper.getPatchConditionMp(reportingWorkId);
        return count;
    }
}