Merge remote-tracking branch 'origin/master'

wu

2024-08-02 928fa3682fcd0bcb59e3ca3da8770ecbb06cf315

Merge remote-tracking branch 'origin/master'

 UI-Project/config.js

@@ -1,7 +1,7 @@
export default {
//  serverUrl: "10.153.19.150:88/api",
 serverUrl: "192.168.1.199:88/api",
  // serverUrl2: "10.153.19.150:88"
  serverUrl2: "192.168.1.199:88"
 serverUrl: "10.153.19.150:88/api",
//  serverUrl: "192.168.1.199:88/api",
  serverUrl2: "10.153.19.150:88"
  // serverUrl2: "192.168.1.199:88"
  //serverUrl:"res.abeim.cn"
}

 UI-Project/src/lang/zh.js

@@ -212,6 +212,14 @@
        layoutnumber:'钢化版图号',
        numberglasses:'玻璃数量',
        specifytemperinga:'是否指定钢化该条信息？',
        temperedswitch:'钢化开关',
        dutyinformation:'值班信息',
        line:'线路',
        process:'工序',
        team:'班组',
        basic:'设备',
        add:'确认保存',
        cancel:'取消',
    },
    workOrder:{
        glassID:'玻璃ID',
@@ -419,5 +427,51 @@
        allstatus: '全部入库状态',
        completedquantity: '完成数量',
        scrapquantity: '报废数量',
    }
    },
    reportmanage:{
        productiontime :'生产时间',
        starttime :'开始时间',
        endtime :'结束时间',
        ctype :'清选择类型',
        cstate :'清选择状态',
        cprocess :'清选择工序',
        all :'全部',
        completed :'完工',
        broke :'破损',
        takeout :'拿走',
        dreportwork :'未报工',
        pendingwork :'待报工',
        reportwork :'已报工',
        incise :'切割',
        edging :'磨边',
        steel :'钢化',
        inquire :'查询',
        signingwork :'报工',
        reporteam :'报工班组',
        reportingequipment :'报工设备',
        line :'线路',
        process :'工序',
        glassID :'玻璃ID',
        projectnumber :'工程号',
        layoutID :'钢化版图ID',
        productiontime :'生产时间',
        type :'类型',
        state :'状态',
        processcards :'流程卡',
        number :'序号',
        layer :'层',
        typebreakage :'破损类型',
        ptypebreakage :' 请选择破损类型',
        causebreakage :'破损原因',
        pcausebreakage :'请选择破损原因',
        responsibleprocess :'责任工序',
        responsiblepersonnel :'责任人员',
        presponsiblepersonnel :'请输入责任人员',
        responsibleteam :'责任班组',
        presponsibleteam :'请选择责任班组',
        responsibleequipment :'责任设备',
        presponsibleequipment :'请选择责任设备',
        remark :'备注',
        premark :'请输入备注',
    },
}

 UI-Project/src/layout/MainErpView.vue

@@ -168,7 +168,7 @@
          <img src="../assets/northGlass.ico"
               alt=""
               style="max-width: 100%;max-height: 100%">
          <h3 style="margin: 1rem  ;font-weight: bold;width: 33vw;"> {{ $t('main.titleFirst') }}{{ user }}{{ $t('main.titleLast') }}</h3>
          <h3 style="margin: 1rem  ;font-weight: bold;width: 33vw;"> {{ $t('main.titleFirst') }}{{ userName }}{{ $t('main.titleLast') }}</h3>
          <!-- <div class="header-left">
            <el-button :icon="isCollapse ? 'el-icon-s-unfold' : 'el-icon-s-fold'" @click="toggleCollapse"
              style="height:30px;"></el-button>

 UI-Project/src/utils/WebSocketService.js

@@ -1,8 +1,8 @@
// WebSocketService.js



let socket = null;

let messages='' ;

export const initializeWebSocket = (socketUrl, messageHandler) => {

  let messages='' ;

    if (typeof WebSocket === "undefined") {

      console.log("Your browser does not support WebSocket");

      return null;


 UI-Project/src/utils/api.js

@@ -1,14 +1,42 @@
// src/services/api.js

import request from 'request';

import request from '../utils/request';

import { ElMessage } from 'element-plus';



 // Replace with your actual backend base URL



export const findTasks = (id, newState) => {

// Function to find list of raw usages

const BASE_URL = 'glassStorage/api/rawUsage';

const taskBASE_URL = 'glassStorage/api/storageTask';



export const findTasks = () => {

  const url = `glassStorage/api/storageTask/findTasks`;

  const options = {

    method: 'POST',

    method: 'get',

    url,

    json: true,

    body: { id, enableState: newState }

    
  };

 
  return new Promise((resolve, reject) => {

    request(options, (error, response, body) => {

      if (error) {

        reject(new Error(error.message));

      } else {

        resolve(body);

      }

    });

  });

};







export const findList = (params) => {

  const url = `${BASE_URL}/findList`;

  const options = {

    method: 'post',

    url,

    json: true,

    body: params

  };



  return new Promise((resolve, reject) => {

@@ -21,3 +49,157 @@
    });

  });

};



// Function to find raw usage by ID

export const findById = (id) => {

  const url = `${BASE_URL}/${id}`;

  const options = {

    method: 'get',

    url,

    json: true

  };



  return new Promise((resolve, reject) => {

    request(options, (error, response, body) => {

      if (error) {

        reject(new Error(error.message));

      } else {

        resolve(body);

      }

    });

  });

};



// Function to insert a new raw usage

export const insertRawUsage = (rawUsage) => {

  const url = `${BASE_URL}`;

  const options = {

    method: 'post',

    url,

    json: true,

    body: rawUsage

  };



  return new Promise((resolve, reject) => {

    request(options, (error, response, body) => {

      if (error) {

        reject(new Error(error.message));

      } else {

        resolve(body);

      }

    });

  });

};





export const updateRawUsage = async (rawUsage) => {

  try {

    const response = await request.post(`${BASE_URL}/updaterawUsage`, rawUsage);

    ElMessage.success('修改成功');

    return response.data;

  } catch (error) {

    ElMessage.error('修改失败');

    throw error;

  }

};



export const deleteRawUsage = async (id) => {

  try {

    const response = await request.post(`${BASE_URL}/id`, id);

    ElMessage.success('删除原始使用数据成功');

    return response.data;

  } catch (error) {

    ElMessage.error('删除原始使用数据失败');

    throw error;

  }

};



export const inStorage = async (RawUsageAndShelfRack) => {

  try {

    const response = await request.post(`${BASE_URL}/inStorage`, RawUsageAndShelfRack);

    ElMessage.success('入库操作成功');

    return response.data;

  } catch (error) {

    ElMessage.error('入库操作失败');

    throw error;

  }

};



export const outStorage = async (RawUsageAndShelfRack) => {

  try {

    const response = await request.post(`${BASE_URL}/outStorage`, RawUsageAndShelfRack);

    ElMessage.success('出库操作成功');

    return response.data;

  } catch (error) {

    ElMessage.error('出库操作失败');

    throw error;

  }

};







export const taskUpdate = async (task) => {

  try {

    const response = await request.post(`${taskBASE_URL}/taskUpdate`, task);



    return response.data;

  } catch (error) {

 
    throw error;

  }

};













const API_URL = 'glassStorage/api/shelfRack';  // Adjust this based on your actual API URL



export const shelfRackfindList = (params) => {

  return request.post(`${API_URL}/findList`, params)

    .then(response => response.data)

    .catch(error => {

      throw error;  // Handle errors appropriately in your frontend

    });

};



export const shelfRackfindById = (id) => {

  return request.get(`${API_URL}/${id}`)

    .then(response => response.data)

    .catch(error => {

      throw error;

    });

};



export const insertShelfRack = (shelfRack) => {

  return request.post(`${API_URL}`, shelfRack)

    .then(response => response.data)

    .catch(error => {

      throw error;

    });

};



export const updateShelfRack = (shelfRack) => {

  return request.put(`${API_URL}`, shelfRack)

    .then(response => response.data)

    .catch(error => {

      throw error;

    });

};



export const shelfRackdeleteById = (id) => {

  return request.delete(`${API_URL}/${id}`)

    .then(response => response.data)

    .catch(error => {

      throw error;

    });

};



export const findShelfRack = () => {

  return request.get(`${API_URL}/findshelfrack`)

    .then(response => response.data)

    .catch(error => {

      throw error;

    });

};

 UI-Project/src/utils/constants.js

@@ -1,3 +1,3 @@
export const WebSocketHost = "192.168.1.199";
// export const WebSocketHost = "10.153.19.150";
// export const WebSocketHost = "192.168.1.199";
export const WebSocketHost = "10.153.19.150";
export const host = "88";

 UI-Project/src/views/Caching/cachingbefore.vue

@@ -7,7 +7,7 @@
import { WebSocketHost ,host} from '@/utils/constants'

import request from "@/utils/request"
import { ref, onMounted , onBeforeUnmount} from "vue";
import { ref, onMounted , onBeforeUnmount,onUnmounted} from "vue";
import { initializeWebSocket, closeWebSocket } from '@/utils/WebSocketService';
// import { ref } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
@@ -77,6 +77,7 @@
    console.error('发生错误:', error);  
  }  
};   
let socket = null;
const socketUrl = `ws://${WebSocketHost}:${host}/api/cacheGlass/api/talk/cacheGlass`;
// 定义消息处理函数，更新 receivedData 变量
const handleMessage = (data) => {
@@ -92,11 +93,13 @@
};
// 初始化 WebSocket，并传递消息处理函数
onMounted(() => {
  // fetchFlowCardId();
  // fetchTableData(); // 获取数据
  initializeWebSocket(socketUrl, handleMessage);
  socket = initializeWebSocket(socketUrl, handleMessage);
});

  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
onBeforeUnmount(() => {
  console.log("关闭了")
  closeWebSocket();

 UI-Project/src/views/Caching/cachingun.vue

@@ -60,7 +60,7 @@
const adda = ref(false)
import { WebSocketHost ,host} from '@/utils/constants'
import request from "@/utils/request"
import { ref, onMounted , onBeforeUnmount} from "vue";
import { ref, onMounted , onBeforeUnmount,onUnmounted} from "vue";
import { initializeWebSocket, closeWebSocket } from '@/utils/WebSocketService';
// import { ref } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
@@ -205,6 +205,7 @@



let socket = null;
const socketUrl = `ws://${WebSocketHost}:${host}/api/unLoadGlass/api/talk/downcache`;
// 定义消息处理函数，更新 receivedData 变量
const handleMessage = (data) => {
@@ -219,13 +220,14 @@
          })); 

};
// 初始化 WebSocket，并传递消息处理函数
onMounted(() => {
  // fetchFlowCardId();
  // fetchTableData(); // 获取数据
  initializeWebSocket(socketUrl, handleMessage);
  socket = initializeWebSocket(socketUrl, handleMessage);
});

  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
onBeforeUnmount(() => {
  console.log("关闭了")
  closeWebSocket();

 UI-Project/src/views/GlassStorage/MaterialRackManagement.vue

@@ -1,144 +1,174 @@
<template>

  <div  class="app-container">

    <el-card style="flex: 1; margin-left: 10px; " :loading="loading">

      <div slot="header" class="clearfix" style="display: flex; align-items: center;">

  <div class="app-container">

    <el-card style="flex: 1; margin-left: 10px" :loading="loading">

      <div

        slot="header"

        class="clearfix"

        style="display: flex; align-items: center"

      >

        <!-- 左侧按钮组 -->

        <div>

          <el-button type="success" size="mini" @click="storage()"

            >原片仓储详情</el-button

          >

          <el-button type="success" size="mini" @click="handleInbound()"

            >入库</el-button

          >

          <el-button type="success" size="mini">吊装位入库</el-button>

        </div>



<!-- 左侧按钮组 -->

<div >

  <el-button type="success" size="mini"  @click="storage()">原片仓储详情</el-button>

  <el-button type="success" size="mini" @click="handleInbound()">入库</el-button>

  <el-button type="success" size="mini" >吊装位入库</el-button>

 
</div>

        <!-- 右侧选择框 -->

        <el-form-item style="margin-top: 15px; width: 150px">

          <el-select v-model="formData2.dzw" placeholder="请选择吊装位">

            <el-option label="吊装位1" value="吊装位1"></el-option>

            <el-option label="吊装位2" value="吊装位2"></el-option>

            <!-- 根据实际情况添加更多选项 -->

          </el-select>

        </el-form-item>

      </div>

      <el-dialog v-model="Hidden" top="10vh" width="80%">

        <el-table

          :data="tableData"

          v-model="dialogVisible3"

          style="width: 98%; height: 200px"

          @selection-change="handleSelectionChange"

          :header-cell-style="{ background: '#F2F3F5', color: '#1D2129' }"

          ref="table"

          empty-text="No Data"

        >

          <el-table-column prop="number" label="库位号"></el-table-column>

          <el-table-column prop="rawType" label="类型"></el-table-column>

          <el-table-column prop="rawWidth" label="长度(mm)"></el-table-column>

          <el-table-column prop="rawHeight" label="高度(mm)"></el-table-column>

          <el-table-column

            prop="rawThickness"

            label="厚度(mm)"

          ></el-table-column>

          <el-table-column prop="pieces" label="数量"></el-table-column>

          <el-table-column prop="createTime" label="入库时间"></el-table-column>

          <el-table-column prop="batchId" label="批次号"></el-table-column>



<!-- 右侧选择框 -->

<el-form-item style="margin-top: 15px; width: 150px;">

  <el-select v-model="formData2.dzw" placeholder="请选择吊装位">

    <el-option label="吊装位1" value="吊装位1"></el-option>

    <el-option label="吊装位2" value="吊装位2"></el-option>

    <!-- 根据实际情况添加更多选项 -->

  </el-select>

</el-form-item>

          <el-table-column

            align="center"

            label="料架状态"

            min-width="80"

            prop="enableState"

          >

            <template #default="scope">

              <el-tag

                :type="getTagType(scope.row.enableState)"

                @click="toggleStatus(scope.row)"

              >

                {{ scope.row.enableState === 1 ? "启用" : "未启用" }}

              </el-tag>

            </template>

          </el-table-column>



</div>

<el-dialog v-model="Hidden" top="10vh" width="80%"  >

          <!-- 操作列 -->

          <el-table-column label="操作" width="250">

            <template #default="{ row }">

              <el-button

                type="primary"

                size="mini"

                @click="edithandleRowClick(row)"

                >修改</el-button

              >

              <el-button type="danger" size="mini" @click="handleDelete(row)"

                >删除</el-button

              >

              <el-button type="warning" size="mini" @click="handleCheckout(row)"

                >出库</el-button

              >

              <!-- <el-button type="success" size="mini" @click="addglass()">添加原片</el-button> -->

            </template>

          </el-table-column>

        </el-table>

        <el-pagination

          v-if="totalItems > 0"

          background

          layout="prev, pager, next"

          :total="totalItems"

          :page-size="pageSize"

          @current-change="handleCurrentChange"

        ></el-pagination>

      </el-dialog>



      <el-table

        :data="tableData" v-model="dialogVisible3"

       
        style="width: 98%; height: 200px"

        :data="tasktableData"

        style="width: 98%; height: 150px"

        @selection-change="handleSelectionChange"

        :header-cell-style="{ background: '#F2F3F5', color: '#1D2129' }"

        ref="table"

       
        empty-text="No Data"

      >

       
        <el-table-column prop="location" label="库位号"></el-table-column>

        <el-table-column prop="type" label="类型"></el-table-column>

        <el-table-column prop="length" label="长度(mm)"></el-table-column>

        <el-table-column prop="height" label="高度(mm)"></el-table-column>

        <el-table-column prop="thickness" label="厚度(mm)"></el-table-column>

        <el-table-column prop="quantity" label="数量"></el-table-column>

        <el-table-column prop="entry_time" label="入库时间"></el-table-column>

        <el-table-column prop="batchnumber" label="批次号"></el-table-column>

       
        <template #header>

          <div style="display: flex; align-items: center">

            <span style="font-size: 16px; font-weight: bold; margin-right: 20px"

              >任务列表</span

            >

          </div>

        </template>

        <el-table-column prop="id" label="Glassid"></el-table-column>

        <el-table-column

  align="center"

  label="料架状态"

  min-width="80"

  prop="shelf_status"

>

<template #default="scope">

        <el-tag :type="getTagType(scope.row.shelf_status)" @click="toggleStatus(scope.row)">

          {{ scope.row.shelf_status === 1 ? '启用' : '未启用' }}

        </el-tag>

      </template>

</el-table-column>

          prop="taskType"

          label="任务描述"

          width="250"

          :formatter="formatTaskType"

        ></el-table-column>

        <el-table-column

          prop="rawThickness"

          label="玻璃厚度"

        ></el-table-column>

        <el-table-column prop="color" label="玻璃膜系"></el-table-column>

        <el-table-column prop="startTime" label="创建时间"></el-table-column>



        <!-- 操作列 -->

        <el-table-column label="操作" width="250">

          <template #default="{ row }">

            <el-button type="primary" size="mini" @click="edithandleRowClick(row)">修改</el-button>

            <el-button type="danger" size="mini" @click="handleDelete(row)">删除</el-button>

            <el-button type="warning" size="mini" @click="handleCheckout(row)">出库</el-button>

            <!-- <el-button type="success" size="mini" @click="addglass()">添加原片</el-button> -->

        <el-table-column

          align="center"

          label="任务状态"

          min-width="80"

          prop="taskState"

        >

          <template #default="scope">

            <el-tag :type="getTagType2(scope.row.taskState)">

              {{ scope.row.taskState == "completed" ? "完成" : "进行中" }}

            </el-tag>

          </template>

        </el-table-column>



        
        <!-- 操作列 -->

        <el-table-column label="操作" width="350">

          <template #default="{ row }">

            <el-button type="primary" size="mini" @click="handleRestart(row)"

              >重新开始</el-button

            >

            <el-button type="danger" size="mini" @click="handleDeletetask(row)"

              >删除任务</el-button

            >

            <el-button type="success" size="mini" @click="handleComplete(row)"

              >任务完成</el-button

            >

          </template>

        </el-table-column>

      </el-table>

      <el-pagination

        v-if="totalItems > 0"

        background

        layout="prev, pager, next"

        :total="totalItems"

        :page-size="pageSize"

        @current-change="handleCurrentChange"

      ></el-pagination>



      
  </el-dialog>





  <el-table

    :data="tasktableData"

    style="width: 98%; height: 150px"

    @selection-change="handleSelectionChange"

    :header-cell-style="{ background: '#F2F3F5', color: '#1D2129' }"

    ref="table"

    empty-text="No Data"

  >





  <template #header>

        <div style="display: flex; align-items: center;">

          <span style="font-size: 16px; font-weight: bold; margin-right: 20px;">任务列表</span>

        
        </div>

      </template>

    <el-table-column prop="Glassid" label="Glassid"></el-table-column>

    <el-table-column prop="taskDescription" label="任务描述" width="250"></el-table-column>

    <el-table-column prop="glassThickness" label="玻璃厚度"></el-table-column>

    <el-table-column prop="glassFilm" label="玻璃膜系"></el-table-column>

    <el-table-column prop="creationTime" label="创建时间"></el-table-column>



    <el-table-column

      align="center"

      label="任务状态"

      min-width="80"

      prop="taskStatus"

    >

      <template #default="scope">

        <el-tag :type="getTagType2(scope.row.taskStatus)">

          {{ scope.row.taskStatus == 'completed' ? '完成' : '进行中' }}

        </el-tag>

      </template>

    </el-table-column>



    <!-- 操作列 -->

    <el-table-column label="操作" width="350">

      <template #default="{ row }">

        <el-button type="primary" size="mini" @click="handleRestart(row)">重新开始</el-button>

        <el-button type="danger" size="mini" @click="handleDeletetask(row)">删除任务</el-button>

        <el-button type="success" size="mini" @click="handleComplete(row)">任务完成</el-button>

      </template>

    </el-table-column>

  </el-table>

    </el-card>









   
    <div class="img-ypcc" >





      <div class="img-car1" :style="'z-index:999;left:397px;top:205px;position:absolute;'">

      <div v-show="cellshow1" style="margin-top:10px;width:200px;height:5px;background-color:#409EFF;"></div>

    <div class="img-ypcc">

      <div

        class="img-car1"

        :style="'z-index:999;left:397px;top:205px;position:absolute;'"

      >

        <div

          v-show="cellshow1"

          style="

            margin-top: 10px;

            width: 200px;

            height: 5px;

            background-color: #409eff;

          "

        ></div>

      </div>

    </div>

   
    </div>

   


    <!-- 入库对话框 -->

    <el-dialog

      title="入库"

@@ -148,9 +178,9 @@
    >

      <el-form :model="formData" ref="form" label-width="80px">

        <el-form-item label="进库料架">

          <el-select v-model="formData.shelf" placeholder="请选择进库料架">

            <el-option label="A1" value="A1"></el-option>

            <el-option label="B2" value="B2"></el-option>

          <el-select v-model="formData.number" placeholder="请选择进库料架">

            <el-option label="1" value="1"></el-option>

            <el-option label="2" value="2"></el-option>

            <!-- 根据实际情况添加更多选项 -->

          </el-select>

        </el-form-item>

@@ -162,91 +192,137 @@
          </el-select>

        </el-form-item>

        <el-form-item label="宽度">

          <el-input v-model.number="formData.width" placeholder="请输入宽度"></el-input>

          <el-input

            v-model.number="formData.rawWidth"

            placeholder="请输入宽度"

          ></el-input>

        </el-form-item>

        <el-form-item label="高度">

          <el-input v-model.number="formData.height" placeholder="请输入高度"></el-input>

          <el-input

            v-model.number="formData.rawHeight"

            placeholder="请输入高度"

          ></el-input>

        </el-form-item>

        <el-form-item label="厚度">

          <el-input v-model.number="formData.thickness" placeholder="请输入厚度"></el-input>

          <el-input

            v-model.number="formData.rawThickness"

            placeholder="请输入厚度"

          ></el-input>

        </el-form-item>

        <el-form-item label="数量">

          <el-input v-model.number="formData.quantity" placeholder="请输入数量"></el-input>

          <el-input

            v-model.number="formData.pieces"

            placeholder="请输入数量"

          ></el-input>

        </el-form-item>

      </el-form>



      <div slot="footer" class="dialog-footer">

        <el-button @click="dialogVisible = false">取 消</el-button>

        <el-button type="primary" @click="handleConfirmInbound">确 定</el-button>

        <el-button type="primary" @click="handleConfirmInbound"

          >确 定</el-button

        >

      </div>

    </el-dialog>





    <el-dialog title="添加原片"  v-model="dialogVisible3" width="50%">

    <el-form :model="formData3" ref="form" label-width="80px">

      <el-form-item label="颜色膜系">

        <el-input v-model="formData.selectedColor" readonly style="width: 250px; height: 35px; font-size: 20px"></el-input>

        <el-dropdown @command="handleCommand">

          <span class="el-dropdown-link">

            选择<i class="el-icon-arrow-down el-icon--right"></i>

          </span>

          <el-dropdown-menu slot="dropdown">

            <el-dropdown-item v-for="color in colors" :key="color['0_glass_id']" :command="color['0_glass_id']">

              {{ color['0_glass_id'] }}

            </el-dropdown-item>

          </el-dropdown-menu>

        </el-dropdown>

      </el-form-item>



      <el-form-item label="长度">

        <el-input v-model="formData.width" required style="width: 250px; font-size: 20px" @focus="clearInput('wid')"></el-input>

      </el-form-item>



      <el-form-item label="高度">

        <el-input v-model="formData.height" required style="width: 250px; font-size: 20px" @focus="clearInput('heig')"></el-input>

      </el-form-item>



      <el-form-item label="厚度">

        <el-input v-model="formData.thickness" required style="width: 250px; font-size: 20px" @focus="clearInput('thinkness')"></el-input>

      </el-form-item>



      <el-form-item label="数量">

        <el-input-number v-model="formData.quantity" required :min="0" :max="9000" style="width: 250px; font-size: 20px" @focus="clearInput('num')"></el-input-number>

      </el-form-item>

    </el-form>



    <span slot="footer" class="dialog-footer">

      <el-button @click="dialogVisible3 = false">关闭</el-button>

      <el-button type="primary" @click="submitForm">提交</el-button>

    </span>

  </el-dialog>



  <el-dialog title="编辑" v-model="editdialogVisible" width="30%" @close="edithandleDialogClose">

      <el-form :model="editForm" ref="editFormRef" label-width="80px">

        <el-form-item label="数量">

          <el-input v-model="editForm.quantity"></el-input>

    <el-dialog title="添加原片" v-model="dialogVisible3" width="50%">

      <el-form :model="formData3" ref="form" label-width="80px">

        <el-form-item label="颜色膜系">

          <el-input

            v-model="formData.selectedColor"

            readonly

            style="width: 250px; height: 35px; font-size: 20px"

          ></el-input>

          <el-dropdown @command="handleCommand">

            <span class="el-dropdown-link">

              选择<i class="el-icon-arrow-down el-icon--right"></i>

            </span>

            <el-dropdown-menu slot="dropdown">

              <el-dropdown-item

                v-for="color in colors"

                :key="color['0_glass_id']"

                :command="color['0_glass_id']"

              >

                {{ color["0_glass_id"] }}

              </el-dropdown-item>

            </el-dropdown-menu>

          </el-dropdown>

        </el-form-item>

        <el-form-item label="批次号">

          <el-input v-model="editForm.batchnumber"></el-input>

        </el-form-item>



        <el-form-item label="长度">

          <el-input v-model="editForm.length"></el-input>

          <el-input

            v-model="formData.width"

            required

            style="width: 250px; font-size: 20px"

            @focus="clearInput('wid')"

          ></el-input>

        </el-form-item>



        <el-form-item label="高度">

          <el-input v-model="editForm.height"></el-input>

          <el-input

            v-model="formData.height"

            required

            style="width: 250px; font-size: 20px"

            @focus="clearInput('heig')"

          ></el-input>

        </el-form-item>



        <el-form-item label="厚度">

          <el-input v-model="editForm.thickness"></el-input>

          <el-input

            v-model="formData.thickness"

            required

            style="width: 250px; font-size: 20px"

            @focus="clearInput('thinkness')"

          ></el-input>

        </el-form-item>



        <el-form-item label="数量">

          <el-input-number

            v-model="formData.quantity"

            required

            :min="0"

            :max="9000"

            style="width: 250px; font-size: 20px"

            @focus="clearInput('num')"

          ></el-input-number>

        </el-form-item>

      </el-form>



      <div  class="dialog-footer">

      <span slot="footer" class="dialog-footer">

        <el-button @click="dialogVisible3 = false">关闭</el-button>

        <el-button type="primary" @click="submitForm">提交</el-button>

      </span>

    </el-dialog>



    <el-dialog

      title="编辑"

      v-model="editdialogVisible"

      width="30%"

      @close="edithandleDialogClose"

    >

      <el-form :model="editForm" ref="editFormRef" label-width="80px">

        <el-form-item label="数量">

          <el-input v-model="editForm.pieces"></el-input>

        </el-form-item>

        <el-form-item label="批次号">

          <el-input v-model="editForm.batchId"></el-input>

        </el-form-item>

        <el-form-item label="长度">

          <el-input v-model="editForm.rawWidth"></el-input>

        </el-form-item>

        <el-form-item label="高度">

          <el-input v-model="editForm.rawHeight"></el-input>

        </el-form-item>

        <el-form-item label="厚度">

          <el-input v-model="editForm.rawThickness"></el-input>

        </el-form-item>

      </el-form>



      <div class="dialog-footer">

        <el-button @click="editdialogVisible = false">取消</el-button>

        <el-button type="primary" @click="editsaveEdit">保存</el-button>

      </div>

    </el-dialog>





  </div>

</template>



@@ -254,363 +330,413 @@




<script setup>

import { ref, onMounted, onBeforeUnmount } from 'vue'; // 导入 Vue 3 的模块

import * as echarts from 'echarts';

import { ElMessage, ElMessageBox } from 'element-plus'

import {tableData} from '@/stores/tableData.js';

import { ref, onMounted, onBeforeUnmount,onUnmounted } from "vue"; // 导入 Vue 3 的模块

//import * as echarts from 'echarts';

import { ElMessage, ElMessageBox } from "element-plus";

// import {tableData} from '@/stores/tableData.js';

import { WebSocketHost, host } from "@/utils/constants";

import { initializeWebSocket, closeWebSocket } from "@/utils/WebSocketService";



import {

  updateRawUsage,

  deleteRawUsage,

  inStorage,

  outStorage,

  taskUpdate,

} from "@/utils/api";





    const loading = ref(false);

   


    const Hidden = ref(false)





    const totalItems = ref(0);

    totalItems.value = 10;

    const pageSize = 10;

    let currentPage = ref(1);

    const handleCurrentChange = (val) => {



      currentPage.value = val;

      
    };



   const getTagType2 =(status) => {

      switch (status) {

        case 'completed':

          return 'success';

        case 'in-progress':

          return 'info';

        case 'warning':

          return 'warning';

        case 'danger':

          return 'danger';

        default:

          return '';

      }

    }



    const getTagType =(status) => {

      return status === 1 ? 'success' : 'danger';

      // 根据状态值决定标签类型，这里假设状态为1时为成功（绿色），否则为失败（红色）

    }



    const toggleStatus = (row) => {

      // 切换料架状态的逻辑

      row.shelf_status = 1 - row.shelf_status; // Toggle between 0 and 1

      // 此处可以添加保存状态的逻辑，比如调用 API 更新数据

    };



   const tasktableData=ref([



    {

          Glassid: 'G001',

          taskDescription: '从吊装位【99】到仓位【56】',

          taskStatus: 'in-progress',

          glassThickness: '5mm',

          glassFilm: '膜系A',

          creationTime: '2024-06-19 10:00:00'

        },

        {

          Glassid: 'G002',

          taskDescription: '从吊装位【99】到仓位【56】',

          taskStatus: 'completed',

          glassThickness: '10mm',

          glassFilm: '膜系B',

          creationTime: '2024-06-19 11:00:00'

        }

        ]);



    const dialogVisible = ref(false);

    const formData = ref({

      shelf: '',

      color: '',

      width: '',

      height: '',

      thickness: '',

      quantity: ''

    });



    const formData2 = ref({

      dzw: '',

     
    });



   
    const handleDelete = (row) => {

  // 使用 Element UI 的 MessageBox.confirm 方法进行二次确认

  ElMessageBox.confirm('确定要执行删除操作吗？', '确认删除', {

    confirmButtonText: '确认',

    cancelButtonText: '取消',

    type: 'warning',

  }).then(() => {

    // 点击确认按钮的回调，执行出库操作

    console.log('执行删除操作', row);

  }).catch(() => {

    // 点击取消按钮的回调，不执行任何操作

    console.log('取消删除操作');

  });

const loading = ref(false);

const Hidden = ref(false);

const tableData = ref([]);

const totalItems = ref(0);

totalItems.value = 10;

const pageSize = 10;

let currentPage = ref(1);

const handleCurrentChange = (val) => {

  currentPage.value = val;

};



    
    const handleCheckout = (row) => {

  // 使用 Element UI 的 MessageBox.confirm 方法进行二次确认

  ElMessageBox.confirm('确定要执行出库操作吗？', '确认出库', {

    confirmButtonText: '确认',

    cancelButtonText: '取消',

    type: 'warning',

  }).then(() => {

    // 点击确认按钮的回调，执行出库操作

    console.log('执行出库操作', row);

  }).catch(() => {

    // 点击取消按钮的回调，不执行任何操作

    console.log('取消出库操作');

  });

const formatTaskType = (row, column) => {

  if (row.taskType === "从仓位到吊装位") {

    return `从仓位${row.shelfRack}到吊装位${row.loadRack}`;

  } else if (row.taskType === "从仓位到上片位") {

    return `从仓位${row.shelfRack}到上片位${row.loadRack}`;

  } else if (row.taskType === "从上片位到仓位") {

    return `从上片位${row.loadRack}到仓位${row.shelfRack}`;

  } else if (row.taskType === "从吊装位到仓位") {

    return `从吊装位${row.loadRack}到仓位${row.shelfRack}`;

  }

};



const getTagType2 = (status) => {

  switch (status) {

    case "completed":

      return "success";

    case "in-progress":

      return "info";

    case "warning":

      return "warning";

    case "danger":

      return "danger";

    default:

      return "";

  }

};



    const handleInbound = () => {

      // 打开入库对话框

      dialogVisible.value = true;

    };

const getTagType = (status) => {

  return status === 1 ? "success" : "danger";

  // 根据状态值决定标签类型，这里假设状态为1时为成功（绿色），否则为失败（红色）

};



    const storage = () => {

      // 打开入库对话框

      Hidden.value = true;

    };

    
const toggleStatus = (row) => {

  // 切换料架状态的逻辑

  row.enableState = 1 - row.enableState; // Toggle between 0 and 1

  // 此处可以添加保存状态的逻辑，比如调用 API 更新数据

};

let socket = null;

const socketUrl = `ws://${WebSocketHost}:${host}/api/glassStorage/api/talk/storageTask`;

// 定义消息处理函数，更新 receivedData 变量

const handleMessage = (data) => {

  // 更新 tableData 的数据



    const handleCloseDialog = () => {

      // 关闭对话框时重置表单数据

      formData.value = {

        shelf: '',

        color: '',

        width: '',

        height: '',

        thickness: '',

        quantity: ''

  tableData.value = data.rack[0]; // 假设 tableData 是响应式对象或变量



  tableData.value.forEach((item) => {

    // 获取 createTime 的时间戳

    const createTimeTimestamp = item.createTime;



    // 创建日期对象

    const date = new Date(createTimeTimestamp);



    // 格式化日期时间为本地格式

    const formattedDateTime = date.toLocaleString();



    // 替换原来的 createTime 字段为格式化后的日期时间字符串

    item.createTime = formattedDateTime;

  });



  tasktableData.value = data.tasks[0]; // 假设 tasktableData 是响应式对象或变量



  tasktableData.value.forEach((item) => {

    // 获取 createTime 的时间戳

    const createTimeTimestamp = item.startTime;



    // 创建日期对象

    const date = new Date(createTimeTimestamp);



    // 格式化日期时间为本地格式

    const formattedDateTime = date.toLocaleString();



    // 替换原来的 createTime 字段为格式化后的日期时间字符串

    item.startTime = formattedDateTime;

  });

};

onMounted(() => {

  socket = initializeWebSocket(socketUrl, handleMessage);

});

  onUnmounted(() => {

    if (socket) {

    closeWebSocket(socket);

    }

    });

onBeforeUnmount(() => {

  console.log("关闭了");

  closeWebSocket();

});



const tasktableData = ref([]);



const dialogVisible = ref(false);

const formData = ref({

  number: "",

  color: "",

  rawWidth: "",

  rawHeight: "",

  rawThickness: "",

  pieces: "",

  loadRack: 1,

});



const formData2 = ref({

  dzw: "",

});



const handleDelete = (row) => {

  // 使用 Element UI 的 MessageBox.confirm 方法进行二次确认

  ElMessageBox.confirm("确定要执行删除操作吗？", "确认删除", {

    confirmButtonText: "确认",

    cancelButtonText: "取消",

    type: "warning",

  })

    .then(() => {

      // 点击确认按钮的回调，执行出库操作



      const intNumber = {

        id: parseInt(row.number),

      };

      dialogVisible.value = false;

    };

      deleteRawUsage(intNumber);



    const handleConfirmInbound = () => {

      // 处理确认入库逻辑，可以在这里提交表单或者执行其他操作

      console.log('Confirm Inbound:', formData.value);

      // 关闭对话框

      dialogVisible.value = false;

    };











    const dialogVisible3 = ref(false);

    const colors = ref([

      { '0_glass_id': 'Red' },

      { '0_glass_id': 'Green' },

      { '0_glass_id': 'Blue' }

      // Add more colors as needed

    ]);



    const formData3 = ref({

      selectedColor: '',

      wid: '',

      heig: '',

      thinkness: '',

      num: ''

      console.log("执行删除操作");

    })

    .catch(() => {

      // 点击取消按钮的回调，不执行任何操作

      console.log("取消删除操作");

    });





    const addglass = () => {

      // 打开入库对话框

      dialogVisible3.value = true;

    };

    const handleCommand = (command) => {

      formData.value.selectedColor = command;

    };



    const clearInput = (field) => {

      formData.value[field] = '';

    };



    const submitForm = () => {

      console.log('提交数据:', formData.value);

      dialogVisible3.value = false;

      // Add your submit logic here

    };

    






    const editdialogVisible = ref(false);

    const editForm = ref({

      quantity: '',

      batchnumber: '',

      length:'',

      height:'',

      thickness:''

    });

    const editFormRef = ref(null);

    let currentRow = ref(null);



    // 处理行点击事件

    const edithandleRowClick = (row) => {

      currentRow.value = row;

      console.log(row)

      editForm.value.quantity = row.quantity.toString();

      editForm.value.batchnumber = row.batchnumber;

      editForm.value.length = row.length;

      editForm.value.height = row.height;

      editForm.value.thickness = row.thickness;

      editdialogVisible.value = true;

      console.log(editForm.value)

    };



    // 添加保存编辑内容

    const editsaveEdit = () => {

      if (!currentRow.value) return;



      // 更新当前行数据

      currentRow.value.quantity = parseInt(editForm.value.quantity);

      currentRow.value.batchnumber = editForm.value.batchnumber;



      // 关闭对话框

      editdialogVisible.value = false;

    };



    // 对话框关闭时重置编辑表单和当前行数据

    const edithandleDialogClose = () => {

      editForm.value.quantity = '';

      editForm.value.batchnumber = '';

      editForm.value.width = '';

      editForm.value.height = '';

      editForm.value.thickness = '';

  


      currentRow.value = null;

    };











    




    const handleRestart = (row) => {

  // 使用 Element UI 的 MessageBox.confirm 方法进行二次确认

  ElMessageBox.confirm('确定要执行重新开始操作吗？', '确认重新开始', {

    confirmButtonText: '确认',

    cancelButtonText: '取消',

    type: 'warning',

  }).then(() => {

    // 点击确认按钮的回调

    console.log('执行重新开始操作', row);

  }).catch(() => {

    // 点击取消按钮的回调，不执行任何操作

    console.log('取消重新开始操作');

  });

};



const handleCheckout = (row) => {

  // 使用 Element UI 的 MessageBox.confirm 方法进行二次确认

  ElMessageBox.confirm("确定要执行出库操作吗？", "确认出库", {

    confirmButtonText: "确认",

    cancelButtonText: "取消",

    type: "warning",

  })

    .then(() => {

      // 点击确认按钮的回调，执行出库操作

      const raw={

        number:parseInt(row.number),

        loadRack:2

      }

      outStorage(raw)

      console.log("执行出库操作", row);

    })

    .catch(() => {

      // 点击取消按钮的回调，不执行任何操作

      console.log("取消出库操作");

    });

};



const handleInbound = () => {

  // 打开入库对话框

  dialogVisible.value = true;

};



const storage = () => {

  // 打开入库对话框

  Hidden.value = true;

};



const handleCloseDialog = () => {

  // 关闭对话框时重置表单数据

  formData.value = {

    number: "",

    color: "",

    rawWidth: "",

    rawHeight: "",

    rawThickness: "",

    pieces: "",

  };

  dialogVisible.value = false;

};



const handleConfirmInbound = () => {

  inStorage(formData.value);

  // 处理确认入库逻辑，可以在这里提交表单或者执行其他操作

  console.log("Confirm Inbound:", formData.value);

  // 关闭对话框

  dialogVisible.value = false;

};



const dialogVisible3 = ref(false);

const colors = ref([

  { "0_glass_id": "Red" },

  { "0_glass_id": "Green" },

  { "0_glass_id": "Blue" },

  // Add more colors as needed

]);



const formData3 = ref({

  selectedColor: "",

  wid: "",

  heig: "",

  thinkness: "",

  num: "",

});



const addglass = () => {

  // 打开入库对话框

  dialogVisible3.value = true;

};

const handleCommand = (command) => {

  formData.value.selectedColor = command;

};



const clearInput = (field) => {

  formData.value[field] = "";

};



const submitForm = () => {

  console.log("提交数据:", formData.value);

  dialogVisible3.value = false;

  // Add your submit logic here

};



const editdialogVisible = ref(false);

const editForm = ref({

  id: "",

  pieces: "",

  batchId: "",

  rawWidth: "",

  rawHeight: "",

  rawThickness: "",

});

const editFormRef = ref(null);

let currentRow = ref(null);



// 处理行点击事件

const edithandleRowClick = (row) => {

  currentRow.value = row;

  console.log(row);

  editForm.value.pieces = row.pieces.toString();

  editForm.value.batchId = row.batchId;

  editForm.value.rawWidth = row.rawWidth;

  editForm.value.rawHeight = row.rawHeight;

  editForm.value.rawThickness = row.rawThickness;

  editForm.value.id = row.number;

  editdialogVisible.value = true;

  console.log(editForm.value);

};



// 添加保存编辑内容

const editsaveEdit = () => {

  if (!currentRow.value) return;



  // 更新当前行数据

  currentRow.value.pieces = editForm.value.pieces;

  currentRow.value.batchId = editForm.value.batchId;

  currentRow.value.rawWidth = editForm.value.rawWidth;

  currentRow.value.rawHeight = editForm.value.rawHeight;

  currentRow.value.rawThickness = editForm.value.rawThickness;

  // 调用更新函数，并处理其返回的 Promise

  updateRawUsage(editForm.value);



  // 关闭对话框

  editdialogVisible.value = false;

};



// 对话框关闭时重置编辑表单和当前行数据

const edithandleDialogClose = () => {

  editForm.value.pieces = "";

  editForm.value.batchId = "";

  editForm.value.rawWidth = "";

  editForm.value.rawHeight = "";

  editForm.value.rawThickness = "";



  currentRow.value = null;

};



const handleRestart = (row) => {

  // 使用 Element UI 的 MessageBox.confirm 方法进行二次确认

  ElMessageBox.confirm("确定要执行重新开始操作吗？", "确认重新开始", {

    confirmButtonText: "确认",

    cancelButtonText: "取消",

    type: "warning",

  })

    .then(() => {

      const taskdata={

        id:row.id,

        Type:"重新开始"

      }

      taskUpdate(taskdata);

      


      console.log("执行重新开始操作", row);

    })

    .catch(() => {

      // 点击取消按钮的回调，不执行任何操作

      console.log("取消重新开始操作");

    });

};



const handleDeletetask = (row) => {

  // 使用 Element UI 的 MessageBox.confirm 方法进行二次确认

  ElMessageBox.confirm('确定要执行删除任务操作吗？', '确认删除任务', {

    confirmButtonText: '确认',

    cancelButtonText: '取消',

    type: 'warning',

  }).then(() => {

    // 点击确认按钮的回调

    console.log('执行删除任务操作', row);

  }).catch(() => {

    // 点击取消按钮的回调，不执行任何操作

    console.log('取消删除任务操作');

  });

  ElMessageBox.confirm("确定要执行删除任务操作吗？", "确认删除任务", {

    confirmButtonText: "确认",

    cancelButtonText: "取消",

    type: "warning",

  })

    .then(() => {

      // 点击确认按钮的回调

      const taskdata={

        id:row.id,

        Type:"删除"

      }

      taskUpdate(taskdata);

      console.log("执行删除任务操作", row);

    })

    .catch(() => {

      // 点击取消按钮的回调，不执行任何操作

      console.log("取消删除任务操作");

    });

};







const handleComplete = (row) => {

  // 使用 Element UI 的 MessageBox.confirm 方法进行二次确认

  ElMessageBox.confirm('确定要执行任务完成操作吗？', '确认任务完成', {

    confirmButtonText: '确认',

    cancelButtonText: '取消',

    type: 'warning',

  }).then(() => {

    // 点击确认按钮的回调

    console.log('执行任务完成操作', row);

  }).catch(() => {

    // 点击取消按钮的回调，不执行任何操作

    console.log('取消任务完成操作');

  });

  ElMessageBox.confirm("确定要执行任务完成操作吗？", "确认任务完成", {

    confirmButtonText: "确认",

    cancelButtonText: "取消",

    type: "warning",

  })

    .then(() => {



      const taskdata={

        id:row.id,

        Type:"完成"

      }

      taskUpdate(taskdata);

      // 点击确认按钮的回调

      console.log("执行任务完成操作", row);

    })

    .catch(() => {

      // 点击取消按钮的回调，不执行任何操作

      console.log("取消任务完成操作");

    });

};















































    




</script>



<style scoped>





#dt { display:block; float:left;line-height: 20px;margin-left: 100px;}

#dta { display:block; float:left;line-height: 20px;margin-left: 80%;}

#dialog-footer{

#dt {

  display: block;

  float: left;

  line-height: 20px;

  margin-left: 100px;

}

#dta {

  display: block;

  float: left;

  line-height: 20px;

  margin-left: 80%;

}

#dialog-footer {

  text-align: center;

  margin-top: -15px;

}







.img-ypcc{

.img-ypcc {

  margin-left: 80px;

  background-image:url('../../assets/ypcc.png');

  background-image: url("../../assets/ypcc.png");

  background-repeat: no-repeat;

    background-attachment: local;

    min-height: 600px;

    width: 1400px;

    max-width: 100%;

    background-size: 1400px 600px;

    overflow: hidden;

    position:relative;

    margin-top:0px

  background-attachment: local;

  min-height: 600px;

  width: 1400px;

  max-width: 100%;

  background-size: 1400px 600px;

  overflow: hidden;

  position: relative;

  margin-top: 0px;

}



.img-car1{

  background-image:url('../../assets/ypccche.png');

.img-car1 {

  background-image: url("../../assets/ypccche.png");

  position: absolute;

  background-repeat: no-repeat;

    background-attachment: local;

    min-height: 400px;

    width: 200px;

    max-width: 100%;

    background-size: 200px 170px;

    overflow: hidden;

    position:relative

  background-attachment: local;

  min-height: 400px;

  width: 200px;

  max-width: 100%;

  background-size: 200px 170px;

  overflow: hidden;

  position: relative;

}



.custom-dialog {


 UI-Project/src/views/Identify/identify.vue

@@ -41,7 +41,7 @@
<script setup lang="ts">  
import { Delete, Upload } from '@element-plus/icons-vue'
import { ElMessage, ElMessageBox } from 'element-plus'
import { ref, onMounted, onBeforeUnmount } from 'vue';  
import { ref, onMounted, onBeforeUnmount,onUnmounted } from 'vue';  
import request from "@/utils/request"
import { WebSocketHost ,host} from '@/utils/constants'
import { initializeWebSocket, closeWebSocket } from '@/utils/WebSocketService';
@@ -181,15 +181,13 @@
    }  
  });  
}
let socket = null;
const socketUrl = `ws://${WebSocketHost}:${host}/api/cacheGlass/api/talk/cacheGlass`;
// 定义消息处理函数，更新 receivedData 变量
const handleMessage = (data) => {
  // 更新 tableData 的数据
  
  // adjustedRects.value = data.currentCutTerritory[0]
  adjustedRects.value = data.currentCutTerritory[0].map(rect => ({  
        ...rect, // 复制原始对象的其他属性  
        x_axis: (rect.x_axis*100) * 0.003, // 将x值除以3  
        ...rect,
        x_axis: (rect.x_axis*100) * 0.003,
        y_axis: (rect.y_axis*100) * 0.003,
        width: (rect.width*100) * 0.002 ,
        widtha: rect.width ,
@@ -197,18 +195,15 @@
        height:( rect.height*100) * 0.002 ,
        glass_state: rect.glass_state
      }));  
 // console.log("更新后数据", tableData);

};

// 初始化 WebSocket，并传递消息处理函数

onMounted(() => {
  // fetchFlowCardId();
  // fetchTableData(); // 获取数据
  initializeWebSocket(socketUrl, handleMessage);
  socket = initializeWebSocket(socketUrl, handleMessage);
});

  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
onBeforeUnmount(() => {
  console.log("关闭了")
  closeWebSocket();

 UI-Project/src/views/PurchaseReturn/purchaseReturn.vue

@@ -3,7 +3,7 @@
import {reactive} from "vue";
import {useRouter} from "vue-router"
import request from "@/utils/request"
import { ref, onMounted, onBeforeUnmount } from 'vue';  
import { ref, onMounted, onBeforeUnmount,onUnmounted } from 'vue';  
import { WebSocketHost ,host} from '@/utils/constants'
import { ElMessage, ElMessageBox } from 'element-plus'
import { initializeWebSocket, closeWebSocket } from '@/utils/WebSocketService';
@@ -22,31 +22,52 @@
const adjustedRectsb = ref([]);
const currentGlassId = ref(null);
const currenttemperingFeedSequence = ref(null);
let socket = null;
const socketUrl = `ws://${WebSocketHost}:${host}/api/temperingGlass/api/talk/temperingGlass`;
const handleMessage = (data) => {
// 进炉中
  if(data.intoGlass!=null){
    adjustedRects1.value =  data.intoGlass[0].map(rect => {  
      console.log( adjustedRects1.value);
        let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta;
        let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta,widtha,heighta;;
        let newX = rect.yCoordinate; 
  if (rect.angle === 0) {  
          adjustedWidth = rect.height * 0.12;  
          adjustedHeight = rect.width * 0.1;  
          adjustedWidtha = rect.height;  
          adjustedHeighta = rect.width;  
          newX = 5087 - (rect.xCoordinate + rect.height); 
        } else {  
          adjustedWidth = rect.width * 0.12;  
          adjustedHeight = rect.height * 0.1;  
          adjustedWidtha = rect.width;  
          adjustedHeighta = rect.height;  
          newX = 5087 - (rect.xCoordinate + rect.width); 
        }  
      if (rect.width < rect.height) {
        widtha = rect.height;
        heighta = rect.width;
      }else {
        widtha = rect.width;
        heighta = rect.height;
      }
      if (rect.angle === 0) {  
    adjustedWidth = widtha * 0.12;
    adjustedHeight = heighta * 0.1;
    adjustedWidtha = widtha;  
    adjustedHeighta = heighta;  
    newX = 5087 - (rect.yCoordinate + widtha); 
    } else {  
    adjustedWidth = heighta * 0.12;  
    adjustedHeight = widtha * 0.1;  
    adjustedWidtha = heighta;  
    adjustedHeighta = widtha;  
    newX = 5087 - (rect.yCoordinate + heighta);  
  }  
  // if (rect.angle === 0) {  
  //         adjustedWidth = heighta * 0.12;  
  //         adjustedHeight = widtha * 0.1;  
  //         adjustedWidtha = heighta;  
  //         adjustedHeighta = widtha;  
  //         newX = 5087 - (rect.xCoordinate + heighta); 
  //       } else {  
  //         adjustedWidth = widtha * 0.12;  
  //         adjustedHeight = heighta * 0.1;  
  //         adjustedWidtha = widtha;  
  //         adjustedHeighta = heighta;  
  //         newX = 5087 - (rect.xCoordinate + widtha); 
  //       }  
        return {  
        ...rect, 
        xcoordinate: newX * 0.12,
        ycoordinate: rect.yCoordinate * 0.1,
        ycoordinate: rect.xCoordinate * 0.1,
        width: adjustedWidth,  
        height: adjustedHeight,  
        widtha: adjustedWidtha, 
@@ -59,25 +80,45 @@
  if(data.intoGlass2!=null){
    adjustedRects2.value =  data.intoGlass2[0].map(rect => {  
      console.log( adjustedRects2.value);
      let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta;
      let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta,widtha,heighta;;
      let newX = rect.yCoordinate; 
      if (rect.width < rect.height) {
        widtha = rect.height;
        heighta = rect.width;
      }else {
        widtha = rect.width;
        heighta = rect.height;
      }
      if (rect.angle === 0) {  
          adjustedWidth = rect.height * 0.12;  
          adjustedHeight = rect.width * 0.1;  
          adjustedWidtha = rect.height;  
          adjustedHeighta = rect.width;  
          newX = 5087 - (rect.xCoordinate + rect.height); 
  } else {  
          adjustedWidth = rect.width * 0.12;  
          adjustedHeight = rect.height * 0.1;  
          adjustedWidtha = rect.width;  
          adjustedHeighta = rect.height;  
          newX = 5087 - (rect.xCoordinate + rect.width); 
    adjustedWidth = widtha * 0.12;
    adjustedHeight = heighta * 0.1;
    adjustedWidtha = widtha;  
    adjustedHeighta = heighta;  
    newX = 5087 - (rect.yCoordinate + widtha); 
    } else {  
    adjustedWidth = heighta * 0.12;  
    adjustedHeight = widtha * 0.1;  
    adjustedWidtha = heighta;  
    adjustedHeighta = widtha;  
    newX = 5087 - (rect.yCoordinate + heighta);  
  }  
  //     if (rect.angle === 0) {  
  //         adjustedWidth = heighta * 0.12;  
  //         adjustedHeight = widtha * 0.1;  
  //         adjustedWidtha = heighta;  
  //         adjustedHeighta = widtha;  
  //         newX = 5087 - (rect.xCoordinate + heighta); 
  // } else {  
  //         adjustedWidth = widtha * 0.12;  
  //         adjustedHeight = heighta * 0.1;  
  //         adjustedWidtha = widtha;  
  //         adjustedHeighta = heighta;  
  //         newX = 5087 - (rect.xCoordinate + widtha); 
  // }  
        return {  
        ...rect, 
        xcoordinate: newX * 0.12,
        ycoordinate: rect.yCoordinate * 0.1,
        ycoordinate: rect.xCoordinate * 0.1,
        width: adjustedWidth,  
        height: adjustedHeight,  
        widtha: adjustedWidtha, 
@@ -90,20 +131,27 @@
  // 进炉前
  if(data.waitingGlass!=null){
    adjustedRectsa.value = data.waitingGlass[0].map(rect => {  
  let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta; 
  let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta,widtha,heighta;; 
  let newX = rect.yCoordinate; 
      if (rect.width < rect.height) {
        widtha = rect.height;
        heighta = rect.width;
      }else {
        widtha = rect.width;
        heighta = rect.height;
      }
  if (rect.angle === 0) {  
    adjustedWidth = rect.width * 0.24;  
    adjustedHeight = rect.height * 0.16;
    adjustedWidtha = rect.width;  
    adjustedHeighta = rect.height;  
    newX = 5190 - (rect.yCoordinate + rect.width); 
    adjustedWidth = widtha * 0.24;  
    adjustedHeight = heighta * 0.16;
    adjustedWidtha = widtha;  
    adjustedHeighta = heighta;  
    newX = 5190 - (rect.yCoordinate + widtha); 
    } else {  
    adjustedWidth = rect.height * 0.24;  
    adjustedHeight = rect.width * 0.16;  
    adjustedWidtha = rect.height;  
    adjustedHeighta = rect.width;  
    newX = 5190 - (rect.yCoordinate + rect.height);  
    adjustedWidth = heighta * 0.24;  
    adjustedHeight = widtha * 0.16;  
    adjustedWidtha = heighta;  
    adjustedHeighta = widtha;  
    newX = 5190 - (rect.yCoordinate + heighta);  
  }  
  return {  
    ...rect, 
@@ -121,20 +169,27 @@
    // 已出炉
  if(data.outGlass!=null){
    adjustedRectsb.value = data.outGlass[0].map(rect => {  
  let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta;
  let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta,widtha,heighta;;
  let newX = rect.yCoordinate; 
      if (rect.width < rect.height) {
        widtha = rect.height;
        heighta = rect.width;
      }else {
        widtha = rect.width;
        heighta = rect.height;
      }
  if (rect.angle === 0) {  
    adjustedWidth = rect.width * 0.24;  
    adjustedHeight = rect.height * 0.16;  
    adjustedWidtha = rect.width;  
    adjustedHeighta = rect.height;  
    newX = 5190 - (rect.yCoordinate + rect.width); 
    adjustedWidth = widtha * 0.24;  
    adjustedHeight = heighta * 0.16;  
    adjustedWidtha = widtha;  
    adjustedHeighta = heighta;  
    // newX = 5190 - (rect.yCoordinate + widtha); 
  } else {  
    adjustedWidth = rect.height * 0.24;  
    adjustedHeight = rect.width * 0.16;  
    adjustedWidtha = rect.height;  
    adjustedHeighta = rect.width;  
    newX = 5190 - (rect.yCoordinate + rect.height);  
    adjustedWidth = heighta * 0.24;  
    adjustedHeight = widtha * 0.16;  
    adjustedWidtha = heighta;  
    adjustedHeighta = widtha;  
    // newX = 5190 - (rect.yCoordinate + heighta);  
  }  
  return {  
        ...rect, // 复制原始对象的其他属性  
@@ -151,8 +206,13 @@
      }
};
onMounted(() => {
  initializeWebSocket(socketUrl, handleMessage);
  socket = initializeWebSocket(socketUrl, handleMessage);
});
  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
function updateRectColors() {  
  adjustedRectsa.value.forEach(rect => {  
    if (rect.glassId === glassId) {  
@@ -163,11 +223,11 @@
function getRectColora(state) {  
  switch (state) {  
    case 0:  
      return '#d1edc4';  
      return '#7AC5CD';  
    case 1:  
      return '#E6E6FA';
      return '#95d475';
    case -1:  
      return '#dedfe0';  
      return '#CDAF95';  
    case 5:  
      return '#911005';  
  }
@@ -175,9 +235,9 @@
function getRectColorb(state) {  
  switch (state) {  
    case 3:  
      return '#f8e3c5';  
      return '#eebe77';  
    case 4:  
      return '#F0F8FF';
      return '#CD6090';
    case 5:  
      return '#911005';  
  }  

 UI-Project/src/views/PurchaseReturn/purchaseStorage.vue

@@ -5,7 +5,7 @@
import { ElMessage, ElMessageBox } from 'element-plus'
import request from "@/utils/request"

import { ref, onMounted, onBeforeUnmount } from 'vue';  
import { ref, onMounted, onBeforeUnmount,onUnmounted } from 'vue';  
import { WebSocketHost ,host} from '@/utils/constants'
import { initializeWebSocket, closeWebSocket } from '@/utils/WebSocketService';
const adjustedRects = ref([]);
@@ -29,27 +29,34 @@
    }
  }
}

let socket = null;
const socketUrl = `ws://${WebSocketHost}:${host}/api/temperingGlass/api/talk/temperingGlass`; 
// 定义消息处理函数，更新 receivedData 变量
const handleMessage = (data) => {
  // 更新 tableData 的数据
  if(data.overGlass!=null){
    adjustedRects.value =  data.overGlass[0].map(rect => {  
  let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta;
  let adjustedWidth, adjustedHeight, adjustedWidtha, adjustedHeighta,widtha,heighta;
      let newX = rect.yCoordinate; 
      if (rect.angle === 0) {  
    adjustedWidth = rect.width * 0.24;  
    adjustedHeight = rect.height * 0.16;  
    adjustedWidtha = rect.width;  
    adjustedHeighta = rect.height;  
    newX = 5190 - (rect.yCoordinate + rect.width);
      if (rect.width < rect.height) {
        widtha = rect.height;
        heighta = rect.width;
      }else {
        widtha = rect.width;
        heighta = rect.height;
      }
    if (rect.angle === 0) {  
    adjustedWidth = widtha * 0.24;  
    adjustedHeight = heighta * 0.16;  
    adjustedWidtha = widtha;  
    adjustedHeighta = heighta;  
    // newX = 5190 - (rect.yCoordinate + rect.width); 
  } else {  
    adjustedWidth = rect.height * 0.24;  
    adjustedHeight = rect.width * 0.16;  
    adjustedWidtha = rect.height;  
    adjustedHeighta = rect.width;  
    newX = 5190 - (rect.yCoordinate + rect.height);
    adjustedWidth = heighta * 0.24;  
    adjustedHeight = widtha * 0.16;  
    adjustedWidtha = heighta;  
    adjustedHeighta = widtha;  
    // newX = 5190 - (rect.yCoordinate + rect.height);  
  }  
  return {  
    ...rect, 
@@ -71,11 +78,11 @@
  });  
}  
function getRectColora(state) {  
  switch (state) {  
  switch (state) { 
    case 3:  
      return '#f8e3c5';  
      return '#eebe77';  
    case 4:  
      return '#F0F8FF';
      return '#CD6090';
    case 5:  
      return '#911005';  
  }  
@@ -110,11 +117,13 @@
  }
}
onMounted(() => {
  // fetchFlowCardId();
  // fetchTableData(); // 获取数据
  initializeWebSocket(socketUrl, handleMessage);
  socket = initializeWebSocket(socketUrl, handleMessage);
});

  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
onBeforeUnmount(() => {
  console.log("关闭了")
  closeWebSocket();

 UI-Project/src/views/ReportWork/reportWork.vue

@@ -1,51 +1,137 @@
<template>
  <div style="height: 600px;">
    <span class="demonstration">生产时间</span>
    <el-date-picker v-model="timeRange" type="daterange" format="YYYY/MM/DD" value-format="YYYY-MM-DD"
      start-placeholder="开始时间" end-placeholder="结束时间" :default-time="defaultTime" />
    <el-select v-model="report.type" placeholder="清选择类型">
      <el-option label="全部" value="0"></el-option>
      <el-option label="完工" value="1"></el-option>
      <el-option label="破损" value="2"></el-option>
      <el-option label="拿走" value="3"></el-option>
    <div style="display: flex; flex-direction: row; align-items: center; margin-top: 20px;">  
    <span style="margin-left: 10px;" class="demonstration">{{ $t('reportmanage.productiontime') }}</span>
    <el-date-picker style="margin-left: 10px;"  v-model="timeRange" type="daterange" format="YYYY/MM/DD" value-format="YYYY-MM-DD"
      :start-placeholder="$t('reportmanage.starttime')" :end-placeholder="$t('reportmanage.endtime')" :default-time="defaultTime" />
    <el-select v-model="report.type" :placeholder="$t('reportmanage.ctype')" style="margin-left: 10px;" >
      <el-option :label="$t('reportmanage.all')" value="0"></el-option>
      <el-option :label="$t('reportmanage.completed')" value="1"></el-option>
      <el-option :label="$t('reportmanage.broke')" value="2"></el-option>
      <el-option :label="$t('reportmanage.takeout')" value="3"></el-option>
    </el-select>
    <el-select v-model="report.status" placeholder="清选择状态">
      <el-option label="全部" value="0"></el-option>
      <el-option label="未报工" value="1"></el-option>
      <el-option label="待报工" value="2"></el-option>
      <el-option label="已报工" value="3"></el-option>
    <el-select v-model="report.status" :placeholder="$t('reportmanage.cstate')" style="margin-left: 10px;" >
      <el-option :label="$t('reportmanage.all')" value="0"></el-option>
      <el-option :label="$t('reportmanage.dreportwork')" value="1"></el-option>
      <el-option :label="$t('reportmanage.pendingwork')" value="2"></el-option>
      <el-option :label="$t('reportmanage.reportwork')" value="3"></el-option>
    </el-select>
    <el-select v-model="report.workingProcedure" placeholder="清选择工序">
      <el-option label="全部" value="0"></el-option>
      <el-option label="切割" value="1"></el-option>
      <el-option label="磨边" value="2"></el-option>
      <el-option label="钢化" value="3"></el-option>
    <el-select v-model="report.workingProcedure" :placeholder="$t('reportmanage.cprocess')" style="margin-left: 10px;" >
      <el-option :label="$t('reportmanage.all')" value="0"></el-option>
      <el-option :label="$t('reportmanage.incise')" value="1"></el-option>
      <el-option :label="$t('reportmanage.edging')" value="2"></el-option>
      <el-option :label="$t('reportmanage.steel')" value="3"></el-option>
    </el-select>
    <el-button type="primary" @click="selectReportData()">查询</el-button>
    <el-button type="success">报工</el-button>
    <el-table height="100%" ref="table" :data="reportData"
    <el-button type="primary" style="margin-left: 10px;" @click="selectReportData()">{{ $t('reportmanage.inquire') }}</el-button>
    <el-button type="success" style="margin-left: 10px;" @click="handleConfirm">{{ $t('reportmanage.signingwork') }}</el-button>
  </div>
    <el-card style="flex: 1;margin-left: 10px;margin-top: 20px;" v-loading="loading">
      <div style="width: 98%; height: calc(100% - 35px); overflow-y: auto;">
    <el-table height="540" ref="table" :data="reportData"
      :header-cell-style="{ background: '#F2F3F5 ', color: '#1D2129' }">
      <el-table-column prop="teamsGroupsName" align="center" label="报工班组" min-width="120" />
      <el-table-column prop="deviceName" align="center" label="报工设备" min-width="120" />
      <el-table-column prop="line" align="center" label="线路" min-width="120" />
      <el-table-column prop="workingProcedure" align="center" label="工序" min-width="120" />
      <el-table-column prop="glassId" align="center" label="玻璃id" min-width="120" />
      <el-table-column prop="engineerId" align="center" label="工程号" min-width="120" />
      <el-table-column prop="temperingLayoutId" align="center" label="钢化版图id" min-width="120" />
      <el-table-column prop="damageTime" align="center" label="生产时间" min-width="120" />
      <el-table-column prop="type" align="center" label="类型" min-width="120" />
      <el-table-column prop="status" align="center" label="状态" min-width="120" />
      <el-table-column prop="processId" align="center" label="流程卡" min-width="120" />
      <el-table-column prop="orderNumber" align="center" label="序号" min-width="120" />
      <el-table-column prop="technologyNumber" align="center" label="层" min-width="120" />
      <el-table-column prop="breakageType" align="center" label="破损类型" min-width="120" />
      <el-table-column prop="breakageReason" align="center" label="破损原因" min-width="120" />
      <el-table-column prop="responsibleProcess" align="center" label="责任工序" min-width="120" />
      <el-table-column prop="responsiblePersonnel" align="center" label="责任人员" min-width="120" />
      <el-table-column prop="responsibleTeam" align="center" label="责任班组" min-width="120" />
      <el-table-column prop="responsibleEquipment" align="center" label="责任设备" min-width="120" />
      <el-table-column prop="remark" align="center" label="备注" min-width="120" />
      <el-table-column prop="teamsGroupsName" align="center" :label="$t('reportmanage.reporteam')" min-width="120" />
      <el-table-column prop="deviceName" align="center" :label="$t('reportmanage.reportingequipment')" min-width="120" />
      <el-table-column prop="line" align="center" :label="$t('reportmanage.line')" min-width="120" />
      <el-table-column prop="workingProcedure" align="center" :label="$t('reportmanage.process')" min-width="120" />
      <el-table-column prop="glassId" align="center" :label="$t('reportmanage.glassID')" min-width="130" />
      <el-table-column prop="engineerId" align="center" :label="$t('reportmanage.projectnumber')" min-width="120" />
      <el-table-column prop="temperingLayoutId" align="center" :label="$t('reportmanage.layoutID')" min-width="120" />
      <el-table-column prop="damageTime" align="center" :label="$t('reportmanage.productiontime')" min-width="230" />
      <el-table-column prop="type" align="center" :label="$t('reportmanage.type')" min-width="120" />
      <el-table-column prop="status" align="center" :label="$t('reportmanage.state')" min-width="120" />
      <el-table-column prop="processId" align="center" :label="$t('reportmanage.processcards')" min-width="140" />
      <el-table-column prop="orderNumber" align="center" :label="$t('reportmanage.number')" min-width="120" />
      <el-table-column prop="technologyNumber" align="center" :label="$t('reportmanage.layer')" min-width="120" />
      <el-table-column prop="breakageType" align="center" :label="$t('reportmanage.typebreakage')" min-width="180">
        <template #default="{ row }">  
        <el-select  
                      v-model="selectValuesa[row.id]"
                      filterable  
                      :placeholder="$t('reportmanage.pcausebreakage')"
                      clearable  
                      @input="handleInputChangea($event, row.id)"
                    >  
                 <el-option  
                    v-for="item in selectOptionsa"  
                    :key="item.basicName"  
                    :label="item.basicName"  
                    :value="item.basicName"  
                 />  
               </el-select>  
               </template>
      </el-table-column>
      <el-table-column prop="breakageReason" align="center" :label="$t('reportmanage.causebreakage')" min-width="180">
        <template #default="{ row }">  
        <el-select  
                      v-model="selectValuesb[row.id]"
                      filterable  
                      :placeholder="$t('reportmanage.ptypebreakage')"
                      clearable  
                      @input="handleInputChangea($event, row.id)"
                    >  
                 <el-option  
                    v-for="item in selectOptionsb"  
                    :key="item.basicName"  
                    :label="item.basicName"  
                    :value="item.basicName"  
                 />  
               </el-select>  
               </template>
      </el-table-column>
      <el-table-column align="center" :label="$t('reportmanage.responsibleprocess')" min-width="120">
        <template #default="{ row }">  
        <span>{{ '切割磨边钢化' }}</span>  
      </template>  
      </el-table-column>
      <el-table-column prop="responsiblePersonnel" align="center" :label="$t('reportmanage.responsiblepersonnel')" min-width="180">
        <template #default="{ row }">
          <el-input :placeholder="$t('reportmanage.presponsiblepersonnel')" v-model="inputValuesa[row.id]" autocomplete="off" />
        </template>
      </el-table-column>
      <el-table-column prop="responsibleTeam" align="center" :label="$t('reportmanage.responsibleteam')" min-width="180">
        <template #default="{ row }">  
        <el-select  
                      v-model="selectValuesc[row.id]"
                      filterable  
                      :placeholder="$t('reportmanage.presponsibleteam')"
                      clearable  
                      @input="handleInputChangea($event, row.id)"
                    >  
                 <el-option  
                    v-for="item in selectOptionsc"  
                    :key="item.basicName"  
                    :label="item.basicName"  
                    :value="item.basicName"  
                 />  
               </el-select>  
               </template>
      </el-table-column>
      <el-table-column prop="responsibleEquipment" align="center" :label="$t('reportmanage.responsibleequipment')" min-width="180">
        <template #default="{ row }">  
        <el-select  
                      v-model="selectValuesd[row.id]"
                      filterable  
                      :placeholder="$t('reportmanage.presponsibleequipment')"
                      clearable  
                      @input="handleInputChangea($event, row.id)"
                    >  
                 <el-option  
                    v-for="item in selectOptionsd"  
                    :key="item.basicName"  
                    :label="item.basicName"  
                    :value="item.basicName"  
                 />  
               </el-select>  
               </template>
      </el-table-column>
      <el-table-column prop="remark" align="center" :label="$t('reportmanage.remark')" min-width="180">
        <template #default="{ row }">
          <el-input :placeholder="$t('reportmanage.premark')" v-model="inputValuesb[row.id]" autocomplete="off" />
        </template>
      </el-table-column>
    </el-table>
    </div>
    </el-card>
  </div>
</template>
<script setup>
@@ -63,7 +149,17 @@
  workingProcedure: '0',
});
const reportData = ref([])
const timeRange = ref(["2022-01-01", "2022-01-01"])
const timeRange = ref(["2022-01-01", "2025-01-01"])
const selectOptionsa = ref([]);
const selectOptionsb = ref([]);
const selectOptionsc = ref([]);
const selectOptionsd = ref([]);
const selectValuesa = reactive({});
const selectValuesb = reactive({});
const selectValuesc = reactive({});
const selectValuesd = reactive({});
const inputValuesa = reactive({});
const inputValuesb = reactive({});


// 查询数据
@@ -90,7 +186,45 @@
    status:"2"
  })
};

// 报工
const handleConfirm = async () => {
  const response = await request.post("/cacheVerticalGlass/damage/submitDamage", reportData.value)
  if (response.code === 200) {
    ElMessage.success(response.message);
  } else {
    ElMessage.error(response.message);
  }
};
const fetchTableData = async () => {  
  try {  
    const response = await request.post('/cacheVerticalGlass/basic_data_produce/selectBasicDataProduceGroup');  
    if (response.code == 200) {  
      selectOptionsa.value = response.data.breakagetype.filter(item => item !== null)
.map(item => ({ basicName: item.basicName }));
      selectOptionsb.value = response.data.breakagereason.filter(item => item !== null)
.map(item => ({ basicName: item.basicName }));
      selectOptionsc.value = response.data.teamsgroups.filter(item => item !== null)
.map(item => ({ basicName: item.basicName }));
      selectOptionsd.value = response.data.device.filter(item => item !== null)
.map(item => ({ basicName: item.basicName }));
    } else {  
      ElMessage.warning(response.data);  
    }  
  } catch (error) {  
    console.error('Error fetching options:', error);  
  }  
}; 
const handleInputChangea = (value, rowId) => {  
  // 更新对应行的 select 值  
  selectValuesa[rowId] = value;  
  selectValuesb[rowId] = value;  
  selectValuesc[rowId] = value;  
  selectValuesd[rowId] = value;  
  inputValuesa[rowId] = value;  
  inputValuesb[rowId] = value;  
};
fetchTableData();  
let socket = null;
const socketUrl = `ws://${WebSocketHost}:${host}/api/temperingGlass/api/talk/screen`;
const handleMessage = (data) => {
  // adjustedRects.value = data.device[0].map(rect => ({  
@@ -100,7 +234,7 @@
  //       thisProcess: rect.thisProcess,
  //     })); 
};
let socket;
// let socket;
onMounted(() => {
  socket = new WebSocket(socketUrl);
  socket.onmessage = (event) => {
@@ -110,19 +244,18 @@
  };
  // };  
});




onUnmounted(() => {
  socket.close();
});

onMounted(() => {
  // fetchFlowCardId();
  // fetchTableData(); // 获取数据
  initializeWebSocket(socketUrl, handleMessage);
  fetchTableData();
  socket = initializeWebSocket(socketUrl, handleMessage);
});
  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
onBeforeUnmount(() => {
  console.log("关闭了")
  closeWebSocket();

 UI-Project/src/views/Returns/returns.vue

@@ -17,6 +17,8 @@
const flakea = ref(false)
const flakeb = ref(false)
const flakec = ref(false)
const dialoglea = ref(false)
const tableDatax = ref([])
const user = ref('');
const projectNo = ref('');
const workstationId = ref('');
@@ -89,13 +91,50 @@
    // ElMessage.error('获取表格数据失败，请重试');
  }
};
onMounted(() => {  
const handlezhiban = () => {
  dialoglea.value = true; // 打开绑定架子对话框
  fetchFlowCardId(); 
};
// 值班信息
const fetchFlowCardId = async () => {
  try  {
    const response = await request.post('/loadGlass/work_assignment/selectWorkAssignment',{
      line: 2001,
      workingProcedure : '冷加工'
    })
    if (response.code == 200) {
      ElMessage.success(response.message);
      tableDatax.value = response.data;
      console.log(tableDatax.value);
      console
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
    // 处理错误
    console.error(error);
  }
}
const handleConfirmb = async () => {
  const response = await request.post("/loadGlass/work_assignment/updateWorkAssignment", tableDatax.value)
  if (response.code === 200) {
    ElMessage.success(response.message);
    dialoglea.value = false;
  } else {
    ElMessage.error(response.message);
  }
};
onMounted(() => {
  list('');  
  fetchOptions('');
  initializeWebSocket(socketUrl, handleMessage);
  socket = initializeWebSocket(socketUrl, handleMessage);
});
onMounted(() => {  
}); 
  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
const list = async () => {  
  try {  
    const response = await request.get('/loadGlass/LoadGlass/list');  
@@ -152,6 +191,7 @@
const titleSelectJsona = ref({
  processTypea: [],
})
let socket = null;
const socketUrl = `ws://${WebSocketHost}:${host}/api/loadGlass/api/talk/loadGlass`;
// 定义消息处理函数，更新 receivedData 变量
const handleMessage = (data) => {
@@ -637,7 +677,6 @@
  }  
};
</script>
 
<template>
  <div>
    <div id="dotClass">
@@ -655,6 +694,7 @@
    <el-button style="margin-top: 5px;margin-left: 15px;"   id="searchButton" type="primary" @click="dialogFormVisible = true">{{ $t('basicData.selectproject') }}</el-button>
    <el-button style="margin-top: 5px;margin-left: 20px;" id="searchButton" type="primary" @click="handleBind">{{ $t('basicData.startloading') }}</el-button>
    <el-button style="margin-top: 5px;margin-left: 20px;"  id="searchButton" type="warning" @click="handleBinda">{{ $t('basicData.stop') }}</el-button>
    <el-button style="margin-top: 5px;margin-left: 20px;" id="searchButton" type="info" @click="handlezhiban">{{ $t('searchOrder.dutyinformation') }}</el-button>
    <!-- <el-button style="margin-top: 5px;margin-left: 20px;"  id="searchButton" type="danger" @click="handleBindb">停止任务</el-button> -->
    
    <el-card style="flex: 1;margin-left: 10px;margin-top: 15px;" v-loading="loading">
@@ -716,6 +756,32 @@
      </div>
    </template>
  </el-dialog>
  
<el-dialog v-model="dialoglea" top="15vh" width="70%" :title="$t('searchOrder.dutyinformation')">
    <el-table  ref="table" style="margin-top: 20px;height: 300px;"
        :data="tableDatax" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
          <el-table-column prop="line" fixed align="center" :label="$t('searchOrder.line')"/>
          <el-table-column prop="workProcesses" fixed align="center" :label="$t('searchOrder.process')" />
          <el-table-column prop="teamsGroupsName" align="center" :label="$t('searchOrder.team')">
        <template #default="{ row }">  
          <el-input v-model="row.teamsGroupsName" autocomplete="off" min-width="150"/>  
        </template>  
      </el-table-column>
          <el-table-column prop="deviceName" align="center" :label="$t('searchOrder.basic')">
            <template #default="{ row }">  
          <el-input v-model="row.deviceName" autocomplete="off" min-width="150"/>  
        </template>
        </el-table-column>
        </el-table>
        <template #footer>
      <div id="dialog-footer">
        <el-button type="primary" @click="handleConfirm">
          {{ $t('searchOrder.add') }}
        </el-button>
        <el-button @click="dialoglea = false">{{ $t('searchOrder.cancel') }}</el-button>
      </div>
    </template>
</el-dialog>
  <el-dialog v-model="blinda" top="30vh" width="25%" :title="$t('basicData.whetherpause')">
    <template #footer>
      <div id="dialog-footer">

 UI-Project/src/views/Slicecage/slicecage.vue

@@ -7,11 +7,12 @@
const router = useRouter()
import request from "@/utils/request"
import { WebSocketHost ,host} from '@/utils/constants'
import { ref, onMounted , onBeforeUnmount, reactive, computed } from "vue";
import { ref, onMounted , onBeforeUnmount, reactive, computed,onUnmounted } from "vue";
import { initializeWebSocket, closeWebSocket } from '@/utils/WebSocketService';
import { ElMessage, ElMessageBox } from 'element-plus'
import { tr } from "element-plus/es/locale";
const dialogFormVisible = ref(false)
const dialoglea = ref(false)
const dialogFormVisiblea = ref(false)
const dialogFormVisibleb = ref(false)
const dialogFormVisiblec = ref(false)
@@ -22,7 +23,9 @@
const tableDatad = ref([])
const tableDataf = ref([])
const tableDatae = ref([])
const tableDatax = ref([])
const carPosition = ref([])
const ganghua = ref('')
const adjustedRects = ref([]);
const project = ref([]);
const adjust = ref([]);
@@ -36,6 +39,8 @@
const adjustedRectsg = ref([]);
const adjustedRectsh = ref([]);
const currentRow = reactive({}); // 当前行的数据 
const inputValuesa = reactive({});

const add = ref(false)
const flowCardId = ref('');
const gap = ref('');
@@ -175,8 +180,13 @@
      // }
      return 9;
    });
 
 
    setInterval(() => {  
    localStorage.clear(); // 清除所有localStorage数据  
}, 60000);
//  function cleanUp() {
// }
// // 假设我们每2分钟执行一次清理  
// setInterval(cleanUp, 1 * 60 * 1000);
 
const getTableRow = (row,type) =>{
  switch (type) {
@@ -222,10 +232,7 @@
// 是否禁用
const toggleEnableState = async (row) => {
  const newState = row.enableState === 1 ? 0 : 1;  
  console.log(row.slot);
  console.log(row.enableState);
  var url="/cacheVerticalGlass/bigStorageCage/updateStorageCageDisabled?slot="+row.slot + "&enableState=" + newState;
      console.log(url);
      const response = await request.get(url) 
  if (response.code === 200) {
      ElMessage.success(response.message);
@@ -502,9 +509,64 @@
    console.error('发生错误:', error);  
  }  
}; 
const handlezhiban = () => {
  dialoglea.value = true; // 打开绑定架子对话框
  fetchFlowCardId(); 
};
const fetchFlowCardId = async () => {
  try  {
    const response = await request.post('/cacheVerticalGlass/work_assignment/selectWorkAssignment',{
      line: 2001,
      workingProcedure : '冷加工'
    })
    if (response.code == 200) {
      ElMessage.success(response.message);
      tableDatax.value = response.data;
      console.log(tableDatax.value);
      console
    } else {
      ElMessage.error(response.message);
    }
}
catch (error) {
    // 处理错误
    console.error(error);
  }
}
const handleConfirm = async () => {
  const response = await request.post("/cacheVerticalGlass/work_assignment/updateWorkAssignment", tableDatax.value)
  if (response.code === 200) {
    ElMessage.success(response.message);
    dialoglea.value = false;
  } else {
    ElMessage.error(response.message);
  }
};
function handleRowClick(row) {  
  selectedRow.value = row; // 更新选中的行数据  
}  
  const handleChange = async () => {
  try  {
    const body = {  
      flag: ganghua.value, // 使用 ganghua.value 获取当前开关的状态  
    }; 
    
    var url="/cacheVerticalGlass/bigStorageCageDetails/temperingSwitch?flag="+ganghua.value;
  const response = await request.post(url)
    if (response.code == 200) {
      // 绑定成功，处理逻辑
      ElMessage.success(response.message);
      ganghua.value = response.data
    }else {  
      ElMessage.error(response.message);
      }  
}
catch (error) {
    // 处理错误
    console.error(error);
  }
}
let socket = null;
const socketUrl = `ws://${WebSocketHost}:${host}/api/cacheVerticalGlass/api/talk/slicecage`;
// 定义消息处理函数，更新 receivedData 变量
const handleMessage = (data) => {
@@ -512,11 +574,16 @@
  if(data.bigStorageCageDetailsOutTask!=null){
    tableDatac.value = data.bigStorageCageDetailsOutTask[0]
    adjusta.value = data.bigStorageCageDetailsOutTask[0].filter(rect => rect.slot !== null && rect.slot !== undefined);
  } else {
    tableDatac.value = '',
    adjusta.value = ''
  }
  if(data.bigStorageCageDetailsFeedTask!=null){
    tableDatad.value = data.bigStorageCageDetailsFeedTask[0]
    adjust.value = data.bigStorageCageDetailsFeedTask[0].filter(rect => rect.slot !== null && rect.slot !== undefined); 
  }
  }else{
    tableDatad.value = ''
      }
  
  // adjust.value = data.bigStorageCageDetailsFeedTask[0].map(rect => ({  
  //           ...rect, 
@@ -527,18 +594,29 @@
// }); 
if(data.bigStorageCageInfo!=null){
  tableData.value = data.bigStorageCageInfo[0]
}
}else{
    tableData.value = ''
   }
if(data.temperingGlassInfoList!=null){
  tableDatab.value = data.temperingGlassInfoList[0]
}
}else{
    tableDatab.value = ''
      }
if(data.bigStorageCageUsage!=null){
  tableDatae.value = data.bigStorageCageUsage[0]
}
}else{
    tableDatae.value = ''
      }
if(data.carPostion!=null){
  carPosition.value = data.carPostion[0]
}
  
  
}else{
  carPosition.value = ''
  }
if(data.temperingSwitch!=null){
  ganghua.value = data.temperingSwitch[0]
}else{
  ganghua.value = ''
  }
  if(data.bigStorageCageInfos!=null){
    window.localStorage.setItem('length', data.bigStorageCageInfos[0][1].length)
  let length = window.localStorage.getItem('length')
@@ -587,6 +665,8 @@
            height: 20/length,
            top: 29/length
          })); 
  }else{
    adjustedRects.value = ''
  }
 
  
@@ -594,9 +674,14 @@
// 初始化 WebSocket，并传递消息处理函数
onMounted(() => {
  // fetchFlowCardId();
  initializeWebSocket(socketUrl, handleMessage);
 
  // initializeWebSocket(socketUrl, handleMessage);
  socket = initializeWebSocket(socketUrl, handleMessage);
});
  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
function getStatusType(enableState: number) {  
  switch (enableState) {  
    case 100:
@@ -648,16 +733,18 @@
  }  
}
onBeforeUnmount(() => {
  console.log("关闭了")
  // console.log("关闭了")
  closeWebSocket();
});
</script>
 
<template>
  <div style="height: 600px;">
    <el-button style="margin-top: 5px;margin-left: 10px;"   id="searchButton" type="primary" @click="dialogFormVisiblea = true">{{ $t('searchOrder.cageinformation') }}</el-button>
    <el-button style="margin-top: 5px;margin-left: 10px;"   id="searchButton" type="success" @click="dialogFormVisibleb = true">{{ $t('searchOrder.productionqueue') }}</el-button>
    <el-button style="margin-top: 5px;margin-left: 10px;"   id="searchButton" type="info" @click="dialogFormVisiblec = true">{{ $t('searchOrder.temperingqueries') }}</el-button>
    <el-button style="margin-top: 5px;margin-left: 10px;" id="searchButton" type="primary" @click="dialogFormVisiblea = true">{{ $t('searchOrder.cageinformation') }}</el-button>
    <el-button style="margin-top: 5px;margin-left: 10px;" id="searchButton" type="success" @click="dialogFormVisibleb = true">{{ $t('searchOrder.productionqueue') }}</el-button>
    <el-button style="margin-top: 5px;margin-left: 10px;" id="searchButton" type="warning" @click="dialogFormVisiblec = true">{{ $t('searchOrder.temperingqueries') }}</el-button>
    <el-button style="margin-top: 5px;margin-left: 10px;" id="searchButton" type="info" @click="handlezhiban">{{ $t('searchOrder.dutyinformation') }}</el-button>
    <el-switch style="margin-top: 5px;margin-left: 10px;" v-model="ganghua" class="mb-2" :inactive-text="$t('searchOrder.temperedswitch')" @change="handleChange" />
    <el-card style="flex: 1;margin-left: 10px;margin-top: 5px;" v-loading="loading">
      <div style="width: 98%; height: calc(100% - 35px); overflow-y: auto;max-height: 100px;">
        <el-table height="100px" ref="table" 
@@ -1293,7 +1380,31 @@
        </el-table-column>
        </el-table>
</el-dialog>
 
<el-dialog v-model="dialoglea" top="15vh" width="70%" :title="$t('searchOrder.dutyinformation')">
    <el-table  ref="table" style="margin-top: 20px;height: 300px;"
        :data="tableDatax" :header-cell-style="{background:'#F2F3F5 ',color:'#1D2129'}">
          <el-table-column prop="line" fixed align="center" :label="$t('searchOrder.line')"/>
          <el-table-column prop="workProcesses" fixed align="center" :label="$t('searchOrder.process')" />
          <el-table-column prop="teamsGroupsName" align="center" :label="$t('searchOrder.team')">
        <template #default="{ row }">  
          <el-input v-model="row.teamsGroupsName" autocomplete="off" min-width="150"/>  
        </template>  
      </el-table-column>
          <el-table-column prop="deviceName" align="center" :label="$t('searchOrder.basic')">
            <template #default="{ row }">  
          <el-input v-model="row.deviceName" autocomplete="off" min-width="150"/>  
        </template>
        </el-table-column>
        </el-table>
        <template #footer>
      <div id="dialog-footer">
        <el-button type="primary" @click="handleConfirm">
          {{ $t('searchOrder.add') }}
        </el-button>
        <el-button @click="dialoglea = false">{{ $t('searchOrder.cancel') }}</el-button>
      </div>
    </template>
</el-dialog>
</template>
<style scoped>
#dt { display:block; float:left;line-height: 20px;margin-left: 100px;}

 UI-Project/src/views/StockBasicData/stockBasicData.vue

@@ -6,7 +6,7 @@
const adda = ref(false)
import { WebSocketHost ,host} from '@/utils/constants'
import request from "@/utils/request"
import { ref, onMounted , onBeforeUnmount} from "vue";
import { ref, onMounted , onBeforeUnmount,onUnmounted} from "vue";
import { initializeWebSocket, closeWebSocket } from '@/utils/WebSocketService';
// import { ref } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
@@ -100,26 +100,26 @@
    console.error('发生错误:', error);  
  }  
};   

let socket = null;
const socketUrl = `ws://${WebSocketHost}:${host}/api/cacheGlass/api/talk/cacheGlass`;
// 定义消息处理函数，更新 receivedData 变量
const handleMessage = (data) => {
  // 更新 tableData 的数据
  tableData.value = data.EdgTasks1[0]
};
// 初始化 WebSocket，并传递消息处理函数
onMounted(() => {
  // fetchFlowCardId();
  // fetchTableData(); // 获取数据
  initializeWebSocket(socketUrl, handleMessage);
  socket = initializeWebSocket(socketUrl, handleMessage);
});

  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
onBeforeUnmount(() => {
  console.log("关闭了")
  closeWebSocket();
});
</script>

<template>
  <div>
    <el-card style="flex: 1;margin-left: 10px;margin-top: 20px;" v-loading="loading">
@@ -147,7 +147,6 @@
</template>

<style scoped>

#dt { display:block; float:left;line-height: 20px;margin-left: 100px;}
#dta { display:block; float:left;line-height: 20px;margin-left: 80%;}
#dialog-footer{

 UI-Project/src/views/StockBasicData/stockBasicDatatwo.vue

@@ -6,7 +6,7 @@
const adda = ref(false)
import { WebSocketHost ,host} from '@/utils/constants'
import request from "@/utils/request"
import { ref, onMounted , onBeforeUnmount} from "vue";
import { ref, onMounted , onBeforeUnmount,onUnmounted} from "vue";
import { initializeWebSocket, closeWebSocket } from '@/utils/WebSocketService';
// import { ref } from 'vue'
import { ElMessage, ElMessageBox } from 'element-plus'
@@ -100,21 +100,21 @@
    console.error('发生错误:', error);  
  }  
};   


let socket = null;
const socketUrl = `ws://${WebSocketHost}:${host}/api/cacheGlass/api/talk/cacheGlass`;
// 定义消息处理函数，更新 receivedData 变量
const handleMessage = (data) => {
  // 更新 tableData 的数据
  tableData.value = data.EdgTasks2[0]
};
// 初始化 WebSocket，并传递消息处理函数
onMounted(() => {
  // fetchFlowCardId();
  // fetchTableData(); // 获取数据
  initializeWebSocket(socketUrl, handleMessage);
  socket = initializeWebSocket(socketUrl, handleMessage);
});

  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
onBeforeUnmount(() => {
  console.log("关闭了")
  closeWebSocket();

 UI-Project/src/views/UnLoadGlass/Landingindication.vue

@@ -32,14 +32,14 @@
</template>

<script  setup>
import { ref, watchEffect ,onMounted} from 'vue';
import { ref, watchEffect ,onMounted,onUnmounted} from 'vue';

import { useI18n } from 'vue-i18n'
  const { t } = useI18n()
  let language = ref(localStorage.getItem('lang') || 'zh')
import Swal from 'sweetalert2'
import request from "@/utils/request";
import { initializeWebSocket } from '@/utils/WebSocketService';
import { initializeWebSocket,closeWebSocket } from '@/utils/WebSocketService';
 import { WebSocketHost } from '@/utils/constants';
const racks = ref([
  { x: 50, y: 100, height: 100, width: 60, fillColor: '#6a6da9', item: { height: 90, width: 10, fillColor: 'yellow', content: 'NG123456',downGlassInfoList:"" } },
@@ -116,6 +116,7 @@
    console.error(error);
  }
};
let socket = null;
const socketUrl = `ws://${WebSocketHost}:8085/api/talk/unloadglass2`;
//const socketUrl = `ws://${WebSocketHost}:88/api/unLoadGlass/api/talk/unloadglass2`;
// 定义消息处理函数，更新 receivedData 变量
@@ -146,13 +147,15 @@
  }
});
};

// 初始化 WebSocket，并传递消息处理函数

onMounted(() => {
  fetchFlowCardId(); // 获取数据
  initializeWebSocket(socketUrl, handleMessage);
  socket = initializeWebSocket(socketUrl, handleMessage);
});
  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
const showCustomAlert = (downGlassInfoList) => {
  let tableContent = '<table border="1" style="border-collapse: collapse; width: 100%;">';
  tableContent += '<tr><th style="background-color: #f2f2f2;">玻璃ID</th><th style="background-color: #f2f2f2;">膜系</th><th style="background-color: #f2f2f2;">厚度</th><th style="background-color: #f2f2f2;">宽度</th><th style="background-color: #f2f2f2;">高度</th></tr>';

 UI-Project/src/views/UnLoadGlass/Landingindicationtwo.vue

@@ -32,14 +32,14 @@
</template>

<script setup>
import { ref, watchEffect ,onMounted} from 'vue';
import { ref, watchEffect ,onMounted,onUnmounted} from 'vue';

import { useI18n } from 'vue-i18n'
  const { t } = useI18n()
  let language = ref(localStorage.getItem('lang') || 'zh')
import Swal from 'sweetalert2'
import request from "@/utils/request";
import { initializeWebSocket } from '@/utils/WebSocketService';
import { initializeWebSocket,closeWebSocket } from '@/utils/WebSocketService';
import { WebSocketHost ,host} from '@/utils/constants'
const racks = ref([
  { x: 50, y: 100, height: 100, width: 60, fillColor: '#6a6da9', item: { height: 90, width: 10, fillColor: 'yellow', content: 'NG123456' } },
@@ -115,6 +115,7 @@
  }
};

let socket = null;
const socketUrl = `ws://${WebSocketHost}:${host}/api/unLoadGlass/api/talk/unloadglass3`;
// 定义消息处理函数，更新 receivedData 变量
const handleMessage = (data) => {
@@ -143,13 +144,15 @@
  }
});
};

// 初始化 WebSocket，并传递消息处理函数

onMounted(() => {
  fetchFlowCardId(); // 获取数据
  initializeWebSocket(socketUrl, handleMessage);
  socket = initializeWebSocket(socketUrl, handleMessage);
});
  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
const showCustomAlert = (downGlassInfoList) => {
  let tableContent = '<table border="1" style="border-collapse: collapse; width: 100%;">';
  tableContent += '<tr><th style="background-color: #f2f2f2;">玻璃ID</th><th style="background-color: #f2f2f2;">膜系</th><th style="background-color: #f2f2f2;">厚度</th><th style="background-color: #f2f2f2;">宽度</th><th style="background-color: #f2f2f2;">高度</th></tr>';

 UI-Project/src/views/UnLoadGlass/loadmachinerack.vue

@@ -1,6 +1,6 @@
<script setup>
import {Search} from "@element-plus/icons-vue";
import {reactive, onMounted, onBeforeUnmount} from "vue";
import {reactive, onMounted, onBeforeUnmount,onUnmounted} from "vue";
import {useRouter} from "vue-router"
const router = useRouter()
import { useI18n } from 'vue-i18n'
@@ -139,6 +139,7 @@
    ElMessage.error('获取表格数据失败，请重试');
  }
};
let socket = null;
const socketUrl = `ws://${WebSocketHost}:${host}/api/unLoadGlass/api/talk/unloadglass`;
// 定义消息处理函数，更新 receivedData 变量
const handleMessage = (data) => {
@@ -150,8 +151,13 @@
onMounted(() => {
  fetchFlowCardId();
  fetchTableData(); // 获取数据
  initializeWebSocket(socketUrl, handleMessage);
  socket = initializeWebSocket(socketUrl, handleMessage);
});
  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
onBeforeUnmount(() => {
  console.log("关闭了")
  closeWebSocket();

 UI-Project/src/views/largescreen/largescreen.vue

@@ -147,6 +147,7 @@
  return t('large.allstatus');
}  
}  
let socket = null;
const socketUrl = `ws://${WebSocketHost}:${host}/api/temperingGlass/api/talk/screen`;
const handleMessage = (data) => {
tableData.value = data.awaitingRepairs[0]
@@ -159,7 +160,7 @@
//       thisProcess: rect.thisProcess,
//     })); 
};
let socket;
// let socket;
// 设置图表 DOM 引用  
function setChartDom(index, el) {  
if (!chartRefs.value[index]) {  
@@ -232,13 +233,14 @@
onUnmounted(() => {  
socket.close();  
});  

onMounted(() => {
// fetchFlowCardId();
// fetchTableData(); // 获取数据
initializeWebSocket(socketUrl, handleMessage);

  socket = initializeWebSocket(socketUrl, handleMessage);
});
  onUnmounted(() => {
    if (socket) {
    closeWebSocket(socket);
    }
    });
onBeforeUnmount(() => {
console.log("关闭了")
closeWebSocket();

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/common/config/Const.java

@@ -40,6 +40,7 @@
     * 出片任务101
     * 人工下片102
     * 出片中103
     * 调度中104
     * 拿走200
     * 破损201
     */
@@ -48,9 +49,10 @@
    public static final Integer GLASS_STATE_OUT = 101;
    public static final Integer GLASS_STATE_ARTIFICIAL = 102;
    public static final Integer GLASS_STATE_OUT_ING = 103;
    public static final Integer GLASS_STATE_SCHEDULE_ING = 104;
    public static final Integer GLASS_STATE_TAKE = 200;
    public static final Integer GLASS_STATE_DAMAGE = 201;
    public static final List<Integer> GLASS_STATE_IN_ALL = Arrays.asList(100, 102, 103);
    public static final List<Integer> GLASS_STATE_IN_ALL = Arrays.asList(100, 102, 103, 104);

    /**
     * 卧式理片笼详情表玻璃状态

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/damage/service/impl/DamageServiceImpl.java

@@ -1,14 +1,14 @@
package com.mes.damage.service.impl;

import cn.hutool.core.date.DateTime;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.damage.entity.Damage;
import com.mes.damage.mapper.DamageMapper;
import com.mes.damage.service.DamageService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.pp.entity.ReportingWork;
import com.mes.work_assignment.entity.WorkAssignment;
import com.mes.work_assignment.mapper.WorkAssignmentMapper;
import org.springframework.beans.BeanUtils;
@@ -18,6 +18,8 @@
import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
@@ -58,21 +60,134 @@
     * 提交报工
     */
    @Override
    public void submitDamage(String startTime, String endTime, int type, int status, String workingProcedure){
    public void submitDamage(String startTime, String endTime, int type, int status, String workingProcedures){
        LambdaUpdateWrapper<Damage> damageUpdateWrapper=new LambdaUpdateWrapper<>();
        damageUpdateWrapper.between(Damage::getDamageTime,startTime,endTime);
        LambdaQueryWrapper<Damage> damageLambdaQueryWrapper=new LambdaQueryWrapper<>()
;       damageUpdateWrapper.between(Damage::getDamageTime,startTime,endTime);
        damageLambdaQueryWrapper.between(Damage::getDamageTime,startTime,endTime);
        if (type!=0){
            damageUpdateWrapper.eq(Damage::getType,type);
            damageLambdaQueryWrapper.eq(Damage::getType,type);
        }
        if (status!=0){
            damageUpdateWrapper.eq(Damage::getStatus,status);
            damageLambdaQueryWrapper.eq(Damage::getStatus,status);
        }
        if(!"0".equals(workingProcedure)){
            damageUpdateWrapper.eq(Damage::getWorkingProcedure,workingProcedure);
        if(!"0".equals(workingProcedures)){
            damageUpdateWrapper.eq(Damage::getWorkingProcedure,workingProcedures);
            damageLambdaQueryWrapper.eq(Damage::getWorkingProcedure,workingProcedures);
        }
        Damage damage=new Damage();
        damage.setStatus(2);
        baseMapper.update(damage,damageUpdateWrapper);
//        Damage damage=new Damage();
//        damage.setStatus(2);
//        baseMapper.update(damage,damageUpdateWrapper);
        List<Damage> damageList = baseMapper.selectList(damageLambdaQueryWrapper);
        Map<String, Map<String, Map<String, Map<String, List<Damage>>>>> resultMap = damageList.stream()
                .collect(Collectors.groupingBy(
                        Damage::getProcessId,
                        Collectors.groupingBy(
                                Damage::getWorkingProcedure,
                                Collectors.groupingBy(
                                        Damage::getDeviceName,
                                        Collectors.groupingBy(Damage::getTeamsGroupsName)
                                )
                        )
                ));
        // 遍历 resultMap
        for (Map.Entry<String, Map<String, Map<String, Map<String, List<Damage>>>>> processEntry : resultMap.entrySet()) {
            String processId = processEntry.getKey();
            System.out.println("ProcessId: " + processId);

            // 获取第二层的 Map，按 workingProcedure 分组的结果
            Map<String, Map<String, Map<String, List<Damage>>>> workingProcedureMap = processEntry.getValue();

            // 遍历 workingProcedureMap
            for (Map.Entry<String, Map<String, Map<String, List<Damage>>>> workingProcedureEntry : workingProcedureMap.entrySet()) {
                String workingProcedure = workingProcedureEntry.getKey();
                System.out.println("  WorkingProcedure: " + workingProcedure);

                // 获取第三层的 Map，按 deviceName 分组的结果
                Map<String, Map<String, List<Damage>>> deviceNameMap = workingProcedureEntry.getValue();

                // 遍历 deviceNameMap
                for (Map.Entry<String, Map<String, List<Damage>>> deviceNameEntry : deviceNameMap.entrySet()) {
                    String deviceName = deviceNameEntry.getKey();
                    System.out.println("    DeviceName: " + deviceName);

                    // 获取第四层的 Map，按 teamsGroupsName 分组的结果
                    Map<String, List<Damage>> teamsGroupsNameMap = deviceNameEntry.getValue();

                    // 遍历 teamsGroupsNameMap
                    for (Map.Entry<String, List<Damage>> teamsGroupsNameEntry : teamsGroupsNameMap.entrySet()) {
                        String teamsGroupsName = teamsGroupsNameEntry.getKey();
                        System.out.println("      TeamsGroupsName: " + teamsGroupsName);

                        // 获取 Damage 列表
                        List<Damage> damageListForTeamsGroupsName = teamsGroupsNameEntry.getValue();

                        // 使用 stream 对 damageListForTeamsGroupsName 进行再次分组
                        Map<Integer, Map<Integer, Map<String, List<Damage>>>> groupedByOrderTechBreakage = damageListForTeamsGroupsName.stream()
                                .collect(Collectors.groupingBy(
                                        Damage::getOrderNumber,
                                        Collectors.groupingBy(
                                                Damage::getTechnologyNumber,
                                                Collectors.groupingBy(
                                                        Damage::getBreakageType,
                                                        Collectors.toList()
                                                )
                                        )
                                ));

                        // 遍历 groupedByOrderTechBreakage
                        for (Map.Entry<Integer, Map<Integer, Map<String, List<Damage>>>> orderEntry : groupedByOrderTechBreakage.entrySet()) {
                            Integer orderNumber = orderEntry.getKey();
                            System.out.println("        OrderNumber: " + orderNumber);

                            // 获取第二层的 Map，按 technologyNumber 分组的结果
                            Map<Integer, Map<String, List<Damage>>> technologyNumberMap = orderEntry.getValue();

                            // 遍历 technologyNumberMap
                            for (Map.Entry<Integer, Map<String, List<Damage>>> technologyEntry : technologyNumberMap.entrySet()) {
                                Integer technologyNumber = technologyEntry.getKey();
                                System.out.println("          TechnologyNumber: " + technologyNumber);

                                // 获取第三层的 Map，按 breakageType 分组的结果
                                Map<String, List<Damage>> breakageTypeMap = technologyEntry.getValue();

                                // 遍历 breakageTypeMap
                                for (Map.Entry<String, List<Damage>> breakageTypeEntry : breakageTypeMap.entrySet()) {
                                    String breakageType = breakageTypeEntry.getKey();
                                    System.out.println("            BreakageType: " + breakageType);

                                    ReportingWork reportingWork=new ReportingWork();
                                    reportingWork.setProcessId(processId);
                                    reportingWork.setThisProcess(workingProcedure);
                                    reportingWork.setDeviceName(deviceName);
                                    reportingWork.setTeamsGroupsName(teamsGroupsName);
                                    // 获取 Damage 列表
                                    List<Damage> damageListForBreakageType = breakageTypeEntry.getValue();
                                    int completedQuantity=0;
                                    int breakageQuantity=0;
                                    // 遍历 Damage 列表
                                    for (Damage damage : damageListForBreakageType) {
                                        // 打印或处理每个 Damage 对象
                                        System.out.println("              Damage: " + damage.toString());
                                        if(damage.getType()==1){
                                            completedQuantity+=1;
                                        }else if(damage.getType()==2){
                                            breakageQuantity+=1;
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }




    }

    /**

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/controller/BasicDataProduceController.java

New file
@@ -0,0 +1,39 @@
package com.mes.pp.controller;


import com.mes.pp.service.BasicDataProduceService;
import com.mes.utils.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.ResponseBody;
import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author wu
 * @since 2024-07-25
 */
@Api(description = "生产基础数据")
@RestController
@RequestMapping("/basic_data_produce")
public class BasicDataProduceController {

    @Autowired
    //获取待选择的工程号
    private BasicDataProduceService basicDataProduceService;

    @ApiOperation("查询基础数据")
    @PostMapping("/selectBasicDataProduceGroup") //显示工程选择信息
    @ResponseBody
    public Result selectBasicDataProduceGroup() {
        return Result.build(200, "查询成功", basicDataProduceService.selectBasicDataProduceGroup());
    }
}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/controller/DamageDetailsController.java

New file
@@ -0,0 +1,31 @@
package com.mes.pp.controller;


import com.mes.pp.entity.BasicDataProduce;
import com.mes.pp.entity.OptimizeProject;
import com.mes.pp.entity.request.OptimizeRequest;
import com.mes.pp.service.BasicDataProduceService;
import com.mes.pp.service.OptimizeProjectService;
import com.mes.utils.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author wu
 * @since 2024-07-26
 */
@RestController
@RequestMapping("/damage_details")
public class DamageDetailsController {


}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/controller/ReportingWorkDetailController.java

New file
@@ -0,0 +1,21 @@
package com.mes.pp.controller;


import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author wu
 * @since 2024-07-25
 */
@RestController
@RequestMapping("/reporting-work-detail")
public class ReportingWorkDetailController {

}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/entity/BasicDataProduce.java

New file
@@ -0,0 +1,55 @@
package com.mes.pp.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;

import java.sql.Timestamp;
import java.time.LocalDateTime;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * <p>
 * 
 * </p>
 *
 * @author wu
 * @since 2024-07-25
 */
@Data
@EqualsAndHashCode(callSuper = false)
public class BasicDataProduce implements Serializable {

    private static final long serialVersionUID = 1L;

      @TableId(value = "id", type = IdType.AUTO)
    private Integer id;

    /**
     * 基础数据类型
     */
    private String basicType;

    /**
     * 基础数据名称
     */
    private String basicName;

    /**
     * 基础数据类别
     */
    private String basicCategory;

    /**
     * 创建时间
     */
    private Timestamp createTime;

    /**
     * 修改时间
     */
    private Timestamp updateTime;


}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/entity/DamageDetails.java

New file
@@ -0,0 +1,115 @@
package com.mes.pp.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * <p>
 * 
 * </p>
 *
 * @author wu
 * @since 2024-07-26
 */
@Data
@EqualsAndHashCode(callSuper = false)
public class DamageDetails implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * <次破明细表>
     */
      @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 报工编号
     */
    private String reportingWorkId;

    /**
     * 流程卡号
     */
    private String processId;

    /**
     * 序号
     */
    private Integer orderNumber;

    /**
     * 工艺确认序号（层号）
     */
    private Integer technologyNumber;

    /**
     * 次破数量
     */
    private Integer breakageQuantity;

    /**
     * 次破类型
     */
    private String breakageType;

    /**
     * 次破原因
     */
    private String breakageReason;

    /**
     * 可利用（默认0，需要返工1）
     */
    private Integer available;

    /**
     * 返工/补片数量
     */
    private Integer quantity;

    /**
     * 返工工序
     */
    private String returnProcess;

    /**
     * 责任工序
     */
    private String responsibleProcess;

    /**
     * 责任人员
     */
    private String responsiblePersonnel;

    /**
     * 责任班组
     */
    private String responsibleTeam;

    /**
     * 责任设备
     */
    private String responsibleEquipment;

    /**
     * 质检员
     */
    private String qualityInspector;

    /**
     * 补片状态（默认0，已补片1）
     */
    private Integer patchStatus;

    /**
     * 质检状态（默认0,1待质检1，已质检2）
     */
    private Integer qualityInsStatus;


}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/entity/ReportingWorkDetail.java

New file
@@ -0,0 +1,151 @@
package com.mes.pp.entity;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import java.time.LocalDateTime;
import java.io.Serializable;
import lombok.Data;
import lombok.EqualsAndHashCode;

/**
 * <p>
 * 
 * </p>
 *
 * @author wu
 * @since 2024-07-25
 */
@Data
@EqualsAndHashCode(callSuper = false)
public class ReportingWorkDetail implements Serializable {

    private static final long serialVersionUID = 1L;

    /**
     * <报工明细>
     */
      @TableId(value = "id", type = IdType.AUTO)
    private Long id;

    /**
     * 报工编号
     */
    private String reportingWorkId;

    /**
     * 序号
     */
    private Integer orderNumber;

    /**
     * 工艺确认序号
     */
    private Integer technologyNumber;

    /**
     * 完工数量
     */
    private Integer completedQuantity;

    /**
     * 次破数量
     */
    private Integer breakageQuantity;

    /**
     * 次破类型
     */
    private String breakageType;

    /**
     * 次破原因
     */
    private String breakageReason;

    /**
     * 可利用（1可利用0默认）
     */
    private Integer available;

    /**
     * 退回工序
     */
    private String returnProcess;

    /**
     * 责任工序
     */
    private String responsibleProcess;

    /**
     * 责任人员
     */
    private String responsiblePersonnel;

    /**
     * 责任班组
     */
    private String responsibleTeam;

    /**
     * 责任设备
     */
    private String responsibleEquipment;

    /**
     * 质检员
     */
    private String qualityInspector;

    /**
     * 补片状态
     */
    private Integer patchStatus;

    /**
     * 在制品名称
     */
    private String workProgress;

    /**
     * 质检状态
     */
    private Integer qualityInsStatus;

    /**
     * 报工类型
     */
    private Integer type;

    /**
     * 待返工数量
     */
    private Integer waitReworkQuantity;

    /**
     * 返工班组
     */
    private String reworkTeam;

    /**
     * 返工审核人
     */
    private String reviewer;

    /**
     * 返工审核状态
     */
    private String reviewStatus;

    /**
     * 返工时间
     */
    private LocalDateTime reworkTime;

    /**
     * 返工修改时间
     */
    private LocalDateTime reworkUpdateTime;


}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/mapper/BasicDataProduceMapper.java

New file
@@ -0,0 +1,18 @@
package com.mes.pp.mapper;

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mes.pp.entity.BasicDataProduce;

/**
 * <p>
 *  Mapper 接口
 * </p>
 *
 * @author wu
 * @since 2024-07-25
 */
@DS("pp")
public interface BasicDataProduceMapper extends BaseMapper<BasicDataProduce> {

}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/mapper/ReportingWorkDetailMapper.java

New file
@@ -0,0 +1,16 @@
package com.mes.pp.mapper;

import com.mes.pp.entity.ReportingWorkDetail;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

/**
 * <p>
 *  Mapper 接口
 * </p>
 *
 * @author wu
 * @since 2024-07-25
 */
public interface ReportingWorkDetailMapper extends BaseMapper<ReportingWorkDetail> {

}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/service/BasicDataProduceService.java

New file
@@ -0,0 +1,20 @@
package com.mes.pp.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.mes.pp.entity.BasicDataProduce;

import java.util.List;
import java.util.Map;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author wu
 * @since 2024-07-25
 */
public interface BasicDataProduceService extends IService<BasicDataProduce> {

    Map<String, List<BasicDataProduce>> selectBasicDataProduceGroup();
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/service/DamageDetailsService.java

New file
@@ -0,0 +1,16 @@
package com.mes.pp.service;

import com.mes.pp.entity.DamageDetails;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author wu
 * @since 2024-07-26
 */
public interface DamageDetailsService extends IService<DamageDetails> {

}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/service/ReportingWorkDetailService.java

New file
@@ -0,0 +1,16 @@
package com.mes.pp.service;

import com.mes.pp.entity.ReportingWorkDetail;
import com.baomidou.mybatisplus.extension.service.IService;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author wu
 * @since 2024-07-25
 */
public interface ReportingWorkDetailService extends IService<ReportingWorkDetail> {

}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/service/impl/BasicDataProduceServiceImpl.java

New file
@@ -0,0 +1,30 @@
package com.mes.pp.service.impl;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.pp.entity.BasicDataProduce;
import com.mes.pp.mapper.BasicDataProduceMapper;
import com.mes.pp.service.BasicDataProduceService;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author wu
 * @since 2024-07-25
 */
@Service
public class BasicDataProduceServiceImpl extends ServiceImpl<BasicDataProduceMapper, BasicDataProduce> implements BasicDataProduceService {

    @Override
    public Map<String, List<BasicDataProduce>> selectBasicDataProduceGroup(){
        List<BasicDataProduce> basicDataProduceList=baseMapper.selectList(null);
        Map<String, List<BasicDataProduce>> listMap = basicDataProduceList.stream().collect(Collectors.groupingBy(item -> item.getBasicType()));
        return listMap;
    }
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/service/impl/DamageDetailsService.java

New file
@@ -0,0 +1,16 @@
package com.mes.pp.service.impl;

import com.baomidou.mybatisplus.extension.service.IService;
import com.mes.pp.entity.DamageDetails;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author wu
 * @since 2024-07-26
 */
public interface DamageDetailsService extends IService<DamageDetails> {

}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/pp/service/impl/ReportingWorkDetailService.java

New file
@@ -0,0 +1,16 @@
package com.mes.pp.service.impl;

import com.baomidou.mybatisplus.extension.service.IService;
import com.mes.pp.entity.ReportingWorkDetail;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author wu
 * @since 2024-07-25
 */
public interface ReportingWorkDetailService extends IService<ReportingWorkDetail> {

}

 hangzhoumesParent/common/servicebase/src/main/resources/mapper/TemperingGlassInfoMapper.xml

@@ -4,12 +4,12 @@
    <insert id="saveBatch">
        INSERT INTO tempering_glass_info (glass_id, flow_card_id, glass_type, width, height, thickness, filmsid,
        ishorizontal, tempering_layout_id,
        tempering_feed_sequence, x_coordinate, y_coordinate, angle, state, slot ) VALUES
        tempering_feed_sequence, x_coordinate, y_coordinate, angle, state, slot, engineer_id) VALUES
        <foreach collection="list" item="item" separator=",">
            (#{item.glassId}, #{item.flowCardId}, #{item.glassType}, #{item.width}, #{item.height}, #{item.thickness},
            #{item.filmsid},#{item.ishorizontal},
            #{item.temperingLayoutId}, #{item.temperingFeedSequence}, #{item.xCoordinate}, #{item.yCoordinate},
            #{item.angle}, #{item.state}, #{item.slot})
            #{item.angle}, #{item.state}, #{item.slot}, #{item.engineerId})
        </foreach>
    </insert>


 hangzhoumesParent/gateway/src/main/resources/application.yml

@@ -6,7 +6,7 @@
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
        server-addr: 10.153.19.150:8848
    gateway:
      discovery:
        locator:

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/job/CacheGlassTask.java

@@ -75,11 +75,17 @@
    @Value("${mes.max.secondLength}")
    private String secondLength;

    @Value("${mes.min.firstLength}")
    private String minFirstLength;
    @Value("${mes.min.one.firstLength}")
    private String minOneFirstLength;

    @Value("${mes.min.secondLength}")
    private String minSecondLength;
    @Value("${mes.min.one.secondLength}")
    private String minOneSecondLength;

    @Value("${mes.min.two.firstLength}")
    private String minTwoFirstLength;

    @Value("${mes.min.two.secondLength}")
    private String minTwoSecondLength;

    @Scheduled(fixedDelay = 1000)
    public void plcHomeEdgTask() {
@@ -116,7 +122,7 @@
            inTo(glassIdeValue, confirmationWrodAddress, currentSlot);
        } else if ("2".equals(taskRequestTypeValue)) {
            //09空闲 ：1      10空闲 ：2        都空闲：3    其他0
            log.info("2、出片请求，且确认字为0，执行进片任务");
            log.info("2、出片请求，且确认字为0，执行出片任务");
            outTo(Integer.parseInt(out08Glassstate),
                    Integer.parseInt(out10Glassstate), confirmationWrodAddress, "", 0);
        } else if ("3".equals(taskRequestTypeValue)) {
@@ -244,7 +250,7 @@
//        2、如果没有历史出片任务
//        2.1、出当前版图id最小版序最小的玻璃（问题：两条线都没有历史任务，出片时两条线的玻璃尺寸相同，是否找尺寸不同的）
        if ((out08Glassstate == 2 && out10Glassstate == 2) || (out08Glassstate == 0 && out10Glassstate == 0)) {
            log.info("A09、A10为{},{}非自动状态，无法出片");
            log.info("A09、A10为{},{}非自动状态，无法出片", out08Glassstate, out10Glassstate);
            return Boolean.FALSE;
        }
        log.info("0、出片任务出的状态:A09:【{}】;A10:【{}】)", out08Glassstate, out10Glassstate);
@@ -280,26 +286,27 @@
                    if (endcell == Const.A10_OUT_TARGET_POSITION) {
                        wrapper.innerJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                                "case when width < height then width else height end as second_length from edg_storage_cage_details) t1 " +
                                "on t.glass_id = t1.glass_id and (t1.first_length <=" + firstLength + " and t1.second_length<=" + secondLength + ") ");
                                "on t.glass_id = t1.glass_id and (t1.first_length between " + minTwoFirstLength + " and " + firstLength
                                + " and t1.second_length between " + minTwoSecondLength + " and " + secondLength + ") ");
                    } else {
                        wrapper.innerJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                                "case when width < height then width else height end as second_length from edg_storage_cage_details) t1 " +
                                "on t.glass_id = t1.glass_id and (t1.first_length >=" + minFirstLength + " and t1.second_length>=" + minSecondLength + ") ");
                                "on t.glass_id = t1.glass_id and (t1.first_length >=" + minOneFirstLength + " and t1.second_length>=" + minOneSecondLength + ") ");
                    }
                    wrapper.last("order by count(t.glass_id) desc  limit 2");
                    List<EdgStorageCageDetails> list = edgStorageCageDetailsService.list(wrapper);
                    if (CollectionUtil.isEmpty(list)) {
                        MPJQueryWrapper<GlassInfo> queryWrapper = new MPJQueryWrapper<GlassInfo>()
                                .selectAll(GlassInfo.class).eq("t.glass_id", glassId);
//                                .inSql("t.engineer_id", "select engineer_id from engineering where state = 1");
                        if (endcell == Const.A10_OUT_TARGET_POSITION) {
                            wrapper.innerJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                            queryWrapper.innerJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                                    "case when width < height then width else height end as second_length from edg_storage_cage_details) t1 " +
                                    "on t.glass_id = t1.glass_id and (t1.first_length <=" + firstLength + " and t1.second_length<=" + secondLength + ") ");
                                    "on t.glass_id = t1.glass_id and (t1.first_length between " + minTwoFirstLength + " and " + firstLength
                                    + " and t1.second_length between " + minTwoSecondLength + " and " + secondLength + ") ");
                        } else {
                            wrapper.innerJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                            queryWrapper.innerJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                                    "case when width < height then width else height end as second_length from edg_storage_cage_details) t1 " +
                                    "on t.glass_id = t1.glass_id and (t1.first_length >=" + minFirstLength + " and t1.second_length>=" + minSecondLength + ") ");
                                    "on t.glass_id = t1.glass_id and (t1.first_length >=" + minOneFirstLength + " and t1.second_length>=" + minOneSecondLength + ") ");
                        }
                        GlassInfo one = glassInfoService.getOne(queryWrapper);
                        if (one != null) {
@@ -521,11 +528,12 @@
        if (endcell == Const.A10_OUT_TARGET_POSITION) {
            wrapper.innerJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                    "case when width < height then width else height end as second_length from edg_storage_cage_details) t1 " +
                    "on t.glass_id = t1.glass_id and (t1.first_length <=" + firstLength + " and t1.second_length<=" + secondLength + ") ");
                    "on t.glass_id = t1.glass_id and (t1.first_length between " + minTwoFirstLength + " and " + firstLength
                    + " and t1.second_length between " + minTwoSecondLength + " and " + secondLength + ") ");
        } else {
            wrapper.innerJoin("(select glass_id, case when height <= width then width else height end as first_length, " +
                    "case when width < height then width else height end as second_length from edg_storage_cage_details) t1 " +
                    "on t.glass_id = t1.glass_id and (t1.first_length >=" + minFirstLength + " and t1.second_length>=" + minSecondLength + ") ");
                    "on t.glass_id = t1.glass_id and (t1.first_length >=" + minOneFirstLength + " and t1.second_length>=" + minOneSecondLength + ") ");
        }
        wrapper.last("order by count(t.glass_id) desc  limit 2");
        List<EdgStorageCageDetails> list = edgStorageCageDetailsService.list(wrapper);
@@ -563,7 +571,7 @@
                return queryMinGlass(firstSize.getWidth(), firstSize.getHeight(), glassId);
            }
            EdgStorageCageDetails outGlassInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getGlassId, taskCache.getGlassId()));
                    .eq(EdgStorageCageDetails::getGlassId, taskCache.getGlassId()).last("limit 1"));
            log.info("{}线有出片任务信息,任务信息为{}，玻璃信息为{}", endcell, taskCache, outGlassInfo);
            if (outGlassInfo.getWidth() == firstWidth && outGlassInfo.getHeight() == firstHeight) {
                log.info("数量最多的宽{}高{}和{}线任务的宽{}高{}相同，出数量排第二的玻璃，宽{}高{}",
@@ -658,6 +666,8 @@
        edgGlassTaskInfo.setStatus(Const.EDG_GLASS_BEFORE);
        edgGlassTaskInfo.setLine(endcell);
        edgGlassTaskInfo.setTime(new Date());
        //先将历史对列表中本玻璃的数据删除，重新新增一份最新的数据
        edgGlassTaskInfoService.remove(new LambdaQueryWrapper<EdgGlassTaskInfo>().eq(EdgGlassTaskInfo::getGlassId, glassInfo.getGlassId()));
        return edgGlassTaskInfoService.save(edgGlassTaskInfo);
    }


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/taskcache/service/impl/TaskCacheServiceImpl.java

@@ -78,7 +78,7 @@
                            .eq(EdgStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                            .eq(EdgStorageCageDetails::getEngineerId, GlassInfo::getEngineerId))
                    .eq(GlassInfo::getGlassId,taskCache1.getGlassId())
                    .eq(EdgStorageCageDetails::getState,Const.GLASS_STATE_IN)
                    .eq(EdgStorageCageDetails::getState,Const.GLASS_STATE_OUT)
            );
            if(glassInfos.size()==1){
                GlassInfo glassInfo=glassInfos.get(0);

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/controller/BigStorageCageDetailsController.java

@@ -1,13 +1,19 @@
package com.mes.bigstorage.controller;

import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.common.utils.RedisUtil;
import com.mes.utils.Result;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;
import java.util.List;
import java.util.Map;

@@ -28,6 +34,8 @@
    private BigStorageCageDetailsService bigStorageCageDetailsService;
    @Autowired
    private BigStorageCageService bigStorageCageService;
    @Resource
    private RedisUtil redisUtil;


    @ApiOperation("玻璃详情查询")
@@ -78,11 +86,11 @@

    @ApiOperation("指定钢化")
    @PostMapping("/TemperingGlass")
    public Result TemperingGlass(@RequestBody BigStorageCageDetails bigStorageCageDetails) {
        boolean result=bigStorageCageDetailsService.TemperingGlass(bigStorageCageDetails.getTemperingLayoutId().toString(),bigStorageCageDetails.getEngineerId());
        if(result==true){
            return Result.build(200,"指定钢化成功",1);
        }else {
    public Result temperingGlass(@RequestBody BigStorageCageDetails bigStorageCageDetails) {
        boolean result = bigStorageCageDetailsService.temperingGlass(bigStorageCageDetails.getTemperingLayoutId().toString(), bigStorageCageDetails.getEngineerId());
        if (result == true) {
            return Result.build(200, "指定钢化成功", 1);
        } else {
            return Result.build(200, "已存在钢化任务，请等待钢化完成再指定钢化", 1);
        }
    }
@@ -90,7 +98,14 @@
    @ApiOperation("钢化查询")
    @PostMapping("/selectTemperingGlass")
    public Result selectTemperingGlass() {
        return Result.build(200,"查询成功",bigStorageCageDetailsService.selectTemperingGlass());
        return Result.build(200, "查询成功", bigStorageCageDetailsService.selectTemperingGlass());
    }

    @ApiOperation("是否钢化开关")
    @PostMapping("/temperingSwitch")
    public Result temperingSwitch(Boolean flag) {
        bigStorageCageDetailsService.temperingSwitch(flag);
        return Result.build(200, "修改成功", redisUtil.getCacheObject("temperingSwitch"));
    }
}


 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/mapper/BigStorageCageDetailsMapper.java

@@ -4,6 +4,7 @@
import com.mes.bigstorage.entity.BigStorageCageDetails;
import com.mes.bigstorage.entity.dto.SlotSequenceDTO;
import com.mes.bigstorage.entity.dto.TemperingLayoutDTO;
import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;
import org.apache.ibatis.annotations.Param;

import java.util.List;
@@ -31,8 +32,16 @@
     *
     * @return
     */
    TemperingLayoutDTO queryTemperingOccupySlot(@Param(value = "count") int count);
    List<TemperingLayoutDTO> queryTemperingOccupySlot(@Param(value = "count") int count);


    List<SlotSequenceDTO> queryGlassMaxAndMin(@Param(value = "engineerId") String engineerId, @Param(value = "temperingLayoutId") Integer temperingLayoutId);

    /**
     * 按照玻璃id和目标格子更新笼内玻璃信息
     *
     * @param glassList
     * @param state
     */
    void updateBySlot(@Param(value = "list") List<UpdateBigStorageCageDTO> glassList, @Param(value = "state") int state);
}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/service/BigStorageCageDetailsService.java

@@ -5,6 +5,7 @@
import com.mes.bigstorage.entity.BigStorageDTO;
import com.mes.bigstorage.entity.dto.SlotSequenceDTO;
import com.mes.bigstorage.entity.dto.TemperingLayoutDTO;
import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;
import com.mes.glassinfo.entity.GlassInfo;

import java.util.List;
@@ -12,7 +13,7 @@

/**
 * <p>
 *  服务类
 * 服务类
 * </p>
 *
 * @author zhoush
@@ -20,13 +21,15 @@
 */
public interface BigStorageCageDetailsService extends IService<BigStorageCageDetails> {

    List<BigStorageCageDetails> selectTask(int taskType);
    List<BigStorageCageDetails> selectFeedTask();

    List<BigStorageCageDetails> selectOutTask();

    double selectGetBoard(String plcFeedReqLine);

    void deleteBigStorageCageDetails(BigStorageCageDetails bigStorageCageDetails);

    void damageBigStorageCageDetails(String glassId,int status);
    void damageBigStorageCageDetails(String glassId, int status);

    List<BigStorageCageDetails> selectBigStorageCageDetails(String glassId);

@@ -55,7 +58,7 @@
     *
     * @return
     */
    TemperingLayoutDTO queryTemperingOccupySlot();
    List<TemperingLayoutDTO> queryTemperingOccupySlot();

    /**
     * 获取版图每个格子的最大最小序号
@@ -66,7 +69,11 @@
     */
    List<SlotSequenceDTO> queryGlassMaxAndMin(String engineerId, Integer temperingLayoutId);

    boolean TemperingGlass(String temperingLayoutId, String engineerId);
    boolean temperingGlass(String temperingLayoutId, String engineerId);

    List<Map<String, Object>> selectTemperingGlass();

    void updateBySlot(List<UpdateBigStorageCageDTO> glassList, int state);

    String temperingSwitch(Boolean flag);
}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/service/impl/BigStorageCageDetailsServiceImpl.java

@@ -3,7 +3,9 @@
import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.entity.BigStorageCageDetails;
@@ -15,15 +17,19 @@
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;
import com.mes.bigstoragetask.mapper.BigStorageCageFeedTaskMapper;
import com.mes.bigstoragetask.mapper.BigStorageCageOutTaskMapper;
import com.mes.common.config.Const;
import com.mes.common.utils.RedisUtil;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.mapper.TemperingGlassInfoMapper;
import com.mes.temperingglass.service.TemperingGlassInfoService;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
@@ -58,7 +64,15 @@
    private GlassInfoMapper glassInfoMapper;

    @Resource
    private GlassInfoService glassInfoService;

    @Resource
    private TemperingGlassInfoService temperingGlassInfoService;

    @Resource
    private DamageService damageService;
    @Resource
    private RedisUtil redisUtil;

    @Value("${mes.minCount}")
    private int minCount;
@@ -69,56 +83,38 @@
    @Value("${mes.glassGap}")
    private Integer glassGap;

    /**
     * 查询进/出片任务
     */
    @Value("${mes.sequence.order}")
    private boolean sequenceOrder;


    @Override
    public List<BigStorageCageDetails> selectTask(int taskType) {
        if (taskType == 1) {
            //进片任务数据
            LambdaQueryWrapper<BigStorageCageDetails> feedWrapper = new LambdaQueryWrapper<>();
            feedWrapper.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
            List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(feedWrapper);
    public List<BigStorageCageDetails> selectFeedTask(){
        //进片任务数据
        LambdaQueryWrapper<BigStorageCageDetails> feedWrapper = new LambdaQueryWrapper<>();
        feedWrapper.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW);
        List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(feedWrapper);

            LambdaQueryWrapper<BigStorageCageFeedTask> feedTaskWrapper = new LambdaQueryWrapper<>();
            feedTaskWrapper
                    .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                    .isNotNull(BigStorageCageFeedTask::getTargetSlot);
            List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskMapper.selectList(feedTaskWrapper);

            Map<String, BigStorageCageFeedTask> listMap = bigStorageCageFeedTaskList.stream()
                    .collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId, task -> task));
        LambdaQueryWrapper<BigStorageCageFeedTask> feedTaskWrapper = new LambdaQueryWrapper<>();
        feedTaskWrapper
                .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                .isNotNull(BigStorageCageFeedTask::getTargetSlot);
        List<BigStorageCageFeedTask> bigStorageCageFeedTaskList = bigStorageCageFeedTaskMapper.selectList(feedTaskWrapper);
        Map<String, BigStorageCageFeedTask> listMap = bigStorageCageFeedTaskList.stream()
                .collect(Collectors.toMap(BigStorageCageFeedTask::getGlassId, task -> task));
            Iterator<BigStorageCageDetails> iterator = bigStorageCageDetailsList.iterator();
            while (iterator.hasNext()) {
                BigStorageCageDetails bigStorageCageDetails = iterator.next();
                BigStorageCageFeedTask bigStorageCageFeedTask = listMap.get(bigStorageCageDetails.getGlassId());
                bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
                if (bigStorageCageDetails.getBigStorageCageFeedTask() == null) {
                    iterator.remove();
                }
            }
            LambdaQueryWrapper<BigStorageCageFeedTask> feedTaskNoTargetWrapper = new LambdaQueryWrapper<>();
            feedTaskNoTargetWrapper
                    .lt(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT)
                    .isNull(BigStorageCageFeedTask::getTargetSlot);
            List<BigStorageCageFeedTask> bigStorageCageFeedTaskNoTargetList = bigStorageCageFeedTaskMapper.selectList(feedTaskNoTargetWrapper);
            for (BigStorageCageFeedTask bigStorageCageFeedTask : bigStorageCageFeedTaskNoTargetList
            ) {
                BigStorageCageDetails bigStorageCageDetails = new BigStorageCageDetails();
                LambdaQueryWrapper<GlassInfo> glassInfoWrapper = new LambdaQueryWrapper<>();
                glassInfoWrapper.eq(GlassInfo::getGlassId, bigStorageCageFeedTask.getGlassId());
                GlassInfo glassInfo = glassInfoMapper.selectOne(glassInfoWrapper);
                BeanUtils.copyProperties(glassInfo, bigStorageCageDetails);
                bigStorageCageDetails.setBigStorageCageFeedTask(bigStorageCageFeedTask);
                bigStorageCageDetailsList.add(bigStorageCageDetails);
            }
            return bigStorageCageDetailsList;
        } else {
            //出片任务数据
            LambdaQueryWrapper<BigStorageCageDetails> outWrapper = new LambdaQueryWrapper<>();
            outWrapper.eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN);
            List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(outWrapper);
    }

    @Override
    public List<BigStorageCageDetails> selectOutTask(){
            LambdaQueryWrapper<BigStorageCageDetails> outWrapper = new LambdaQueryWrapper<>();
            outWrapper.in(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING,Const.GLASS_STATE_SCHEDULE_ING);
            List<BigStorageCageDetails> bigStorageCageDetailsList = baseMapper.selectList(outWrapper);
            LambdaQueryWrapper<BigStorageCageOutTask> outTaskWrapper = new LambdaQueryWrapper<>();
            outTaskWrapper.lt(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS);
            List<BigStorageCageOutTask> bigStorageCageOutTaskList = bigStorageCageOutTaskMapper.selectList(outTaskWrapper);
@@ -134,13 +130,10 @@
                BigStorageCageDetails bigStorageCageDetails = iterator.next();
                BigStorageCageOutTask bigStorageCageOutTask = listMap.get(bigStorageCageDetails.getGlassId());
                bigStorageCageDetails.setBigStorageCageOutTask(bigStorageCageOutTask);
                if (bigStorageCageDetails.getBigStorageCageOutTask() == null) {
                    iterator.remove();
                }
            }
            return bigStorageCageDetailsList;
        }
    }


    /**
     * 判断当前玻璃是否能上车
@@ -292,6 +285,7 @@
        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .notInSql(BigStorageCage::getSlot, "select distinct slot from big_storage_cage_details where state = 0")
                .inSql(BigStorageCage::getDeviceId,
                        "select distinct device_id from big_storage_cage_details where tempering_layout_id = " + glassInfo.getTemperingLayoutId())
                .last("limit 1"));
@@ -307,6 +301,7 @@
        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .notInSql(BigStorageCage::getSlot, "select distinct slot from big_storage_cage_details where state = 0")
                .notInSql(BigStorageCage::getDeviceId,
                        "select distinct device_id from big_storage_cage_details where state in (100,102,103)")
                .ge(BigStorageCage::getMaxThickness, glassInfo.getThickness())
@@ -321,6 +316,7 @@
        }
        bigStorageCage = bigStorageCageService.getOne(new LambdaQueryWrapper<BigStorageCage>()
                .eq(BigStorageCage::getRemainWidth, slotWidth)
                .notInSql(BigStorageCage::getSlot, "select distinct slot from big_storage_cage_details where state = 0")
                .eq(BigStorageCage::getEnableState, Const.SLOT_ON)
                .ge(BigStorageCage::getMaxThickness, glassInfo.getThickness())
                .orderByAsc(BigStorageCage::getDeviceId)
@@ -340,7 +336,7 @@


    @Override
    public TemperingLayoutDTO queryTemperingOccupySlot() {
    public List<TemperingLayoutDTO> queryTemperingOccupySlot() {
        return baseMapper.queryTemperingOccupySlot(minCount);
    }

@@ -350,47 +346,49 @@
    }

    @Override
    public boolean TemperingGlass(String temperingLayoutId, String engineerId) {
    public boolean temperingGlass(String temperingLayoutId, String engineerId) {
        LambdaQueryWrapper<TemperingGlassInfo> temperingGlassInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
        temperingGlassInfoLambdaQueryWrapper
                .eq(TemperingGlassInfo::getState,Const.TEMPERING_NEW);
        List<TemperingGlassInfo> temperingGlassInfoList=temperingGlassInfoMapper.selectList(temperingGlassInfoLambdaQueryWrapper);
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW);
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoMapper.selectList(temperingGlassInfoLambdaQueryWrapper);

        if(temperingGlassInfoList.size()==0){
            LambdaQueryWrapper<BigStorageCageDetails> wrapper =new LambdaQueryWrapper<>();
            wrapper.eq(BigStorageCageDetails::getTemperingLayoutId,temperingLayoutId)
                    .eq(BigStorageCageDetails::getEngineerId,engineerId)
                    .in(BigStorageCageDetails::getState,Const.GLASS_STATE_IN,Const.GLASS_STATE_ARTIFICIAL);
            List<BigStorageCageDetails> bigStorageCageDetailsList=baseMapper.selectList(wrapper);

            for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList
            ) {
                TemperingGlassInfo temperingGlassInfo = new TemperingGlassInfo();
                LambdaQueryWrapper<GlassInfo> glassInfoLambdaQueryWrapper = new LambdaQueryWrapper<>();
                glassInfoLambdaQueryWrapper.eq(GlassInfo::getGlassId, bigStorageCageDetails.getGlassId());
                GlassInfo glassInfo = glassInfoMapper.selectOne(glassInfoLambdaQueryWrapper);

                BeanUtils.copyProperties(glassInfo, temperingGlassInfo);
                temperingGlassInfo.setAngle((int) glassInfo.getAngle());
                temperingGlassInfo.setState(Const.TEMPERING_NEW);
                temperingGlassInfo.setSlot(bigStorageCageDetails.getSlot());
                temperingGlassInfoMapper.insert(temperingGlassInfo);
        if (temperingGlassInfoList.size() == 0) {
            List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                    .selectAll(GlassInfo.class)
                    .select("-1 as state")
                    .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
                    .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                    .eq(GlassInfo::getTemperingLayoutId, temperingLayoutId)
                    .eq(GlassInfo::getEngineerId, engineerId)
                    .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                    .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
            if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                temperingGlassInfoService.saveBatch(temperingGlassInfos);
                return true;
            }
            return true;
        } else {
            return false;
        }


        return false;
    }


    @Override
    public List<Map<String, Object>> selectTemperingGlass(){
    public List<Map<String, Object>> selectTemperingGlass() {
        QueryWrapper<BigStorageCageDetails> wrapper = new QueryWrapper<>();
        wrapper.select("engineer_id,tempering_layout_id,count(*) as count")
                .in("state",Const.GLASS_STATE_IN,Const.GLASS_STATE_ARTIFICIAL)
                .in("state", Const.GLASS_STATE_IN, Const.GLASS_STATE_ARTIFICIAL)
                .groupBy("engineer_id,tempering_layout_id");
        List<Map<String, Object>> TemperingGlass = baseMapper.selectMaps(wrapper);
        return TemperingGlass;
    }

    @Override
    public void updateBySlot(List<UpdateBigStorageCageDTO> glassList, int state) {
        baseMapper.updateBySlot(glassList, state);
    }

    @Override
    public String temperingSwitch(Boolean flag) {
        redisUtil.setCacheObject("temperingSwitch", flag);
        return "success";
    }
}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstoragetask/entity/UpdateBigStorageCageDTO.java

New file
@@ -0,0 +1,16 @@
package com.mes.bigstoragetask.entity;

import lombok.Data;

/**
 * @Author : zhoush
 * @Date: 2024/7/26 9:05
 * @Description:
 */
@Data
public class UpdateBigStorageCageDTO {

    private String glassId;

    private int targetSlot;
}

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/PlcSlicecage.java

@@ -5,6 +5,7 @@
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.common.S7object;
import com.mes.common.utils.RedisUtil;
import com.mes.device.PlcParameterObject;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
@@ -31,6 +32,8 @@
    private BigStorageCageDetailsService bigStorageCageDetailsService;
    @Resource
    private TemperingGlassInfoService temperingGlassInfoService;
    @Resource
    private RedisUtil redisUtil;

    private JSONObject jsonObject = new JSONObject();
    public void queryDataSource1() throws InterruptedException {
@@ -42,11 +45,11 @@
        jsonObject.append("bigStorageCageInfos", bigStorageCageService.querybigStorageCageDetail());

        //进片任务数据
        List<BigStorageCageDetails> bigStorageCageDetailsFeedTask=bigStorageCageDetailsService.selectTask(1);
        List<BigStorageCageDetails> bigStorageCageDetailsFeedTask=bigStorageCageDetailsService.selectFeedTask();
        jsonObject.append("bigStorageCageDetailsFeedTask", bigStorageCageDetailsFeedTask);

        //出片任务数据
        List<BigStorageCageDetails> bigStorageCageDetailsOutTask=bigStorageCageDetailsService.selectTask(2);
        List<BigStorageCageDetails> bigStorageCageDetailsOutTask=bigStorageCageDetailsService.selectOutTask();
        jsonObject.append("bigStorageCageDetailsOutTask", bigStorageCageDetailsOutTask);

        //理片笼使用情况
@@ -56,6 +59,15 @@
        //理片笼表格信息
        jsonObject.append("bigStorageCageInfo", bigStorageCageService.querybigStorageCageDetailAll());

        //钢化开关
        boolean temperingSwitch=false;
        if(redisUtil.getCacheObject("temperingSwitch")==null){
            redisUtil.setCacheObject("temperingSwitch", false);
        }else{
            temperingSwitch=redisUtil.getCacheObject("temperingSwitch");
        }
        jsonObject.append("temperingSwitch", temperingSwitch);

    }

    public void queryDataSource2() throws InterruptedException {

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/job/PlcStorageCageTask.java

@@ -16,10 +16,12 @@
import com.mes.bigstorage.service.BigStorageCageService;
import com.mes.bigstoragetask.entity.BigStorageCageFeedTask;
import com.mes.bigstoragetask.entity.BigStorageCageOutTask;
import com.mes.bigstoragetask.entity.UpdateBigStorageCageDTO;
import com.mes.bigstoragetask.service.BigStorageCageFeedTaskService;
import com.mes.bigstoragetask.service.BigStorageCageOutTaskService;
import com.mes.common.S7object;
import com.mes.common.config.Const;
import com.mes.common.utils.RedisUtil;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.device.PlcParameterObject;
@@ -64,6 +66,9 @@
    private TemperingGlassInfoService temperingGlassInfoService;
    @Resource
    private DamageService damageService;

    @Resource
    private RedisUtil redisUtil;

    private static final String REQUEST_WORD = "1";

@@ -178,11 +183,6 @@
        String d01Id = plcParameterObject.getPlcParameter("D01ID").getValue();
        String d04Id = plcParameterObject.getPlcParameter("D04ID").getValue();
        log.info("1、获取d01Id扫描ID为：{};获取d04Id扫描ID为：{};", d01Id, d04Id);
        //两条线都有进卧转立任务，直接结束
//        if (StringUtils.isNotBlank(d01Id) && StringUtils.isNotBlank(d04Id)) {
//            log.info("两条线都存在进片任务，结束任务");
//            return;
//        }
        //获取两条线卧转立是否有玻璃，且任务状态为1/2
        List<Integer> lineList = bigStorageCageFeedTaskService.querySitToUpGlass();
        if (CollectionUtils.isEmpty(lineList)) {
@@ -249,92 +249,115 @@
        Date startDate = new Date();
        log.info("大理片笼空车进片任务开始执行时间：{}", startDate);
        PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
        String e02State = plcMesObject.getPlcParameter("E02State").getAddress();
        String e02State = plcMesObject.getPlcParameter("E02State").getValue();
        if (REQUEST_WORD.equals(e02State)) {
            log.info("出片忙碌，结束出片任务");
            return;
        }
        String mesToPLCAddress = plcMesObject.getPlcParameter("MESToPLC").getAddress();
        List<BigStorageCageOutTask> outingList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>().eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_NEW));
        Assert.isTrue(CollectionUtils.isEmpty(outingList), "有正在执行出片的任务，结束当前出片线程");

        //是否有正在钢化的玻璃
        List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.selectJoinList(TemperingGlassInfo.class, new MPJLambdaWrapper<TemperingGlassInfo>()
                .selectAll(TemperingGlassInfo.class)
                .leftJoin(BigStorageCageOutTask.class, BigStorageCageOutTask::getGlassId, TemperingGlassInfo::getGlassId)
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                .isNull(BigStorageCageOutTask::getGlassId)
                .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));
        if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
            log.info("有正在出片的钢化任务");
            computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
        List<BigStorageCageOutTask> outingList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
                .eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_NEW));
        if (CollectionUtils.isNotEmpty(outingList)) {
            log.info("有正在执行出片的任务，结束当前出片线程");
            return;
        }
        //是否有人工下片任务   有直接出
        List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL).orderByDesc(BigStorageCageDetails::getWidth));
        if (CollectionUtils.isNotEmpty(artificialList)) {
            computeOutGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress);
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
        //钢化优先：获取理片笼  玻璃小片  破损表 数量   判断笼内版图是否到齐
        List<TemperingLayoutDTO> temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll();
        if (CollectionUtils.isNotEmpty(temperingLayoutDTOList)) {
            //玻璃到齐包括已出片的
            //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务  结束
            for (TemperingLayoutDTO item : temperingLayoutDTOList) {
                List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                        .selectAll(GlassInfo.class)
                        .select("-1 as state")
                        .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
                        .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                        .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                        .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId())
                        .eq(GlassInfo::getEngineerId, item.getEngineerId())
                        .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
                if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                    temperingGlassInfoService.saveBatch(temperingGlassInfos);
                    computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
                    Date endDate = new Date();
                    log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                    return;
                }
        if (redisUtil.getCacheObject("temperingSwitch")) {
            //是否有正在钢化的玻璃
            List<TemperingGlassInfo> temperingGlassInfoList = temperingGlassInfoService.selectJoinList(TemperingGlassInfo.class, new MPJLambdaWrapper<TemperingGlassInfo>()
                    .selectAll(TemperingGlassInfo.class)
                    .leftJoin(BigStorageCageOutTask.class, BigStorageCageOutTask::getGlassId, TemperingGlassInfo::getGlassId)
                    .eq(TemperingGlassInfo::getState, Const.TEMPERING_NEW)
                    .isNull(BigStorageCageOutTask::getGlassId)
                    .orderBy(Boolean.TRUE, sequenceOrder, TemperingGlassInfo::getTemperingFeedSequence));
            if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
                log.info("有正在出片的钢化任务");
                computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
                Date endDate = new Date();
                log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
            }
        }
        //未到齐 执行内部调度任务
        TemperingLayoutDTO temperingOccupySlot = bigStorageCageDetailsService.queryTemperingOccupySlot();
        if (null != temperingOccupySlot) {
            List<SlotSequenceDTO> slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId());
            for (int i = 0; i < slotSequenceList.size() - 1; i++) {
                SlotSequenceDTO first = slotSequenceList.get(i);
                SlotSequenceDTO second = slotSequenceList.get(i + 1);
                int slotWidth = carWidth - first.getRemainWidth() - glassGap;
                if (first.getMinSequence() == second.getMaxSequence() + 1
                        && second.getRemainWidth() > slotWidth) {
                    List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                            .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN));
                    List<BigStorageCageOutTask> outTasks = list.stream().map(e -> new BigStorageCageOutTask(e.getGlassId(), first.getSlot(), second.getSlot(),
                            e.getWidth() * 10, e.getHeight() * 10, 0, 0, 1)).collect(Collectors.toList());
                    bigStorageCageOutTaskService.saveBatch(outTasks);

                    //向plc写入确认字
                    int returnData = 0;
                    int count = 1;
                    while (returnData == 0) {
                        log.info("已向plc第{}次送协议", count);
                        S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);
                        returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0);
                        log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData);
            //是否有人工下片任务   有直接出
            List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL).orderByDesc(BigStorageCageDetails::getWidth));
            if (CollectionUtils.isNotEmpty(artificialList)) {
                computeOutGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress);
                Date endDate = new Date();
                log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                return;
            }
            //钢化优先：获取理片笼  玻璃小片  破损表 数量   判断笼内版图是否到齐
            List<TemperingLayoutDTO> temperingLayoutDTOList = bigStorageCageDetailsService.temperingIsAll();
            if (CollectionUtils.isNotEmpty(temperingLayoutDTOList)) {
                //玻璃到齐包括已出片的
                //到齐，将玻璃小片数据存入钢化小片表，逻辑生成出片任务  结束
                for (TemperingLayoutDTO item : temperingLayoutDTOList) {
                    List<TemperingGlassInfo> temperingGlassInfos = glassInfoService.selectJoinList(TemperingGlassInfo.class, JoinWrappers.lambda(GlassInfo.class)
                            .selectAll(GlassInfo.class)
                            .select("-1 as state")
                            .selectAs(BigStorageCageDetails::getSlot, TemperingGlassInfo::getSlot)
                            .innerJoin(BigStorageCageDetails.class, BigStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                            .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                            .eq(GlassInfo::getTemperingLayoutId, item.getTemperingLayoutId())
                            .eq(GlassInfo::getEngineerId, item.getEngineerId())
                            .orderBy(Boolean.TRUE, sequenceOrder, GlassInfo::getTemperingFeedSequence));
                    if (CollectionUtils.isNotEmpty(temperingGlassInfos)) {
                        temperingGlassInfoService.saveBatch(temperingGlassInfos);
                        computeOutGlassInfo(temperingGlassInfoList, Boolean.TRUE, mesToPLCAddress);
                        Date endDate = new Date();
                        log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                        return;
                    }
                    Date endDate = new Date();
                    log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
                    return;
                }
            }
        }
        //执行内部调度任务
        List<TemperingLayoutDTO> temperingOccupySlotList = bigStorageCageDetailsService.queryTemperingOccupySlot();
        if (CollectionUtils.isNotEmpty(temperingOccupySlotList)) {
            loop:
            for (TemperingLayoutDTO temperingOccupySlot : temperingOccupySlotList) {
                List<SlotSequenceDTO> slotSequenceList = bigStorageCageDetailsService.queryGlassMaxAndMin(temperingOccupySlot.getEngineerId(), temperingOccupySlot.getTemperingLayoutId());
                for (int i = 0; i < slotSequenceList.size() - 1; i++) {
                    SlotSequenceDTO first = slotSequenceList.get(i);
                    SlotSequenceDTO second = slotSequenceList.get(i + 1);
                    int slotWidth = carWidth - first.getRemainWidth() - glassGap;
                    if (first.getMinSequence() == second.getMaxSequence() + 1
                            && second.getRemainWidth() > slotWidth && slotWidth >= 0) {
                        List<BigStorageCageDetails> list = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                                .eq(BigStorageCageDetails::getSlot, first.getSlot()).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_IN)
                                .orderBy(Boolean.TRUE, sequenceOrder, BigStorageCageDetails::getTemperingFeedSequence));
                        if (CollectionUtils.isNotEmpty(list)) {
                            List<BigStorageCageOutTask> outTasks = new ArrayList<>();
                            int serialNumber = 1;
                            for (BigStorageCageDetails item : list) {
                                outTasks.add(new BigStorageCageOutTask(item.getGlassId(), first.getSlot(), second.getSlot(),
                                        item.getWidth() * 10, item.getHeight() * 10, 1, serialNumber++, Const.BIG_STORAGE_OUT_NEW));
                            }
                            //新增调度任务
                            bigStorageCageOutTaskService.saveBatch(outTasks);
                            //更新理片笼详情表调度的后的玻璃位置信息：生成任务后先将玻璃格子位置进行调整，玻璃状态改为调度中，新增调度完成任务，处理调度完成后玻璃状态改为100.
                            List<String> glassList = list.stream().map(BigStorageCageDetails::getGlassId).collect(Collectors.toList());
                            bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>().set(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING)
                                    .set(BigStorageCageBaseInfo::getSlot, second.getSlot()).in(BigStorageCageDetails::getGlassId, glassList));
                            //两次更新笼子的剩余尺寸：第一次防止有玻璃继续进调度后的笼子，第二次更新：计算格子的实际尺寸
                            // 仅更新调度后的格子信息：起始格子完成后更新：防止调度出片过程中有新玻璃进入，
                            updateSlotRemainBySlots(Arrays.asList(second.getSlot()));
                            break loop;
                        }
                    }
                }
            }
            //向plc写入确认字
            int returnData = 0;
            int count = 1;
            while (returnData == 0) {
                log.info("已向plc第{}次送协议", count);
                S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);
                returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0);
                log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData);
            }
            Date endDate = new Date();
            log.info("大理片笼出片任务结束时间：{}，共耗时：{}ms,结束扫码任务", endDate, endDate.getTime() - startDate.getTime());
            return;
        }
    }

@@ -348,17 +371,21 @@
        if (CollectionUtils.isNotEmpty(list)) {
            log.info("2、获取所有正在进片的玻璃信息id:{}", list);
            List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
            List<Object> inSuccessGlassIdsObj = bigStorageCageFeedTaskService.listObjs(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                    .select(BigStorageCageFeedTask::getGlassId).in(BigStorageCageFeedTask::getGlassId, glassIds)
            List<BigStorageCageFeedTask> inSuccessGlass = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                    .in(BigStorageCageFeedTask::getGlassId, glassIds)
                    .in(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_SLOT));
            List<String> inSuccessGlassIds = inSuccessGlassIdsObj.stream().map(String::valueOf).collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(inSuccessGlassIds)) {
                log.info("3、获取进片已完成的玻璃信息id:{}", inSuccessGlassIds);
                bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                        .set(BigStorageCageDetails::getState, Const.GLASS_STATE_IN).in(BigStorageCageDetails::getGlassId, inSuccessGlassIds));
                log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", inSuccessGlassIds);
            if (CollectionUtils.isNotEmpty(inSuccessGlass)) {
                log.info("3、获取进片已完成的玻璃信息id:{}", inSuccessGlass);
                List<Integer> inSuccessGlassSlot = inSuccessGlass.stream().map(BigStorageCageFeedTask::getTargetSlot).collect(Collectors.toList());
                List<UpdateBigStorageCageDTO> storageCageDTOList = inSuccessGlass.stream().map(e -> {
                    UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
                    BeanUtils.copyProperties(e, storageCageDTO);
                    return storageCageDTO;
                }).collect(Collectors.toList());
                bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
                log.info("4、大理片笼进片状态已完成已完成的玻璃信息id:{}", inSuccessGlass);
                //更新理片笼玻璃尺寸
                updateSlotRemain(inSuccessGlassIds, Boolean.TRUE);
                updateSlotRemainBySlots(inSuccessGlassSlot);
                log.info("5、大理片笼进片目标格子尺寸更新完成");
            }

@@ -379,16 +406,58 @@
        if (CollectionUtils.isNotEmpty(list)) {
            log.info("2、获取所有正在出片的玻璃信息id:{}", list);
            List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
            List<Object> outSuccessGlassIdsObj = bigStorageCageOutTaskService.listObjs(new LambdaQueryWrapper<BigStorageCageOutTask>()
                    .select(BigStorageCageOutTask::getGlassId).in(BigStorageCageOutTask::getGlassId, glassIds).in(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_ALL));
            List<String> outSuccessGlassIds = outSuccessGlassIdsObj.stream().map(String::valueOf).collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(outSuccessGlassIds)) {
                log.info("3、获取出片已完成的玻璃信息id:{}", outSuccessGlassIdsObj);
                bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                        .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT).in(BigStorageCageDetails::getGlassId, outSuccessGlassIds));
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", outSuccessGlassIdsObj);
            List<BigStorageCageOutTask> outSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
                    .in(BigStorageCageOutTask::getGlassId, glassIds).in(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_ALL));
            if (CollectionUtils.isNotEmpty(outSuccessGlass)) {
                log.info("3、获取出片已完成的玻璃信息id:{}", outSuccessGlass);
                List<UpdateBigStorageCageDTO> storageCageDTOList = outSuccessGlass.stream().map(e -> {
                    UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
                    storageCageDTO.setGlassId(e.getGlassId());
                    storageCageDTO.setTargetSlot(e.getStartSlot());
                    return storageCageDTO;
                }).collect(Collectors.toList());
                bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_OUT);
                List<Integer> outSuccessSlotList = outSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).collect(Collectors.toList());
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", outSuccessGlass);
                //更新理片笼玻璃尺寸
                updateSlotRemain(outSuccessGlassIds, Boolean.FALSE);
                updateSlotRemainBySlots(outSuccessSlotList);
                log.info("5、大理片笼进片目标格子尺寸更新完成");
            }
        }
        Date endDate = new Date();
        log.info("end:大理片笼出片完成后更新大理片笼数据任务结束时间：{}，共耗时：{}ms,结束任务", endDate, endDate.getTime() - startDate.getTime());
        return;

    }

    @Scheduled(fixedDelay = 300)
    public void updateScheduleGlassStateTask() {
        Date startDate = new Date();
        log.info("1、大理片笼调度完成后更新大理片笼数据任务开始执行时间：{}", startDate);
        //因为大理片笼和调度任务是两个库的数据，所以要分开查找
        List<Object> list = bigStorageCageDetailsService.listObjs(new LambdaQueryWrapper<BigStorageCageDetails>()
                .select(BigStorageCageDetails::getGlassId).eq(BigStorageCageDetails::getState, Const.GLASS_STATE_SCHEDULE_ING));
        if (CollectionUtils.isNotEmpty(list)) {
            log.info("2、获取所有正在出片的玻璃信息id:{}", list);
            List<String> glassIds = list.stream().map(String::valueOf).collect(Collectors.toList());
            List<BigStorageCageOutTask> scheduleSuccessGlass = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
                    .in(BigStorageCageOutTask::getGlassId, glassIds).eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_SUCCESS)
                    .notIn(BigStorageCageOutTask::getEndSlot, Const.TEMPERING_OUT_TARGET_POSITION, Const.ARTIFICIAL_OUT_TARGET_POSITION));
            if (CollectionUtils.isNotEmpty(scheduleSuccessGlass)) {
                log.info("3、获取调度已完成的玻璃信息id:{}", scheduleSuccessGlass);
                List<UpdateBigStorageCageDTO> storageCageDTOList = scheduleSuccessGlass.stream().map(e -> {
                    UpdateBigStorageCageDTO storageCageDTO = new UpdateBigStorageCageDTO();
                    storageCageDTO.setGlassId(e.getGlassId());
                    storageCageDTO.setTargetSlot(e.getEndSlot());
                    return storageCageDTO;
                }).collect(Collectors.toList());
                bigStorageCageDetailsService.updateBySlot(storageCageDTOList, Const.GLASS_STATE_IN);
                List<String> scheduleSuccessGlassIds = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
                log.info("4、大理片笼出片状态已完成已完成的玻璃信息id:{}", scheduleSuccessGlassIds);
                //更新理片笼玻璃尺寸
                List<Integer> slotList = scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getStartSlot).distinct().collect(Collectors.toList());
                slotList.addAll(scheduleSuccessGlass.stream().map(BigStorageCageOutTask::getEndSlot).distinct().collect(Collectors.toList()));
                updateSlotRemainBySlots(slotList);
                log.info("5、大理片笼进片目标格子尺寸更新完成");
            }
        }
@@ -412,9 +481,10 @@
            log.info("获取进片任务表中破损的玻璃信息{}", inDamageTaskInfoList);
            bigStorageCageFeedTaskService.remove(new LambdaQueryWrapper<BigStorageCageFeedTask>().eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_DAMAGE));
            //理片笼详情表数据状态更新
            bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                    .set(BigStorageCageDetails::getState, Const.GLASS_STATE_DAMAGE).in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList())));
            bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW).in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList())));
            //将破损信息新增入破损表
            List<Integer> slotList = new ArrayList<>();
            for (BigStorageCageFeedTask bigStorageCageFeedTask : inDamageTaskInfoList) {
                Damage damage = new Damage();
                damage.setGlassId(bigStorageCageFeedTask.getGlassId());
@@ -423,7 +493,10 @@
                damage.setRemark("进笼前卧转立");
                damage.setStatus(2);
                damageService.insertDamage(damage);
                slotList.add(bigStorageCageFeedTask.getTargetSlot());
            }
            //更新格子剩余宽度
            updateSlotRemainBySlots(slotList);
            log.info("进片任务执行完成");
        }
        //获取出片任务表中状态为破损的数据
@@ -431,15 +504,15 @@
                .eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_DAMAGE));
        if (CollectionUtils.isNotEmpty(outDamageTaskInfoList)) {
            log.info("获取出片任务表中破损的玻璃信息{}", outDamageTaskInfoList);
            bigStorageCageOutTaskService.remove(new LambdaQueryWrapper<BigStorageCageOutTask>().eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_IN_DAMAGE));
            bigStorageCageOutTaskService.remove(new LambdaQueryWrapper<BigStorageCageOutTask>().eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_DAMAGE));
            List<String> glassIdList = outDamageTaskInfoList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
            //移除钢化下片表数据
            temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().in(TemperingGlassInfo::getGlassId, glassIdList));
            //理片笼详情表数据状态更新
            bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                    .set(BigStorageCageDetails::getState, Const.GLASS_STATE_DAMAGE).in(BigStorageCageDetails::getGlassId, glassIdList));
            //理片笼详情表数据状态删除
            bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>().in(BigStorageCageDetails::getGlassId, glassIdList));

            //将破损信息新增入破损表
            List<Integer> slotList = new ArrayList<>();
            for (BigStorageCageOutTask bigStorageCageOutTask : outDamageTaskInfoList) {
                Damage damage = new Damage();
                damage.setGlassId(bigStorageCageOutTask.getGlassId());
@@ -448,7 +521,10 @@
                damage.setRemark("出片后卧转立");
                damage.setStatus(2);
                damageService.insertDamage(damage);
                slotList.add(bigStorageCageOutTask.getStartSlot());
            }
            //更新格子剩余宽度
            updateSlotRemainBySlots(slotList);
            log.info("出片任务执行完成");
        }
        Date endDate = new Date();
@@ -596,9 +672,9 @@
            BeanUtils.copyProperties(info, cageDetails);
            //2、获取目标格子信息
            BigStorageDTO bigStorageDTO = bigStorageCageDetailsService.queryTargetSlotByTempering(info);
            //3、更新大理片笼表剩余宽度（更新大理片笼剩余尺寸移到进笼完成后执行）
//            bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - info.getWidth() - glassGap)
//                    .eq(BigStorageCage::getSlot, bigStorageDTO.getSlot()));
            //3、临时更新格子的剩余尺寸：防止相邻玻璃进同一格子造成剩余尺寸不足，玻璃越界的情况，任务完成后再次更新大理片笼表剩余宽度（按照笼内玻璃数量更新大理片笼剩余尺寸）
            bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, bigStorageDTO.getWidth() - Math.max(info.getWidth(), info.getHeight()) - glassGap)
                    .eq(BigStorageCage::getSlot, bigStorageDTO.getSlot()));
            //4、更新进片任务表，目标格子及状态（状态改为2 电气扫到自行处理）  遇到问题：无法批量更新，批量更新无法走指定从库
            e.setTargetSlot(bigStorageDTO.getSlot());
            bigStorageCageFeedTaskService.updateById(e);
@@ -609,6 +685,7 @@
            cageDetails.setDeviceId(bigStorageDTO.getDeviceId());
            cageDetails.setGap(glassGap);
            bigStorageCageDetailsService.save(cageDetails);

        }
        sendTaskListToPLC(taskList, line);
        return Boolean.TRUE;
@@ -624,6 +701,7 @@
        for (int i = 1; i <= taskList.size(); i++) {
            s7control.writeWord(plcMesObject.getPlcParameter("StartAddToImport" + i).getAddress(), taskList.get(i - 1).getLine());
            s7control.writeWord(plcMesObject.getPlcParameter("TargetAddToImport" + i).getAddress(), taskList.get(i - 1).getTargetSlot());
            log.info("向plc发送第{}片玻璃已完成", i);
        }
        int returnData = 0;
        int count = 1;
@@ -634,6 +712,15 @@
        }
    }

    /**
     * 出片一次仅生成一车玻璃
     *
     * @param list
     * @param isTempering
     * @param mesToPLCAddress
     * @param <T>
     * @return
     */
    private <T extends BigStorageCageBaseInfo> Boolean computeOutGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) {
        //任务数据  获取车子存放玻璃最大数量  玻璃间隔
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
@@ -659,7 +746,6 @@
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                        e.getWidth() * 10, e.getHeight(), 0, 0, 1));
            }

        }
        Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size());
@@ -669,9 +755,6 @@
        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)
                .in(BigStorageCageDetails::getGlassId, glassIds));
        //更新笼子内格子的剩余尺寸(移至出片任务完成后)
//        updateSlotRemain(list, glassIds);

        int returnData = 0;
        int count = 1;
        while (returnData == 0) {
@@ -683,46 +766,91 @@
    }

    /**
     * 更新笼子内格子的剩余尺寸
     * 出片一次生成一炉玻璃
     *
     * @param taskGlassIds 本次任务出去的玻璃ids
     * @param flag         是否进出片 true 进片  false 出片
     * @param list
     * @param isTempering
     * @param mesToPLCAddress
     * @param <T>
     * @return
     */
    public void updateSlotRemain(List<String> taskGlassIds, Boolean flag) {
        //按照玻璃id获取玻璃信息及玻璃的格子号
        List<BigStorageCageDetails> glassList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .in(BigStorageCageDetails::getGlassId, taskGlassIds));
        //获取需要出去/进笼（包括待出去的）的所有玻璃格子号
        List<Integer> slotList = glassList.stream().map(BigStorageCageDetails::getSlot).distinct().collect(Collectors.toList());
    private <T extends BigStorageCageBaseInfo> Boolean computeOutMoreGlassInfo(List<T> list, Boolean isTempering, String mesToPLCAddress) {
        //任务数据  获取车子存放玻璃最大数量  玻璃间隔
        List<BigStorageCageOutTask> bigStorageCageOutTaskList = new ArrayList<>();
        //打车剩余尺寸
        Integer remainWidth = carWidth;
        int trainNumber = 1;
        int serialNumber = 1;
        int maxX = 0;
        for (T e : list) {
            int maxLength = Math.max((int) e.getWidth(), (int) e.getHeight());
            if (serialNumber > outCarMaxSize || maxLength > remainWidth) {
                remainWidth = carWidth;
                trainNumber = trainNumber + 1;
                serialNumber = 1;
                maxX = 0;
            }
            remainWidth = remainWidth - maxLength - glassGap;
            if (isTempering) {
                int minLength = Math.min((int) e.getWidth(), (int) e.getHeight());
                if (maxX + minLength <= xMaxSize) {
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.TEMPERING_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight() * 10, trainNumber, serialNumber++, 1));
                    maxX = Math.max(maxX, e.getXCoordinate());
                } else {
                    remainWidth = carWidth - maxLength - glassGap;
                    trainNumber = trainNumber + 1;
                    serialNumber = 1;
                    maxX = e.getXCoordinate();
                    bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                            e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1));
                }
            } else {
                bigStorageCageOutTaskList.add(new BigStorageCageOutTask(e.getGlassId(), e.getSlot(), Const.ARTIFICIAL_OUT_TARGET_POSITION,
                        e.getWidth() * 10, e.getHeight(), trainNumber, serialNumber++, 1));
            }
        }
        Assert.isFalse(CollectionUtils.isEmpty(bigStorageCageOutTaskList), "未获取出片数据，结束出片任务");
        log.info("获取出片任务数据{}条，执行保存", bigStorageCageOutTaskList.size());
        bigStorageCageOutTaskService.saveBatch(bigStorageCageOutTaskList);
        List<String> glassIds = bigStorageCageOutTaskList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
        log.info("将出片玻璃{}玻璃状态改为已出片", glassIds);
        bigStorageCageDetailsService.update(new LambdaUpdateWrapper<BigStorageCageDetails>()
                .set(BigStorageCageDetails::getState, Const.GLASS_STATE_OUT_ING)
                .in(BigStorageCageDetails::getGlassId, glassIds));
        int returnData = 0;
        int count = 1;
        while (returnData == 0) {
            S7object.getinstance().plccontrol.writeWord(mesToPLCAddress, 1);
            returnData = S7object.getinstance().plccontrol.readWord(mesToPLCAddress, 1).get(0);
            log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, mesToPLCAddress, returnData);
        }
        return Boolean.TRUE;
    }

    public void updateSlotRemainBySlots(List<Integer> slotList) {
        //获取格子内所有的玻璃信息
        List<BigStorageCageDetails> inSlotGlassList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                .in(BigStorageCageDetails::getSlot, slotList).in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL));
        //获取待进片/出去的玻璃信息
        Map<Integer, Double> slotRemainMap = null;
        if (flag) {
            slotRemainMap = inSlotGlassList.stream().filter(e -> taskGlassIds.contains(e.getGlassId()))
                    .collect(Collectors.groupingBy(BigStorageCageDetails::getSlot, Collectors.summingDouble(item -> item.getWidth() + glassGap)));
        } else {
            slotRemainMap = inSlotGlassList.stream().filter(e -> !taskGlassIds.contains(e.getGlassId()))
                    .collect(Collectors.groupingBy(BigStorageCageDetails::getSlot, Collectors.summingDouble(item -> item.getWidth() + glassGap)));
        }
        //格子内有玻璃的，计算为： 格子的宽度 - （给子内玻璃的尺寸+间距）
        if (CollectionUtils.isNotEmpty(slotRemainMap)) {
        Map<Integer, Double> slotRemainMap = new HashMap<>();
        //是否存在有格子非空的玻璃
        if (CollectionUtils.isNotEmpty(inSlotGlassList)) {
            //存在  将格子内的玻璃分别进行更新
            slotRemainMap = inSlotGlassList.stream()
                    .collect(Collectors.groupingBy(BigStorageCageDetails::getSlot, Collectors.summingDouble(item -> Math.max(item.getWidth(), item.getHeight()) + glassGap)));
            slotRemainMap.forEach((e, v) -> {
                bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, slotWidth - v)
                double remainWidth = slotWidth - v >= 0 ? slotWidth - v : 0;
                bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, remainWidth)
                        .eq(BigStorageCage::getSlot, e));
            });
        }
        //只更新进笼完成的状态，如果进笼完成，格子内必定有玻璃，不存在出片后格子内没有玻璃的情况，所有格子尺寸重置，只能存在于出片任务
        if (!flag) {
            Set<Integer> remainSlotList = slotRemainMap.keySet();
            slotList.removeAll(remainSlotList);
            if (CollectionUtils.isNotEmpty(slotList)) {
                bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, slotWidth)
                        .in(BigStorageCage::getSlot, slotList));
            }
        //过滤不存在玻璃的格子 将宽度重置为原始宽度5000
        Set<Integer> remainSlotList = slotRemainMap.keySet();
        slotList.removeAll(remainSlotList);
        if (CollectionUtils.isNotEmpty(slotList)) {
            bigStorageCageService.update(new LambdaUpdateWrapper<BigStorageCage>().set(BigStorageCage::getRemainWidth, slotWidth)
                    .in(BigStorageCage::getSlot, slotList));
        }

    }

    public Boolean computeIsRun(int line, String glassId) {

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/application-cz.yml

@@ -14,6 +14,11 @@
          username: sa
          password: beibo.123/
          driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
        pp:
          url: jdbc:mysql://192.168.1.199:3306/pp?serverTimezone=GMT%2b8
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
  cloud:
    nacos:
      discovery:

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/application-dev.yml

@@ -14,6 +14,11 @@
          username: sa
          password: beibo.123/
          driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
        pp:
          url: jdbc:mysql://127.0.0.1:3306/pp?serverTimezone=GMT%2b8
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
  cloud:
    nacos:
      discovery:

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/application-prod.yml

@@ -14,6 +14,11 @@
          username: sa
          password: beibo.123/
          driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
        pp:
          url: jdbc:mysql://10.153.19.150:3306/pp?serverTimezone=GMT%2b8
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
  cloud:
    nacos:
      discovery:

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/application.yml

@@ -3,7 +3,7 @@

spring:
  profiles:
    active: cz
    active: prod
  application:
    name: cacheVerticalGlass
mybatis-plus:

 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/resources/mapper/BigStorageCageDetailsMapper.xml

@@ -44,13 +44,15 @@
    </select>

    <select id="queryTemperingOccupySlot" resultMap="temperingLayoutDTO">
        SELECT TEMPERING_LAYOUT_ID,
        SELECT ENGINEER_ID,
               TEMPERING_LAYOUT_ID,
               COUNT(DISTINCT SLOT) as SLOT_COUNT
        FROM BIG_STORAGE_CAGE_DETAILS
        WHERE STATE = 100
        GROUP BY ENGINEER_ID,
                 TEMPERING_LAYOUT_ID
        HAVING SLOT_COUNT &gt;= #{count} LIMIT 1
        HAVING SLOT_COUNT &gt;= #{count}
        ORDER BY SLOT_COUNT DESC
    </select>
    <select id="queryGlassMaxAndMin" resultMap="slotSequenceDTO">
        SELECT T.*,
@@ -71,4 +73,18 @@
                 INNER JOIN BIG_STORAGE_CAGE T1 ON T.SLOT = T1.SLOT
        ORDER BY T.MAX_SEQUENCE DESC
    </select>

    <update id="updateBySlot">
        update big_storage_cage_details
        <set>
            state = #{state}
        </set>
        <where>
            (glass_id,slot) in (
            <foreach collection="list" item="item" separator=",">
                (#{item.glassId}, #{item.targetSlot})
            </foreach>
            )
        </where>
    </update>
</mapper>

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/job/push.java

New file
@@ -0,0 +1,54 @@
package com.mes.job;



import cn.hutool.json.JSONObject;



import com.mes.shelfrack.entity.request.RawUsageAndShelfRack;

import com.mes.shelfrack.service.ShelfRackService;

import com.mes.storagetask.entity.request.StorageTaskRequest;

import com.mes.storagetask.service.StorageTaskService;

import com.mes.tools.WebSocketServer;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.scheduling.annotation.Scheduled;

import lombok.extern.slf4j.Slf4j;

import org.springframework.stereotype.Component;



import java.text.SimpleDateFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;

import java.util.Map;



@Slf4j

@Component

public class push {



    @Autowired

    private StorageTaskService storageTaskService;

    @Autowired

    private ShelfRackService shelfRackService;





    @Scheduled(fixedDelay = 2000)

    public void sendDownWorkstations() {

        log.info("发送任务信息和架子信息");

        JSONObject jsonObject = new JSONObject();



        List<RawUsageAndShelfRack> rack =  shelfRackService.selectshelf_rack();

        List<StorageTaskRequest>  tasks =  storageTaskService.Tasks();



        jsonObject.append("rack",rack);

        jsonObject.append("tasks",tasks);

        log.info(jsonObject.toString());

        ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("storageTask");

        if (sendwServer != null) {

            for (WebSocketServer webserver : sendwServer) {

                if (webserver != null&&webserver.session.isOpen()) {

                    log.info("已发送");

                    webserver.sendMessage(String.valueOf(jsonObject));

                }

            }

        }

    }





}


 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/loadposition/entity/LoadPosition.java

@@ -1,5 +1,7 @@
package com.mes.loadposition.entity;



import com.baomidou.mybatisplus.annotation.IdType;

import com.baomidou.mybatisplus.annotation.TableId;

import com.baomidou.mybatisplus.annotation.TableName;

import io.swagger.annotations.ApiModel;

import io.swagger.annotations.ApiModelProperty;

@@ -27,8 +29,8 @@
    /**

     *   

     */

    @ApiModelProperty(" ")

    private Long id;

    @TableId(value = "id", type = IdType.AUTO)

    private Integer id;



    /**

     *  架子编号

@@ -58,7 +60,7 @@
     *  仓储任务编号

     */

    @ApiModelProperty("仓储任务编号")

    private Long storageTaskId;

    private Integer storageTaskId;



    /**

     *  上片位类型


 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/rawusage/controller/RawUsageController.java

@@ -1,5 +1,6 @@
package com.mes.rawusage.controller;



import com.mes.shelfrack.entity.request.RawUsageAndShelfRack;

import com.mes.utils.Result;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.ResponseEntity;

@@ -80,8 +81,8 @@
     */

    @ApiOperation(value = "修改", notes = "修改数据")

    @ApiResponses({@ApiResponse(code = 200, message = "操作成功")})

    @PutMapping

    public Result update( @RequestBody RawUsage rawUsage) {

    @PostMapping("/updaterawUsage")

    public Result updaterawUsage(@RequestBody RawUsage rawUsage) {

        boolean result = rawUsageService.updateById(rawUsage);

        return Result.success(result);

    }

@@ -89,14 +90,30 @@
    /**

     * 删除

     *

     * @param id

     * @param

     * @return

     */

    @ApiOperation(value = "删除", notes = "删除数据")

    @DeleteMapping("/{id}")

    public Result delete(@PathVariable("id") Long id) {

        int result = rawUsageService.getBaseMapper().deleteById(id);

        return Result.success(result);

    @PostMapping("/id")

    public Result delete(@RequestBody RawUsage rawUsage) {

         rawUsageService.updateRawPackageAndStorageRack(rawUsage);

        return Result.success();

    }



    @ApiOperation(value = "入库", notes = "入库")

    @PostMapping("/inStorage")

    public Result inStorage(@RequestBody RawUsageAndShelfRack rawUsage) {

        rawUsageService.inStorage(rawUsage);

        return Result.success();

    }



    @ApiOperation(value = "出库", notes = "出库")

    @PostMapping("/outStorage")

    public Result outStorage(@RequestBody RawUsageAndShelfRack rawUsage) {

        rawUsageService.outStorage(rawUsage);

        return Result.success();

    }







}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/rawusage/entity/RawUsage.java

@@ -2,6 +2,9 @@


import java.io.Serializable;

import java.util.Date;



import com.baomidou.mybatisplus.annotation.IdType;

import com.baomidou.mybatisplus.annotation.TableId;

import com.baomidou.mybatisplus.annotation.TableName;

import io.swagger.annotations.ApiModel;

import io.swagger.annotations.ApiModelProperty;

@@ -27,8 +30,8 @@
    /**

     *   

     */

    @ApiModelProperty(" ")

    private Long id;

    @TableId(value = "id", type = IdType.AUTO)

    private Integer id;



    /**

     *  玻璃类型


 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/rawusage/service/RawUsageService.java

@@ -2,6 +2,8 @@


import com.mes.rawusage.entity.RawUsage;

import com.baomidou.mybatisplus.extension.service.IService;

import com.mes.shelfrack.entity.ShelfRack;

import com.mes.shelfrack.entity.request.RawUsageAndShelfRack;



import java.util.List;

/**

@@ -12,6 +14,23 @@


    List<RawUsage> findList(RawUsage params);



    /**

     * @param raw

     * 修改

     */

    void updateRawPackageAndStorageRack(RawUsage raw);



    /**

     * @param raw

     * 入库

     */

    void inStorage(RawUsageAndShelfRack raw);





    /**

     * @param raw

     * 出库

     */

    void outStorage(RawUsageAndShelfRack raw);



}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/rawusage/service/impl/RawUsageServiceImpl.java

@@ -6,9 +6,20 @@
import com.mes.rawusage.mapper.RawUsageMapper;

import com.mes.rawusage.entity.RawUsage;

import com.mes.rawusage.service.RawUsageService;

import com.mes.shelfrack.entity.ShelfRack;

import com.mes.shelfrack.entity.request.RawUsageAndShelfRack;

import com.mes.shelfrack.mapper.ShelfRackMapper;

import com.mes.storagetask.entity.StorageTask;

import com.mes.storagetask.mapper.StorageTaskMapper;

import org.springframework.beans.BeanUtils;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;



import java.lang.reflect.InvocationTargetException;

import java.time.LocalDateTime;

import java.util.List;



import static cn.hutool.core.date.DateTime.now;



/**

 * @author system

@@ -19,6 +30,10 @@


    @Autowired

    private RawUsageMapper rawUsageMapper;

    @Autowired

    private ShelfRackMapper shelfRackMapper;

    @Autowired

    private StorageTaskMapper storageTaskMapper;



    @Override

    public List<RawUsage> findList(RawUsage params){

@@ -26,6 +41,98 @@
        return rawUsageMapper.selectList(query);

    }



    @Override

    public void updateRawPackageAndStorageRack(RawUsage raw) {

        // Step 1: 查询raw_package_id

        LambdaQueryWrapper<ShelfRack> queryWrapper = Wrappers.lambdaQuery(ShelfRack.class)

                .eq(ShelfRack::getNumber, raw.getId());

        ShelfRack shelfRack = shelfRackMapper.selectOne(queryWrapper);

        if (shelfRack == null) {

            throw new RuntimeException("未找到与指定货架ID关联的原料包信息");

        }





        // Step 2: 更新raw_package表

        RawUsage rawUsage=new RawUsage();



        rawUsage.setState("空闲");

        rawUsage.setId(shelfRack.getRawPackageId());

        rawUsageMapper.updateById(rawUsage);



        // Step 3: 更新storage_rack表



        ShelfRack rack = new ShelfRack();

        rack.setState("空闲");

        rack.setRawPackageId(null);  // 设置RawPackageId为特定的空值，例如0

        LambdaQueryWrapper<ShelfRack> queryWrapper2 = Wrappers.lambdaQuery(ShelfRack.class)

                .eq(ShelfRack::getNumber, raw.getId());

        shelfRackMapper.update(rack, queryWrapper2);





    }











    @Override

    public void inStorage(RawUsageAndShelfRack raw) {

        RawUsage rawPackage = new RawUsage();

        BeanUtils.copyProperties(raw,rawPackage);

        rawPackage.setRawType(raw.getRawThickness() + raw.getColor());

        rawPackage.setState("使用中");

        rawPackage.setLeftPieces(rawPackage.getPieces());

        rawUsageMapper.insert(rawPackage);



        // 更新架表

        ShelfRack rack = new ShelfRack();

        rack.setState("使用中");

        rack.setRawPackageId(rawPackage.getId());  // 设置RawPackageId为特定的空值，例如0

        LambdaQueryWrapper<ShelfRack> queryWrapper = Wrappers.lambdaQuery(ShelfRack.class)

                .eq(ShelfRack::getNumber, raw.getNumber());

        shelfRackMapper.update(rack, queryWrapper);

        StorageTask storageTask=new StorageTask();

        storageTask.setTaskState("等待中");

        storageTask.setTaskType("从仓位到吊装位");

        storageTask.setLoadRack(raw.getLoadRack());

        storageTask.setShelfRack(raw.getNumber());

        storageTask.setRouteGroup(1);

        storageTask.setStartTime(now());

        storageTask.setFinishTime(now());

        insertTask(storageTask);





    }





    @Override

    public void outStorage(RawUsageAndShelfRack raw) {

        ShelfRack rack = new ShelfRack();

        rack.setState("等待出库");

        rack.setRawPackageId(null);  // 设置RawPackageId为特定的空值，例如0

        LambdaQueryWrapper<ShelfRack> queryWrapper = Wrappers.lambdaQuery(ShelfRack.class)

                .eq(ShelfRack::getNumber, raw.getNumber());

        shelfRackMapper.update(rack, queryWrapper);





        StorageTask storageTask=new StorageTask();

        storageTask.setTaskState("等待中");

        storageTask.setTaskType("从仓位到吊装位");

        storageTask.setLoadRack(raw.getLoadRack());

        storageTask.setShelfRack(raw.getNumber());

        storageTask.setRouteGroup(1);

        storageTask.setStartTime(now());

        storageTask.setFinishTime(now());

        insertTask(storageTask);

    }





    public void insertTask(StorageTask storageTask) {

        storageTaskMapper.insert(storageTask);



    }









}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/shelfrack/controller/ShelfRackController.java

@@ -1,5 +1,6 @@
package com.mes.shelfrack.controller;



import com.mes.shelfrack.entity.request.RawUsageAndShelfRack;

import com.mes.utils.Result;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.ResponseEntity;

@@ -105,7 +106,7 @@
    @ApiResponses({@ApiResponse(code = 200, message = "查询成功")})

    @GetMapping("/findshelfrack")

    public Result findshelfrack() {

        List<Map<String, Object>> result = shelfRackService.selectshelf_rack();

        List<RawUsageAndShelfRack> result = shelfRackService.selectshelf_rack();

        return Result.success(result);

    }




 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/shelfrack/entity/ShelfRack.java

@@ -2,6 +2,9 @@


import java.io.Serializable;

import java.util.Date;



import com.baomidou.mybatisplus.annotation.IdType;

import com.baomidou.mybatisplus.annotation.TableId;

import com.baomidou.mybatisplus.annotation.TableName;

import io.swagger.annotations.ApiModel;

import io.swagger.annotations.ApiModelProperty;

@@ -27,8 +30,8 @@
    /**

     *   

     */

    @ApiModelProperty(" ")

    private Long id;

    @TableId(value = "id", type = IdType.AUTO)

    private Integer id;



    /**

     *  架子编号

@@ -46,7 +49,7 @@
     *  包号编号

     */

    @ApiModelProperty("包号编号")

    private Long rawPackageId;

    private Integer rawPackageId;



    /**

     *  修改时间


 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/shelfrack/entity/request/RawUsageAndShelfRack.java

New file
@@ -0,0 +1,76 @@
package com.mes.shelfrack.entity.request;



import com.baomidou.mybatisplus.annotation.IdType;

import com.baomidou.mybatisplus.annotation.TableId;

import io.swagger.annotations.ApiModelProperty;

import lombok.Data;

import lombok.EqualsAndHashCode;



import java.io.Serializable;

import java.util.Date;



@Data



@EqualsAndHashCode(callSuper = false)

public class RawUsageAndShelfRack {



    private static final long serialVersionUID = 1L;



    @ApiModelProperty("ID")

    private Integer id;



    @ApiModelProperty("玻璃类型")

    private String rawType;



    @ApiModelProperty("宽度")

    private Float rawWidth;



    @ApiModelProperty("高度")

    private Float rawHeight;



    @ApiModelProperty("厚度")

    private Float rawThickness;



    @ApiModelProperty("颜色")

    private String color;



    @ApiModelProperty("总数量")

    private Integer pieces;



    @ApiModelProperty("剩余数量")

    private Integer leftPieces;



    @ApiModelProperty("物料编码")

    private String qrcode;



    @ApiModelProperty("创建时间")



    private Date createTime;







    private Date productionTime;



    @ApiModelProperty("批次号")

    private String batchId;



    @ApiModelProperty("架子编号")

    private String number;



    @ApiModelProperty("工作状态")

    private String state;



    @ApiModelProperty("包号编号")

    private Integer rawPackageId;





    private Date modTime;



    @ApiModelProperty("启用状态")

    private String enableState;



    @ApiModelProperty("上片位编号")

    private String loadRack;





}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/shelfrack/mapper/ShelfRackMapper.java

@@ -3,6 +3,7 @@
import com.baomidou.mybatisplus.core.mapper.BaseMapper;

import com.github.yulichang.base.MPJBaseMapper;

import com.mes.shelfrack.entity.ShelfRack;

import com.mes.shelfrack.entity.request.RawUsageAndShelfRack;



import java.util.List;

import java.util.Map;

@@ -18,5 +19,5 @@
public interface ShelfRackMapper extends MPJBaseMapper<ShelfRack> {





    List<Map<String, Object>> selectshelf_rack();

    List<RawUsageAndShelfRack> selectshelf_rack();

}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/shelfrack/service/ShelfRackService.java

@@ -2,6 +2,7 @@


import com.mes.shelfrack.entity.ShelfRack;

import com.baomidou.mybatisplus.extension.service.IService;

import com.mes.shelfrack.entity.request.RawUsageAndShelfRack;



import java.util.List;

import java.util.Map;

@@ -14,6 +15,6 @@


    List<ShelfRack> findList(ShelfRack params);



    List<Map<String, Object>> selectshelf_rack();

    List<RawUsageAndShelfRack> selectshelf_rack();



}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/shelfrack/service/impl/ShelfRackServiceImpl.java

@@ -7,6 +7,7 @@
import com.github.yulichang.toolkit.JoinWrappers;

import com.mes.common.config.Const;

import com.mes.rawusage.entity.RawUsage;

import com.mes.shelfrack.entity.request.RawUsageAndShelfRack;

import com.mes.shelfrack.mapper.ShelfRackMapper;

import com.mes.shelfrack.entity.ShelfRack;

import com.mes.shelfrack.service.ShelfRackService;

@@ -51,7 +52,7 @@




    @Override

    public  List<Map<String, Object>> selectshelf_rack() {

    public  List<RawUsageAndShelfRack> selectshelf_rack() {

        return baseMapper.selectshelf_rack();

    }




 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/storagetask/controller/StorageTaskController.java

@@ -1,5 +1,7 @@
package com.mes.storagetask.controller;



import com.mes.shelfrack.entity.request.RawUsageAndShelfRack;

import com.mes.storagetask.entity.request.StorageTaskRequest;

import com.mes.utils.Result;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.http.ResponseEntity;

@@ -106,9 +108,22 @@
    @ApiResponses({@ApiResponse(code = 200, message = "查询成功")})

    @GetMapping("/findTasks")

    public Result findLatestTasks() {

        List<Map<String, Object>> result = storageTaskService.Tasks();

        List<StorageTaskRequest> result = storageTaskService.Tasks();

        return Result.success(result);

    }







    @ApiOperation(value = "任务操作", notes = "任务操作")

    @PostMapping("/taskUpdate")

    public Result taskUpdate(@RequestBody Map<String, Object> storageTaskMap) {



        StorageTask task = new StorageTask();

        task.setType((String) storageTaskMap.get("Type")); // 假设Type是存储在Map中的一个键

        task.setId((int) storageTaskMap.get("id"));

        storageTaskService.taskUpdate(task);

        return Result.success();

    }





}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/storagetask/entity/StorageTask.java

@@ -2,11 +2,15 @@


import java.io.Serializable;

import java.util.Date;



import com.baomidou.mybatisplus.annotation.IdType;

import com.baomidou.mybatisplus.annotation.TableId;

import com.baomidou.mybatisplus.annotation.TableName;

import io.swagger.annotations.ApiModel;

import io.swagger.annotations.ApiModelProperty;

import lombok.Data;

import lombok.EqualsAndHashCode;

import org.apache.xmlbeans.impl.xb.xsdschema.Public;

import org.springframework.stereotype.Component;



/**

@@ -27,9 +31,8 @@
    /**

     *   

     */

    @ApiModelProperty(" ")

    private Long id;



    @TableId(value = "id", type = IdType.AUTO)

    private Integer id;

    /**

     *  任务类型

     */

@@ -72,6 +75,8 @@
    @ApiModelProperty("完成时间")

    private Date finishTime;



    @ApiModelProperty("前端任务类型")

    private String Type;





}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/storagetask/entity/request/StorageTaskRequest.java

New file
@@ -0,0 +1,77 @@
package com.mes.storagetask.entity.request;



import com.baomidou.mybatisplus.annotation.IdType;

import com.baomidou.mybatisplus.annotation.TableId;

import io.swagger.annotations.ApiModelProperty;

import lombok.Data;

import lombok.EqualsAndHashCode;



import java.util.Date;



@Data

@EqualsAndHashCode(callSuper = false)

public class StorageTaskRequest {





    private static final long serialVersionUID = 1L;



    /**

     *

     */

    @TableId(value = "id", type = IdType.AUTO)

    private Integer id;

    /**

     * 任务类型

     */

    @ApiModelProperty("任务类型")

    private String taskType;







    @ApiModelProperty("前端任务类型")

    private String Type;



    /**

     * 工作状态

     */

    @ApiModelProperty("工作状态")

    private String taskState;



    /**

     * 仓储架号

     */

    @ApiModelProperty("仓储架号")

    private String shelfRack;



    /**

     * 上片位编号

     */

    @ApiModelProperty("上片位编号")

    private String loadRack;



    /**

     * 线路

     */

    @ApiModelProperty("线路")

    private Integer routeGroup;



    /**

     * 创建时间

     */

    @ApiModelProperty("创建时间")

    private Date startTime;



    /**

     * 完成时间

     */

    @ApiModelProperty("完成时间")

    private Date finishTime;



    @ApiModelProperty("颜色")

    private String color;



    @ApiModelProperty("厚度")

    private Float rawThickness;





}


 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/storagetask/mapper/StorageTaskMapper.java

@@ -2,6 +2,7 @@


import com.baomidou.mybatisplus.core.mapper.BaseMapper;

import com.mes.storagetask.entity.StorageTask;

import com.mes.storagetask.entity.request.StorageTaskRequest;

import org.apache.ibatis.annotations.Param;

import org.springframework.stereotype.Repository;



@@ -19,6 +20,6 @@
public interface StorageTaskMapper extends BaseMapper<StorageTask> {





    List<Map<String, Object>> selectTasks();

    List<StorageTaskRequest>  selectTasks();



}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/storagetask/service/StorageTaskService.java

@@ -2,6 +2,7 @@


import com.mes.storagetask.entity.StorageTask;

import com.baomidou.mybatisplus.extension.service.IService;

import com.mes.storagetask.entity.request.StorageTaskRequest;



import java.util.List;

import java.util.Map;

@@ -17,5 +18,7 @@


    Map<String, Optional<StorageTask>> findLatestTasks();



    List<Map<String, Object>> Tasks();

    List<StorageTaskRequest>  Tasks();



    void taskUpdate(StorageTask storageTask);

}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/java/com/mes/storagetask/service/impl/StorageTaskServiceImpl.java

@@ -3,6 +3,14 @@
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.core.toolkit.Wrappers;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

import com.mes.loadposition.entity.LoadPosition;

import com.mes.loadposition.mapper.LoadPositionMapper;

import com.mes.rawusage.entity.RawUsage;

import com.mes.rawusage.mapper.RawUsageMapper;

import com.mes.shelfrack.entity.ShelfRack;

import com.mes.shelfrack.entity.request.RawUsageAndShelfRack;

import com.mes.shelfrack.mapper.ShelfRackMapper;

import com.mes.storagetask.entity.request.StorageTaskRequest;

import com.mes.storagetask.mapper.StorageTaskMapper;

import com.mes.storagetask.entity.StorageTask;

import com.mes.storagetask.service.StorageTaskService;

@@ -25,6 +33,13 @@


    @Autowired

    private StorageTaskMapper storageTaskMapper;

    @Autowired

    private LoadPositionMapper loadPositionMapper;

    @Autowired

    private ShelfRackMapper shelfRackMapper;

    @Autowired

    private RawUsageMapper rawUsageMapper;





    @Override

    public List<StorageTask> findList(StorageTask params){

@@ -56,12 +71,97 @@




    @Override

    public  List<Map<String, Object>> Tasks() {

    public   List<StorageTaskRequest>  Tasks() {

        return baseMapper.selectTasks();

    }







    @Override

    public void taskUpdate(StorageTask request) {

        Integer taskId = request.getId();

        String taskType = request.getTaskType();

        String Type = request.getType();

        String taskState = request.getTaskState();

        String shelfRack = request.getShelfRack();

        String loadRack = request.getLoadRack();



        if ("重新开始".equals(Type)) {

            StorageTask storageTask = new StorageTask();

            storageTask.setTaskState("等待中");

            LambdaQueryWrapper<StorageTask> queryWrapper = Wrappers.lambdaQuery(StorageTask.class)

                    .eq(StorageTask::getId, request.getId());

            storageTaskMapper.update(request,queryWrapper);

        } else if ("完成".equals(Type)) {

            StorageTask existingTask = storageTaskMapper.selectById(taskId);

            if (existingTask != null && "正在工作".equals(existingTask.getTaskState())) {

                if ("从仓位到上片位".equals(taskType) || "从仓位到吊装位".equals(taskType)) {

                    LoadPosition loadPosition = new LoadPosition();

                    loadPosition.setState("正在使用");

                    loadPosition.setStorageTaskId(request.getId());

                    LambdaQueryWrapper<LoadPosition> queryWrapper = Wrappers.lambdaQuery(LoadPosition.class)

                            .eq(LoadPosition::getNumber, request.getLoadRack());

                    loadPositionMapper.update(loadPosition, queryWrapper);

                    StorageTask storageTask = new StorageTask();

                    storageTask.setTaskState("正在使用");

                    LambdaQueryWrapper<StorageTask> StorageTaskqueryWrapper = Wrappers.lambdaQuery(StorageTask.class)

                            .eq(StorageTask::getId, request.getId());

                    storageTaskMapper.update(request,StorageTaskqueryWrapper);

                } else if ("从上片位到仓位".equals(taskType)) {

                    LoadPosition loadPosition = new LoadPosition();

                    loadPosition.setState("使用中");

                    loadPosition.setStorageTaskId(null);

                    LambdaQueryWrapper<LoadPosition> queryWrapper = Wrappers.lambdaQuery(LoadPosition.class)

                            .eq(LoadPosition::getNumber, request.getLoadRack());

                    loadPositionMapper.update(loadPosition, queryWrapper);

                    ShelfRack loshelfRack = new ShelfRack();

                    LambdaQueryWrapper<RawUsage> RawUsagequeryWrapper = Wrappers.lambdaQuery(RawUsage.class)

                            .eq(RawUsage::getId,loshelfRack.getRawPackageId());

                    RawUsage RawUsage = rawUsageMapper.selectOne(RawUsagequeryWrapper);

                    if(RawUsage.getLeftPieces()==0){

                        loshelfRack.setState("空闲");

                    }else {

                        loshelfRack.setState("使用中");

                    }

                    LambdaQueryWrapper<ShelfRack> loshelfRackqueryWrapper = Wrappers.lambdaQuery(ShelfRack.class)

                            .eq(ShelfRack::getNumber, request.getLoadRack());

                    shelfRackMapper.update(loshelfRack, loshelfRackqueryWrapper);

                } else if ("从吊装位到仓位".equals(taskType)) {

                    LoadPosition loadPosition = new LoadPosition();

                    loadPosition.setState("空闲");

                    loadPosition.setStorageTaskId(null);

                    LambdaQueryWrapper<LoadPosition> queryWrapper = Wrappers.lambdaQuery(LoadPosition.class)

                            .eq(LoadPosition::getNumber, request.getLoadRack());

                    loadPositionMapper.update(loadPosition, queryWrapper);

                    ShelfRack loshelfRack = new ShelfRack();

                    LambdaQueryWrapper<RawUsage> RawUsagequeryWrapper = Wrappers.lambdaQuery(RawUsage.class)

                            .eq(RawUsage::getId,loshelfRack.getRawPackageId());

                    RawUsage RawUsage = rawUsageMapper.selectOne(RawUsagequeryWrapper);

                    if(RawUsage.getLeftPieces()==1){

                        loshelfRack.setEnableState("启用");

                    }else {

                        loshelfRack.setEnableState(loshelfRack.getEnableState());

                    }

                    loadPosition.setState("使用中");

                    LambdaQueryWrapper<ShelfRack> loshelfRackqueryWrapper = Wrappers.lambdaQuery(ShelfRack.class)

                            .eq(ShelfRack::getNumber, request.getLoadRack());

                    shelfRackMapper.update(loshelfRack, loshelfRackqueryWrapper);

                }

                StorageTask storageTask = new StorageTask();

                storageTask.setTaskState("已完成");

                LambdaQueryWrapper<StorageTask> StorageTaskqueryWrapper = Wrappers.lambdaQuery(StorageTask.class)

                        .eq(StorageTask::getId, request.getId());

                storageTaskMapper.update(storageTask, StorageTaskqueryWrapper);

            }

        } else if ("删除".equals(Type)) {



            LambdaQueryWrapper<StorageTask> StorageTaskqueryWrapper = Wrappers.lambdaQuery(StorageTask.class)

                    .eq(StorageTask::getId, request.getId());

            storageTaskMapper.delete(StorageTaskqueryWrapper);

        }

    }









}

 hangzhoumesParent/moduleService/GlassStorageModule/src/main/resources/mapper/ShelfRackMapper.xml

@@ -2,15 +2,24 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">

<mapper namespace="com.mes.shelfrack.mapper.ShelfRackMapper">





        <select id="selectshelf_rack" resultType="java.util.Map">

        <![CDATA[

            SELECT a.number, b.raw_type, b.raw_width, b.raw_height, b.raw_thickness, b.left_pieces, a.mod_time, a.enable_state, b.pieces,

                   datediff(now(), b.create_time) as rukutime,

                   concat(if(ROUND(b.left_pieces / b.pieces * 100, 0) < 20, 20, ROUND(b.left_pieces / b.pieces * 100, 0)), '%') as bfb

            FROM shelf_rack AS a

                     LEFT JOIN raw_usage AS b ON a.raw_package_id = b.id

            ]]>

    </select>

    <resultMap id="ShelfRackResultMap" type="com.mes.shelfrack.entity.request.RawUsageAndShelfRack">

        <result property="number" column="number"/>

        <result property="rawType" column="raw_type"/>

        <result property="rawWidth" column="raw_width"/>

        <result property="rawHeight" column="raw_height"/>

        <result property="rawThickness" column="raw_thickness"/>

        <result property="enableState" column="enable_state"/>

        <result property="pieces" column="pieces"/>

        <result property="createTime" column="createTime"  />

        <result property="batchId" column="batch_id"/>

    </resultMap>

    <select id="selectshelf_rack" resultMap="ShelfRackResultMap">

    <![CDATA[

        SELECT a.number, b.raw_type, b.raw_width, b.raw_height, b.raw_thickness, a.enable_state, b.pieces,

               b.batch_id,DATE_FORMAT(b.create_time, '%Y-%m-%d %H:%i:%s') as createTime

        FROM shelf_rack AS a

                 LEFT JOIN raw_usage AS b ON a.raw_package_id = b.id

        ]]>

</select>



</mapper>


 hangzhoumesParent/moduleService/GlassStorageModule/src/main/resources/mapper/StorageTaskMapper.xml

@@ -3,8 +3,21 @@
<mapper namespace="com.mes.storagetask.mapper.StorageTaskMapper">





    <resultMap id="StorageTaskRequest" type="com.mes.storagetask.entity.request.StorageTaskRequest">

        <result property="loadRack" column="load_rack"/>

        <result property="color" column="color"/>

        <result property="taskState" column="task_state"/>

        <result property="shelfRack" column="shelf_rack"/>

        <result property="startTime" column="start_time"/>

        <result property="rawThickness" column="raw_thickness"/>

        <result property="routeGroup" column="route_group"/>

        <result property="id" column="id"  />

        <result property="taskType" column="task_type"/>

    </resultMap>



    <select id="selectTasks" resultType="java.util.Map">





    <select id="selectTasks" resultMap="StorageTaskRequest">

        <![CDATA[

        SELECT d.*, g.raw_thickness, g.color

        FROM (


 hangzhoumesParent/moduleService/GlassStorageModule/src/test/java/mes/GlassStorageModuleApplicationTest.java

@@ -1,6 +1,9 @@
package mes;

import com.mes.GlassStorageApplication;
import com.mes.rawusage.entity.RawUsage;
import com.mes.rawusage.service.RawUsageService;
import com.mes.shelfrack.entity.ShelfRack;
import com.mes.shelfrack.service.ShelfRackService;
import com.mes.storagetask.entity.StorageTask;
import com.mes.storagetask.service.StorageTaskService;
@@ -30,6 +33,8 @@
    private StorageTaskService storageTaskService;
    @Autowired
    private ShelfRackService shelfRackService;
    @Autowired
    private RawUsageService rawUsageService;


    @Test
@@ -57,6 +62,13 @@



    @Test
    public void updateRawPackageAndStorageRack() {
        RawUsage raw=new RawUsage();

        raw.setId(null);
        rawUsageService.updateRawPackageAndStorageRack(raw);
    }




 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/downworkstation/controller/DownWorkstationController.java

@@ -77,17 +77,9 @@
        // 调用 DownWorkstationService 中的方法清除指定工位ID的信息
        int workstationId = (int) requestData.get("workstationId");

        int totalWorkstations = downWorkstationService.getTotalQuantity(workstationId);
        int downWorkstations = downWorkstationService.getRacksNumber(workstationId);


        if (downWorkstations == totalWorkstations) {
            downWorkstationService.clearFlowCardId(workstationId);
            return Result.build(200, "清除工位信息成功", 1);
        } else {
            // 如果总数量和落架数量不一致，返回错误响应
            return Result.build(500, "清除工位信息失败", 1);
        }



        // 构建响应数据

 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/job/DownLoadCacheGlassTask.java

@@ -134,13 +134,15 @@
        log.info("2、查询卧式理片笼里面的空格:{}", nearestEmpty);
        GlassInfo glassInfo = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>().eq(GlassInfo::getGlassId, glassId));
        Assert.isFalse(null == glassInfo, "玻璃信息不存在");
        if ("1".equals(requestWord) && (glassInfo.getWidth() > throughWidth || glassInfo.getHeight() > throughHeight)) {
            log.info("玻璃当前尺寸宽：{}，高：{}只能直通，当前进片任务需等待", glassInfo.getWidth(), glassInfo.getHeight());
        double glassWidth = Math.max(glassInfo.getWidth(), glassInfo.getHeight());
        double glassHeight = Math.min(glassInfo.getWidth(), glassInfo.getHeight());
        if ("1".equals(requestWord) && (glassWidth > throughWidth || glassHeight > throughHeight)) {
            log.info("玻璃当前尺寸宽：{}，高：{}只能直通，当前进片任务需等待", glassWidth, glassHeight);
            return;
        }
        Boolean checkFlag = Boolean.FALSE;
        //玻璃尺寸是否走人工下片
        if (glassInfo.getWidth() > maxWidth || glassInfo.getHeight() > maxHeight || glassInfo.getWidth() < minWidth || glassInfo.getHeight() < minHeight) {
        if (glassWidth > maxWidth || glassHeight > maxHeight || glassWidth < minWidth || glassHeight < minHeight) {
            log.info("该玻璃尺寸不符合要求，需要走人工下片直接进片");
        } else {
            log.info("该玻璃尺寸非人工下片");
@@ -148,6 +150,7 @@
            DownWorkstation one = downWorkstationService.getOne(new LambdaQueryWrapper<DownWorkstation>()
                    .eq(DownWorkstation::getLayer, glassInfo.getLayer())
                    .eq(DownWorkstation::getFlowCardId, glassInfo.getFlowCardId()));
            //是否已经绑定   true：已绑定    false:未绑定
            Boolean isBind = Boolean.FALSE;
            if (null != one) {
                log.info("该流程卡已绑定架子");
@@ -157,7 +160,7 @@
            if (!checkFlag && !isBind) {
                log.info("该玻璃的流程卡未绑定架子，获取是否有空架子");
                List<DownWorkstation> list = downWorkstationService.list(new LambdaQueryWrapper<DownWorkstation>()
                        .isNull(DownWorkstation::getFlowCardId).orderByDesc(DownWorkstation::getWorkstationId));
                        .and(on -> on.isNull(DownWorkstation::getFlowCardId).or().eq(DownWorkstation::getFlowCardId, "")).orderByDesc(DownWorkstation::getWorkstationId));
                if (CollectionUtils.isNotEmpty(list)) {
                    log.info("有空架子,将流程卡与架子好绑定，执行进片任务 结束");
                    //绑定流程卡
@@ -176,28 +179,31 @@
                    endLoop:
                    for (DownGlassInfoDTO e : downGlassInfoDTOList) {
                        List<GlassInfo> glassInfoList = e.getGlassInfoList();
                        Optional<GlassInfo> glassInfoTempOptional = glassInfoList.stream().filter(item -> item.getWidth() == glassInfo.getWidth() && item.getHeight() == glassInfo.getHeight()
                                && item.getThickness() == glassInfo.getThickness() && item.getFilmsid().equals(glassInfo.getFilmsid()))
                                .findFirst();
                        if (glassInfoTempOptional.isPresent()) {
                            GlassInfo item = glassInfoTempOptional.get();
                            //玻璃是否为多层
                            checkFlag = multilayerCheck(item, Boolean.FALSE);
                            if (checkFlag) {
                                //玻璃替换 仅替换流程卡id及层数
                                String tempFlowCardId = item.getFlowCardId();
                                Integer tempLayer = item.getLayer();
                                String flowCardId = glassInfo.getFlowCardId();
                                Integer layer = glassInfo.getLayer();
                                log.info("替换流程卡信息,当前玻璃信息:{}的流程卡号{}及层数{},替换后玻璃信息:{}的流程卡号{}及层数{}",
                                        item, glassInfo, flowCardId, layer, tempFlowCardId, tempLayer);
                                glassInfo.setFlowCardId(tempFlowCardId);
                                glassInfo.setLayer(tempLayer);
                                glassInfoService.updateById(glassInfo);
                                item.setFlowCardId(flowCardId);
                                item.setLayer(layer);
                                glassInfoService.updateById(item);
                                break endLoop;
                        List<GlassInfo> glassInfoTempList = glassInfoList.stream().filter(item -> item.getWidth() == glassInfo.getWidth() && item.getHeight() == glassInfo.getHeight()
                                && item.getThickness() == glassInfo.getThickness() && item.getFilmsid().equals(glassInfo.getFilmsid())).collect(Collectors.toList());
                        if (CollectionUtils.isNotEmpty(glassInfoTempList)) {
                            for (GlassInfo item : glassInfoTempList) {
                                //玻璃是否为多层：1、先获取当前流程卡落架最多的层数，如果为空，表明未绑定流程卡，未落架，然后按照是否可绑定架子决定是否替换。（可忽略不计，本校验仅在前一次调用起作用）
//                                          2、判断落架最多的层数是否为当前替换玻璃的层数，是  则走替换逻辑返回true
//                                          3、不是最多的层数，获取落架最多层数的相同次序的玻璃尺寸与当前替换玻璃的尺寸比较，相同走替换，否则继续循环
//                                          4、单层玻璃直接走替换
                                checkFlag = multilayerCheck(item, Boolean.FALSE);
                                if (checkFlag) {
                                    //玻璃替换 仅替换流程卡id及层数
                                    String tempFlowCardId = item.getFlowCardId();
                                    Integer tempLayer = item.getLayer();
                                    String flowCardId = glassInfo.getFlowCardId();
                                    Integer layer = glassInfo.getLayer();
                                    log.info("替换流程卡信息,当前玻璃信息:{}的流程卡号{}及层数{},替换后玻璃信息:{}的流程卡号{}及层数{}",
                                            item, glassInfo, flowCardId, layer, tempFlowCardId, tempLayer);
                                    glassInfo.setFlowCardId(tempFlowCardId);
                                    glassInfo.setLayer(tempLayer);
                                    glassInfoService.updateById(glassInfo);
                                    item.setFlowCardId(flowCardId);
                                    item.setLayer(layer);
                                    glassInfoService.updateById(item);
                                    break endLoop;
                                }
                            }
                        }
                    }
@@ -210,7 +216,6 @@
        downStorageCageDetails.setState(Const.GLASS_STATE_IN);
        downStorageCageDetails.setSlot(nearestEmpty.getSlot());
        downStorageCageDetailsService.save(downStorageCageDetails);

        //        生成进片任务
        initDownGlassTask(glassInfo, 0, nearestEmpty.getSlot(), Const.GLASS_CACHE_TYPE_IN);
    }
@@ -221,9 +226,9 @@
            log.info("G06、G11、G13分别为{},{}、{}非自动状态，无法出片", glassStatus06, glassStatus11, glassStatus13);
            return Boolean.FALSE;
        }

        List<DownStorageCageDetails> tempList = downStorageCageDetailsService.list(new LambdaQueryWrapper<DownStorageCageDetails>()
                .eq(DownStorageCageDetails::getState, Const.GLASS_STATE_IN));
        log.info("出片1、笼内的玻璃信息有：{}", tempList);
        //获取待进片玻璃
        DownStorageCageDetails cageDetails = new DownStorageCageDetails();
        if (StringUtils.isNotBlank(glassId)) {
@@ -234,12 +239,15 @@
            cageDetails.setSlot(empty.getSlot());
            tempList.add(cageDetails);
        }

        log.info("笼内玻璃的数据有：{}", tempList);
        log.info("出片2：笼内玻璃的数据(包括待进片)有：{}", tempList);
        if (CollectionUtils.isEmpty(tempList)) {
            log.info("笼内没有玻璃,无法执行出片");
            return Boolean.FALSE;
        }
        //优先走08片台的玻璃：走人工下片或者2号机械臂
        //1、08台忙碌，仅走1号机械臂
        //2、08台空闲，先走扔工下片或2号机械臂，无玻璃出片 在走1号机械臂
        //机械臂被禁用的情况下不能继续向禁用的机械臂放玻璃
        Boolean flag08 = "1".equals(out08Glassstate) ? Boolean.TRUE : Boolean.FALSE;
        if (!flag08) {
            generateTaskByShelf(glassStatus06, glassStatus11, flag08, glassStatus13, tempList, cageDetails, glassId);
@@ -248,7 +256,6 @@
                return generateTaskByShelf(glassStatus06, glassStatus11, !flag08, glassStatus13, tempList, cageDetails, glassId);
            }
        }

        return Boolean.TRUE;
    }

@@ -264,7 +271,6 @@
                    log.info("架子已经占满，多层玻璃无法找到对应的格子，需执行替换玻璃的操作");
                    return Boolean.FALSE;
                }

            }
            if (downGlassInfoDTO.getLayer().equals(glassInfo.getLayer())) {
                log.info("当前玻璃的流程在架子上落架最多 直接进片");
@@ -293,7 +299,6 @@
            glassStatus13, List<DownStorageCageDetails> tempList, DownStorageCageDetails cageDetails, String glassId) {
        //获取2个机械臂范围内的架子绑定的流程卡信息
        List<Integer> workList = new ArrayList();

        if (flag08) {
            if (!"2".equals(glassStatus11)) {
                workList.addAll(Const.G11_WORK_STATION);
@@ -306,51 +311,59 @@
        List<Integer> workStationAll = Arrays.asList(1, 2, 3, 4, 5, 6);
        List<Integer> offWorkStationList = workStationAll.stream().filter(e -> !workList.contains(e)).collect(Collectors.toList());
        List<DownStorageCageDetails> list = new ArrayList();
        //是否有空架子 true：有   false:无
        Boolean isEmptyShelf = Boolean.FALSE;
        //对笼内玻璃进行过滤，仅出符合逻辑的玻璃
        if (CollectionUtils.isNotEmpty(workList)) {
            List<DownWorkstation> downWorkstationList = downWorkstationService.list(new LambdaQueryWrapper<DownWorkstation>()
                    .eq(DownWorkstation::getEnableState, Const.SLOT_ON).in(DownWorkstation::getWorkstationId, workList));
//            log.info("架子被禁用，无法出片落架");
            if (CollectionUtils.isEmpty(downWorkstationList)) {
                log.info("笼子被禁用，无法走机械臂下片");
                //走人工下片
                if (!"2".equals(glassStatus13)) {
                    list = tempList.stream().filter(item -> item.getWidth() > maxWidth || item.getHeight() > maxHeight).collect(Collectors.toList());
                if (flag08 && !"2".equals(glassStatus13)) {
                    list = tempList.stream().filter(item -> {
                        double firstLength = Math.max(item.getWidth(), item.getHeight());
                        double secondLength = Math.min(item.getWidth(), item.getHeight());
                        return firstLength > maxWidth || secondLength > maxHeight;
                    }).collect(Collectors.toList());
                }
            } else {
                //获取可落架的的架子信息（包括空架子）
                List<DownWorkstation> workstationsIsNotBind = downWorkstationList.stream().filter(item -> null == (item.getFlowCardId())).collect(Collectors.toList());
                //将架子的流程卡号及层数作为key
                //仅获取空架子信息
                List<DownWorkstation> workstationsIsNotBind = downWorkstationList.stream().filter(item -> StringUtils.isBlank(item.getFlowCardId())).collect(Collectors.toList());
                //将架子的流程卡号及层数作为key  不存在空架子的情况
                if (CollectionUtils.isEmpty(workstationsIsNotBind)) {
                    log.info("不存在未绑定流程卡架子");
                    //筛选出对应架子已绑定流程卡可下片的玻璃
                    Map<String, List<DownWorkstation>> listMap = downWorkstationList.stream()
                            .filter(item -> null != (item.getFlowCardId())).collect(Collectors.groupingBy(item -> item.getFlowCardId() + ":" + item.getLayer()));
                            .filter(item -> StringUtils.isNotBlank(item.getFlowCardId())).collect(Collectors.groupingBy(item -> item.getFlowCardId() + ":" + item.getLayer()));
                    //过滤筛选获取架子上对应流程卡+层数的笼子内的玻璃信息
                    list = tempList.stream().filter(item -> listMap.containsKey(item.getFlowCardId() + ":" + item.getLayer())).collect(Collectors.toList());
                } else {
                    log.info("存在未绑定流程卡架子，直接获取笼内所有玻璃,且未绑定架子的玻璃信息");
                    //获取禁用架子的流程号，将笼内绑定架子且架子被禁用的流程卡信息

                    //获取禁用及非本机械臂的架子的流程号及层数对应的玻璃信息
                    List<DownWorkstation> downWorkstationOffList = downWorkstationService.list(new LambdaQueryWrapper<DownWorkstation>()
                            .and(i -> i.in(DownWorkstation::getWorkstationId, offWorkStationList).or().eq(DownWorkstation::getEnableState, Const.SLOT_OFF)));
                    //获取被禁用的流程卡信息
                    //获取被禁用的流程卡信息 为空：将返回笼内的所有玻璃信息
                    if (CollectionUtils.isEmpty(downWorkstationOffList)) {
                        list = tempList;
                    } else {
                        Map<String, List<DownWorkstation>> listOffMap = downWorkstationOffList.stream().filter(item -> null != (item.getFlowCardId())).collect(Collectors.groupingBy(item -> item.getFlowCardId() + ":" + item.getLayer()));
                        //笼内存在无法出片的玻璃信息，过滤无法出片的玻璃信息，仅获取可出片的玻璃信息   无法出片的玻璃为：未绑定架子、绑定架子被禁用、非本机械臂对应的架子
                        Map<String, List<DownWorkstation>> listOffMap = downWorkstationOffList.stream().filter(item -> StringUtils.isNotBlank(item.getFlowCardId())).collect(Collectors.groupingBy(item -> item.getFlowCardId() + ":" + item.getLayer()));
                        list = tempList.stream().filter(item -> !listOffMap.containsKey(item.getFlowCardId() + ":" + item.getLayer())).collect(Collectors.toList());
                    }
                    //空架子表示置为true
                    isEmptyShelf = Boolean.TRUE;
                    //todo:如果禁用架子已绑定流程卡，因为时间不确定，笼子内的玻璃可重新绑定新架子
//                    list = tempList.stream().filter(item -> !listMap.containsKey(item.getFlowCardId() + ":" + item.getLayer())).collect(Collectors.toList());

                }
            }
        } else {
            if (flag08 && !"2".equals(glassStatus13)) {
                //直接走人工下片
                list = tempList.stream().filter(item -> item.getWidth() > maxWidth || item.getHeight() > maxHeight).collect(Collectors.toList());
                list = tempList.stream().filter(item -> {
                    double firstLength = Math.max(item.getWidth(), item.getHeight());
                    double secondLength = Math.min(item.getWidth(), item.getHeight());
                    return firstLength > maxWidth || secondLength > maxHeight;
                }).collect(Collectors.toList());
            }
        }
        if (CollectionUtils.isEmpty(list)) {
@@ -358,10 +371,12 @@
            return Boolean.FALSE;
        }
        String tempGlassId = null;
        Boolean isBind = Boolean.FALSE;
        Boolean isNeedBind = Boolean.FALSE;

        for (DownStorageCageDetails item : list) {
            if (item.getWidth() > maxWidth || item.getHeight() > maxHeight) {
            double firstLength = Math.max(item.getWidth(), item.getHeight());
            double secondLength = Math.min(item.getWidth(), item.getHeight());
            if (firstLength > maxWidth || secondLength > maxHeight) {
                if (flag08 && !"2".equals(glassStatus13)) {
                    log.info("玻璃宽度或高度超出阈值，执行人工下片");
                    tempGlassId = item.getGlassId();
@@ -378,7 +393,7 @@
                //架子都未绑定流程卡，出笼内子数量最多尺寸最大的玻璃id,无  则返回扫描扫到的玻璃id进行出片
                tempGlassId = downStorageCageDetailsService.getGlassInfoMaxCount(glassId, offWorkStationList);

                isBind = Boolean.TRUE;
                isNeedBind = Boolean.TRUE;
                break loop;
            }
            //将笼子内的玻璃进行过滤，仅获取无法落架的流程卡玻璃
@@ -391,7 +406,7 @@
                if (isEmptyShelf) {
                    //架子都未绑定流程卡，出笼内子数量最多尺寸最大的玻璃id,无  则返回扫描扫到的玻璃id进行出片
                    tempGlassId = downStorageCageDetailsService.getGlassInfoMaxCount(glassId, offWorkStationList);
                    isBind = Boolean.TRUE;
                    isNeedBind = Boolean.TRUE;
                    break loop;
                }
            }
@@ -409,16 +424,13 @@
                    DownGlassInfoDTO downGlassInfoDTO = downGlassInfoService.queryDownGlassMaxLayer(item.getFlowCardId());
                    if (null == downGlassInfoDTO) {
//                    历史落架玻璃按照相关流程卡取数据库未找到最多玻璃信息，表明当前流程卡下的有层的玻璃均未落架，直接可出当前玻璃
                        log.info("");
                        isBind = Boolean.FALSE;
                        tempGlassId = item.getGlassId();
                        log.info("当前流程卡不存在落架的玻璃，可直接出片落架，玻璃id:{}", tempGlassId);
                        break loop;
                    }
                    if (downGlassInfoDTO.getLayer().equals(downGlassInfoDTO.getLayer())) {
                        log.info("当前玻璃的流程在架子上落架最多,直接出片");
                        //更新玻璃状态，生成出片任务
                        tempGlassId = item.getGlassId();
                        isBind = Boolean.FALSE;
                        log.info("当前玻璃的流程在架子上落架最多,直接出片，玻璃id:{}", tempGlassId);
                        break loop;
                    }
                    Integer sequence = downGlassInfoService.queryMaxSequence(item.getFlowCardId(), item.getLayer());
@@ -427,10 +439,8 @@
                            .eq(DownGlassInfo::getFlowCardId, downGlassInfoDTO.getFlowCardId())
                            .eq(DownGlassInfo::getLayer, downGlassInfoDTO.getLayer()).eq(DownGlassInfo::getSequence, sequence));
                    if (null != downGlassInfoDTO && downGlassInfo.getWidth() == item.getWidth() && downGlassInfo.getHeight() == item.getHeight()) {
                        log.info("相同次序玻璃对应上，可执行进片任务");
                        //更新玻璃状态，生成出片任务
                        tempGlassId = item.getGlassId();
                        isBind = Boolean.FALSE;
                        log.info("相同次序玻璃对应上，可执行进片任务，玻璃id:{}", tempGlassId);
                        break loop;
                    }
                }
@@ -445,7 +455,6 @@
                        List<DownStorageCageDetails> downStorageCageDetails = singleLayerMap.get(e.getFlowCardId() + e.getLayer());
                        if (CollectionUtils.isNotEmpty(downStorageCageDetails)) {
                            tempGlassId = downStorageCageDetails.get(0).getGlassId();
                            isBind = Boolean.FALSE;
                            break;
                        }
                    }
@@ -457,12 +466,12 @@
            return Boolean.FALSE;
        } else {
            //按照出片的玻璃id更新笼内的玻璃状态为已出片
            return generateDownGlassOutTask(tempGlassId, Const.GLASS_CACHE_TYPE_OUT, isBind, cageDetails, workList);
            return generateDownGlassOutTask(tempGlassId, Const.GLASS_CACHE_TYPE_OUT, isNeedBind, cageDetails, workList);
        }
    }

    public Boolean generateDownGlassOutTask(String glassId, Integer taskType, Boolean
            isBind, DownStorageCageDetails cageDetails, List<Integer> workList) {
            isNeedBind, DownStorageCageDetails cageDetails, List<Integer> workList) {
        //按玻璃id获取玻璃信息
        DownStorageCageDetails downStorageCageDetails = null;
        if (glassId.equals(cageDetails.getGlassId())) {
@@ -486,10 +495,10 @@
        }

        Integer endCell = null;
        if (isBind) {
        if (isNeedBind) {
            //获取空架子信息，将空架子信息绑定流程卡
            DownWorkstation emptyDownWorkstation = downWorkstationService.getOne(new LambdaQueryWrapper<DownWorkstation>()
                    .isNull(DownWorkstation::getFlowCardId).in(DownWorkstation::getWorkstationId, workList).orderByDesc(DownWorkstation::getWorkstationId).last("limit 1"));
                    .and(on -> on.isNull(DownWorkstation::getFlowCardId).or().eq(DownWorkstation::getFlowCardId, "")).in(DownWorkstation::getWorkstationId, workList).orderByDesc(DownWorkstation::getWorkstationId).last("limit 1"));
            if (null != emptyDownWorkstation) {
                log.info("获取到空架子信息，绑定流程卡");
                downWorkstationService.updateFlowCardIdAndCount(downStorageCageDetails.getFlowCardId(), emptyDownWorkstation.getWorkstationId(), downStorageCageDetails.getLayer());
@@ -515,7 +524,7 @@
        //生成任务信息
        DownGlassInfo downGlassInfo = new DownGlassInfo();
        BeanUtils.copyProperties(downStorageCageDetails, downGlassInfo);
        //todo：落架片序
        //落架片序
        downGlassInfo.setSequence(downGlassInfoService.queryMaxSequence(downGlassInfo.getFlowCardId(), downGlassInfo.getLayer()));
        downGlassInfoService.save(downGlassInfo);
        //生成任务信息