|
package com.example.erp.service.pp;
|
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.baomidou.dynamic.datasource.annotation.DS;
|
import com.example.erp.common.RabbitMQUtil;
|
import com.example.erp.dto.pp.MesCalculateDTO;
|
import com.example.erp.entity.pp.*;
|
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.DeserializationFeature;
|
import com.fasterxml.jackson.databind.ObjectMapper;
|
import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.beans.factory.annotation.Value;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.transaction.interceptor.TransactionAspectSupport;
|
|
import java.io.BufferedReader;
|
import java.io.InputStreamReader;
|
import java.io.OutputStream;
|
import java.lang.reflect.Field;
|
import java.math.BigDecimal;
|
import java.net.HttpURLConnection;
|
import java.net.URL;
|
import java.nio.charset.StandardCharsets;
|
import java.sql.Date;
|
import java.util.*;
|
import java.util.stream.Collectors;
|
|
@Service
|
@Transactional(rollbackFor = Exception.class)
|
@DS("sd")
|
public class GlassOptimizeService {
|
@Autowired
|
GlassOptimizeMapper glassOptimizeMapper;
|
@Autowired
|
SysErrorService sysErrorService;
|
|
@Value("${mesIp:localhost}")
|
private String mesIp;
|
|
RabbitMQUtil rabbitMQUtil;
|
//模拟计算
|
|
/*public Map<String, Object> SimulationCalculation(Map<String,Object> message) {
|
Map<String, Object> map = new HashMap<>();
|
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);
|
// 收集所有需要保存的玻璃明细数据
|
List<Map<String, Object>> allGlassDetails = new ArrayList<>();
|
|
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); // 默认值
|
}
|
}
|
}
|
}
|
// 在保存之前处理 glassPoint 数据
|
for (Map<String, Object> detail : objectMap2) {
|
if (detail.containsKey("glassPoint")) {
|
Object glassPointObj = detail.get("glassPoint");
|
if (glassPointObj != null) {
|
try {
|
// 如果 glassPointObj 已经是字符串，则不需要转换
|
if (!(glassPointObj instanceof String)) {
|
// 将对象转换为 JSON 字符串
|
String glassPointStr = mapper.writeValueAsString(glassPointObj);
|
detail.put("glassPoint", glassPointStr);
|
}
|
} catch (Exception e) {
|
// 如果转换失败，记录错误并移除该字段
|
System.err.println("转换 glassPoint 失败: " + e.getMessage());
|
detail.remove("glassPoint");
|
}
|
} else {
|
// 如果 glassPointObj 为 null，移除该字段
|
detail.remove("glassPoint");
|
}
|
}
|
}
|
// 将当前批次的玻璃明细添加到总列表中
|
allGlassDetails.addAll(objectMap2);
|
}
|
|
Map<String, Object> projectInfo = glassOptimizeMapper.getGlassProjectList(projectId);
|
if (projectInfo != null && Integer.parseInt(projectInfo.get("tempering_state").toString()) == 1) {
|
// tempering_state 为 1 时的处理逻辑
|
glassOptimizeMapper.addOptimizeDetail(allGlassDetails,projectId);
|
List<OptimizeHeatDetail> optimizeHeatDetail = glassOptimizeMapper.selectOptimizeHeatDetail(projectId);
|
for (OptimizeHeatDetail projectdetail:optimizeHeatDetail){
|
OptimizeDetail optimizeDetail=glassOptimizeMapper.selectOptimizeDetailById(projectId,projectdetail.getProcessId(),
|
projectdetail.getOrderSort(),projectdetail.getLayer());
|
glassOptimizeMapper.updateOptimizeDetail(optimizeDetail.getId(),projectdetail.getLayoutId(),projectdetail.getSort());
|
}
|
} else {
|
// tempering_state 为 0 时的处理逻辑
|
glassOptimizeMapper.addOptimizeDetail(allGlassDetails,projectId);
|
}
|
List<Map<String, Object>> materialStoreList = glassOptimizeMapper.materialStoreOptimizeUse(projectId);
|
double totalUseArea = 0.0;
|
for (Map<String, Object> material : materialStoreList) {
|
if (material.containsKey("totalArea")) {
|
Object totalAreaObj = material.get("totalArea");
|
if (totalAreaObj != null) {
|
try {
|
double area = Double.parseDouble(totalAreaObj.toString());
|
totalUseArea += area;
|
} catch (NumberFormatException e) {
|
System.err.println("无法解析总面积数据: " + totalAreaObj);
|
}
|
}
|
}
|
}
|
glassOptimizeMapper.updateProjectOptimize(projectId, 1, optimalResults, totalUseArea);
|
return true;
|
} catch (Exception e) {
|
e.printStackTrace();
|
return false;
|
}
|
}
|
|
|
public Boolean updateOptimizeResult(Map<String, Object> object, String processId) {
|
try {
|
ObjectMapper mapper = new ObjectMapper();
|
|
List<Map<String, Object>> objectMapList = (List<Map<String, Object>>) object.get("layouts");
|
|
Map<String, Object> glassInfo = glassOptimizeMapper.getGlassInfo(processId);
|
glassOptimizeMapper.deleteOffcutDetails(processId);
|
|
int stockId = 1;
|
for (Map<String, Object> objectMap : objectMapList) {
|
List<Map<String, Object>> objectMap2 = (List<Map<String, Object>>) objectMap.get("glassDetails");
|
|
// 分离 glassDetails 为两部分
|
List<Map<String, Object>> normalDetails = new ArrayList<>(); // isRemain 为 false 的部分
|
List<Map<String, Object>> offCutDetails = new ArrayList<>(); // isRemain 为 true 的部分
|
|
for (Map<String, Object> detail : objectMap2) {
|
boolean isRemain = false;
|
if (detail.containsKey("isRemain")) {
|
Object isRemainObj = detail.get("isRemain");
|
if (isRemainObj != null) {
|
if (isRemainObj instanceof Number) {
|
// 数字类型: 1表示true，0表示false
|
isRemain = ((Number) isRemainObj).intValue() == 1;
|
} else if (isRemainObj instanceof Boolean) {
|
// 布尔类型
|
isRemain = (Boolean) isRemainObj;
|
} else {
|
// 字符串类型: "1"/"true"表示true，"0"/"false"表示false
|
String isRemainStr = isRemainObj.toString().toLowerCase();
|
isRemain = "1".equals(isRemainStr) || "true".equals(isRemainStr);
|
}
|
}
|
}
|
// 处理 glassPoint 序列化
|
if (detail.containsKey("glassPoint")) {
|
Object glassPointObj = detail.get("glassPoint");
|
if (glassPointObj != null) {
|
try {
|
// 如果 glassPointObj 已经是字符串，则不需要转换
|
if (!(glassPointObj instanceof String)) {
|
// 将对象转换为 JSON 字符串
|
String glassPointStr = mapper.writeValueAsString(glassPointObj);
|
detail.put("glassPoint", glassPointStr);
|
}
|
} catch (Exception e) {
|
// 如果转换失败，记录错误并移除该字段
|
System.err.println("转换 glassPoint 失败: " + e.getMessage());
|
detail.remove("glassPoint");
|
}
|
}
|
}
|
|
if (isRemain) {
|
offCutDetails.add(detail);
|
} else {
|
normalDetails.add(detail);
|
}
|
}
|
|
// 保存所有数据到 optimize_detail
|
if (!normalDetails.isEmpty()) {
|
for (Map<String, Object> detail : normalDetails) {
|
glassOptimizeMapper.updateNormalDetails(detail, processId);
|
}
|
}
|
|
// 对 remainDetails 部分先删除 offcut 再处理
|
if (!offCutDetails.isEmpty()) {
|
if (glassInfo != null) {
|
String glassType = (String) glassInfo.get("glass_type");
|
String glassThickness = (String) glassInfo.get("glass_thickness");
|
// 余料存入optimizeoffcut
|
for (Map<String, Object> detail : offCutDetails) {
|
glassOptimizeMapper.addUpdateOffcut(detail, processId, glassType, glassThickness, stockId);
|
}
|
}
|
}
|
stockId++;
|
}
|
// 更新优化结果文件
|
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 Object getOptimizeInfoSv(String processId) {
|
// 获取布局信息
|
List<Map<String, Object>> layouts = glassOptimizeMapper.getOptimizeLayoutsInfo(processId);
|
// 获取玻璃明细信息
|
List<Map<String, Object>> glassDetails = glassOptimizeMapper.getOptimizeDetailsInfo(processId);
|
// 获取余料信息
|
List<Map<String, Object>> offsets = glassOptimizeMapper.getOptimizeOffsetsInfo(processId);
|
// 将玻璃明细和余料合并到一个列表中
|
List<Map<String, Object>> allDetails = new ArrayList<>();
|
if (glassDetails != null) {
|
allDetails.addAll(glassDetails);
|
}
|
if (offsets != null) {
|
allDetails.addAll(offsets);
|
}
|
|
// 解析 glassPoint 字符串
|
ObjectMapper mapper = new ObjectMapper();
|
for (Map<String, Object> detail : allDetails) {
|
if (detail.containsKey("glassPoint")) {
|
Object glassPointObj = detail.get("glassPoint");
|
if (glassPointObj instanceof String) {
|
String glassPointStr = (String) glassPointObj;
|
if (glassPointStr != null && !glassPointStr.isEmpty() && !glassPointStr.equals("null")) {
|
try {
|
// 解析 JSON 字符串为对象
|
Object parsedGlassPoint = mapper.readValue(glassPointStr, Object.class);
|
detail.put("glassPoint", parsedGlassPoint);
|
} catch (Exception e) {
|
System.err.println("解析 glassPoint 失败: " + e.getMessage());
|
// 解析失败时保留原字符串或设置默认值
|
detail.put("glassPoint", new ArrayList<>());
|
}
|
} else {
|
// 空字符串或 null 时设置默认值
|
detail.put("glassPoint", new ArrayList<>());
|
}
|
}
|
}
|
}
|
|
// 按照stockId将明细分组并添加到对应的布局中
|
if (layouts != null && !layouts.isEmpty()) {
|
for (Map<String, Object> layout : layouts) {
|
Object stockIdObj = layout.get("stockId");
|
if (stockIdObj != null) {
|
Integer stockId = null;
|
if (stockIdObj instanceof Number) {
|
stockId = ((Number) stockIdObj).intValue();
|
} else {
|
try {
|
stockId = Integer.valueOf(stockIdObj.toString());
|
} catch (NumberFormatException e) {
|
// 如果无法转换为数字，则跳过该布局
|
continue;
|
}
|
}
|
List<Map<String, Object>> matchedDetails = new ArrayList<>();
|
for (Map<String, Object> detail : allDetails) {
|
Object layoutIdObj = detail.get("layoutId");
|
Object stockSortObj = detail.get("stockSort");
|
Integer detailStockId = null;
|
if (layoutIdObj != null) {
|
if (layoutIdObj instanceof Number) {
|
detailStockId = ((Number) layoutIdObj).intValue();
|
} else {
|
try {
|
detailStockId = Integer.valueOf(layoutIdObj.toString());
|
} catch (NumberFormatException e) {
|
// 跳过无效的layoutId
|
continue;
|
}
|
}
|
} else if (stockSortObj != null) {
|
if (stockSortObj instanceof Number) {
|
detailStockId = ((Number) stockSortObj).intValue();
|
} else {
|
try {
|
detailStockId = Integer.valueOf(stockSortObj.toString());
|
} catch (NumberFormatException e) {
|
// 跳过无效的stockSort
|
continue;
|
}
|
}
|
}
|
// 如果detail的stockId与layout的stockId匹配，则添加到匹配列表中
|
if (detailStockId != null && detailStockId.equals(stockId)) {
|
matchedDetails.add(detail);
|
}
|
}
|
// 将匹配的明细添加到布局的glassDetails字段中
|
layout.put("glassDetails", matchedDetails);
|
}
|
}
|
}
|
// Map<String, Object> result = new HashMap<>();
|
Map<String, Object> result = new LinkedHashMap<>();
|
result.put("layouts", layouts);
|
result.put("optimizeUse", glassOptimizeMapper.materialOptimizeUse(processId));
|
return result;
|
}
|
|
|
//工程信息
|
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>> tempDataList = null;
|
if (Integer.parseInt(stringObjectMap.get("optimize_state").toString())==1) {
|
tempDataList = glassOptimizeMapper.optimizeTemp(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());
|
}
|
}
|
}
|
}
|
if (tempDataList != null && !tempDataList.isEmpty()) {
|
dataList.addAll(tempDataList);
|
}
|
map.put("optimizeState", Integer.parseInt(stringObjectMap.get("optimize_state").toString()));
|
map.put("data", dataList);
|
map.put("project", glassOptimizeMapper.selectProjectCount(projectNo));
|
map.put("grindingTrimming", glassOptimizeMapper.getGrindingTrimming(username));
|
return map;
|
}
|
|
|
//工程信息流程卡
|
public Map<String, Object> getProcessCardSv(String projectNo) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", glassOptimizeMapper.getProcessCardMp(projectNo));
|
return map;
|
}
|
|
//库存信息
|
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<>();
|
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;
|
}
|
|
|
//工程查询流程卡
|
public Map<String, Object> getFlowCardList(String optionVal, Integer radio) {
|
Map<String, Object> map = new HashMap<>();
|
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;
|
}
|
|
//工程管理查询
|
public Map<String, Object> OptimizeProjectMange(Date startSelectTime, Date endSelectTime, OptimizeProjectMange optimizeProjectMange) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", glassOptimizeMapper.optimizeProjectMangeMp(startSelectTime, endSelectTime , optimizeProjectMange));
|
return map;
|
}
|
|
//修改排版状态
|
public Boolean updateProjectState(String projectNumber, Integer state,Integer states, Integer code) throws JsonProcessingException {
|
if (!projectNumber.isEmpty()) {
|
//撤销模拟计算
|
if(code==1){
|
glassOptimizeMapper.deleteOptimizeHeatDetail(projectNumber);
|
glassOptimizeMapper.deleteOptimizeHeatLayout(projectNumber);
|
glassOptimizeMapper.updateProjectTemperingStateMp(projectNumber, states);
|
Map<String, Object> temperingState = glassOptimizeMapper.getProjectState(projectNumber);
|
|
if (temperingState != null && temperingState.containsKey("optimize_state")) {
|
Object optimizeStateObj = temperingState.get("optimize_state");
|
if (optimizeStateObj != null) {
|
try {
|
int optimizeState = Integer.parseInt(optimizeStateObj.toString());
|
if (optimizeState == 1) {
|
glassOptimizeMapper.updateProjectTemperingId(projectNumber);
|
}
|
} catch (NumberFormatException e) {
|
// 处理转换异常，记录日志或采取其他适当措施
|
System.err.println("解析 optimize_state 失败: " + e.getMessage());
|
}
|
}
|
}
|
}
|
//撤销优化排版
|
else if(code==2){
|
glassOptimizeMapper.deleteOptimizeDetail(projectNumber);
|
glassOptimizeMapper.deleteOptimizeLayout(projectNumber);
|
glassOptimizeMapper.deleteOptimizeOffcut(projectNumber);
|
glassOptimizeMapper.deleteOptimizeProjectFile(projectNumber);
|
glassOptimizeMapper.updateOptimizeUse(projectNumber);
|
glassOptimizeMapper.updateProjectOptimizeStateMp(projectNumber, states);
|
}
|
//允许生产
|
else if(code==3){
|
Boolean isSeccess = issuingProjects(projectNumber);
|
if(isSeccess){
|
glassOptimizeMapper.updateProjectStateMp(projectNumber, state);
|
}else{
|
return false;
|
}
|
}
|
//生产不可见
|
else if(code==4){
|
Map<String, Object> cancelResult = issuingCancelProject(projectNumber);
|
// 获取返回结果中的data字段
|
Map<String, Object> responseData = (Map<String, Object>) cancelResult.get("data");
|
// 检查响应中的code字段，只有当code为200或202时才允许更新状态
|
if (responseData != null && responseData.containsKey("code")) {
|
Object responseCode = responseData.get("code");
|
if (responseCode.equals(200) || responseCode.equals(202)) {
|
glassOptimizeMapper.updateProjectStateMp(projectNumber, state);
|
} else if (responseCode.equals(201)) {
|
// 当返回201时，抛出自定义异常或返回错误信息
|
throw new RuntimeException(responseData.get("message").toString());
|
} else {
|
return false;
|
}
|
} else {
|
return false;
|
}
|
|
}
|
//初始化工程
|
else if(code==5){
|
glassOptimizeMapper.updateProjectStateMp(projectNumber, state);
|
}
|
return true;
|
} else {
|
return false;
|
}
|
}
|
|
//删除工程
|
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;
|
}
|
|
|
public Map<String, Object> getProjectListSv() {
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", glassOptimizeMapper.getProjectListMp());
|
return map;
|
}
|
|
//模拟计算工程号查询
|
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,Integer technologyNumber,String patchState) {
|
Map<String, Object> map = new HashMap<>();
|
if(patchState.equals("0")){
|
map.put("data", glassOptimizeMapper.selectComputeDetailMp(processId,technologyNumber));
|
}else{
|
map.put("data", glassOptimizeMapper.selectComputeDetailMpPatchState(processId,technologyNumber));
|
}
|
return map;
|
}
|
|
public Map<String, Object> getProcessCardDetailSv(String processId, Integer technologyNumber) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", glassOptimizeMapper.getProcessCardDetailmMp(processId,technologyNumber));
|
return map;
|
}
|
|
public Map<String, Object> selectGlassTypeSv() {
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", glassOptimizeMapper.selectGlassTypeMp());
|
return map;
|
}
|
|
|
public Map<String, Object> getProjectIdSv() {
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", glassOptimizeMapper.getProjectIdSv());
|
return map;
|
}
|
|
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();
|
}
|
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(projectType.equals("2")){
|
deleteProject(projectId,2);
|
}
|
|
// 创建一个映射来存储 (processId-technologyNumber) 组合到 rack 编号的映射
|
Map<String, Integer> rackMap = new HashMap<>();
|
int rackCounter = 1;
|
|
// 如果为空流程卡，则将 type 设置为 1
|
if (flowCardList == null || flowCardList.isEmpty()) {
|
type = 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";
|
}
|
}
|
} 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("钢化")){
|
String existingConfig = glassOptimizeMapper.selectConfigByUserAndType(username, 1);
|
if (existingConfig == null) {
|
String configName = "钢化推荐";
|
glassOptimizeMapper.insertOptimizeConfig(json,1,username,configName);
|
}else {
|
glassOptimizeMapper.updateOptimizeConfig(json,1,username);
|
}
|
} else if (type.equals("修边")) {
|
String existingConfig = glassOptimizeMapper.selectConfigByUserAndType(username, 5);
|
if (existingConfig == null) {
|
String configName = "修边配置";
|
glassOptimizeMapper.insertOptimizeConfig(json,5,username,configName);
|
}else {
|
glassOptimizeMapper.updateOptimizeConfig(json,5,username);
|
}
|
}else if (type.equals("磨量")) {
|
String existingConfig = glassOptimizeMapper.selectConfigByUserAndType(username, 4);
|
if (existingConfig == null) {
|
String configName = "磨量配置";
|
glassOptimizeMapper.insertOptimizeConfig(json,4,username,configName);
|
}else{
|
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 {
|
System.out.println(mesIp);
|
// 1. 创建URL对象
|
URL url = new URL("http://" + mesIp + ":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;
|
}
|
|
|
public Map<String, Object> getReportDataSv(String processId) {
|
Map<String, Object> perimap = new HashMap<>();
|
perimap.put("peridata", glassOptimizeMapper.getPeriMeterDataSv(processId));
|
|
Map<String, Object> map = new HashMap<>();
|
Object layoutSetObj = glassOptimizeMapper.getReportDataProcessIdSv(processId);
|
map.put("reportData", layoutSetObj);
|
List<Map<String, Object>> peridata = (List<Map<String, Object>>) perimap.get("peridata");
|
double totalPerimeter = 0.0;
|
if (peridata != null && !peridata.isEmpty()) {
|
for (Map<String, Object> perimeterData : peridata) {
|
if (perimeterData.containsKey("perimeter") && perimeterData.get("perimeter") != null) {
|
try {
|
Object perimeterObj = perimeterData.get("perimeter");
|
if (perimeterObj instanceof Number) {
|
totalPerimeter += ((Number) perimeterObj).doubleValue();
|
} else {
|
totalPerimeter += Double.parseDouble(perimeterObj.toString());
|
}
|
} catch (NumberFormatException e) {
|
System.err.println("无法解析周长数据: " + perimeterData.get("perimeter"));
|
}
|
}
|
}
|
}
|
|
if (layoutSetObj instanceof List) {
|
List<Map<String, Object>> layoutSet = (List<Map<String, Object>>) layoutSetObj;
|
if (!layoutSet.isEmpty()) {
|
layoutSet.get(0).put("rectanglePerimeter", totalPerimeter);
|
}
|
}
|
return map;
|
}
|
|
public Map<String, Object> getMaterialInfoSv(String processId) {
|
Map<String, Object> map = new HashMap<>();
|
// List<Map<String, Object>> materialList = glassOptimizeMapper.getMaterialInfoSv(processId);
|
List<Map<String, Object>> layoutSet = glassOptimizeMapper.getLayoutSetSv(processId);
|
|
// // 创建一个Map来存储每个stock_code的总面积
|
// Map<String, Double> stockCodeAreaMap = new HashMap<>();
|
//
|
// // 遍历layoutSet计算每个stock_code的总面积(面积*使用率)
|
// for (Map<String, Object> layout : layoutSet) {
|
// Object stockCodeObj = layout.get("stock_code");
|
// Object widthObj = layout.get("width");
|
// Object heightObj = layout.get("height");
|
// Object usageRateObj = layout.get("usage_rate");
|
//
|
// if (stockCodeObj != null && widthObj != null && heightObj != null && usageRateObj != null) {
|
// try {
|
// String stockCode = stockCodeObj.toString();
|
// double width = Double.parseDouble(widthObj.toString());
|
// double height = Double.parseDouble(heightObj.toString());
|
// double usageRate = Double.parseDouble(usageRateObj.toString());
|
//
|
// // 计算单条数据的面积(平方米)
|
// double area = (width * height * usageRate) / 1000000.0;
|
//
|
// // 累加到对应stock_code的总面积
|
// stockCodeAreaMap.put(stockCode, stockCodeAreaMap.getOrDefault(stockCode, 0.0) + area);
|
// } catch (NumberFormatException e) {
|
// System.err.println("数据转换错误: " + e.getMessage());
|
// }
|
// }
|
// }
|
//
|
// // 将计算出的总面积添加到materialList中对应的物料数据
|
// for (Map<String, Object> material : materialList) {
|
// Object stockCodeObj = material.get("code");
|
// if (stockCodeObj != null) {
|
// String stockCode = stockCodeObj.toString();
|
// if (stockCodeAreaMap.containsKey(stockCode)) {
|
// material.put("totalArea", stockCodeAreaMap.get(stockCode));
|
// }
|
// }
|
// }
|
|
map.put("materialList", layoutSet);
|
return map;
|
}
|
|
|
public Map<String, Object> getProductListSv(String processId) {
|
Map<String, Object> productMap = new HashMap<>();
|
List<Map<String, Object>> productInfo = glassOptimizeMapper.selectProjectList(processId);
|
List<Map<String, Object>> tempProductInfo = glassOptimizeMapper.selectTempProject(processId);
|
productInfo.addAll(tempProductInfo);
|
productMap.put("productInfo", productInfo);
|
Map<String, Object> map = new HashMap<>();
|
|
if (productInfo != null && !productInfo.isEmpty()) {
|
// 按照 processCard 分组
|
Map<String, List<Map<String, Object>>> groupedByProcessCard = new HashMap<>();
|
for (Map<String, Object> item : productInfo) {
|
String processCard = String.valueOf(item.get("processCard"));
|
if (processCard != null) {
|
groupedByProcessCard.computeIfAbsent(processCard, k -> new ArrayList<>()).add(item);
|
}
|
}
|
|
// 为每个 processCard 计算统计信息
|
List<Map<String, Object>> result = new ArrayList<>();
|
for (Map.Entry<String, List<Map<String, Object>>> entry : groupedByProcessCard.entrySet()) {
|
String processCard = entry.getKey();
|
List<Map<String, Object>> items = entry.getValue();
|
|
// 计算统计信息
|
double longestSide = 0;
|
double shortestSide = Double.MAX_VALUE;
|
int specQuantity = items.size();
|
int totalQuantity = 0;
|
|
// 使用 BigDecimal 精确计算面积
|
BigDecimal totalArea = BigDecimal.ZERO;
|
|
for (Map<String, Object> item : items) {
|
// 安全获取长和宽
|
Number widthObj = (Number) item.get("width");
|
Number heightObj = (Number) item.get("height");
|
|
if (widthObj == null || heightObj == null) {
|
continue;
|
}
|
|
double width = widthObj.doubleValue();
|
double height = heightObj.doubleValue();
|
|
// 更新最长边和最短边
|
double maxSide = Math.max(width, height);
|
double minSide = Math.min(width, height);
|
|
if (maxSide > longestSide) {
|
longestSide = maxSide;
|
}
|
if (minSide < shortestSide) {
|
shortestSide = minSide;
|
}
|
|
// 安全获取数量
|
Number quantityObj = (Number) item.get("quantity");
|
if (quantityObj != null) {
|
totalQuantity += quantityObj.intValue();
|
}
|
|
// 安全获取面积 —— 使用 BigDecimal 精确累加
|
Object areaObj = item.get("Area");
|
if (areaObj != null) {
|
// 关键：通过 toString() 转为字符串再构造 BigDecimal，避免 double 精度损失
|
BigDecimal area = new BigDecimal(areaObj.toString());
|
totalArea = totalArea.add(area);
|
}
|
}
|
|
// 处理 shortestSide 的边界情况
|
if (shortestSide == Double.MAX_VALUE) {
|
shortestSide = 0;
|
}
|
|
// 构造返回数据
|
Map<String, Object> resultMap = new HashMap<>();
|
resultMap.put("processCard", processCard);
|
resultMap.put("longestSide", longestSide);
|
resultMap.put("shortestSide", shortestSide);
|
resultMap.put("specQuantity", specQuantity);
|
resultMap.put("totalQuantity", totalQuantity);
|
resultMap.put("totalArea", totalArea);
|
|
result.add(resultMap);
|
}
|
|
map.put("productList", result);
|
}
|
return map;
|
}
|
|
|
public Map<String, Object> getProjectState(String projectNo) {
|
Map<String, Object> map = new HashMap<>();
|
map.put("data", glassOptimizeMapper.getProjectState(projectNo));
|
return map;
|
}
|
|
public Map<String, Object> issuingCancelProject(String projectNo){
|
Map<String, Object> result = new HashMap<>();
|
Map<String, Object> responseData = new HashMap<>();
|
|
try {
|
// 1. 创建URL对象
|
URL url = new URL("http://" + mesIp + ":88/api/loadGlass/engineering/optimizeCancelTask");
|
// URL url = new URL("http://localhost:88/api/loadGlass/engineering/optimizeCancelTask");
|
|
|
// 2. 打开连接
|
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
|
conn.setRequestMethod("POST");
|
conn.setRequestProperty("Content-Type", "application/json");
|
conn.setRequestProperty("Accept", "application/json");
|
conn.setDoOutput(true);
|
|
// 3. 准备请求体 - 将projectNo转换为engineerId格式
|
String engineerId = projectNo;
|
// 如果传入的是JSON字符串，需要提取真正的projectNo值
|
if (projectNo.startsWith("{") && projectNo.contains("\"projectNo\"")) {
|
try {
|
JSONObject jsonObject = JSONObject.parseObject(projectNo);
|
engineerId = jsonObject.getString("projectNo");
|
} catch (Exception e) {
|
// 解析失败时使用原始值
|
System.err.println("解析projectNo JSON失败: " + e.getMessage());
|
}
|
}
|
|
// 构建新的JSON请求体，使用engineerId字段
|
String jsonInputString = "{\"engineerId\":\"" + engineerId + "\"}";
|
System.out.println("engineerId: " + engineerId);
|
System.out.println("Request: " + jsonInputString);
|
|
//发送请求
|
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());
|
}
|
String fullResponse = response.toString();
|
System.out.println("Response: " + fullResponse);
|
|
// 直接将响应内容解析为Map
|
responseData = JSONObject.parseObject(fullResponse, Map.class);
|
}
|
|
//关闭连接
|
conn.disconnect();
|
} catch (Exception e) {
|
e.printStackTrace();
|
// 异常情况下将异常信息放入data
|
responseData.put("error", e.getMessage());
|
}
|
|
// 构造最终返回结果
|
result.put("data", responseData);
|
|
return result;
|
}
|
|
|
public void processExternalOptimizeRequest(MesCalculateDTO mesCalculateDTO){
|
// 使用反射将对象转换为 Map，使用 Java 字段名
|
List<Map<String, Object>> materialDetailList = new ArrayList<>();
|
if (mesCalculateDTO.getEngineeringRawQueueList() != null) {
|
for (MesCalculateDTO.EngineeringRawQueue materialDetail : mesCalculateDTO.getEngineeringRawQueueList()) {
|
Map<String, Object> materialMap = objectToMapUsingFields(materialDetail);
|
materialDetailList.add(materialMap);
|
}
|
}
|
|
List<Map<String, Object>> glassDetailList = new ArrayList<>();
|
if (mesCalculateDTO.getGlassInfoList() != null) {
|
for (MesCalculateDTO.GlassInfo glassDetail : mesCalculateDTO.getGlassInfoList()) {
|
Map<String, Object> glassMap = objectToMapUsingFields(glassDetail);
|
glassDetailList.add(glassMap);
|
}
|
}
|
|
List<Map<String, Object>> glassDamageList = new ArrayList<>();
|
if (mesCalculateDTO.getDamageList() != null) {
|
for (MesCalculateDTO.DamageList damageInfo : mesCalculateDTO.getDamageList()) {
|
Map<String, Object> damageMap = objectToMapUsingFields(damageInfo);
|
glassDamageList.add(damageMap);
|
}
|
}
|
|
List<Map<String, Object>> glassDamageTempList = new ArrayList<>();
|
if (mesCalculateDTO.getDamageList() != null) {
|
for (MesCalculateDTO.DamageList damageInfo : mesCalculateDTO.getDamageList()) {
|
Map<String, Object> damageMap = objectToMapUsingFields(damageInfo);
|
// 创建新的Map只保留glassId字段并添加reportState字段
|
Map<String, Object> filteredDamageMap = new HashMap<>();
|
if (damageMap.containsKey("glassId")) {
|
filteredDamageMap.put("glassId", damageMap.get("glassId"));
|
}
|
filteredDamageMap.put("reportState", 10);
|
glassDamageTempList.add(filteredDamageMap);
|
}
|
}
|
|
String projectNo = mesCalculateDTO.getEngineerId();
|
System.out.println("projectNo: " + projectNo);
|
|
for (Map<String, Object> materialDetail : materialDetailList) {
|
Object stockId = materialDetail.get("rawSequence");
|
Map<String, Object> trimInfo = glassOptimizeMapper.getTrimInfo(projectNo, stockId);
|
if (trimInfo != null) {
|
materialDetail.putAll(trimInfo);
|
}
|
}
|
|
Map<String, Object> glassOptimaizeMap = new HashMap<>();
|
Map<String, Object> optimizeProperty = glassOptimizeMapper.getGlassType(projectNo);
|
|
glassOptimaizeMap.put("requestSource", "ERP");
|
glassOptimaizeMap.put("usageRate", mesCalculateDTO.getUsageRate());
|
glassOptimaizeMap.put("optimizeProperty", optimizeProperty);
|
glassOptimaizeMap.put("engineeringRawQueueList", materialDetailList);
|
glassOptimaizeMap.put("glassInfoList", glassDetailList);
|
|
try {
|
ObjectMapper objectMapper = new ObjectMapper();
|
|
String glassDamageListJson = objectMapper.writeValueAsString(glassDamageList);
|
System.out.println("damageList JSON: " + glassDamageListJson);
|
|
String glassDamageTempListJson = objectMapper.writeValueAsString(glassDamageTempList);
|
System.out.println("glassDamageTempListJson: " + glassDamageTempListJson);
|
|
String optimizeJsonString = objectMapper.writeValueAsString(glassOptimaizeMap);
|
System.out.println("glassTypeMap JSON: " + optimizeJsonString);
|
|
// 获取并输出动态优化返回结果
|
String optimizeResult = callDynamicOptimizeApi(optimizeJsonString);
|
System.out.println("动态优化返回结果: " + optimizeResult);
|
|
// 将结果转换为JSON格式
|
Object optimaizeResultJson = null;
|
try {
|
// 尝试解析为JSON对象
|
optimaizeResultJson = objectMapper.readValue(optimizeResult, Object.class);
|
} catch (Exception e) {
|
// 如果不是有效的JSON字符串，创建一个包含原始字符串的Map
|
Map<String, String> errorResult = new HashMap<>();
|
errorResult.put("result", optimizeResult);
|
optimaizeResultJson = errorResult;
|
}
|
|
// 输出JSON格式的结果
|
String jsonOptimizeResult = objectMapper.writeValueAsString(optimaizeResultJson);
|
System.out.println("动态优化返回结果JSON格式: " + jsonOptimizeResult);
|
|
// 调用issuingDamageDynamicProjects接口
|
Boolean MESResult = issuingDamageDynamicProjects(projectNo, glassDamageTempList);
|
System.out.println("MES返回结果: " + MESResult);
|
|
|
// 检查issuingDamageDynamicProjects接口调用结果，如果失败则停止后续操作
|
if (!MESResult) {
|
System.out.println("issuingDamageDynamicProjects接口调用失败，停止后续操作");
|
return;
|
}
|
|
// 调用cutFiles接口
|
Boolean cutFileResult = callCutFilesApi(jsonOptimizeResult);
|
System.out.println("调用cutFiles接口返回结果: " + cutFileResult);
|
|
// 检查cutFiles接口调用结果，如果失败则停止后续操作
|
if (!cutFileResult) {
|
System.out.println("cutFiles接口调用失败，停止后续操作");
|
return;
|
}
|
|
// 调用issuingDynamicProjects接口
|
Boolean MESTwiceResult = issuingDynamicProjects(projectNo);
|
System.out.println("MES二次返回结果: " + MESTwiceResult);
|
|
// 检查issuingDynamicProjects接口调用结果，如果失败则停止后续操作
|
if (!MESTwiceResult) {
|
System.out.println("issuingDynamicProjects接口调用失败，停止后续操作");
|
}
|
|
} catch (JsonProcessingException e) {
|
System.err.println("转换JSON失败: " + e.getMessage());
|
}
|
}
|
|
|
|
|
// 使用反射将对象转换为 Map，使用 Java 字段名
|
private Map<String, Object> objectToMapUsingFields(Object obj) {
|
Map<String, Object> map = new HashMap<>();
|
if (obj == null) return map;
|
|
Class<?> clazz = obj.getClass();
|
Field[] fields = clazz.getDeclaredFields();
|
|
for (Field field : fields) {
|
try {
|
field.setAccessible(true);
|
Object value = field.get(obj);
|
// 使用 Java 字段名作为 key
|
map.put(field.getName(), value);
|
} catch (IllegalAccessException e) {
|
// 记录或处理异常
|
System.err.println("访问字段失败: " + field.getName() + ", 错误: " + e.getMessage());
|
}
|
}
|
return map;
|
}
|
|
private String callDynamicOptimizeApi(String jsonData) {
|
try {
|
URL url = new URL("http://" + mesIp + ":8078/api/dynamicOptimize");
|
|
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
|
|
// 设置请求方法
|
conn.setRequestMethod("POST");
|
|
// 设置请求头
|
conn.setRequestProperty("Content-Type", "application/json; charset=UTF-8");
|
conn.setRequestProperty("Accept", "application/json");
|
|
// 允许输出
|
conn.setDoOutput(true);
|
|
// 设置超时时间
|
conn.setConnectTimeout(10000); // 10秒连接超时
|
conn.setReadTimeout(30000); // 30秒读取超时
|
|
// 发送JSON数据
|
try (OutputStream os = conn.getOutputStream()) {
|
byte[] input = jsonData.getBytes(StandardCharsets.UTF_8);
|
os.write(input, 0, input.length);
|
}
|
|
// 读取响应
|
StringBuilder response = new StringBuilder();
|
try (BufferedReader br = new BufferedReader(
|
new InputStreamReader(conn.getInputStream(), StandardCharsets.UTF_8))) {
|
String responseLine;
|
while ((responseLine = br.readLine()) != null) {
|
response.append(responseLine.trim());
|
}
|
}
|
|
String responseResult = response.toString();
|
System.out.println("优化软件响应结果: " + responseResult);
|
// 断开连接
|
conn.disconnect();
|
|
ObjectMapper objectMapper = new ObjectMapper();
|
// 启用类型转换功能，允许将浮点数转换为整数
|
objectMapper.configure(DeserializationFeature.ACCEPT_FLOAT_AS_INT, true);
|
Map<String, Object> responseMap = objectMapper.readValue(responseResult, Map.class);
|
|
// 检查code是否为200
|
Object codeObj = responseMap.get("code");
|
int code = -1;
|
if (codeObj instanceof Integer) {
|
code = (Integer) codeObj;
|
} else if (codeObj instanceof String) {
|
try {
|
code = Integer.parseInt((String) codeObj);
|
} catch (NumberFormatException e) {
|
System.err.println("无法解析code字段: " + codeObj);
|
}
|
}
|
|
if (code == 200) {
|
// 设置回滚点，用于事务处理
|
Object savePoint = TransactionAspectSupport.currentTransactionStatus().createSavepoint();
|
try {
|
// 返回data字段的内容作为JSON字符串
|
Object dataObj = responseMap.get("data");
|
if (dataObj != null) {
|
// 确保 dataObj 是 Map 类型并验证 projectNo 字段
|
if (dataObj instanceof Map) {
|
Map<String, Object> dataMap = (Map<String, Object>) dataObj;
|
|
// 验证 projectNo 是否存在
|
Object projectNoObj = dataMap.get("projectNo");
|
if (projectNoObj == null) {
|
throw new RuntimeException("projectNo 不能为空");
|
}
|
|
String projectNo = projectNoObj.toString();
|
dataMap.put("projectNo", projectNo);
|
|
// 删除已存在的相关数据
|
glassOptimizeMapper.deleteOptimizeDynamicProject(projectNo);
|
glassOptimizeMapper.deleteOptimizeDynamicLayout(projectNo);
|
glassOptimizeMapper.deleteOptimizeDynamicDetail(projectNo);
|
|
// 插入动态项目
|
glassOptimizeMapper.insertDynamicProject(dataMap);
|
|
// 处理 layouts 数组并插入
|
Object layoutsObj = dataMap.get("layouts");
|
if (layoutsObj instanceof List) {
|
@SuppressWarnings("unchecked")
|
List<Map<String, Object>> layouts = (List<Map<String, Object>>) layoutsObj;
|
|
for (Map<String, Object> layout : layouts) {
|
// 为每个 layout 添加 projectNo
|
layout.put("projectNo", projectNo);
|
|
// 获取当前 layout 的 glassDetails
|
Object glassDetailsObj = layout.get("glassDetails");
|
if (glassDetailsObj instanceof List) {
|
@SuppressWarnings("unchecked")
|
List<Map<String, Object>> glassDetails = (List<Map<String, Object>>) glassDetailsObj;
|
|
// 为每个 glassDetail 添加 projectNo 和处理 glassPoint
|
for (Map<String, Object> detail : glassDetails) {
|
detail.put("projectNo", projectNo);
|
|
|
// 处理 isRotate 为 1 时交换 width 和 height 的逻辑
|
if (detail.containsKey("isRotate")) {
|
Object isRotateObj = detail.get("isRotate");
|
int isRotate = 0;
|
if (isRotateObj instanceof Number) {
|
isRotate = ((Number) isRotateObj).intValue();
|
} else if (isRotateObj instanceof String) {
|
isRotate = Integer.parseInt(isRotateObj.toString());
|
}
|
|
if (isRotate == 1) {
|
// 交换 width 和 height
|
Object widthObj = detail.get("width");
|
Object heightObj = detail.get("height");
|
detail.put("width", heightObj);
|
detail.put("height", widthObj);
|
|
|
}
|
}
|
|
// 处理 glassPoint 字段转换
|
if (detail.containsKey("glassPoint")) {
|
Object glassPointObj = detail.get("glassPoint");
|
if (glassPointObj != null) {
|
try {
|
// 如果 glassPointObj 已经是字符串，则不需要转换
|
if (!(glassPointObj instanceof String)) {
|
// 将对象转换为 JSON 字符串
|
String glassPointStr = objectMapper.writeValueAsString(glassPointObj);
|
detail.put("glassPoint", glassPointStr);
|
}
|
} catch (Exception e) {
|
// 如果转换失败，记录错误并移除该字段
|
System.err.println("转换 glassPoint 失败: " + e.getMessage());
|
detail.remove("glassPoint");
|
}
|
} else {
|
// 如果 glassPointObj 为 null，移除该字段
|
detail.remove("glassPoint");
|
}
|
}
|
}
|
|
glassOptimizeMapper.insertDynamicDetail(glassDetails, projectNo);
|
}
|
|
// 插入 layout 到 optimize_dynamic_layout 表
|
glassOptimizeMapper.insertDynamicLayout(layout);
|
}
|
}
|
}
|
return responseResult;
|
} else {
|
return "{}"; // 如果data字段为空，返回空JSON对象
|
}
|
} catch (Exception e) {
|
// 发生异常时回滚事务
|
TransactionAspectSupport.currentTransactionStatus().rollbackToSavepoint(savePoint);
|
throw e; // 重新抛出异常
|
}
|
} else {
|
// 当code不是200时，返回错误信息
|
Object messageObj = responseMap.get("message");
|
String errorMessage = "接口返回错误码: " + code;
|
if (messageObj != null) {
|
errorMessage = messageObj.toString();
|
}
|
return errorMessage;
|
}
|
|
} catch (Exception e) {
|
System.err.println("调用动态优化接口失败: " + e.getMessage());
|
e.printStackTrace();
|
return "调用动态优化接口失败: " + e.getMessage();
|
}
|
}
|
|
|
public Boolean issuingDamageDynamicProjects(String projectNo, List<Map<String, Object>> glassDamageTempList){
|
boolean saveState=false;
|
try {
|
System.out.println(mesIp);
|
// 1. 创建URL对象
|
URL url = new URL("http://" + mesIp + ":88/api/loadGlass/engineering/engineerOptimizeImport");
|
|
// 2. 打开连接
|
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
|
conn.setRequestMethod("POST");
|
conn.setRequestProperty("Content-Type", "application/json");
|
conn.setRequestProperty("Accept", "application/json");
|
conn.setDoOutput(true);
|
|
// 3. 准备请求体
|
|
// 获取glassInfolList数据
|
List<Map<String, Object>> glassInfolList = glassOptimizeMapper.selectOptimizeDynamicDetail(projectNo);
|
|
// 处理damageList，对glassInfolList中存在的glassId设置reportState为10，不存在的设置为1
|
List<Map<String, Object>> processedDamageList = new ArrayList<>();
|
Set<String> glassIdSet = new HashSet<>();
|
|
// 收集glassInfolList中的所有glassId
|
for (Map<String, Object> glassInfo : glassInfolList) {
|
if (glassInfo.containsKey("glassId") && glassInfo.get("glassId") != null) {
|
glassIdSet.add(glassInfo.get("glassId").toString());
|
}
|
}
|
|
// 处理glassDamageTempList，根据glassId是否在glassInfolList中存在来设置reportState
|
for (Map<String, Object> damageItem : glassDamageTempList) {
|
if (damageItem.containsKey("glassId") && damageItem.get("glassId") != null) {
|
String glassId = damageItem.get("glassId").toString();
|
Map<String, Object> processedItem = new HashMap<>(damageItem);
|
|
// 如果glassId在glassInfolList中存在，reportState保持为10，否则改为1
|
if (glassIdSet.contains(glassId)) {
|
// glassId存在，保持reportState为10（已在glassDamageTempList中设置）
|
processedItem.put("reportState", 10);
|
} else {
|
// glassId不存在，将reportState改为1
|
processedItem.put("reportState", 6);
|
}
|
|
processedDamageList.add(processedItem);
|
}
|
}
|
|
Map<String, Object> optimizeProject=glassOptimizeMapper.selectOptimizeDynamicProject(projectNo);
|
optimizeProject.put("engineeringRawQueueList", glassOptimizeMapper.selectOptimizeDynamicLayout(projectNo));
|
optimizeProject.put("glassInfolList", glassOptimizeMapper.selectOptimizeDynamicDetail(projectNo));
|
optimizeProject.put("flowCardInfoList", glassOptimizeMapper.selectFlowCardDynamicInfoList(projectNo));
|
optimizeProject.put("damageList", processedDamageList);
|
ObjectMapper mapper = new ObjectMapper();
|
mapper.registerModule(new JavaTimeModule());
|
String jsonInputString = mapper.writeValueAsString(optimizeProject);
|
System.out.println("传给MES的数据"+ jsonInputString);
|
|
//发送请求
|
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("MES第一次返回信息： " + 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;
|
}
|
|
|
public Boolean issuingDynamicProjects(String projectNo){
|
boolean saveState=false;
|
try {
|
System.out.println(mesIp);
|
// 1. 创建URL对象
|
URL url = new URL("http://" + mesIp + ":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.selectOptimizeDynamicProject(projectNo);
|
optimizeProject.put("engineeringRawQueueList", glassOptimizeMapper.selectOptimizeDynamicLayout(projectNo));
|
optimizeProject.put("glassInfolList", glassOptimizeMapper.selectOptimizeDynamicDetail(projectNo));
|
optimizeProject.put("flowCardInfoList", glassOptimizeMapper.selectFlowCardDynamicInfoList(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("MES第二次返回信息: " + 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;
|
}
|
|
|
private Boolean callCutFilesApi(String jsonOptimizeResult) {
|
boolean saveState = false;
|
try {
|
System.out.println(mesIp);
|
// 1. 创建URL对象
|
URL url = new URL("http://" + mesIp + ":8078/api/resultToCutFiles");
|
|
// 2. 打开连接
|
HttpURLConnection conn = (HttpURLConnection) url.openConnection();
|
conn.setRequestMethod("POST");
|
conn.setRequestProperty("Content-Type", "application/json");
|
conn.setRequestProperty("Accept", "application/json");
|
conn.setDoOutput(true);
|
|
// 3. 发送请求体
|
try(OutputStream os = conn.getOutputStream()) {
|
byte[] input = jsonOptimizeResult.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.toString());
|
JSONObject obj = JSONObject.parseObject(response.toString());
|
if(obj.get("code").equals(200)){
|
saveState = true;
|
}
|
|
}
|
|
//关闭连接
|
conn.disconnect();
|
} catch (Exception e) {
|
e.printStackTrace();
|
saveState = false;
|
}
|
return saveState;
|
}
|
}
|
