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

guoyujie

2025-07-30 6f788dbafd2a6b75fc7e4b95d61eb87f19c4736b

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

 north-glass-erp/northglass-erp/config.js

@@ -1,4 +1,5 @@
export default {
  serverUrl:"localhost:8086",
  serverUrlTemp:"10.153.19.150:8079",
  //serverUrl:"192.168.1.199:8086"
}

 north-glass-erp/northglass-erp/src/utils/requestTemp.js

New file
@@ -0,0 +1,59 @@
import axios from 'axios'
import config from '../../config'
import useUserInfoStore from '@/stores/userInfo'
const userStore=useUserInfoStore()
const request = axios.create({
    baseURL: `http://${config.serverUrlTemp}`,  // 注意！！ 这里是全局统一加上了 后端接口前缀 前缀，后端必须进行跨域配置！
    timeout: 60000
})



//

// request 拦截器
// 可以自请求发送前对请求做一些处理
// 比如统一加token，对请求参数统一加密
request.interceptors.request.use(config => {
    config.headers['Content-Type'] = 'application/json;charset=utf-8';
    if(userStore.user){
        config.headers['satoken'] = userStore.user.token;
    }
      // 设置请求头
    return config
}, error => {
    return Promise.reject(error)
});

// response 拦截器
// 可以在接口响应后统一处理结果
request.interceptors.response.use(
    response => {
        let res = response.data
        //传递报错信息，把报错信息传递到pinia中
        userStore.setResponseCode(parseInt(res.code),res.msg)
        if((res.code != 200 && res.code != '200')){
            if(response.config.responseType !== 'blob'){
                return Promise.reject(res.code)
            }
        }

        // 如果是返回的文件
        if (response.config.responseType === 'blob') {
            return res
        }
        // 兼容服务端返回的字符串数据
        if (typeof res === 'string') {
            res = res ? JSON.parse(res) : res
        }
        return res;
    },
    error => {
        console.log('err' + error) // for debug
        return Promise.reject(error)
    }
)


export default request


 north-glass-erp/northglass-erp/src/views/pp/glassOptimize/GlassComputed.vue

@@ -5,6 +5,7 @@
import {onMounted, ref} from 'vue';
import {ElMessage, ElLoading} from "element-plus";
import request from "@/utils/request";
import requestTemp from "@/utils/requestTemp";

const props = defineProps({
  project : null
@@ -58,6 +59,35 @@
// 用于存储从后端获取到的数据，初始化为空数组
const receivedData = ref([]);

const fetchProjectInfo = async (projectNumber) => {
  try {
    const res = await request.post(`/glassOptimize/getProjectByProjectNo/${projectNumber}`);
    console.log('完整响应数据:', res); // 用于调试查看完整响应结构

    if (Number(res.code) === 200 && res.data && res.data.data && res.data.data.length > 0) {
      // 正确访问嵌套的数据结构
      const projectData = res.data.data[0]; // 注意这里是 res.data.data[0]

      console.log('获取到的glass_thickness:', projectData.glass_thickness);
      console.log('获取到的glass_type:', projectData.glass_type);

      // 确保computed.value已初始化
      if (!computed.value) {
        computed.value = {};
      }

      computed.value.glass_thickness = projectData.glass_thickness;
      computed.value.glass_type = projectData.glass_type;

      console.log('设置后的computed.value:', computed.value);
    } else {
      console.warn('未找到项目信息或数据格式不正确');
    }
  } catch (error) {
    console.error('获取项目信息失败', error);
    ElMessage.error('获取项目信息失败');
  }
};

console.log(receivedData)
const handleFetchData = async (projectNumber) => {
@@ -65,6 +95,8 @@
    const res = await request.post(`/glassOptimize/selectProjectCompute/${projectNumber}`);
    if (Number(res.code) === 200 && res.data && res.data.data) {
      receivedData.value = res.data.data;
      // 获取项目信息
      await fetchProjectInfo(projectNumber);
    } else {
      console.error('请求出现问题，状态码：', res.code, '，错误信息：', res.msg);
      if (res.code === 404) {
@@ -86,6 +118,65 @@
  console.log('父组件接收到的数据1:', data);
}

// 发送数据到钢化计算接口
// 发送数据到钢化计算接口
const sendToComputeTempering = async () => {
  let loading;
  try {
    // 显示加载提示
    loading = ElLoading.service({
      lock: true,
      text: '正在计算中，请稍候...',
      background: 'rgba(0, 0, 0, 0.7)'
    });

    console.log('发送到后端的数据', JSON.stringify(computedCard.value, null, 2));

    // 发送数据到钢化计算接口
    const response = await requestTemp.post('/computeTempering/inputTemperingData', computedCard.value);

    console.log('后端原始响应:', response);

    // 检查响应结构并正确处理
    if (response && (response.code === 200 || response.status === 200)) {
      // ElMessage.success('模拟计算成功!');

      // 处理返回的数据
      let resultData = response.data;

      // 如果data是字符串，需要解析JSON
      if (typeof resultData === 'string') {
        try {
          resultData = JSON.parse(resultData);
        } catch (parseError) {
          console.error('解析返回数据失败:', parseError);
          ElMessage.warning('返回数据格式异常，使用原始数据');
          // 即使解析失败也继续使用原始数据
        }
      }

      // 更新computedData以显示返回的结果
      computedData.value = {
        code: 200,
        data: resultData
      };

      console.log('接收到的处理后数据:', computedData.value);
    } else {
      // 处理错误情况
      const errorMessage = response?.msg || response?.message || '模拟计算失败';
      ElMessage.error(errorMessage);
    }
  } catch (error) {
    console.error('请求失败:', error);

    // 确保关闭加载提示
    if (loading) {
      loading.close();
    }
  }
};

const handleSimulation = async () => {
  let arry = computeCardRef.value.selectFullData();
  let data = arry;
@@ -96,77 +187,108 @@
    return acc;
  }, []);

  if(data.length===arry.length){
    state.value=1
  }else{
    state.value=2
  if (data.length === arry.length) {
    state.value = 1
  } else {
    state.value = 2
  }
  // 计算钢化流程卡的数量总和
  let maxQty = 0;
  if (data.length > 0) {
    // 遍历所有勾选了钢化的流程卡，累加它们的数量
    arry.forEach(item => {
      if (item.tempering) {
        maxQty += item.total_num || 0;
      }
    });

  if(props.project!=null){
    computed.value.glass_thickness=props.project.glass_thickness
    computed.value.glass_type=props.project.glass_type
  }
  if(data.length>0){
    data.forEach(item=>{
      const processCard = {
        process_no: item.processId,
        layers: item.technologyNumber,
        total_layers: item.total_layers,
        total_num: item.total_num,
        total_area: item.total_area,
        is_must: true,
        allow_rotate: item.allow_rotate,
        priority_level: 0,
        tempering: item.tempering,
        curtain_wall: item.curtain_wall,
        patch_state: item.patch_state,
        merge: item.merge,
        glass_details: []
      };
    // 将计算出的钢化数量总和添加到 computed.value 中
    computed.value.max_qty = maxQty;

      request.post(`/glassOptimize/selectComputeDetail/${item.processId}/${item.technologyNumber}/${item.patch_state}`).then((res) => {
        if(Number(res.code) === 200){
          res.data.data.forEach(items=>{
            const detail={
              process_id:null,
              technology_number:null,
              order_number:null,
              layers_number:null,
              max_width:null,
              max_height:null,
              child_width:null,
              child_height:null,
              quantity:null,
              patch_state:null
            }
            detail.process_id=items.process_id
            detail.technology_number=items.technology_number
            detail.order_number=items.order_number
            detail.layers_number=item.total_layers
            detail.max_width=items.maxwidth
            detail.max_height=items.maxheight
            detail.child_width=items.width
            detail.child_height=items.height
            detail.quantity=items.quantity
            detail.patch_state=item.patch_state
    if (data.length > 0) {
      // 创建所有异步请求的Promise数组
      const detailPromises = [];
      data.forEach(item => {
        const processCard = {
          process_no: item.processId,
          layers: item.technologyNumber,
          total_layers: item.total_layers,
          total_num: item.total_num,
          total_area: item.total_area,
          is_must: true,
          allow_rotate: item.allow_rotate,
          priority_level: 0,
          tempering: item.tempering,
          curtain_wall: item.curtain_wall,
          patch_state: item.patch_state,
          merge: item.merge,
          glass_details: []
        };

            processCard.glass_details.push(detail)
          })
        // 创建异步请求Promise并保存
        const detailPromise = request.post(`/glassOptimize/selectComputeDetail/${item.processId}/${item.technologyNumber}/${item.patch_state}`).then((res) => {
          if (Number(res.code) === 200) {
            res.data.data.forEach(items => {
              const detail = {
                process_id: items.process_id,
                technology_number: items.technology_number,
                order_number: items.order_number,
                layers_number: item.total_layers,
                max_width: items.maxwidth,
                max_height: items.maxheight,
                child_width: items.width,
                child_height: items.height,
                quantity: items.quantity,
                patch_state: item.patch_state
              }
              processCard.glass_details.push(detail)
            })
            return processCard;
          } else {
            ElMessage.warning(res.msg)
            return processCard;
          }
        }).catch(error => {
          console.error('获取详情失败:', error);
          return processCard;
        });

        detailPromises.push(detailPromise);
      });

        }else{
          ElMessage.warning(res.msg)
      // 等待所有异步请求完成
      try {
        const completedProcessCards = await Promise.all(detailPromises);

        // 将完成的流程卡添加到computed.value中
        if (!computed.value.process_cards) {
          computed.value.process_cards = [];
        }
      })
      computed.value.process_cards.push(processCard)
    })
    console.log(computed.value)
  }else{
    ElMessage.warning("没有需要钢化工艺的数据请直接保存")
    state.value=3
    return
  }
        computed.value.process_cards = completedProcessCards;

        console.log('完整的computed.value数据:', computed.value);
      } catch (error) {
        console.error('处理流程卡详情时出错:', error);
        ElMessage.error('获取流程卡详情失败');
      }
    } else {
      ElMessage.warning("没有需要钢化工艺的数据请直接保存")
      state.value = 3
      // 即使没有钢化数据，也要设置 max_qty 为 0
      computed.value.max_qty = 0;
      return
    }

    // 合并数据
    computedCard.value = {
      ...computed.value,
      ...computedCard.value
    };

    // console.log('最终发送到后端的数据:', computedCard.value);

    await sendToComputeTempering();
  };


  /*request.post(`/glassOptimize/simulationCalculate`,computed.value).then((res) => {
@@ -265,7 +387,7 @@
      text: '正在计算中，请稍候...',
      background: 'rgba(0, 0, 0, 0.7)'
    });
   console.log('发送到后端的数据',computedCard.value)
   // console.log('发送到后端的数据',computedCard.value)
  const mockData = {
      code: 200,
      data: [

 north-glass-erp/northglass-erp/src/views/pp/glassOptimize/page/Compute.vue

@@ -215,6 +215,11 @@
 
};
const handleSimulationClick = () => {
      inputValues.project_no = inputValue.value;

      inputValues.glass_thickness =  props.project.glass_thickness ;
      inputValues.glass_type = props.project.glass_type;
      inputValues.tempering_time = heatingTime.value || inputValues.tempering_time || 0;

      inputValues.load_width = furnaceWidth.value
      inputValues.load_length = furnaceLength.value
@@ -228,7 +233,7 @@
  // 触发父组件的 simulate-click 事件
  emit('simulate-click');

 

};



 north-glass-erp/northglass-erp/src/views/pp/glassOptimize/page/ComputeCard.vue

@@ -100,6 +100,8 @@
  processId: null,
  technologyNumber: null,
  patchState: null,
  glassThickness: String,  // 添加玻璃厚度属性
  glassType: String        // 添加玻璃类型属性
});



 north-glass-erp/src/main/java/com/example/erp/controller/pp/GlassOptimizeController.java

@@ -83,6 +83,16 @@
        return Result.seccess(glassOptimizeService.getProjectListSv());
    }

    @ApiOperation("根据工程卡号工程查询流程卡")
    @PostMapping  ("/getProjectByProjectNo/{projectNo}")
    public Result getProjectByProjectNo(
            @PathVariable String projectNo
    ){
        return Result.seccess(glassOptimizeService.getProjectByProjectNoSv(projectNo));
    }



    //工程管理查询
    @ApiOperation("工程管理查询接口")
    @PostMapping("/optimizeProjectMange/{startSelectTime}/{endSelectTime}")

 north-glass-erp/src/main/java/com/example/erp/mapper/pp/GlassOptimizeMapper.java

@@ -176,4 +176,5 @@
    //工程信息流程卡
    List<Map<String, Object>> getProcessCardMpThirdParty(String projectNo);

    List<Map<String, Object>> getProjectByProjectNoSv(String projectNo);
}

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

@@ -834,7 +834,9 @@
    }





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

 north-glass-erp/src/main/resources/mapper/pp/GlassOptimize.xml

@@ -1469,6 +1469,37 @@
            fc.layer,
            fc.order_number
    </select>
    <select id="getProjectByProjectNoSv" resultType="java.util.Map">
        SELECT
            p.id,
            p.project_no as projectNumber,
            p.project_name,
            p.glass_type,
            p.glass_thickness,
            p.type,
            p.state,
            p.glass_total as quantity,
            p.glass_total_area,
            p.process_qty,
            p.process_cards,
            p.remark,
            a.name,
            p.create_time,
            p.update_time,
            p.optimize_state
        FROM
            (
                pp.optimize_project p
                    LEFT JOIN pp.optimize_admin a ON ((
                    p.creater = a.Id
                    )))
        WHERE
            ( p.state = 1 ) and p.tempering_state=0 and optimize_state=0 and p.project_no = #{projectNo}
        ORDER BY
            p.create_time DESC,
            p.project_no

    </select>

    <delete id="deleteOptimizeDetailThirdParty">
        delete from pp.other_flow_card