提交装箱打印添加批次

guoyujie

2025-08-11 a12834e87a110fbf1414e24eb574f2e87b29e03c

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

@@ -4,30 +4,418 @@
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.example.erp.entity.pp.FlowCard;
import com.example.erp.entity.pp.OptimizeProjectMange;
import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.example.erp.common.RabbitMQUtil;
import com.example.erp.entity.pp.*;
import com.example.erp.entity.sd.Delivery;
import com.example.erp.entity.sd.OrderDetail;
import com.example.erp.entity.userInfo.Log;
import com.example.erp.entity.userInfo.SysError;
import com.example.erp.mapper.pp.GlassOptimizeMapper;
import com.example.erp.service.userInfo.SysErrorService;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.transaction.interceptor.TransactionAspectSupport;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.math.BigDecimal;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.sql.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.text.DecimalFormat;
import java.time.LocalDate;
import java.util.*;
import java.util.concurrent.TimeoutException;
import java.util.stream.Collectors;

@Service
@Transactional(rollbackFor = Exception.class)
@DS("sd")
public class GlassOptimizeService {
    @Autowired
    GlassOptimizeMapper glassOptimizeMapper;
    @Autowired
    SysErrorService sysErrorService;

    RabbitMQUtil rabbitMQUtil;
    //模拟计算

    //工程信息
    public Map<String, Object> projectInfoSv(String projectNo) {
    /*public Map<String, Object> SimulationCalculation(Map<String,Object> message) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.projectInfoMp(projectNo));
        try {
            rabbitMQUtil = new RabbitMQUtil();
            // 发送消息


            // 获取 computeData 和 cardData
            *//*Object computeData = message.get("computeData");
            Object cardData = message.get("cardData");*//*

            rabbitMQUtil.sendMessage(message.toString());
            System.out.println("send message: " + message);
            String date = rabbitMQUtil.receiveMessages();
            System.out.println("Received message: " + date);

            // 关闭连接
            rabbitMQUtil.close();
            map.put("data", date);

        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException | InterruptedException e) {
            e.printStackTrace();
        }

        return map;
    }*/

    public Map<String, Object> SimulationCalculation(Map<String,Object> message) {
        Map<String, Object> map = new HashMap<>();
        try {
            URL url = new URL("https://example.com"); // 替换为你的目标 URL
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();

            conn.setRequestMethod("POST");
            conn.setDoOutput(true); // 允许写入请求体
            conn.setConnectTimeout(5000);
            // 读取超时（等待服务器响应的最大时间）
            conn.setReadTimeout(108000);

            // 写入请求体数据
            String postData = message.toString();
            try (OutputStream os = conn.getOutputStream()) {
                byte[] input = postData.getBytes(StandardCharsets.UTF_8);
                os.write(input, 0, input.length);
            }

            // 3. 获取状态码
            int statusCode = conn.getResponseCode();
            System.out.println("状态码: " + statusCode);

            // 4. 读取响应内容
            BufferedReader reader = new BufferedReader(
                    new InputStreamReader(conn.getInputStream())
            );
            String line;
            StringBuilder response = new StringBuilder();
            while ((line = reader.readLine()) != null) {
                response.append(line);
            }
            reader.close();

            // 输出响应内容
            System.out.println("响应内容:\n" + response.toString());

        }catch (Exception e) {
            e.printStackTrace();
        }

        return map;
    }


//模拟计算保存
    public Boolean addSimulation(Map<String, Object> object) {
        try {
            Map<String, Object> objectMap = (Map<String, Object>) object.get("inputValues");
            String projectNo = objectMap.get("project_no").toString();
            String userName = object.get("userName").toString();
            Map<String, Object> optimizeProjectMap = glassOptimizeMapper.selectProjectCount(projectNo);

            if(Integer.valueOf(object.get("state").toString())==3){
                List<Map<String, Object>> flowCardList = glassOptimizeMapper.selectProjectComputeMp(projectNo);
                int index=0;
                for (Map<String, Object> flowCard:flowCardList){
                    List<Map<String, Object>> glassDetailList=new ArrayList<>();
                    if(Integer.valueOf(flowCard.get("patch_state").toString())==0){
                         glassDetailList = glassOptimizeMapper.selectComputeDetailMp(flowCard.get("processId").toString(),
                                Integer.valueOf(flowCard.get("technologyNumber").toString()));

                    }else{
                         glassDetailList = glassOptimizeMapper.selectComputeDetailMpPatchState(flowCard.get("processId").toString(),
                                Integer.valueOf(flowCard.get("technologyNumber").toString()));
                    }
                    for (Map<String, Object> glassDetail:glassDetailList){
                        for(int i=0;i<Integer.valueOf(glassDetail.get("quantity").toString());i++){
                            index+=1;
                            glassOptimizeMapper.insertOptimizeHeatDetail(
                                    projectNo,flowCard.get("processId").toString(),
                                    Integer.valueOf(flowCard.get("technologyNumber").toString()),
                                    Integer.valueOf(flowCard.get("patch_state").toString()),
                                    Integer.valueOf(glassDetail.get("order_number").toString()),
                                    Double.valueOf(glassDetail.get("width").toString()),
                                    Double.valueOf(glassDetail.get("height").toString()),index,userName
                            );

                        }
                    }
                    glassOptimizeMapper.updateProjectTemperingStateMp(projectNo,1);
                }
            }else{
                List<Map<String, Object>> objectList = (List<Map<String, Object>>) object.get("projectdetail");
                for (Map<String, Object> objectMap1:objectList){
                    Integer count = glassOptimizeMapper.selectPatchLogState(objectMap1.get("process_id").toString(),
                            Integer.valueOf(objectMap1.get("layers_number").toString()),Integer.valueOf(objectMap1.get("order_number").toString()),projectNo);
                    if(count>0){
                        objectMap1.put("patchState",1);
                    }else {
                        objectMap1.put("patchState",0);
                    }
                }
                glassOptimizeMapper.addSimulation(object);
                glassOptimizeMapper.addratioResult(object);
                glassOptimizeMapper.addratioProjectResult(object);


                if(Integer.valueOf(object.get("state").toString())==2){
                    List<Map<String, Object>> flowCardList = glassOptimizeMapper.selectProjectComputeMp(projectNo);
                    List<String> rackinfosList = (List<String>) object.get("rackinfos");
                    Iterator<Map<String, Object>> iterator = flowCardList.iterator();
                    while (iterator.hasNext()) {
                        Map<String, Object> map = iterator.next();
                        for(String rackinfos:rackinfosList){
                            String processId=rackinfos.substring(0,14);
                            String processId1=map.get("processId").toString();
                            Integer technologyNumber= Integer.valueOf(rackinfos.substring(15));
                            Integer technologyNumber1= Integer.valueOf(map.get("technologyNumber").toString());
                            if(map.get("processId").toString().equals(processId) && Integer.valueOf(map.get("technologyNumber").toString())==technologyNumber){
                                iterator.remove();
                            }
                        }
                    }

                    int index=0;
                    for (Map<String, Object> flowCard:flowCardList){
                        List<Map<String, Object>> glassDetailList=new ArrayList<>();
                        if(flowCard.get("patch_state").toString()=="0"){
                            glassDetailList = glassOptimizeMapper.selectComputeDetailMp(flowCard.get("processId").toString(),
                                    Integer.valueOf(flowCard.get("technologyNumber").toString()));

                        }else{
                            glassDetailList = glassOptimizeMapper.selectComputeDetailMp(flowCard.get("processId").toString(),
                                    Integer.valueOf(flowCard.get("technologyNumber").toString()));
                        }
                        for (Map<String, Object> glassDetail:glassDetailList){
                            for(int i=0;i<Integer.valueOf(glassDetail.get("quantity").toString());i++){
                                index+=1;
                                glassOptimizeMapper.insertOptimizeHeatDetail(
                                        projectNo,flowCard.get("processId").toString(),
                                        Integer.valueOf(flowCard.get("technologyNumber").toString()),
                                        Integer.valueOf(flowCard.get("patch_state").toString()),
                                        Integer.valueOf(glassDetail.get("order_number").toString()),
                                        Double.valueOf(glassDetail.get("width").toString()),
                                        Double.valueOf(glassDetail.get("height").toString()),index,userName
                                );

                            }
                        }
                    }
                }

            }
            if(Integer.valueOf(optimizeProjectMap.get("optimize_state").toString())==1){
                List<OptimizeHeatDetail> optimizeHeatDetail = glassOptimizeMapper.selectOptimizeHeatDetail(projectNo);
                for (OptimizeHeatDetail projectdetail:optimizeHeatDetail){
                    OptimizeDetail optimizeDetail=glassOptimizeMapper.selectOptimizeDetailById(projectNo,projectdetail.getProcessId(),
                            projectdetail.getOrderSort(),projectdetail.getLayer());
                    glassOptimizeMapper.updateOptimizeDetail(optimizeDetail.getId(),projectdetail.getLayoutId(),projectdetail.getSort());
                }
            }

            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    //优化设置保存
    public Boolean optimizeParmsSave(Map<String, Object> object,String username) {
        try {
            ObjectMapper mapper = new ObjectMapper();
            String jsonString = mapper.writeValueAsString(object);

            glassOptimizeMapper.optimizeParmsSave(jsonString,username);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }



    //优化调整结果保存
    public Boolean saveOptimizeResult(Map<String, Object> object,String projectId) {
        try {
            Map<String, Object> optimalResults = (Map<String, Object>) object.get("optimalResults");
            List<Map<String, Object>> originalFilm = (List<Map<String, Object>>) object.get("originalFilm");
            glassOptimizeMapper.addOptimizeUse(originalFilm,projectId,"admin");

            Map<String, Object> glassInfo = glassOptimizeMapper.getGlassInfo(projectId);

            ObjectMapper mapper = new ObjectMapper();
            String json = mapper.writeValueAsString(optimalResults);
            glassOptimizeMapper.addOptimizeProjectFile(json,projectId,"admin");

            List<Map<String, Object>> objectMapList = (List<Map<String, Object>>) optimalResults.get("layouts");
            glassOptimizeMapper.addOptimizeLayout(objectMapList,projectId);
            for(Map<String, Object> objectMap:objectMapList){
                List<Map<String, Object>> objectMap2 = (List<Map<String, Object>>) objectMap.get("glassDetails");
                //迭代玻璃明细集合处理余料和其他
                Iterator<Map<String, Object>> iterator = objectMap2.iterator();
                while (iterator.hasNext()) {
                    Map<String, Object> map = iterator.next();
                    // 修改isRemain判断逻辑，支持数字0/1和字符串"0"/"1"
                    boolean isRemain = false;
                    if (map.containsKey("isRemain")) {
                        Object isRemainObj = map.get("isRemain");
                        if (isRemainObj != null) {
                            if (isRemainObj instanceof Number) {
                                // 数字类型: 1表示true，0表示false
                                isRemain = ((Number) isRemainObj).intValue() == 1;
                            } else {
                                // 字符串类型: "1"表示true，"0"表示false
                                isRemain = "1".equals(isRemainObj.toString());
                            }
                        }
                    }

                    if (isRemain) {
                        System.out.println( map);
                        if (glassInfo != null) {
                            String glassType = (String) glassInfo.get("glass_type");
                            String glassThickness = (String) glassInfo.get("glass_thickness");
                            // 余料存入optimizeoffcut
                            glassOptimizeMapper.addOptimizeOffcut(map, projectId, glassType, glassThickness);
                        }
                        iterator.remove(); // 从原列表中移除
                    }else {
                        // 处理isRotate字段转换 (现在是0/1)
                        if (map.containsKey("isRotate")) {
                            Object isRotateObj = map.get("isRotate");
                            if (isRotateObj != null) {
                                if (isRotateObj instanceof Number) {
                                    // 直接使用数字值
                                    map.put("isRotate", ((Number) isRotateObj).intValue());
                                } else {
                                    // 字符串形式的"0"/"1"
                                    String isRotateStr = isRotateObj.toString();
                                    if ("1".equals(isRotateStr)) {
                                        map.put("isRotate", 1);
                                    } else {
                                        map.put("isRotate", 0);
                                    }
                                }
                            } else {
                                map.put("isRotate", 0); // 默认值
                            }
                        }
                    }
                }

                glassOptimizeMapper.addOptimizeDetail(objectMap2,projectId);
            }
            glassOptimizeMapper.updateProjectOptimizeStateMp(projectId,1);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }


    public Boolean updateOptimizeResult(Map<String, Object> object,String processId){
        try {
            ObjectMapper mapper = new ObjectMapper();
            String jsonString = mapper.writeValueAsString(object);
            glassOptimizeMapper.updateOptimizeResult(jsonString,processId);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

   //优化调整结果查询
    public Map<String, Object> selectOptimizeResult(String processId) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.selectOptimizeResult(processId));
        map.put("optimizeUse", glassOptimizeMapper.materialStoreOptimizeUse(processId));
        return map;
    }

    //工程信息
    public Map<String, Object> projectInfoSv(String projectNo,String username) {
        Map<String, Object> stringObjectMap = glassOptimizeMapper.selectProjectCount(projectNo);
        Map<String, Object> map = new HashMap<>();
//        if(Integer.parseInt(stringObjectMap.get("optimize_state").toString())==1){
//            map.put("optimizeState", Integer.parseInt(stringObjectMap.get("optimize_state").toString()));
//            map.put("data", glassOptimizeMapper.getOptimizeDetail(projectNo));
//            map.put("project", glassOptimizeMapper.selectProjectCount(projectNo));
//            map.put("grindingTrimming", null);
//        } else if (Integer.parseInt(stringObjectMap.get("tempering_state").toString())==1) {
//            map.put("optimizeState", Integer.parseInt(stringObjectMap.get("optimize_state").toString()));
//            map.put("data", glassOptimizeMapper.analogComputationOptimization(projectNo));
//            map.put("project", glassOptimizeMapper.selectProjectCount(projectNo));
//            map.put("grindingTrimming", glassOptimizeMapper.getGrindingTrimming(username));
//        } else{
//            map.put("optimizeState", Integer.parseInt(stringObjectMap.get("optimize_state").toString()));
//            map.put("data", glassOptimizeMapper.firstOptimization(projectNo));
//            map.put("project", glassOptimizeMapper.selectProjectCount(projectNo));
//            map.put("grindingTrimming", glassOptimizeMapper.getGrindingTrimming(username));
//        }
        map.put("optimizeState", Integer.parseInt(stringObjectMap.get("optimize_state").toString()));
        map.put("data", glassOptimizeMapper.firstOptimization(projectNo));
        map.put("project", glassOptimizeMapper.selectProjectCount(projectNo));
        map.put("grindingTrimming", glassOptimizeMapper.getGrindingTrimming(username));
        return map;
    }




    public Object optimizeInfoSv(String projectNo, String username) {
        Map<String, Object> stringObjectMap = glassOptimizeMapper.selectProjectCount(projectNo);
        Map<String, Object> map = new HashMap<>();
        List<Map<String, Object>> dataList = null;
        if (Integer.parseInt(stringObjectMap.get("tempering_state").toString())==1){
            dataList = glassOptimizeMapper.computeAndOptimization(projectNo);
        } else {
            dataList = glassOptimizeMapper.directOptimization(projectNo);
        }

        // 获取磨量配置数据
        List<Map<String, Object>> grindingTrimmingList = glassOptimizeMapper.getGrindingOptimize(username);
        // 将磨量配置数据拼接到每条主数据后面
        if (dataList != null && !dataList.isEmpty() && grindingTrimmingList != null && !grindingTrimmingList.isEmpty()) {
            // 获取第一条磨量配置数据（通常只有一条记录）
            Map<String, Object> grindingConfig = grindingTrimmingList.get(0);
            // 将磨量配置添加到每条主数据中
            for (Map<String, Object> dataItem : dataList) {
                // 将磨量配置的字段添加到每条数据中
                for (Map.Entry<String, Object> entry : grindingConfig.entrySet()) {
                    // 避免覆盖原有字段
                    if (!dataItem.containsKey(entry.getKey())) {
                        dataItem.put(entry.getKey(), entry.getValue());
                    }
                }
            }
        }
        map.put("data", dataList);
        return map;
    }


    //工程信息流程卡
    public Map<String, Object> getProcessCardSv(String projectNo) {
@@ -37,9 +425,24 @@
    }

    //库存信息
    public Map<String, Object> materialStoreSv(String thickness, String model) {
    public Map<String, Object> materialStoreSv(String thickness, String model, String projectNumber,Integer type,String username) {
        Map<String, Object> stringObjectMap = glassOptimizeMapper.selectProjectCount(projectNumber);
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.materialStoreMp(thickness,model));
        if(Integer.parseInt(stringObjectMap.get("optimize_state").toString())==0){
            if(type==1){
                map.put("data", glassOptimizeMapper.materialStoreMp(thickness,model));
            }else if(type==2){
                map.put("data", glassOptimizeMapper.surplusMaterialsMp(thickness,model));
            }else{
                map.put("data", glassOptimizeMapper.materialStoreSurplusMp(thickness,model));
            }
            map.put("edgeTrimming", glassOptimizeMapper.getEdgeTrimming(username));
        }else{
            map.put("data", glassOptimizeMapper.materialStoreOptimizeUse(projectNumber));
            map.put("edgeTrimming", null);
        }
        map.put("state", Integer.parseInt(stringObjectMap.get("state").toString()));

        return map;
    }

@@ -47,7 +450,28 @@
    //工程查询流程卡
    public Map<String, Object> getFlowCardList(String optionVal, Integer radio) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.getFlowCardListMp(optionVal, radio));
        if(radio==1){
            map.put("data", glassOptimizeMapper.getFlowCardListWhole(optionVal));
        }else if(radio==2){
            map.put("data", glassOptimizeMapper.getFlowCardListNormal(optionVal));
        }else{
            map.put("data", glassOptimizeMapper.getFlowCardListPatch(optionVal));
        }


        return map;
    }

    public Map<String, Object> getUpdateFlowCardList(String type,String thickness, Integer radio,String projectNo) {
        Map<String, Object> map = new HashMap<>();
        if(radio==1){
            map.put("data", glassOptimizeMapper.getFlowCardListModify(type,thickness,projectNo));
        }else if(radio==2){
            map.put("data", glassOptimizeMapper.getFlowCardListNormal(type));
        }else{
            map.put("data", glassOptimizeMapper.getFlowCardListPatch(type));
        }


        return map;
    }
@@ -60,9 +484,34 @@
    }

    //修改排版状态
    public Boolean updateProjectState(String projectNumber, Integer state) {
    public Boolean updateProjectState(String projectNumber, Integer state,Integer states, Integer code) {
        if (!projectNumber.isEmpty()) {
            glassOptimizeMapper.updateProjectStateMp(projectNumber, state);
            //撤销模拟计算
            if(code==1){
                glassOptimizeMapper.deleteOptimizeHeatDetail(projectNumber);
                glassOptimizeMapper.deleteOptimizeHeatLayout(projectNumber);
                glassOptimizeMapper.updateProjectTemperingStateMp(projectNumber, states);
            }
            //撤销优化排版
            else if(code==2){
                glassOptimizeMapper.deleteOptimizeDetail(projectNumber);
                glassOptimizeMapper.deleteOptimizeLayout(projectNumber);
                glassOptimizeMapper.deleteOptimizeProjectFile(projectNumber);
                glassOptimizeMapper.updateOptimizeUse(projectNumber);
                glassOptimizeMapper.updateProjectOptimizeStateMp(projectNumber, states);
            }
            //允许生产
            else if(code==3){
                glassOptimizeMapper.updateProjectStateMp(projectNumber, state);
            }
            //生产不可见
            else if(code==4){
                glassOptimizeMapper.updateProjectStateMp(projectNumber, state);
            }
            //初始化工程
            else if(code==5){
                glassOptimizeMapper.updateProjectStateMp(projectNumber, state);
            }
            return true;
        } else {
            return false;
@@ -70,10 +519,37 @@
    }

    //删除工程
    public Map<String, Object> deleteProject(String projectNumber) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.deleteProjectMp(projectNumber));
        return map;
    public boolean deleteProject(String projectNumber,Integer type) {
        Map<String, Object> stringObjectMap = glassOptimizeMapper.selectProjectCount(projectNumber);
        if(stringObjectMap.get("tempering_state").equals(1)){
            glassOptimizeMapper.deleteOptimizeHeatDetail(projectNumber);
            glassOptimizeMapper.deleteOptimizeHeatLayout(projectNumber);
        }
        if(stringObjectMap.get("optimize_state").equals(1)){
            glassOptimizeMapper.deleteOptimizeDetail(projectNumber);
            glassOptimizeMapper.deleteOptimizeLayout(projectNumber);
            glassOptimizeMapper.deleteOptimizeLayout(projectNumber);
            glassOptimizeMapper.updateOptimizeUse(projectNumber);
            glassOptimizeMapper.deleteOptimizeHeatDetail(projectNumber);
            glassOptimizeMapper.deleteOptimizeHeatLayout(projectNumber);
        }
        List<FlowCard> flowCardList =glassOptimizeMapper.getFlowCardList(projectNumber);
        List<PatchLog> patchLogList =glassOptimizeMapper.getPatchLogList(projectNumber);
        if(flowCardList!=null){
            for (FlowCard flowCard:flowCardList){
                glassOptimizeMapper.updateFlowCardProjectReturn(flowCard.getProcessId(),flowCard.getTechnologyNumber(),projectNumber);
            }
        }
        if(patchLogList!=null){
            for (PatchLog patchLog:patchLogList){
                glassOptimizeMapper.updatePatchLogProjectReturn(patchLog.getProcessId(),patchLog.getTechnologyNumber(),projectNumber);
            }
        }
        //判断是否是修改工程
        if(type.equals(1)){
            glassOptimizeMapper.deleteProjectMp(projectNumber);
        }
        return true;
    }


@@ -87,13 +563,30 @@
    public Map<String, Object>selectProjectComputeSv(String projectNumber) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.selectProjectComputeMp(projectNumber));
        //map.put("project", glassOptimizeMapper.selectProjectCount(projectNumber));
        return map;
    }

    public Map<String, Object>selectProjectComputeAll(String projectNumber) {
        Map<String, Object> map = new HashMap<>();
        List<Map<String, Object>> projectComputeMpList=glassOptimizeMapper.selectProjectComputeMp(projectNumber);
        for (Map<String, Object> stringObjectMap : projectComputeMpList) {
            stringObjectMap.get("process_id");
            stringObjectMap.get("technology_number");
        }
        map.put("data", glassOptimizeMapper.selectProjectComputeMp(projectNumber));
        //map.put("project", glassOptimizeMapper.selectProjectCount(projectNumber));
        return map;
    }

    //模拟计算流程卡详情
    public Map<String, Object>selectComputeDetailSv(String processId) {
    public Map<String, Object>selectComputeDetailSv(String processId,Integer technologyNumber,String patchState) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.selectComputeDetailMp(processId));
        if(patchState.equals("0")){
            map.put("data", glassOptimizeMapper.selectComputeDetailMp(processId,technologyNumber));
        }else{
            map.put("data", glassOptimizeMapper.selectComputeDetailMpPatchState(processId,technologyNumber));
        }
        return map;
    }

@@ -116,37 +609,388 @@
        return map;
    }

    public Boolean addProjectSv(String optionVal, String projectId, String projectNmae, Map<String, Object> object) {
        String userName = "";
        if (object.get("userName") != null) {
            userName = object.get("userName").toString();
        }
        if ("null".equals(projectNmae)) {
            projectNmae = "";
        }
        Double sumArea = (double) 0;
        Double area = (double) 0;
        Integer sumQuantity = 0;
        List<FlowCard> flowCardList = JSONArray.parseArray(JSONObject.toJSONString(object.get("projectdetail")), FlowCard.class);
        if (!flowCardList.isEmpty()) {
            for (FlowCard flowCard : flowCardList) {
                //给流程卡表添加对应的工程号
                glassOptimizeMapper.updateFlowCardProject(flowCard.getProcessId(),flowCard.getTechnologyNumber(),projectId);
                area = glassOptimizeMapper.getSelectArea(flowCard.getProcessId(),flowCard.getTechnologyNumber());
                sumArea += area;
                sumQuantity +=flowCard.getQuantity();
    public String addProjectSv(String optionVal, String projectId, String projectNmae, Map<String, Object> object) {
        String saveState = "true";
        //设置回滚点
        Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
        try {
            String userName = "";
            if (object.get("userName") != null) {
                userName = object.get("userName").toString();
            }
            int index = optionVal.indexOf("mm");
            // 获取 "mm" 前面的部分
            String glass_thickness = optionVal.substring(0, index);
            // 获取 "mm" 后面的部分
            String glass_type = optionVal.substring(index + 2);
            glassOptimizeMapper.addProjectMp(projectId,projectNmae,glass_thickness,glass_type,sumQuantity,sumArea,userName);
            return true;
        }
        else {
            return false;
            String projectType = "";
            if (object.get("projectType") != null) {
                projectType = object.get("projectType").toString();
            }
            if ("null".equals(projectNmae)) {
                projectNmae = "";
            }
            BigDecimal sumArea = new BigDecimal(0);
            double area = 0;
            Integer sumQuantity = 0;
            Integer type = 0;
            int state1 = 0;
            int state2 = 0;
            StringBuilder processId= new StringBuilder();
            List<FlowCard> flowCardList = JSONArray.parseArray(JSONObject.toJSONString(object.get("projectdetail")), FlowCard.class);
            if (!flowCardList.isEmpty()) {
                if(projectType.equals("2")){
                    deleteProject(projectId,2);
                }

                // 创建一个映射来存储 (processId-technologyNumber) 组合到 rack 编号的映射
                Map<String, Integer> rackMap = new HashMap<>();
                int rackCounter = 1;

                for (FlowCard flowCard : flowCardList) {
                    // 为每个唯一的 processId-technologyNumber 组合分配 rack 编号
                    String key = flowCard.getProcessId() + "-" + flowCard.getTechnologyNumber();
                    if (!rackMap.containsKey(key)) {
                        rackMap.put(key, rackCounter++);
                    }
                    int rackValue = rackMap.get(key);

                    if(flowCard.getPatchState().equals(0)){
                        state1=1;
                        //给流程卡表添加对应的工程号
                        Boolean a = glassOptimizeMapper.updateFlowCardProject(flowCard.getProcessId(),flowCard.getTechnologyNumber(),projectId);
                        // 更新流程卡的rack字段
                        glassOptimizeMapper.updateFlowCardRack(flowCard.getProcessId(), flowCard.getTechnologyNumber(), rackValue);
                        area = glassOptimizeMapper.getSelectArea(flowCard.getProcessId(),flowCard.getTechnologyNumber()).doubleValue();
                        sumArea = sumArea.add(BigDecimal.valueOf(area));
                        sumQuantity +=flowCard.getQuantity();
                        processId.append(flowCard.getProcessId()).append("-").append(flowCard.getTechnologyNumber()).append(";");
                    }else{
                        state2=1;
                        Boolean a=glassOptimizeMapper.updatePatchLogProject(flowCard.getProcessId(),flowCard.getTechnologyNumber(),projectId);
                        area = glassOptimizeMapper.getSelectAreaPatchLog(flowCard.getProcessId(),flowCard.getTechnologyNumber()).doubleValue();
                        sumArea = sumArea.add(BigDecimal.valueOf(area));
                        sumQuantity +=flowCard.getQuantity();
                        processId.append(flowCard.getProcessId()).append("-").append(flowCard.getTechnologyNumber()).append(";");
                    }

                }
                if(state1==1&&state2==0){
                    type=1;
                }else if(state1==1&&state2==1){
                    type=2;
                }
                int index = optionVal.indexOf("mm");
                // 获取 "mm" 前面的部分
                String glass_thickness = optionVal.substring(0, index);
                // 获取 "mm" 后面的部分
                String glass_type = optionVal.substring(index + 2);
                if(projectType.equals("2")){
                    glassOptimizeMapper.updateProjectMp(projectId,projectNmae,glass_thickness,glass_type,sumQuantity,sumArea.doubleValue(),userName,
                            flowCardList.size(), String.valueOf(processId),type);
                }else{
                    if(glassOptimizeMapper.selectProjectCount(projectId)==null){
                        glassOptimizeMapper.addProjectMp(projectId,projectNmae,glass_thickness,glass_type,sumQuantity,sumArea.doubleValue(),userName,
                                flowCardList.size(), String.valueOf(processId),type);
                    }else{
                        TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
                        return "false1";
                    }
                }
            }else {
                return "false2";

            }
        } catch (Exception e) {
            TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
            //将异常传入数据库
            SysError sysError = new SysError();
            sysError.setError(e+Arrays.toString(e.getStackTrace()));
            sysError.setFunc("addProjectSv");
            sysErrorService.insert(sysError);
            saveState = "false";

        }
        return saveState;

    }

    public Map<String, Object> getConfiguration(String type,String username) {
        Map<String, Object> map = new HashMap<>();
        if(type.equals("钢化")){
            map.put("data", glassOptimizeMapper.getTemperedConfiguration(username));
        }else if(type.equals("磨量")){
            map.put("data", glassOptimizeMapper.getGrindingTrimming(username));
        }else if(type.equals("修边")){
            map.put("data", glassOptimizeMapper.getEdgeTrimming(username));
        }

        return map;
    }

    public Boolean saveConfiguration(Map<String,Object> object,String type,String username) {
        String json = "";
        if (object.get("json") != null) {
            json = object.get("json").toString();
        }
        if(type.equals("钢化")){
            glassOptimizeMapper.updateOptimizeConfig(json,1,username);
        } else if (type.equals("修边")) {
            glassOptimizeMapper.updateOptimizeConfig(json,5,username);
        }else if (type.equals("磨量")) {
            glassOptimizeMapper.updateOptimizeConfig(json,4,username);
        }
        return true;

    }




    public String simulatedTypesetting1(Map<String, Object> object) {

        String optionVal = "";
        int quantity;
        Double area;
        if (object.get("optionVal") != null) {
            optionVal = object.get("optionVal").toString();
        }
        if (object.get("quantity") != null) {
            quantity = Integer.valueOf(object.get("quantity").toString());
        } else {
            quantity = 0;
        }
        if (object.get("area") != null) {
            area = Double.valueOf(object.get("area").toString());
        } else {
            area = 0.0;
        }

        JSONArray materialStore = JSONArray.parseArray(JSONObject.toJSONString(object.get("materialStore")));


        List<Map<String, Object>> flowCardListNormal = glassOptimizeMapper.getFlowCardListSimulated(optionVal);


        Queue<Map<String, Object>> queue = flowCardListNormal.stream()
                .filter(item -> {
                    if ((quantity>0 ? (Integer.valueOf(item.get("quantity").toString()) > quantity):false) || (area>0 ? (Double.valueOf(item.get("area").toString()) > area):false)) {
                        return false;
                    }
                    return true;
                })
                .collect(Collectors.toCollection(LinkedList::new));

        List<Map<String, Object>> result = new ArrayList<>();

        while (!queue.isEmpty()) {
            List<Map<String, Object>> currentGroup = new ArrayList<>();
            Map<String, Object> currentGroupMap = new HashMap<>();
            int currentCount = 0;
            double currentArea = 0;

            // 处理当前轮次队列中的所有元素
            int queueSize = queue.size();
            boolean addedAny = false;

            String processId="";
            for (int i = 0; i < queueSize; i++) {
                Map<String, Object> item = queue.poll();
                if ((quantity>0?currentCount + Integer.valueOf(item.get("quantity").toString()) <= quantity:true)
                && (area>0?currentArea + Double.valueOf(item.get("area").toString()) <= area:true)) {
                    if(i+1==queueSize){
                        processId=processId+item.get("process_id").toString()+"/"+item.get("technology_number").toString();
                    }else{
                        processId=processId+item.get("process_id").toString()+"/"+item.get("technology_number").toString()+";";
                    }
                    currentGroup.add(item);
                    currentCount += Integer.valueOf(item.get("quantity").toString());
                    currentArea += Double.valueOf(item.get("area").toString());
                    addedAny = true;
                } else {
                    queue.offer(item); // 放回队列等待下次处理
                }
            }

            if (currentGroup.isEmpty()) {
                throw new RuntimeException("无法继续分组，剩余数据无法放入任何分组");
            }
            currentGroupMap.put("processId",processId);
            currentGroupMap.put("count",currentCount);
            currentGroupMap.put("area",Math.round(currentArea * 100) / 100.0);
            result.add(currentGroupMap);
            //System.out.println("流程卡:"+processId+"数量:"+currentCount+"面积:"+Math.round(currentArea * 100) / 100.0);
        }

        for (Map<String, Object> objectMap:result){
            Map<String,Object> map = new HashMap<>();
            String[] substrings = objectMap.get("processId").toString().split(";");
            List<Map<String, Object>> flowCardMap = new ArrayList<>();
            List<String> processIdList=new ArrayList<>();
            List<Integer> technologyNumberList=new ArrayList<>();
            for(String substring : substrings) {
                String processId = substring.substring(0, 14);
                Integer technologyNumber = Integer.valueOf(substring.substring(15));
                processIdList.add(processId);
                technologyNumberList.add(technologyNumber);
            }
            map.put("data",glassOptimizeMapper.simulatedTypesettingUsingOpt(processIdList,technologyNumberList));
            objectMap.put("cuttingRate",90);
        }
        System.out.println(result);

        return "";

    }










    //模拟计算工程号查询
    public Map<String, Object>selectProjectComputeMpThirdParty(String projectNumber) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.selectProjectComputeMpThirdParty(projectNumber));
        return map;
    }

    //模拟计算流程卡详情
    public Map<String, Object>selectComputeDetailThirdParty(String processId,Integer technologyNumber) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.selectComputeDetailMpThirdParty(processId,technologyNumber));
        return map;
    }

    public Boolean simulationSaveThirdParty(Map<String, Object> object) {
        try {
            Map<String, Object> objectMap = (Map<String, Object>) object.get("inputValues");
            String projectNo = objectMap.get("project_no").toString();
            Map<String, Object> optimizeProjectMap = glassOptimizeMapper.selectProjectCount(projectNo);
            glassOptimizeMapper.addSimulation(object);
            glassOptimizeMapper.addratioResult(object);
            glassOptimizeMapper.addratioProjectResult(object);

            List<OptimizeHeatDetail> optimizeHeatDetail = glassOptimizeMapper.selectOptimizeHeatDetail(projectNo);
            for (OptimizeHeatDetail projectdetail:optimizeHeatDetail){
                OptimizeDetail optimizeDetail=glassOptimizeMapper.selectOptimizeDetailById(projectNo,projectdetail.getProcessId(),
                        projectdetail.getOrderSort(),projectdetail.getLayer());
                glassOptimizeMapper.updateOptimizeDetail(optimizeDetail.getId(),projectdetail.getLayoutId(),projectdetail.getSort());
            }


            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    //删除工程
    public boolean deleteProjectThirdParty(String projectNumber) {
        Map<String, Object> stringObjectMap = glassOptimizeMapper.selectProjectCount(projectNumber);
        if(stringObjectMap.get("state").equals(2)){
            glassOptimizeMapper.deleteOptimizeDetailThirdParty(projectNumber);
            glassOptimizeMapper.deleteOptimizeDetail(projectNumber);
        }else if(stringObjectMap.get("state").equals(10)){
            glassOptimizeMapper.deleteOptimizeDetailThirdParty(projectNumber);
            glassOptimizeMapper.deleteOptimizeHeatDetail(projectNumber);
            glassOptimizeMapper.deleteOptimizeHeatLayout(projectNumber);
        }
        glassOptimizeMapper.deleteProjectMp(projectNumber);

        return true;
    }

    //工程信息
    public Map<String, Object> projectInfoThirdParty(String projectNo) {
        Map<String, Object> stringObjectMap = glassOptimizeMapper.selectProjectCount(projectNo);
        Map<String, Object> map = new HashMap<>();
        if(stringObjectMap.get("state").equals(2)){
            map.put("data", glassOptimizeMapper.firstOptimizationThirdParty(projectNo));
            map.put("grindingTrimming", null);
        }else{
            map.put("data", glassOptimizeMapper.firstOptimizationThirdParty(projectNo));
            map.put("grindingTrimming", null);
        }
        return map;
    }

    //库存信息
    public Map<String, Object> materialStoreSvThirdParty(String projectNumber) {
        Map<String, Object> stringObjectMap = glassOptimizeMapper.selectProjectCount(projectNumber);
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.materialStoreOptimizeUse(projectNumber));
        map.put("edgeTrimming", null);
        map.put("state", Integer.parseInt(stringObjectMap.get("state").toString()));
        return map;
    }

    //工程信息流程卡
    public Map<String, Object> getProcessCardMpThirdParty(String projectNo) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.getProcessCardMpThirdParty(projectNo));
        return map;
    }


    public Map<String, Object> getProjectByProjectNoSv(String projectNo) {
        Map<String, Object> map = new HashMap<>();
        map.put("data", glassOptimizeMapper.getProjectByProjectNoSv(projectNo));
        return map;
    }


    public Boolean issuingProjects(String projectNo) throws JsonProcessingException {
        boolean  saveState=false;
        try {
            // 1. 创建URL对象
            URL url = new URL("http://localhost:88/api/loadGlass/engineering/importEngineer");

            // 2. 打开连接
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("Accept", "application/json");
            conn.setDoOutput(true);

            // 3. 准备请求体
            Map<String, Object> optimizeProject=glassOptimizeMapper.selectOptimizeProject(projectNo);
            optimizeProject.put("engineeringRawQueueList", glassOptimizeMapper.selectOptimizeLayout(projectNo));
            optimizeProject.put("glassInfolList", glassOptimizeMapper.selectOptimizeDetail(projectNo));
            optimizeProject.put("flowCardInfoList", glassOptimizeMapper.selectFlowCardInfoList(projectNo));
            ObjectMapper mapper = new ObjectMapper();
            mapper.registerModule(new JavaTimeModule());
            String jsonInputString = mapper.writeValueAsString(optimizeProject);

            //发送请求
            try(OutputStream os = conn.getOutputStream()) {
                byte[] input = jsonInputString.getBytes(StandardCharsets.UTF_8);
                os.write(input, 0, input.length);
            }

            // 获取响应
            try(BufferedReader br = new BufferedReader(
                    new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8))) {
                StringBuilder response = new StringBuilder();
                String responseLine;
                while ((responseLine = br.readLine()) != null) {
                    response.append(responseLine.trim());
                }
                System.out.println("Response: " + response.toString());
                JSONObject obj = JSONObject.parseObject(response.toString());
                if(obj.get("code").equals(200)&&obj.get("data").equals(true)){
                    saveState=true;
                }

            }

            //关闭连接
            conn.disconnect();
        } catch (Exception e) {
            e.printStackTrace();
            saveState= false;
        }
        return saveState;
    }

}