标签不显示标题问题

guoyujie

13 小时以前 91b61fe723df498d62c596372521d426299f0f8b

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

@@ -4,67 +4,75 @@
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
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.dto.pp.OrderNumberTransferDTO;
import com.example.erp.entity.pp.*;
import com.example.erp.entity.sd.BasicData;
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.mm.FinishedOperateLogMapper;
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.sd.*;
import com.example.erp.mapper.userInfo.LogMapper;
import com.example.erp.service.sd.OrderProcessDetailService;
import com.example.erp.service.userInfo.LogService;
import com.example.erp.service.userInfo.SysErrorService;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import lombok.RequiredArgsConstructor;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpMethod;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;
import org.springframework.web.client.RestTemplate;

import java.text.SimpleDateFormat;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.LocalTime;
import java.time.format.DateTimeFormatter;
import java.util.*;

@Service
@DS("pp")
@RequiredArgsConstructor
public class ReportingWorkService {
    final
    ReportingWorkMapper reportingWorkMapper;
    final
    BasicDateProduceMapper basicDateProduceMapper;
    final
    DamageDetailsMapper damageDetailsMapper;
    final
    OrderProcessDetailMapper orderProcessDetailMapper;
    final
    ReportingWorkDetailMapper
            reportingWorkDetailMapper;
    final OrderMapper
            orderMapper;
    private final ReportingWorkTransferMapper reportingWorkTransferMapper;
    private final ReportingWorkMapper reportingWorkMapper;
    private final BasicDateProduceMapper basicDateProduceMapper;
    private final DamageDetailsMapper damageDetailsMapper;
    private final OrderProcessDetailMapper orderProcessDetailMapper;
    private final ReportingWorkDetailMapper reportingWorkDetailMapper;
    private final OrderMapper  orderMapper;
    private final OrderDetailMapper orderDetailMapper;

    final
    FlowCardMapper flowCardMapper;
    private final FlowCardMapper flowCardMapper;

    final
    OrderProcessDetailService orderProcessDetailService;
    private final OrderProcessDetailService orderProcessDetailService;

    final
    LogService logService;
    private final LogService logService;

    final LogMapper logMapper;
    private final LogMapper logMapper;
    private final OrderGlassDetailMapper orderGlassDetailMapper;
    private final SysErrorService sysErrorService;
    private final FinishedOperateLogMapper finishedOperateLogMapper;
    private final RestTemplate restTemplate;
    private final PatchLogMapper patchLogMapper;
    private final ReworkMapper reworkMapper;
    private final BasicDateMapper basicDataMapper;


    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) {
    /*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, OrderDetailMapper orderDetailMapper, FinishedOperateLogMapper finishedOperateLogMapper, ReportingWorkTransferMapper reportingWorkTransferMapper) {
        this.reportingWorkMapper = reportingWorkMapper;
        this.basicDateProduceMapper = basicDateProduceMapper;
        this.damageDetailsMapper = damageDetailsMapper;
@@ -77,7 +85,10 @@
        this.logMapper = logMapper;
        this.orderGlassDetailMapper = orderGlassDetailMapper;
        this.sysErrorService = sysErrorService;
    }
        this.orderDetailMapper = orderDetailMapper;
        this.finishedOperateLogMapper = finishedOperateLogMapper;
        this.reportingWorkTransferMapper = reportingWorkTransferMapper;
    }*/

    public Map<String, Object> AddSelectLastWorkSv(String processIdStr, String technologyStr, String process, String reportType) {
        Map<String, Object> map = new HashMap<>();
@@ -145,7 +156,7 @@
                if (retrievedData!=null){
                    Integer reviewedState = retrievedData.getReviewedState();
                    //根据审核状态查询未审核数据
                    if (reviewedState==1){//已审核
                   // if (reviewedState==1){//已审核
                        //不是第一道工序，查询报工数据
                        List<Map<String,String>>  details = reportingWorkMapper.SelectReworlDetailMp(processIdStr, technologyStr, process,previousProcess,laminating);
                        if(process.equals("中空")){
@@ -163,24 +174,24 @@
                            });
                        }
                        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 );
                    }
//                    }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 );
//                    }
                }
            }

@@ -196,6 +207,8 @@
            map.put("historyTeams", reportingWorkMapper.historyTeamsMp(processIdStr, process));
            //历史工序
            map.put("historyProcess", reportingWorkMapper.SelectHistoryProcessMp(historyProcess, process));
            //是否合片工序
            map.put("laminating", laminating);
        }
        return map;
    }
@@ -204,6 +217,8 @@
    public Map<String, Object> SelectProcessSv(String userId) {
        Map<String, Object> map = new HashMap<>();
        String process = reportingWorkMapper.selectUserProcess(userId);
        //工序列表
        List<Map<String, Object>> processNameList = flowCardMapper.getProcessNameList();
        if (process==null) {
            map.put("process", reportingWorkMapper.SelectProcessMp());
        }
@@ -216,7 +231,7 @@
                map.put("process",reportingWorkMapper.getSelectProcessDuoqu() );
            }
        }

        map.put("processNameList", processNameList);
        return map;
    }

@@ -257,7 +272,8 @@
        reportingWorkMapper.insert(reportingWork);
        //副表循环插入，并且插入次破信息表。再根据次破信息修改订单玻璃流程表的完工数量与刺破数量
        reportingWorkDetails.forEach(reportingWorkDetail -> {

            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();
@@ -362,6 +378,8 @@


        });
        reportingWorkMapper.update(reportingWork, new LambdaUpdateWrapper<ReportingWork>()
                .eq(ReportingWork::getId, reportingWork.getId()));

        //保存日志
        Log log = new Log();
@@ -383,8 +401,11 @@
        String result = processId.substring(index);
        String technologyStr = reportingWork.get("technologyStr");
        String[] processIdStr = processId.split("/");
        String nowDate = LocalDate.now().toString();
        //获取报工工序是否为复合工程
        String laminating = reportingWorkMapper.getProcessLaminating(thisProcess);
//合片工序
if (thisProcess.equals("夹胶") || thisProcess.equals("中空") || thisProcess.equals("包装")){
if (laminating.indexOf("step")!=-1){
    LambdaUpdateWrapper
                <ReportingWork> updateWrapper = new LambdaUpdateWrapper<>();
        updateWrapper
@@ -392,7 +413,8 @@
                .eq(ReportingWork::getThisProcess, reportingWork.get("process"))
                .eq(ReportingWork::getReviewedState, 0)
                .setSql("reviewed_state =1")
                .set(ReportingWork::getReviewed, userName);
                .set(ReportingWork::getReviewed, userName)
                .set(ReportingWork::getExamineTime, nowDate);
        reportingWorkMapper.update(null, updateWrapper);
}else {
    reportingWorkMapper.ReviewReportingWorkMp(processIdStr[0],reportingWork.get("process"),technologyStr,userName);
@@ -473,73 +495,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;
    }

    //报工管理查询
@@ -550,8 +578,8 @@
        }
        Map<String, Object> map = new HashMap<>();
        map.put("data", reportingWorkMapper.selectReportingWorkMp(offset, pageSize, selectTime1, selectTime2, orderId, reportingWork));
        map.put("total", reportingWorkMapper.getPageTotal(offset, pageSize, selectTime1, selectTime2, orderId, reportingWork));
        map.put("footSum" ,reportingWorkMapper.getFootSum(selectTime1, selectTime2, orderId,reportingWork));
       // map.put("total", reportingWorkMapper.getPageTotal(offset, pageSize, selectTime1, selectTime2, orderId, reportingWork));
        map.put("total" ,reportingWorkMapper.getFootSum(offset, pageSize, selectTime1, selectTime2, orderId, reportingWork));
        return map;
    }

@@ -566,38 +594,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);
@@ -606,35 +661,13 @@
                            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;
        }
@@ -650,6 +683,12 @@
        map.put("data", reportingWorkMapper.selectQualityTestingMp(offset, pageSize, selectTime1, selectTime2, state, processId, reportingWork));
        map.put("total", reportingWorkMapper.getQualityPageTotal(offset, pageSize, selectTime1, selectTime2, state, processId, reportingWork));

        return map;
    }

    public Map<String, Object>  qualityReviewSearchSv() {
        Map<String, Object> map = new HashMap<>();
        map.put("data", reportingWorkMapper.qualityReviewSearchMp());
        return map;
    }

@@ -814,4 +853,351 @@

        }
    }

    @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(
                new QueryWrapper<OrderDetail>()
                        .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())){
            result.put("msg","新旧订单客户不一致");
            result.put("data",false);
            return result;
        }
        if(!Objects.equals(oldOrderDetail.getProductId(), newOrderDetail.getProductId())){
            result.put("msg","新旧订单产品不一致");
            result.put("data",false);
            return result;
        }
        if (!Objects.equals(oldOrderDetail.getWidth(), newOrderDetail.getWidth())
                || !Objects.equals(oldOrderDetail.getHeight(), newOrderDetail.getHeight())){
            result.put("msg","新旧订单尺寸不一致");
            result.put("data",false);
            return result;
        }


        //获取旧订单是否流程卡是否存在
        List<OrderProcessDetail> oldOrderProcessDetailList = orderProcessDetailMapper
                .selectList(new QueryWrapper<OrderProcessDetail>()
                        .eq("order_id", reportingWork.get("oldOrderId"))
                        .eq("order_number", reportingWork.get("oldOrderNumber"))
                );
        if(oldOrderProcessDetailList.isEmpty()){
            result.put("msg","旧订单未分流程卡");
            result.put("data",false);
            return result;
        }
        //获取新订单是否流程卡是否存在
        List<OrderProcessDetail> newOrderProcessDetailList = orderProcessDetailMapper
                .selectList(new QueryWrapper<OrderProcessDetail>()
                        .eq("order_id", reportingWork.get("newOrderId"))
                        .eq("order_number", reportingWork.get("newOrderNumber"))
                );
        if(newOrderProcessDetailList.isEmpty()){
            result.put("msg","新订单未分流程卡");
            result.put("data",false);
            return result;
        }
        //新订单是否存在已经排版序号
        List<FlowCard> newFlowCardLayoutStatus = flowCardMapper.selectList(new QueryWrapper<FlowCard>()
                .eq("order_id", reportingWork.get("newOrderId"))
                .eq("order_number", reportingWork.get("newOrderNumber"))
                .gt("layout_status",0)
        );
        if(!newFlowCardLayoutStatus.isEmpty()){
            result.put("msg","新订单此序号存在排版");
            result.put("data",false);
            return result;
        }
        List<ReportingWorkTransfer> reportingWorkTransferList = reportingWorkTransferMapper
                .selectList(new QueryWrapper<ReportingWorkTransfer>()
                        .eq("old_order", reportingWork.get("newOrderId"))
                        .eq("old_order_number", reportingWork.get("newOrderNumber"))
                );
        if(!reportingWorkTransferList.isEmpty()){
            result.put("msg","新订单序号之前已转出报工数据，无法进行转入");
            result.put("data",false);
            return result;
        }

        //获取旧订单报工数据汇总
        List<OrderProcessDetail> oldOrderProcessDetailForReport = orderProcessDetailMapper
                .selectList(new QueryWrapper<OrderProcessDetail>()
                        .eq( "order_id", reportingWork.get("oldOrderId"))
                        .eq("order_number", reportingWork.get("oldOrderNumber"))
                        .gt("reporting_work_num",0)
        );

        if (oldOrderProcessDetailForReport.isEmpty()){
            result.put("msg","旧订单没有可转出的报工数据");
            result.put("data",false);
            return result;
        }
        List<String> oldOrderProcessIdList = new ArrayList<>();
        oldOrderProcessDetailList.forEach(oldOrderProcessDetail -> oldOrderProcessIdList.add(oldOrderProcessDetail.getProcessId()));

        //获取旧数据破损表是否存在破损
        List<DamageDetails> damageDetails = damageDetailsMapper.selectList(
                new QueryWrapper<DamageDetails>()
                        .in("process_id",oldOrderProcessIdList)
                        .eq("order_number", reportingWork.get("oldOrderNumber"))
                        .eq("quantity",0)
        );
        if(!damageDetails.isEmpty()){
            result.put("msg","旧订单存在报工未处理破损数据");
            result.put("data",false);
            return result;
        }
        //获取补片表是否存在补片未审核状态
        List<PatchLog> patchLogs = patchLogMapper.selectList(
                new QueryWrapper<PatchLog>()
                        .eq("order_id", reportingWork.get("oldOrderId"))
                        .eq("order_sort", reportingWork.get("oldOrderNumber"))
                        .eq("review_status",0)
        );
        if (patchLogs.isEmpty()){
            result.put("msg","旧订单存在补片未审核数据");
            result.put("data",false);
            return result;
        }
        List<Rework> reworks = reworkMapper.selectList(
                new QueryWrapper<Rework>()
                    .eq("order_id", reportingWork.get("oldOrderId"))
                    .eq("order_sort", reportingWork.get("oldOrderNumber"))
                    .eq("review_status",0)
        );
        if (patchLogs.isEmpty()){
            result.put("msg","旧订单存在返工未审核数据，请先审核报工后再进行转出");
            result.put("data",false);
            return result;
        }


        Map<String,Object> log = new HashMap<>();
        log.put("oldOrderBeforeChange",oldOrderProcessDetailForReport);

        Map<String,Object> newOrderLog = new HashMap<>();
        newOrderLog.put("newOrderBeforeChange",newOrderProcessDetailList);

        //传给mes流程卡数量集合
        List<OrderNumberTransferDTO> orderNumberTransferList = new ArrayList<>();

        oldOrderProcessDetailForReport.forEach(oldOrderProcessDetail -> {
            //修改报工状态为3
            reportingWorkMapper.update(null,new UpdateWrapper<ReportingWork>()
                    .set("reviewed_state",3)
                    .eq("process_id",oldOrderProcessDetail.getProcessId())
                    .gt("reviewed_state",0)
            );


            int maxNum = 0;
            for(OrderProcessDetail newOrderProcessDetail : newOrderProcessDetailList){
                if(oldOrderProcessDetail.getReportingWorkNum() == 0){
                    break;
                }
                //判断小片是否一致，工序是否一致
                if(newOrderProcessDetail.getProcess().equals(oldOrderProcessDetail.getProcess()) &&
                        Objects.equals(newOrderProcessDetail.getTechnologyNumber(), oldOrderProcessDetail.getTechnologyNumber())){
                    //判断是否为第一道工序，给可转移最大值赋值
                    if(oldOrderProcessDetail.getProcess().equals("切割")){
                        FlowCard  thisFlowCard = flowCardMapper.selectOne(new QueryWrapper<FlowCard>()
                                .eq("process_id", newOrderProcessDetail.getProcessId())
                                .eq("order_number", newOrderProcessDetail.getOrderNumber())
                                .eq("technology_number",newOrderProcessDetail.getTechnologyNumber())
                        );
                        maxNum = thisFlowCard.getQuantity()+thisFlowCard.getExportNumber()
                                -thisFlowCard.getImportNumber();
                    }else{
                        //当不是第一道工序则，拿上一道工序减去当前工序作为最大值
                        maxNum = orderProcessDetailMapper.selectById(newOrderProcessDetail.getId()-1).getReportingWorkNum()
                        -orderProcessDetailMapper.selectById(newOrderProcessDetail.getId()).getReportingWorkNum()
                        ;
                    }
                    //判断被转移的数量是否大于可转移的数量最大值
                    int transferNum = 0;
                    if(oldOrderProcessDetail.getReportingWorkNum() > maxNum){
                        transferNum = maxNum;
                        oldOrderProcessDetail.setReportingWorkNum(oldOrderProcessDetail.getReportingWorkNum()-maxNum);
                        oldOrderProcessDetail.setReportingWorkNumCount(oldOrderProcessDetail.getReportingWorkNumCount()-maxNum);
                    }else{
                        transferNum = oldOrderProcessDetail.getReportingWorkNum();
                        oldOrderProcessDetail.setReportingWorkNum(0);
                        oldOrderProcessDetail.setReportingWorkNumCount(0);
                    }
                    //更新旧订单小片流程表的报工数量
                    orderProcessDetailMapper.update(null,new UpdateWrapper<OrderProcessDetail>()
                            .set("reporting_work_num",oldOrderProcessDetail.getReportingWorkNum())
                            .set("reporting_work_num_count",oldOrderProcessDetail.getReportingWorkNumCount())
                            .eq("id",oldOrderProcessDetail.getId())
                    );
                    //更新新订单小片流程表的报工数量
                    orderProcessDetailMapper.update(null,new UpdateWrapper<OrderProcessDetail>()
                            .set("reporting_work_num",transferNum)
                            .set("reporting_work_num_count",transferNum)
                            .eq("id",newOrderProcessDetail.getId())
                    );
                    if(oldOrderProcessDetail.getProcess().equals("切割")){
                        //更新旧订单流程卡转出数量
                        flowCardMapper.update(null,new UpdateWrapper<FlowCard>()
                                .setSql("export_number = export_number + "+transferNum)
                                .eq("process_id", oldOrderProcessDetail.getProcessId())
                                .eq("order_number", oldOrderProcessDetail.getOrderNumber())
                                .eq("technology_number",oldOrderProcessDetail.getTechnologyNumber())
                        );
                        //更新新订单流程卡转出数量
                        flowCardMapper.update(null,new UpdateWrapper<FlowCard>()
                                .setSql("import_number = import_number + "+transferNum)
                                .eq("process_id", newOrderProcessDetail.getProcessId())
                                .eq("order_number", newOrderProcessDetail.getOrderNumber())
                                .eq("technology_number",newOrderProcessDetail.getTechnologyNumber())
                        );

                        //传给mes数据赋值
                        OrderNumberTransferDTO orderNumberTransfer = new OrderNumberTransferDTO();
                        orderNumberTransfer.setChangeNumber(transferNum);
                        orderNumberTransfer.setOldProcessId(oldOrderProcessDetail.getProcessId());
                        orderNumberTransfer.setNewProcessId(newOrderProcessDetail.getProcessId());
                        orderNumberTransfer.setOldOrderNumber(oldOrderProcessDetail.getOrderNumber());
                        orderNumberTransfer.setNewOrderNumber(newOrderProcessDetail.getOrderNumber());
                        orderNumberTransfer.setOldTechnologyNumber(oldOrderProcessDetail.getTechnologyNumber());
                        orderNumberTransfer.setNewTechnologyNumber(newOrderProcessDetail.getTechnologyNumber());
                        orderNumberTransferList.add(orderNumberTransfer);

                    }
                }
            }
        });


        //把旧订单数据和新订单数据传到日志表当中
        log.put("oldOrderChange",JSON.toJSONString(oldOrderProcessDetailForReport));

        newOrderLog.put("newOrderChange",orderProcessDetailMapper
                .selectList(new QueryWrapper<OrderProcessDetail>()
                        .eq("order_id", reportingWork.get("newOrderId"))
                        .eq("order_number", reportingWork.get("newOrderNumber"))
                ));
        //旧订单信息传入日志
        ReportingWorkTransfer reportingWorkTransfer = new ReportingWorkTransfer();
        reportingWorkTransfer.setOldOrder(reportingWork.get("oldOrderId"));
        reportingWorkTransfer.setOldOrderNumber(Integer.valueOf(reportingWork.get("oldOrderNumber")));
        reportingWorkTransfer.setOldReportContent(JSON.toJSONString(log));

        //新订单信息传入日志
        reportingWorkTransfer.setNewOrder(reportingWork.get("newOrderId"));
        reportingWorkTransfer.setNewOrderNumber(Integer.valueOf(reportingWork.get("newOrderNumber")));
        reportingWorkTransfer.setNewReportContent(JSON.toJSONString(newOrderLog));
        reportingWorkTransferMapper.insert(reportingWorkTransfer);
        //restTemplate.postForObject("http://localhost:8086/order/test",orderNumberTransferList,String.class);

        //向mes发送http请求
        ResponseEntity<OrderNumberTransferDTO> response =restTemplate.exchange(
                "http://localhost:88/api/loadGlass/order/order/orderChange",
                HttpMethod.POST,
                new HttpEntity<>(orderNumberTransferList),
                OrderNumberTransferDTO.class);

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

    }

    public Map<String, Object> selectShiftQuantitySv(Map<String, Object> reportingWork) {
        String  creatorId = (String) reportingWork.get("userId");
        List<LocalDateTime> dateList = (List<LocalDateTime>) reportingWork.get("searchDate");
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
        String startDate = LocalDateTime.now().with(LocalTime.MIN).format(formatter);
        String endDate = LocalDateTime.now().format(formatter);
        if (dateList.get(0)!=null){
            startDate = String.valueOf(dateList.get(0));
        }
        if (dateList.get(1)!=null){
            endDate = String.valueOf(dateList.get(1));
        }
        List<String> date = new ArrayList<>();
        date.add(startDate);
        date.add(endDate);
        Map<String, Object> result = new HashMap<>();
        BasicData basicData = basicDataMapper
                .selectOne(new QueryWrapper<BasicData>().eq("basic_name", reportingWork.get("process")));
        result.put("data",orderProcessDetailMapper.selectShiftQuantitySv(creatorId, startDate, endDate,basicData.getNickname()));
        result.put("date",date);
        return result;
    }

    public Map<String, Object> selectReportingWorkRecordByPhoneSv(Map<String,Object> reportingWork) {
        List<LocalDateTime> dateList = (List<LocalDateTime>) reportingWork.get("searchDate");
        String startDate = LocalDate.now().minusDays(14).toString();
        String endDate = LocalDate.now().toString();
        if (dateList.get(0)!=null){
            startDate = String.valueOf(dateList.get(0));
        }
        if (dateList.get(1)!=null){
            endDate = String.valueOf(dateList.get(1));
        }
        List<String> date = new ArrayList<>();
        date.add(startDate);
        date.add(endDate);
        Map<String, Object> result = new HashMap<>();
        result.put("data",reportingWorkMapper.selectList(
                new QueryWrapper<ReportingWork>().nested(
                                reportingWork.get("process")!=null,
                                wrapper-> wrapper.eq("creator_id",reportingWork.get("userId"))//当工序为空时，查询所有报工信息
                        )
                        .gt("reviewed_state",-1)
                        .between("date(reporting_work_time)",startDate,endDate)
                        .orderByDesc("id")));
        result.put("date",date);

         return result;

    }


}