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

guoyujie

2025-07-08 7104751e2f26872d4891d01d42ee88cf19715d01

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

@@ -7,18 +7,16 @@
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.example.erp.common.Constants;
import com.example.erp.entity.pp.FlowCard;
import com.example.erp.entity.sd.OrderDetail;
import com.example.erp.entity.sd.OrderGlassDetail;
import com.example.erp.entity.sd.OrderProcessDetail;
import com.example.erp.entity.sd.*;
import com.example.erp.entity.userInfo.Log;
import com.example.erp.exception.ServiceException;
import com.example.erp.mapper.pp.FlowCardMapper;
import com.example.erp.mapper.sd.OrderGlassDetailMapper;
import com.example.erp.mapper.sd.OrderProcessDetailMapper;
import com.example.erp.mapper.sd.*;
import com.example.erp.service.userInfo.LogService;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.springframework.stereotype.Service;

import java.time.LocalDate;
import java.util.List;
import java.util.Map;

@@ -44,20 +42,43 @@
    OrderProcessDetailMapper orderProcessDetailMapper;
    final
    LogService logService;
    private final ProductMapper productMapper;
    private final ProductDetailMapper productDetailMapper;

    public FlowCardService(FlowCardMapper flowCardMapper, OrderGlassDetailMapper orderGlassDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, LogService logService) {
    private final OrderDetailMapper orderDetailMapper;
    private final OrderMapper orderMapper;

    public FlowCardService(FlowCardMapper flowCardMapper, OrderGlassDetailMapper orderGlassDetailMapper, OrderProcessDetailMapper orderProcessDetailMapper, LogService logService, ProductMapper productMapper, ProductDetailMapper productDetailMapper, OrderDetailMapper orderDetailMapper, OrderMapper orderMapper) {
        this.flowCardMapper = flowCardMapper;
        this.orderGlassDetailMapper = orderGlassDetailMapper;
        this.orderProcessDetailMapper = orderProcessDetailMapper;
        this.logService = logService;
        this.productMapper = productMapper;
        this.productDetailMapper = productDetailMapper;
        this.orderDetailMapper = orderDetailMapper;
        this.orderMapper = orderMapper;
    }

    //流程卡管理查询
    public Map<String, Object> selectProcessCard(Integer pageNum, Integer pageSize, Date selectTime1, Date selectTime2, FlowCard flowCard) {
    public Map<String, Object> selectProcessCard(Integer pageNum, Integer pageSize,List<String> selectDate, FlowCard flowCard) {
        Integer offset = (pageNum - 1) * pageSize;
        String endDate = LocalDate.now().toString();
        String startDate = LocalDate.now().minusDays(15).toString();
        if(selectDate !=null && selectDate.size()==2){
            if(!selectDate.get(0).isEmpty()){
                startDate = selectDate.get(0);
            }
            if(!selectDate.get(1).isEmpty()){
                endDate = selectDate.get(1);
            }
        }
        Map<String, Object> map = new HashMap<>();
        map.put("data", flowCardMapper.selectFlowCard(offset, pageSize, selectTime1, selectTime2, flowCard));
        map.put("total", flowCardMapper.getPageTotal(offset, pageSize, selectTime1, selectTime2, flowCard));
        map.put("data", flowCardMapper.selectFlowCard(offset, pageSize, startDate, endDate, flowCard));
        map.put("total", flowCardMapper.getPageTotal(offset, pageSize, startDate, endDate, flowCard));
        List<String> list = new ArrayList<>();
        list.add(startDate);
        list.add(endDate);
        map.put("selectDate",list);
        return map;
    }

@@ -217,6 +238,7 @@
    public Object flowCardDetailSv(String processId, FlowCard flowCard) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", flowCardMapper.flowCardDetailMp(processId, flowCard));
        map.put("merge", flowCardMapper.flowCardDetailMergeMp(processId));
        return map;
    }

@@ -274,7 +296,7 @@
        }
    }

    public Map<String, Object> getSelectPrintingSv(Map<String, Object> object, String printMerge, String printLike, String merge) {
    public Map<String, Object> getSelectPrintingSv(Map<String, Object> object, String printMerge, String printLike, String merge, String flashback, String compound, String landingSequence) {
        if (printMerge == null) {
            printMerge = "";
        }
@@ -288,8 +310,11 @@
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();//最终结果
        List<FlowCard> flowCardList = JSONArray.parseArray(JSONObject.toJSONString(object.get("printList")), FlowCard.class);
        if (!flowCardList.isEmpty()) {
            Set<String> processedProcessIds = new HashSet<>();  // 用来存放已处理过的 processId
            Set<String> processedKeys = new HashSet<>();
            for (FlowCard flowCard : flowCardList) {
                String processId = flowCard.getProcessId();
                Integer orderNumber = flowCard.getOrderNumber();
                String uniqueKey = processId + "|" + orderNumber;  // 用特殊字符连接防止冲突
                Map<String, Object> itemmap = new HashMap<>();
                //流程卡表头表尾数据
                //是否传入合并层数
@@ -297,43 +322,65 @@
                    //是否包含切割
                    //boolean containsCutting = flowCard.getProcess().contains("切割");
                    String processSub = flowCard.getProcess().substring(0, 2);
                    if (processSub.equals("夹胶") || processSub.equals("中空")) {//工艺是否包含夹胶中空
                        itemmap.put("detail", flowCardMapper.getPrimaryListLimt(flowCard.getProcessId(), String.valueOf(flowCard.getTechnologyNumber()), flowCard.getGlassChild(), flowCard.getProcess(), flowCard.getOrderId()));
                    //获取工序对应的别称
                    String processName = flowCardMapper.getProcessName(processSub);
                    if (processName.equals("stepC") || processName.equals("stepD")) {//工艺是否包含夹胶中空
                        itemmap.put("detail", flowCardMapper.getPrimaryListLimt(flowCard.getProcessId(),
                                String.valueOf("null".equals(compound)
                                        ? flowCard.getTechnologyNumber()//正常层
                                        : compound ),//同架层
                                flowCard.getGlassChild(), flowCard.getProcess(), flowCard.getOrderId()));

                        List<Map<String, Object>> detailList = flowCardMapper.getDetailList(flowCard.getProcessId(), flowCard.getTechnologyNumber(), flowCard.getProcess());
                        itemmap.put("detailList", detailList);
                        if (compound == null
                                || "null".equals(compound)
                                || compound.trim().isEmpty()){
                            List<Map<String, Object>> detailList = flowCardMapper.getDetailList(flowCard.getProcessId(), flowCard.getTechnologyNumber(), flowCard.getProcess(),flashback,landingSequence);
                            itemmap.put("detailList", detailList);
                        }else {//有需要同架的层
                            List<Map<String, Object>> detailList = flowCardMapper.getDetailCompoundList(flowCard.getProcessId(), flowCard.getTechnologyNumber(), flowCard.getProcess(),flashback,compound,landingSequence);
                            itemmap.put("detailList", detailList);
                        }
                    } else {
                        if (merge.equals("1") && flowCard.getMerge().equals(1)) {
                        if (merge.equals("1") && flowCard.getMerge().equals(1)) {//否
                            // 检查是否已经处理过该 processId，如果处理过则跳过
                            if (processedProcessIds.contains(flowCard.getProcessId())) {
                            if (processedKeys.contains(uniqueKey)) {
                                continue;
                            }
                            // 将该 processId 加入已处理集合
                            processedProcessIds.add(flowCard.getProcessId());
                            processedKeys.add(uniqueKey);
                            itemmap.put("detail", flowCardMapper.getPrimaryList(flowCard.getProcessId(), String.valueOf(flowCard.getTechnologyNumber()), flowCard.getGlassChild(), flowCard.getProcess(), flowCard.getOrderId()));

                            List<Map<String, Object>> detailList = flowCardMapper.getDetailListMerge(flowCard.getProcessId(), flowCard.getProcess());
                            List<Map<String, Object>> detailList = flowCardMapper.getDetailListMerge(flowCard.getProcessId(), flowCard.getProcess(),flashback,landingSequence);
                            itemmap.put("detailList", detailList);
                        } else {
                            itemmap.put("detail", flowCardMapper.getPrimaryList(flowCard.getProcessId(), String.valueOf(flowCard.getTechnologyNumber()), flowCard.getGlassChild(), flowCard.getProcess(), flowCard.getOrderId()));

                            List<Map<String, Object>> detailList = flowCardMapper.getDetailListLike(flowCard.getProcessId(), String.valueOf(flowCard.getTechnologyNumber()), flowCard.getProcess());
                            itemmap.put("detailList", detailList);
                            itemmap.put("detail", flowCardMapper.getPrimaryListLimt(flowCard.getProcessId(),
                                    String.valueOf("null".equals(compound)
                                            ? flowCard.getTechnologyNumber()//正常层
                                            : compound ),//同架层
                                    flowCard.getGlassChild(), flowCard.getProcess(), flowCard.getOrderId()));
                            if (compound == null
                                    || "null".equals(compound)
                                    || compound.trim().isEmpty()){
                                List<Map<String, Object>> detailList = flowCardMapper.getDetailListLike(flowCard.getProcessId(), String.valueOf(flowCard.getTechnologyNumber()), flowCard.getProcess(),flashback,landingSequence);
                                itemmap.put("detailList", detailList);
                            }else {//有需要同架的层
                                List<Map<String, Object>> detailList = flowCardMapper.getDetailListLikeCompound(flowCard.getProcessId(), String.valueOf(flowCard.getTechnologyNumber()), flowCard.getProcess(),flashback,compound,landingSequence);
                                itemmap.put("detailList", detailList);
                            }
                        }

                    }

                } else {
                } else {//否
                    //流程卡明细数据
                    if (printLike.equals("") || printLike.equals("null")) {
                        itemmap.put("detail", flowCardMapper.getPrimaryListMerge(flowCard.getProcessId(), printMerge, flowCard.getOrderId()));

                        List<Map<String, Object>> detailList = flowCardMapper.getDetailList(flowCard.getProcessId(), flowCard.getTechnologyNumber(), flowCard.getProcess());
                        List<Map<String, Object>> detailList = flowCardMapper.getDetailList(flowCard.getProcessId(), flowCard.getTechnologyNumber(), flowCard.getProcess(), flashback, landingSequence);
                        itemmap.put("detailList", detailList);
                    } else {
                        itemmap.put("detail", flowCardMapper.getPrimaryList(flowCard.getProcessId(), String.valueOf(flowCard.getTechnologyNumber()), flowCard.getGlassChild(), flowCard.getProcess(), flowCard.getOrderId()));

                        List<Map<String, Object>> detailList = flowCardMapper.getDetailListLike(flowCard.getProcessId(), printMerge, flowCard.getProcess());
                        List<Map<String, Object>> detailList = flowCardMapper.getDetailListLike(flowCard.getProcessId(), printMerge, flowCard.getProcess(), flashback, landingSequence);
                        itemmap.put("detailList", detailList);
                    }
                }
@@ -373,7 +420,7 @@
        return map;
    }

    public Map<String, Object> getSelectPrintProject(String printProject, String merge) {
    public Map<String, Object> getSelectPrintProject(String printProject, String merge, String flashback, String landingSequence) {

        Map<String, Object> map = new HashMap<>();
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();//最终结果
@@ -382,18 +429,23 @@
        }
        List<FlowCard> flowCardList = flowCardMapper.getFlowCardListPrintProject(printProject);
        if (!flowCardList.isEmpty()) {
            Set<String> processedProcessIds = new HashSet<>();  // 用来存放已处理过的 processId
            Set<String> processedKeys = new HashSet<>();

            for (FlowCard flowCard : flowCardList) {
                Map<String, Object> itemmap = new HashMap<>();


                String processId = flowCard.getProcessId();
                Integer orderNumber = flowCard.getOrderNumber();
                String uniqueKey = processId + "|" + orderNumber;  // 用特殊字符连接防止冲突
                //是否包含切割
                //boolean containsCutting = flowCard.getProcess().contains("切割");
                String processSub = flowCard.getProcess().substring(0, 2);
                if (processSub.equals("夹胶") || processSub.equals("中空")) {
                //获取工序对应的别称
                String processName = flowCardMapper.getProcessName(processSub);
                if (processName.equals("stepC") || processName.equals("stepD")) {//工艺是否包含夹胶中空
                    itemmap.put("detail", flowCardMapper.getPrimaryListLimt(flowCard.getProcessId(), String.valueOf(flowCard.getTechnologyNumber()), flowCard.getGlassChild(), flowCard.getProcess(), flowCard.getOrderId()));
                    if (flowCard.getPatchState().equals(0)) {
                        List<Map<String, Object>> detailList = flowCardMapper.getDetailList(flowCard.getProcessId(), flowCard.getTechnologyNumber(), flowCard.getProcess());
                        List<Map<String, Object>> detailList = flowCardMapper.getDetailList(flowCard.getProcessId(), flowCard.getTechnologyNumber(), flowCard.getProcess(), flashback, landingSequence);
                        itemmap.put("detailList", detailList);
                    } else {
                        List<Map<String, Object>> detailList = flowCardMapper.getDetailLists(flowCard.getProcessId(), flowCard.getTechnologyNumber(), flowCard.getProcess(), flowCard.getOrderNumber());
@@ -405,18 +457,18 @@
                    if (flowCard.getPatchState().equals(0)) {
                        if (merge.equals("1") && flowCard.getMerge().equals(1)) {
                            // 检查是否已经处理过该 processId，如果处理过则跳过
                            if (processedProcessIds.contains(flowCard.getProcessId())) {
                            if (processedKeys.contains(uniqueKey)) {
                                continue;
                            }
                            // 将该 processId 加入已处理集合
                            processedProcessIds.add(flowCard.getProcessId());
                            processedKeys.add(uniqueKey);
                            itemmap.put("detail", flowCardMapper.getPrimaryList(flowCard.getProcessId(), String.valueOf(flowCard.getTechnologyNumber()), flowCard.getGlassChild(), flowCard.getProcess(), flowCard.getOrderId()));

                            List<Map<String, Object>> detailList = flowCardMapper.getDetailListMerge(flowCard.getProcessId(), flowCard.getProcess());
                            List<Map<String, Object>> detailList = flowCardMapper.getDetailListMerge(flowCard.getProcessId(), flowCard.getProcess(), flashback, landingSequence);
                            itemmap.put("detailList", detailList);
                        } else {
                            itemmap.put("detail", flowCardMapper.getPrimaryList(flowCard.getProcessId(), String.valueOf(flowCard.getTechnologyNumber()), flowCard.getGlassChild(), flowCard.getProcess(), flowCard.getOrderId()));
                            List<Map<String, Object>> detailList = flowCardMapper.getDetailListLike(flowCard.getProcessId(), String.valueOf(flowCard.getTechnologyNumber()), flowCard.getProcess());
                            List<Map<String, Object>> detailList = flowCardMapper.getDetailListLike(flowCard.getProcessId(), String.valueOf(flowCard.getTechnologyNumber()), flowCard.getProcess(), flashback, landingSequence);
                            itemmap.put("detailList", detailList);
                        }

@@ -569,14 +621,15 @@
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();//最终结果
        List<FlowCard> flowCardList = JSONArray.parseArray(JSONObject.toJSONString(object.get("printList")), FlowCard.class);
        if (!flowCardList.isEmpty()) {
            Set<String> processedProcessIds = new HashSet<>();  // 用来存放已处理过的 processId

            Set<String> processedKeys = new HashSet<>();
            if (lableType != 2) {//成品标签
                for (FlowCard flowCard : flowCardList) {
                    String processId = flowCard.getProcessId();

                    Integer orderNumber = flowCard.getOrderNumber();
                    String uniqueKey = processId + "|" + orderNumber;  // 用特殊字符连接防止冲突
                    // 检查是否已经处理过该 processId，如果处理过则跳过
                    if (processedProcessIds.contains(processId)) {
                    if (processedKeys.contains(uniqueKey)) {
                        continue;
                    }
                    Map<String, Object> itemmap = new HashMap<>();
@@ -584,7 +637,7 @@
                    list.add(itemmap);

                    // 将该 processId 加入已处理集合
                    processedProcessIds.add(processId);
                    processedKeys.add(uniqueKey);
                }
            } else {//小片标签
                for (FlowCard flowCard : flowCardList) {
@@ -604,14 +657,15 @@
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();//最终结果
        List<FlowCard> flowCardList = JSONArray.parseArray(JSONObject.toJSONString(object.get("printList")), FlowCard.class);
        if (!flowCardList.isEmpty()) {
            Set<String> processedProcessIds = new HashSet<>();  // 用来存放已处理过的 processId

            Set<String> processedKeys = new HashSet<>();
            if (lableType != 2) {//成品标签
                for (FlowCard flowCard : flowCardList) {
                    String processId = flowCard.getProcessId();
                    Integer orderNumber = flowCard.getOrderNumber();
                    String uniqueKey = processId + "|" + orderNumber;  // 用特殊字符连接防止冲突

                    // 检查是否已经处理过该 processId，如果处理过则跳过
                    if (processedProcessIds.contains(processId)) {
                    if (processedKeys.contains(uniqueKey)) {
                        continue;
                    }
                    Map<String, Object> itemmap = new HashMap<>();
@@ -619,7 +673,7 @@
                    list.add(itemmap);

                    // 将该 processId 加入已处理集合
                    processedProcessIds.add(processId);
                    processedKeys.add(uniqueKey);
                }
            } else {//小片标签
                for (FlowCard flowCard : flowCardList) {
@@ -707,8 +761,10 @@

                //工艺流程
                List<Map<String, Object>> processList = flowCardMapper.getProcessList(flowCard.getProcessId(), flowCard.getTechnologyNumber());

                //工序列表
                List<Map<String, Object>> processNameList = flowCardMapper.getProcessNameList();
                itemmap.put("processList", processList);
                itemmap.put("processNameList", processNameList);
                //  itemmap.put("numberList", numberList);
                list.add(itemmap);

@@ -789,6 +845,7 @@
            }
        }
        map.put("data", list);
        map.put("orderOtherMoney", flowCardMapper.selectorderOtherMoney());
        map.put("type", flowCardMapper.selectType());
        return map;
    }
@@ -798,25 +855,31 @@
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();//最终结果
        List<FlowCard> flowCardList = JSONArray.parseArray(JSONObject.toJSONString(object.get("printList")), FlowCard.class);
        if (!flowCardList.isEmpty()) {
            Set<String> processedProcessIds = new HashSet<>();  // 用来存放已处理过的 processId
            Set<String> processedKeys = new HashSet<>();

            if (lableType != 2) {//成品标签
                for (FlowCard flowCard : flowCardList) {
                    String orderId = flowCard.getOrderId();
                    String processId = flowCard.getProcessId();
                    String orderNumber = flowCard.getOrderNumber().toString();
                    String uniqueKey = processId + "|" + orderNumber;  // 用特殊字符连接防止冲突
                       if (processId!=null){
                           // 检查是否已经处理过该 processId，如果处理过则跳过
                           if (processedProcessIds.contains(processId) && processedProcessIds.contains(orderNumber)) {
                           if (processedKeys.contains(uniqueKey)) {
                               continue;
                           }
                           Map<String, Object> itemmap = new HashMap<>();
                           itemmap.put("data", flowCardMapper.getPrintCustomDataDetails(flowCard.getProcessId(), flowCard.getOrderNumber(), flowCard.getPrintQuantity()));
                           Integer sumQuantity = flowCardMapper.getSumQuantity(flowCard.getOrderId());
                           List<Map<String, Object>> details = flowCardMapper.getPrintCustomDataDetails(flowCard.getProcessId(), flowCard.getOrderNumber(), flowCard.getPrintQuantity());

                           for (Map<String, Object> detail : details) {
                               detail.put("sumQuantity", sumQuantity);
                           }
                           itemmap.put("data", details);
                           list.add(itemmap);

                           // 将该 processId 加入已处理集合
                           processedProcessIds.add(processId);
                           processedProcessIds.add(orderNumber);
                           processedKeys.add(uniqueKey);
                       } else{

                           Map<String, Object> itemmap = new HashMap<>();
@@ -864,23 +927,27 @@

    }

    public String mergeFlowCard(Map<String, Object> object) {
    public String mergeFlowCard(Map<String, Object> object, Integer merge) {
        String returns = "false";
        List<FlowCard> flowCardList = JSONArray.parseArray(JSONObject.toJSONString(object.get("flowCard")), FlowCard.class);
        if (!flowCardList.isEmpty()) {
            List<Map<String, Object>> flowCardList1 = flowCardMapper.selectFlowCardMerge(flowCardList.get(0).getProcessId());
            int index = 1;
            for (int i = 0; i < flowCardList1.size(); i++) {
                if (Integer.valueOf(flowCardList1.get(i).get("count2").toString()) > 1) {
                    List<Integer> technologyNumber = Arrays.stream(flowCardList1.get(i).get("count1").toString().split(","))
                            .map(Integer::parseInt)
                            .collect(Collectors.toList());
                    flowCardMapper.updateFlowCardMerge(flowCardList.get(0).getProcessId(), technologyNumber, index);
                    index += 1;
                    returns = "true";
            if (merge == 0){
                int index = 1;
                for (int i = 0; i < flowCardList1.size(); i++) {
                    if (Integer.valueOf(flowCardList1.get(i).get("count2").toString()) > 1) {
                        List<Integer> technologyNumber = Arrays.stream(flowCardList1.get(i).get("count1").toString().split(","))
                                .map(Integer::parseInt)
                                .collect(Collectors.toList());
                        flowCardMapper.updateFlowCardMerge(flowCardList.get(0).getProcessId(), technologyNumber, index);
                        index += 1;
                        returns = "true";
                    }
                }
            }else {//取消合并
                flowCardMapper.updateFlowCardIsMerge(flowCardList.get(0).getProcessId());
                returns = "true";
            }


        }

@@ -922,6 +989,66 @@
        }
        return flowCardList;
    }

    public Map<String,Object> getProcessCardAll(Map<String, String> processCards) {
        String processCard = processCards.get("processCard");
        if (!processCard.contains("/")) {
            throw new ServiceException(Constants.Code_600, "错误的流程卡号，请检查!");
        }

        String[] processCardList = processCard.split("/");
        List<String> result = IntStream.range(0, processCardList[1].length())
                .mapToObj(i -> String.valueOf(processCardList[1].charAt(i)))
                .collect(Collectors.toList());

        List<FlowCard> flowCardList = flowCardMapper.selectList(
                new QueryWrapper<FlowCard>()
                        .eq("process_id", processCardList[0])
                        .in("technology_number", result)
        );
        for (FlowCard flowCard : flowCardList) {
            flowCard.setOrderGlassDetail(
                    orderGlassDetailMapper.selectOne(
                            new QueryWrapper<OrderGlassDetail>()
                                    .eq("order_id", flowCard.getOrderId())
                                    .eq("order_number", flowCard.getOrderNumber())
                                    .eq("technology_number", flowCard.getTechnologyNumber())
                    )
            );
            String str = flowCard.getOrderGlassDetail().getGlassChild();
            String delimiter = "mm";
            int index = str.indexOf(delimiter);
            Integer subString = Integer.valueOf(str.substring(0, index).trim());
            flowCard.getOrderGlassDetail().setThickness(subString);
        }
        OrderDetail orderDetail = orderDetailMapper
                .selectOne(new QueryWrapper<OrderDetail>()
                        .eq("order_id", flowCardList.get(0).getOrderId())
                        .eq("order_number", flowCardList.get(0).getOrderNumber())
        );
        Product product = productMapper
                .selectOne(new QueryWrapper<Product>()
                        .eq("id",orderDetail.getProductId()));
        product.setProductDetails(productDetailMapper
                .selectList(new QueryWrapper<ProductDetail>()
                        .eq("prod_id",orderDetail.getProductId())
                )
        );

        Order order = orderMapper.
                selectOne(new QueryWrapper<Order>()
                        .eq("order_id", flowCardList.get(0).getOrderId()));
        order.setMoney(null);

        Map<String,Object> map = new HashMap<>();
        map.put("product",product);
        map.put("flowCard",flowCardList);
        map.put("order",order);


        return map;
    }


    public Boolean checkboxDeleteSv(Map<String, Object> object) {
        String userName = "";
@@ -982,7 +1109,6 @@
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();//最终结果
        List<FlowCard> flowCardList = JSONArray.parseArray(JSONObject.toJSONString(object.get("printList")), FlowCard.class);
        if (!flowCardList.isEmpty()) {
            Set<String> processedProcessIds = new HashSet<>();  // 用来存放已处理过的 processId
            for (FlowCard flowCard : flowCardList) {
                Map<String, Object> itemmap = new HashMap<>();
                //是否是工程明细打印
@@ -1174,6 +1300,7 @@
                    newOrderDetail.setLandingSequence(flowCardNo);
                    orderDetailList.add(newOrderDetail);
                    orderDetail.setQuantity(orderDetail.getQuantity() - shelfQuantity);
                    orderDetail.setBaiscQuantity(String.valueOf(Integer.valueOf(orderDetail.getBaiscQuantity())-shelfQuantity));
                    flowCardNo += 1;
                    shelfQuantity = shelfQuantity - shelfQuantity;
                } else {
@@ -1184,6 +1311,7 @@
                    newOrderDetail.setOrderNumber(orderDetail.getOrderNumber());
                    newOrderDetail.setShape(orderDetail.getShape());
                    newOrderDetail.setLandingSequence(flowCardNo);
                    newOrderDetail.setBaiscQuantity(String.valueOf(orderDetail.getBaiscQuantity()));
                    orderDetailList.add(newOrderDetail);
                    //当前架子剩余数量
                    shelfQuantity = shelfQuantity - Math.toIntExact(orderDetail.getQuantity());
@@ -1222,6 +1350,12 @@

        }
    }


    public List exportDateProcessSv(Map<String, Object> dates) {
        List<LocalDate> date= (List<LocalDate>) dates.get("date");
        return flowCardMapper.exportDateProcessMp(date);
    }
}