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

@@ -5,24 +5,29 @@
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.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;
import com.example.erp.mapper.sd.OrderGlassDetailMapper;
import com.example.erp.mapper.sd.OrderMapper;
import com.example.erp.mapper.sd.OrderProcessDetailMapper;
import com.example.erp.mapper.userInfo.LogMapper;
import com.example.erp.service.sd.OrderProcessDetailService;
import org.springframework.beans.factory.annotation.Autowired;
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;

import java.text.SimpleDateFormat;
import java.time.LocalDateTime;
@@ -51,8 +56,15 @@
    final
    OrderProcessDetailService orderProcessDetailService;

    final
    LogService logService;

    public ReportingWorkService(ReportingWorkMapper reportingWorkMapper, BasicDateProduceMapper basicDateProduceMapper, DamageDetailsMapper damageDetailsMapper, ReportingWorkDetailMapper reportingWorkDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, OrderProcessDetailService orderProcessDetailService, OrderMapper orderMapper, FlowCardMapper flowCardMapper) {
    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, SysErrorService sysErrorService) {
        this.reportingWorkMapper = reportingWorkMapper;
        this.basicDateProduceMapper = basicDateProduceMapper;
        this.damageDetailsMapper = damageDetailsMapper;
@@ -61,86 +73,150 @@
        this.orderProcessDetailService = orderProcessDetailService;
        this.orderMapper = orderMapper;
        this.flowCardMapper = flowCardMapper;
        this.logService = logService;
        this.logMapper = logMapper;
        this.orderGlassDetailMapper = orderGlassDetailMapper;
        this.sysErrorService = sysErrorService;
    }

    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 laminating = reportingWorkMapper.getProcessLaminating(process);
        //查询流程卡工艺流程
        String technologicalProcess = reportingWorkMapper.SelectTechnologicalProcess(processIdStr);
        String technologicalProcess = reportingWorkMapper.SelectTechnologicalProcess(processIdStr,technologyStr);

        //定义-的位置
        int index = technologicalProcess.indexOf("-");
        //获取工艺流程第一个工序
        String interceptProcess = technologicalProcess.substring(0, index);
        String[] processList = technologicalProcess.split("->");
        int length = processList.length;
        if (technologicalProcess!=null || !technologicalProcess.equals("")){
            String[] processList = technologicalProcess.split("->");
            //获取工艺流程第一个工序
            String interceptProcess = processList[0];
            int length = processList.length;

        //定义当前工序上下工序
        String previousProcess = "";
        String nextProcess = "";
            //定义当前工序上下工序
            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];
            //循环该流程卡工艺流程
            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;
                }
                //获取当前工序的下一道工序
                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(technologyStr,processIdStr));

            //判断本工序是不是第一道工序
            if (interceptProcess.equals(process)) {
                //是第一道工序，查询流程卡数据
                map.put("Detail", reportingWorkMapper.SelectTechnologicalNumMp(processIdStr, technologyStr, process,reportType));
            } else {
                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 );
                    }
                }
            }

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

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

            //获取该流程卡号历史报工工序
            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));
        }

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

        //判断本工序是不是第一道工序
        if (interceptProcess.equals(process)) {
            //是第一道工序，查询流程卡数据
            map.put("Detail", reportingWorkMapper.SelectTechnologicalNumMp(processIdStr, technologyStr, process));
        } else {
            //不是第一道工序，查询报工数据
            map.put("Detail", reportingWorkMapper.SelectReworlDetailMp(processIdStr, technologyStr, 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;
    }

    //查询工序
    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;
    }

@@ -159,29 +235,28 @@
        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);
            List<DamageDetails> damageDetails = reportingWorkDetail.getDamageDetails();
            //次破明细表插入数据
@@ -191,18 +266,26 @@
                    damageDetail.setOrderNumber(reportingWorkDetail.getOrderNumber());
                    damageDetail.setProcessId(reportingWork.getProcessId());
                    damageDetail.setTechnologyNumber(reportingWorkDetail.getTechnologyNumber());
                    if (damageDetail.getResponsibleProcess() != reportingWork.getThisProcess()) {
                    //跨工序次破修改质检状态
                    if (!damageDetail.getResponsibleProcess().equals(reportingWork.getThisProcess()) && qualityInsStatus==2) {
                        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;
@@ -242,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())
@@ -250,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
@@ -271,6 +353,13 @@

        });

        //保存日志
        Log log = new Log();
        log.setContent(reportingWorkMap.toString());
        log.setFunction("saveReportingWork报工新增");
        log.setOperatorId((String) reportingWorkJson.get("userId"));
        log.setOperator((String) reportingWorkJson.get("userName"));
        logService.saveLog(log);
        return true;
    }

@@ -278,17 +367,27 @@
    public boolean ReviewReportingWorkSv(Map<String, String> reportingWork) {

        String processId = reportingWork.get("processId");

        LambdaUpdateWrapper
        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(processIdStr[0],reportingWork.get("process"),technologyStr,userName);


}
        return true;
    }

@@ -303,6 +402,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,15 +413,20 @@
                    .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()));
        map.put("title", "补片状态");
        return map;

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

        //获取该流程卡号历史报工工序
@@ -356,6 +463,7 @@
        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);

        //删除刺破明细表刺破数据
        damageDetailsMapper.delete(
                new LambdaQueryWrapper<DamageDetails>()
@@ -368,14 +476,21 @@
                .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 -> {
                    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")) {
@@ -387,6 +502,14 @@
            }
            //插入报工数据
            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")) {
@@ -397,7 +520,15 @@
        }

        //修改小片流程表数量为报工明细表数量
        orderProcessDetailMapper.updateQuantity(reportingWork.getReportingWorkId(), reportingWork.getThisProcess(), "add");
        //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;
    }

@@ -414,7 +545,7 @@
    }

    //删除报工
    public Boolean deleteWorkSv(String reportingWorkId, String processId, String thisProcess) {
    public Boolean deleteWorkSv(String reportingWorkId, String processId, String thisProcess, String userId, String userName) {
        if (!reportingWorkId.isEmpty() && !processId.isEmpty() && !thisProcess.isEmpty()) {
            //获取当前报工编号下工序
            String nextProcess = reportingWorkMapper.selectNextProcess(reportingWorkId);
@@ -422,54 +553,76 @@
            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);
                            //保存日志
                            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.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.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;
@@ -507,4 +660,122 @@

        return map;
    }

    public String getPatchConditionSv(String reportingWorkId) {
        String count=reportingWorkMapper.getPatchConditionMp(reportingWorkId);
        return count;
    }
    @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)

            );


            //判断报工表是否存在，不存在则新增报工主副表数据，存在则修改副表数据
            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);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e +Arrays.toString(e.getStackTrace()));
            sysError.setFunc("汉玻mes报工");
            sysErrorService.insert(sysError);
            throw new ServiceException(Constants.Code_500, "数据请求异常，请检查");

        }
    }
}