更新

严智鑫

2024-03-26 8202416bb5fae55d50fd1d598acc56d79846f776

更新

 CacheGlassModule/.vs/CacheVerticalGlassModule/v16/.suo

Binary files differ

 CacheGlassModule/.vs/ProjectSettings.json

New file
@@ -0,0 +1,3 @@
{
  "CurrentProjectSetting": null
}

 CacheGlassModule/.vs/VSWorkspaceState.json

New file
@@ -0,0 +1,6 @@
{
  "ExpandedNodes": [
    ""
  ],
  "PreviewInSolutionExplorer": false
}

 CacheGlassModule/.vs/slnx.sqlite

Binary files differ

 CacheGlassModule/pom.xml

@@ -9,9 +9,9 @@
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.MES-Module</groupId>
    <artifactId>MES-Module</artifactId>
    <artifactId>MES-UnLoadGlassModule</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>MES-Module</name>
    <name>MES-UnLoadGlassModule</name>
    <description>project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
@@ -115,7 +115,7 @@
            <artifactId>spring-boot-starter-cache</artifactId>
        </dependency>


        <!--  rabbitmq    -->
        <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
@@ -148,7 +148,39 @@
            <version>2.13.0</version>
        </dependency>

<!--websocket-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>
        <dependency>
            <groupId>com.github.xingshuangs</groupId>
            <artifactId>iot-communication</artifactId>
            <version>1.4.2</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-websocket</artifactId>
        </dependency>

        <dependency>
            <groupId>com.google.code.gson</groupId>
            <artifactId>gson</artifactId>
            <version>2.8.9</version>
        </dependency>
        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi</artifactId>
            <version>5.2.4</version>
        </dependency>

        <dependency>
            <groupId>org.apache.poi</groupId>
            <artifactId>poi-ooxml</artifactId>
            <version>5.2.4</version>
        </dependency>

        <!--websocket-->
<!--        <dependency>-->
<!--            <groupId>org.springframework.boot</groupId>-->
<!--            <artifactId>spring-boot-starter-websocket</artifactId>-->
@@ -159,6 +191,10 @@
            <artifactId>netty-all</artifactId>
            <version>4.1.36.Final</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-jpa</artifactId>
        </dependency>

    </dependencies>


 CacheGlassModule/src/main/java/com/mes/controller/OrderTestController.java

@@ -1,22 +1,35 @@
package com.mes.controller;

import com.mes.mapper.OrderTestMapper;
import com.mes.mapper.SelectInfo;

import java.util.List;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import com.mes.common.Result;
import com.mes.entity.Tempered;
import com.mes.service.pp.SelectdppService;

//@CrossOrigin  //解决单个controller 跨域问题
@RestController
@RequestMapping("/order11111111")
@RequestMapping("/Temper")

public class OrderTestController {
    @Autowired
    private OrderTestMapper orderMapper;
    private SelectInfo SelectInfo;

//    @GetMapping //查询order表结果集
//    public Result index(){
//        return Result.seccess(orderMapper.findAll());
//
//    }
    @Autowired
    private SelectdppService SelectppService;

   @GetMapping("/Tindex") //查询order表结果集
   @ResponseBody
   public Result index(){
       System.out.println(1);
       List<Tempered> h=SelectppService.getSelectTempered("P24030707");
       System.out.println(h.size());
       return Result.seccess(h);
    
   }
//
//    @PostMapping  //插入
//    public Integer save(@RequestBody Order order) {

 CacheGlassModule/src/main/java/com/mes/entity/BigStorageCage.java

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

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`big_storage_cage`")
public class BigStorageCage {
    @TableId(type = IdType.AUTO)
    private  Integer id;//大理片笼表id
    private  Integer device_id;//设备id
    private  String slot;//栅格号
    private  String enable_state;//启用状态
    private  Integer remain_width;//剩余宽度

}

 CacheGlassModule/src/main/java/com/mes/entity/BigStorageCageDetails.java

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

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`big_storage_cage_details`")
public class BigStorageCageDetails {
    @TableId(type = IdType.AUTO)
    private  Integer id;//大理片笼详情表id
    private  Integer deviceid;//设备id
    private  Integer slot;//栅格号
    private  Integer glassid;//玻璃id
    private  Integer sequence;//小片在格内的顺序
    private  String flowcardid;//流程卡号
    private  Integer glasstype;//玻璃类型
    private  Double width;//宽
    private  Double height;//高
    private  Double thickness;//厚度
    private  Integer temperinglayoutid;//钢化版图id
    private  Integer temperingfeedsequence;//钢化版图片序
    private  Integer state;//状态
    private  Integer gap;//玻璃间隙

}

 CacheGlassModule/src/main/java/com/mes/entity/DownGlassInfo.java

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

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`down_glass_info`")
public class DownGlassInfo {
    @TableId(type = IdType.AUTO)
    private  Integer id;//下片玻璃信息表id
    private  String flowcardid;//流程卡号
    private  Integer sequence;//顺序
    private  Integer width;//宽
    private  Integer height;//高
    private  Integer thickness;//厚度

}

 CacheGlassModule/src/main/java/com/mes/entity/DownStorageCage.java

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

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`down_storage_cage`")
public class DownStorageCage {
    @TableId(type = IdType.AUTO)
    private  Integer id;//下片前理片笼表id
    private  Integer deviceid;//设备id
    private  String slot;//栅格号
    private  String enablestate;//启用状态
    private  Integer remainwidth;//剩余

}

 CacheGlassModule/src/main/java/com/mes/entity/DownStorageCagedetails.java

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

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`down_storage_cage_details`")
public class DownStorageCagedetails {
    @TableId(type = IdType.AUTO)
    private  Integer id;//下片前理片笼明细表id
    private  Integer deviceid;//设备id
    private  Integer slot;//栅格号
    private  Integer glassid;//玻璃id
    private  Integer sequence;//小片在格内的顺序
    private  String flow_card_id;//流程卡号
    private  Integer glass_type;//玻璃类型
    private  Double width;//宽
    private  Double height;//高
    private  Double thickness;//厚度
    private  Integer temperinglayoutid;//钢化版图id
    private  Integer tempering_feed_sequence;//钢化版图片序
    private  Integer state;//状态
    private  Integer gap;//玻璃间隙

}

 CacheGlassModule/src/main/java/com/mes/entity/DownWorkstation.java

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

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`down_workstation`")
public class DownWorkstation {
    @TableId(type = IdType.AUTO)
    private  Integer id;//下片工位表id
    private  Integer flowcard_id;//工位id
    private  String glass_type;//流程卡号
    private  Integer width;//设备id
    private  Integer height;//启用状态
    private  Integer thickness;//工作状态

}

 CacheGlassModule/src/main/java/com/mes/entity/EdgStorageCage.java

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

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`edg_storage_cage`")
public class EdgStorageCage {
    @TableId(type = IdType.AUTO)
    private  Integer id;//磨边前理片笼表id
    private  Integer flowcard_id;//设备id
    private  String glass_type;//栅格号
    private  String height;//启用状态
    private  Integer thickness;//剩余

}

 CacheGlassModule/src/main/java/com/mes/entity/EdgStorageCageDetails.java

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

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`edg_storage_cage_details`")
public class EdgStorageCageDetails {
    @TableId(type = IdType.AUTO)
    private  Integer id;//磨边前理片笼详情表id
    private  Integer deviceid;//设备id
    private  Integer slot;//栅格号
    private  Integer glassid;//玻璃id
    private  Integer sequence;//小片在格内的顺序
    private  String flowcardid;//流程卡号
    private  Integer glasstype;//玻璃类型
    private  Double width;//宽
    private  Double height;//高
    private  Double thickness;//厚度
    private  Double edgwidth;//磨前宽
    private  Double edgheight;//磨前高
    private  Integer temperinglayoutid;//钢化版图id
    private  Integer temperingfeedsequence;//钢化版图片序
    private  Integer patternsequence;//原片顺序
    private  Integer state;//状态 
    private  Integer gap;//玻璃间隙

}

 CacheGlassModule/src/main/java/com/mes/entity/Engineering.java

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

import java.math.BigInteger;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`engineering`")
public class Engineering {
    @TableId(type = IdType.AUTO)
    private  BigInteger id;//工程表id
    private  Integer engineerid;//工程号
    private  String engineername;//工程名称
    private  Double avgavailability;//平均利用率
    private  Double validavailability;//有效利用率
    private  Double lastavailability;//尾片利用率
    private  Integer state;//状态
    private  Integer glasstotal;//小片总数
    private  Double glasstotalarea;//小片总面积
    private  Integer planpatterntotal;//计划原片总数
    private  Double planpatterntotalarea;//计划原片总面积
    private  Integer realitypatterntotal;//实际原片总数
    private  Double realitypatterntotalarea;//实际原片总面积
    private  Integer filmsid;//膜系id
    private  String notes;//备注

}

 CacheGlassModule/src/main/java/com/mes/entity/GlassFilms.java

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

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`glass_films`")
public class GlassFilms {
    @TableId(type = IdType.AUTO)
    private  Integer id;//膜系表id
    private  Integer films_id;//膜系id
    private  String films_name;//膜系


}

 CacheGlassModule/src/main/java/com/mes/entity/GlassInfo.java

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

import java.math.BigInteger;

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`glass_info`")
public class GlassInfo {
    @TableId(type = IdType.AUTO)
    private  BigInteger id;//玻璃信息表id
    private  String flowcardid;//流程卡
    private  Integer glasstype;//流程卡玻璃类型
    private  Double width;//宽
    private  Double height;//高
    private  Double thickness;//厚度
    private  Integer filmsid;//膜系
    private  Double edgwidth;//磨前宽
    private  Double edgheight;//磨前高
    private  Integer ismultiple;//是否配片
    private  Double maxwidth;//配片最大宽
    private  Double maxheight;//配片最大高
    private  Integer ishorizontal;//钢化是否接受横放
    private  Integer patternsequence;//原片顺序
    private  Integer temperinglayoutid;//钢化版图id
    private  Integer temperingfeedsequence;//钢化版图片序
    private  Integer xcoordinate;//x坐标
    private  Integer ycoordinate;//y坐标
    private  Integer angle;//旋转角度（逆时针）

}

 CacheGlassModule/src/main/java/com/mes/entity/Tempered.java

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

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("v_optimize_heat_layout")
public class Tempered {
    private  String projectno;//工程号
    private  String glassthickness;//厚度
    private  String glasstype;//类型
    private  String loadrate;//装载率
    private  String furnacesqty;//钢化炉数
    private  String glasstotal;//玻璃数量
    private  String glasstotalarea;//玻璃面积
    private  String layoutid;//版图ID
    private  String layoutrate;//当前版图装载率
    private  String glassqty;//当前版图玻璃数量
    private  String loadwidth;//炉宽
    private  String loadlength;//炉长
    private  String xspace;//X间隔
    private  String width;//宽
    private  String height;//高
    private  String yspace;//Y间隔
    private  String xaxis;//坐标
    private  String yaxis;//坐标
    private  String rotateangle;//旋转角度
    private  String processid;//流程卡
    private  String id;//版图优化玻璃ID
    private  String glassid;//玻璃ID
    private  String sort;//玻璃ID

}

 CacheGlassModule/src/main/java/com/mes/entity/Tempering.java

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

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`tempering_glass_info`")
public class Tempering {
    @TableId(type = IdType.AUTO)
    private  Integer id;//钢化小片信息表id
    private  String flowcard_id;//流程卡
    private  Integer glass_type;//流程卡玻璃类型
    private  Double width;//宽
    private  Double height;//高
    private  Double thickness;//厚度
    private  Integer filmsid;//膜系
    private  Integer ishorizontal;//钢化是否接受横放
    private  Integer tempering_layout_id;//钢化版图id
    private  Integer tempering_feed_sequence;//钢化版图片序
    private  Integer x_coordinate;//x坐标
    private  Integer y_coordinate;//y坐标
    private  Integer angle;//旋转角度（逆时针）
    private  Integer state;//状态

}

 CacheGlassModule/src/main/java/com/mes/entity/UpPattenUsage.java

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

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`up_patten_usage`")
public class UpPattenUsage {
    @TableId(type = IdType.AUTO)
    private  Integer id;//原片使用情况表id
    private  Integer engineeringid;//工程号
    private  Integer filmsid;//膜系id
    private  Double width;//宽
    private  Double height;//高
    private  Double thickness;//厚度
    private  Integer layoutsequence;//原片版图片序
    private  Integer state;//状态

}

 CacheGlassModule/src/main/java/com/mes/entity/UpWorkstation.java

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

import com.baomidou.mybatisplus.annotation.IdType;
import com.baomidou.mybatisplus.annotation.TableId;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@Data  //lombok 简写java代码 实体类的get与set
@TableName("`up_workstation`")
public class UpWorkstation {
    @TableId(type = IdType.AUTO)
    private  Integer id;//上片工位表id
    private  Integer workstationid;//工位号
    private  Integer deviceid;//设备id
    private  Integer enablestate;//启用状态
    private  Integer workstate;//工作状态
    private  Double patternwidth;//原片宽
    private  Double patternheigth;//原片高
    private  Double patternthickness;//原片厚度
    private  Integer filmsid;//膜系
    private  Integer number;//数量

}

 CacheGlassModule/src/main/java/com/mes/mapper/SelectInfo.java

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

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.mes.entity.GlassInfo;
import com.mes.entity.OrderTest;
import com.mes.entity.Tempered;

import java.util.List;

import org.apache.ibatis.annotations.*;

@Mapper
public interface SelectInfo {
    //玻璃信息  按ID查询
    @Select("select * from `glass_info` where id=#{id}")
    GlassInfo SelectGlassId(String id);

    //钢化按工程查询
    @Select("select * from `v_optimize_heat_layout` where project_no=#{projeceid} ")
    List<Tempered> SelectTempered(String projeceid);
//
//    @Insert("INSERT `order`(order_id)VALUES(#{order_id})")
//    Integer insert(Order order);
//
//    @Delete("delete from `order` where id=#{id}")
//    Integer deleteById(@Param("id") Integer id);
//
//    @Update("update `order` set order_id=#{order_id} where id=#{id}")
//    Integer update(@Param("id") Integer id,@Param("order_id") String order_id);
}

 CacheGlassModule/src/main/java/com/mes/mapper/userInfo/SysMenuItemMapper.java

@@ -2,11 +2,12 @@

import com.mes.entity.userInfo.SysMenuItem;
import org.apache.ibatis.annotations.Mapper;
import org.apache.ibatis.annotations.Select;

import java.util.List;

@Mapper
public interface SysMenuItemMapper {

     @Select("select  * from sys_menu_item")
     List<SysMenuItem> findAll() ;
}

 CacheGlassModule/src/main/java/com/mes/mapper/userInfo/UserMapper.java

@@ -15,9 +15,8 @@
    List<User> findAll();

    User findOne(Integer id);
    
    @Select("select user_name FROM `user` where login_name=#{LoginName}  ")

    @Select("select user_name FROM `user` where login_name=#{LoginName}  ")
    User findOneLoginName(String LoginName);

    @Select("select count(id) FROM `user` where login_name=#{userName} and password=#{password}  ")

 CacheGlassModule/src/main/java/com/mes/service/CacheGlassService/Logic.java

New file
@@ -0,0 +1,77 @@
package com.mes.service.CacheGlassService;

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

import com.mes.common.PlcTools.S7control;
import com.mes.entity.GlassInfo;
import com.mes.mapper.SelectInfo;


@Service
public class Logic {
    @Autowired
    private SelectInfo selectInfo;
    //识别逻辑
    public void identify(String Number){
        //查询任务
        // PlcParameterObject plcmes=PLCAutoMes.PlcMesObject;
        // S7control.getinstance().WriteWord(plcmes.getPlcParameter("MESToGaStatus").getAddress(),(short) 1);
        boolean isexist=isExist(Number);
        if (isexist) {
            //存在逻辑    1.添加信息 2.回复PLC存在
            //S7control.getinstance().WriteWord(plcmes.getPlcParameter("MESToGaStatus").getAddress(),(short) 1);
        }else {
            //不存在逻辑  1.回复PLC不存在
            //S7control.getinstance().WriteWord(plcmes.getPlcParameter("MESToGaStatus").getAddress(),(short) 2);
        }
    }
    //理片 进
    public void process(String imagePath){
        //查询消息队列里的玻璃

        //返回结果
    }
    //理片 出
    public void processOut(String imagePath){
        //查询任务

        //返回结果
    }
    //磨边
    public void processMb(String imagePath){
        //查询任务

        //返回结果
    }

    //查询消息队列里此玻璃ID的数据   
    public boolean SelectMessageId(String Number){
        //查询是否存在
        GlassInfo GlassInfo=selectInfo.SelectGlassId(Number);
        if(GlassInfo==null){
            return false;//返回 不存在
        }
        return true;//返回 存在
    }
    //删除消息队列里此玻璃ID的数据   
    public boolean DeleteMessageId(String Number){
        //查询是否存在
        GlassInfo GlassInfo=selectInfo.SelectGlassId(Number);
        if(GlassInfo==null){
            return false;//返回 不存在
        }
        return true;//返回 存在
    }
    //是否存在此编号玻璃 
    public boolean isExist(String Number){
        //查询是否存在
        GlassInfo GlassInfo=selectInfo.SelectGlassId(Number);
        if(GlassInfo==null){
            return false;//返回 不存在
        }
        return true;//返回 存在
    }
    
}


 CacheGlassModule/src/main/java/com/mes/service/ModuleB.java

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

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import com.rabbitmq.client.DeliverCallback;

import java.util.HashMap;
import java.util.Map;

public class ModuleB {
    private final static String QUEUE_NAME = "hangzhou2";

    public static void main(String[] argv) throws Exception {
        // 创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("10.153.19.150");
        //factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 声明队列
            Map<String, Object> args = new HashMap<>();
            args.put("x-max-length-bytes",20000);
//            args.put("x-max-length",5000);
            channel.queueDeclare(QUEUE_NAME, false, false, false, args);

            // 创建消费者
            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String receivedMessage = new String(delivery.getBody(), "UTF-8");
                System.out.println(" [x] Received '" + receivedMessage + "'");
            };
            // 开始消费消息
          channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> {
           });
        }
    }
}


 CacheGlassModule/src/main/java/com/mes/service/MqMessage.java

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


import java.util.List;

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






@Service
public class MqMessage {
    @Autowired
    private RabbitMQUtils rabbitMQUtils;

    public boolean Add(String message, String queueName,String messageId){
        try {
            return rabbitMQUtils.sendMessageWithId(message, queueName,messageId);
        } catch (Exception e) {
            // TODO: handle exception
            return false;//异常时错误
        }
    }
    //根据ID查找消息
    public String SelectId(String queueName,boolean isDelete,String messageId){

        try {
            String content=rabbitMQUtils.consumeMessageById(messageId,queueName,isDelete);
            
            return content;
        } catch (Exception e) {
            // TODO: handle exception
            return null;//异常时错误
        } 
    }
    public boolean Delete(String queueName,String messageId){
        try
        {
            rabbitMQUtils.consumeMessageById(messageId,queueName,false);
            return true;
        }catch(Exception e){
            return false;
        }
        
    }
    //无修改
    public void Update(){
        
    }
    
    
}


 CacheGlassModule/src/main/java/com/mes/service/RabbitMQUtils.java

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

import com.fasterxml.jackson.databind.ObjectMapper;
import com.rabbitmq.client.*;

import java.util.*;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

import org.springframework.stereotype.Repository;

@Repository
public class RabbitMQUtils {
    // ObjectMapper对象，用于序列化和反序列化JSON
    private static ObjectMapper objectMapper = new ObjectMapper();
    private static String host = "10.153.19.150"; // RabbitMQ 主机名
    private static Map<String, Object> args = new HashMap<>(); // 队列参数

    static {
        // 设置队列参数
        args.put("x-max-length-bytes", 1024 * 1024);
    }

    //    private static  Map<String, Object> args = new HashMap<>();
//     args.put("x-max-length-bytes",1024 * 1024);
    // 发送消息到 RabbitMQ 队列中
    public String sendMessage(String message, String queueName) throws Exception {
        // 创建连接工厂并设置主机名
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);

        // 使用 try-with-resources 语句创建连接和通道，并发送消息
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 声明队列
            channel.queueDeclare(queueName, false, false, false, args);

            // 发布消息到队列
            channel.basicPublish("", queueName, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "' to queue '" + queueName + "'");
        }

        return message;
    }


    // 从 RabbitMQ 队列中接收消息
    public String receiveMessage(String queueName) throws Exception {
        // 创建连接工厂并设置主机名
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);

        // 创建阻塞队列
        BlockingQueue<String> messageQueue = new ArrayBlockingQueue<>(1);

        // 使用 try-with-resources 语句创建连接和通道，并接收消息
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 声明队列
            channel.queueDeclare(queueName, false, false, false, args);

            // 设置消息接收回调
            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String receivedMessage = new String(delivery.getBody(), "UTF-8");
               // System.out.println(" [x] Received '" + receivedMessage + "'");

                // 将接收到的消息放入阻塞队列
                try {
                    messageQueue.put(receivedMessage);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };

            // 消费队列中的消息
            channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {

            });

            // 阻塞并等待获取消息
            return messageQueue.take();
        }
    }


    //获取消息  并消费？
    public List<String> readMessage(String queueName,boolean is) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);
        List<String> messages = new ArrayList<>();
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            boolean autoAck = false;

            GetResponse response = channel.basicGet(queueName, autoAck);
            if (response != null) {
                String message = new String(response.getBody(), "UTF-8");
                messages.add(message);
                // 手动确认消息处理完成
                if(is){
                    long deliveryTag = response.getEnvelope().getDeliveryTag();
                    channel.basicAck(deliveryTag, false);
                }

            }
        }

        return messages;
    }



    private static Set<String> sentMessageIds = new HashSet<>();
//根据id发送消息
    public boolean sendMessageWithId(String queueName, String message, String messageId) throws Exception {
        if (sentMessageIds.contains(messageId)) {
            System.err.println("Message with ID " + messageId + " has already been sent.");
            return false; // 消息重复，发送失败
        }

        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);

        try (Connection connection = factory.newConnection(); Channel channel = connection.createChannel()) {
            channel.queueDeclare(queueName, false, false, false, args);

            AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
                    .messageId(messageId)
                    .build();

            channel.basicPublish("", queueName, properties, message.getBytes("UTF-8"));
            System.out.println("Sent message with ID: " + messageId);

            sentMessageIds.add(messageId); // 将 messageId 添加到已发送集合中

            return true; // 消息成功发送
        } catch (Exception e) {
            System.err.println("Failed to send message: " + e.getMessage());
            return false; // 消息发送失败
        }
    }
    //根据id查找消息   是否删除
    public String consumeMessageById(String messageId,String queueName,boolean isDelete) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);

        try (Connection connection = factory.newConnection(); Channel channel = connection.createChannel()) {
            channel.queueDeclare(queueName, false, false, false, args);

            GetResponse response;
            while ((response = channel.basicGet(queueName, false)) != null) {
                String receivedMessage = new String(response.getBody(), "UTF-8");
                if (response.getProps().getMessageId().equals(messageId)) {
                    if(isDelete){
                        long deliveryTag = response.getEnvelope().getDeliveryTag();
                        channel.basicAck(deliveryTag, false);
                    }
                    System.out.println("Selected message: "+messageId+ receivedMessage);
                    return receivedMessage; // 返回选定的消息内容
                } else {
                    // 对于不符合条件的消息，进行 Nack 操作
//                    long deliveryTag = response.getEnvelope().getDeliveryTag();
//                    channel.basicNack(deliveryTag, false, true);
                    return "Specified message not found in the queue.";
                }
            }

            return "Specified message not found in the queue.";
        }
    }

//     //消费指定消息
//     public String consumeSelectedMessage(int messageToConsume, String queueName) throws Exception {
//         ConnectionFactory factory = new ConnectionFactory();
//         factory.setHost(host);

//         try (Connection connection = factory.newConnection(); Channel channel = connection.createChannel()) {
//             channel.queueDeclare(queueName, false, false, false, args);

//             for (int i = 0; i < messageToConsume; i++) {
//                 GetResponse response = channel.basicGet(queueName, false);
//                 if (response == null) {
//                     return "Queue does not have enough messages.";
//                 }
// //                long deliveryTag = response.getEnvelope().getDeliveryTag();
// //                channel.basicAck(deliveryTag, false);
//             }

//             GetResponse selectedResponse = channel.basicGet(queueName, false);
//             if (selectedResponse != null) {
//                 byte[] body = selectedResponse.getBody();
//                 String selectedMessage = new String(body, "UTF-8");
//                 long deliveryTag = selectedResponse.getEnvelope().getDeliveryTag();
//                 channel.basicAck(deliveryTag, false);
//                 return selectedMessage;
//             } else {
//                 return "Specified message not found in the queue.";
//             }
//         }
//     }

    // 发送 JSON 消息到队列
    public boolean sendJsonMessage(Object message, String queueName) throws Exception {
        // 创建连接工厂并设置主机名
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);

        // 使用 try-with-resources 语句创建连接和通道，并发送 JSON 消息
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 声明队列
            channel.queueDeclare(queueName, false, false, false, args);

            // 将对象转换为 JSON 字符串
            String jsonMessage = objectMapper.writeValueAsString(message);

            // 发布 JSON 消息到队列
            channel.basicPublish("", queueName, null, jsonMessage.getBytes());
            System.out.println(" [x] Sent JSON message: '" + jsonMessage + "' to queue '" + queueName + "'");

            return true; // 发送消息成功
        } catch (Exception e) {
            e.printStackTrace();
            return false; // 发送消息失败
        }
    }

    // 接收 JSON 消息并转换为对象
    public <T> T receiveJsonMessage(Class<T> valueType, String queueName) throws Exception {
        // 创建连接工厂并设置主机名
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);

        // 使用 try-with-resources 语句创建连接和通道，并接收 JSON 消息
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 声明队列
            channel.queueDeclare(queueName, false, false, false, args);

            // 获取队列中的消息
            GetResponse response = channel.basicGet(queueName, true);
            if (response != null) {
                byte[] body = response.getBody();
                String jsonMessage = new String(body, "UTF-8");
                System.out.println(" [x] Received JSON message: '" + jsonMessage + "' from queue '" + queueName + "'");

                // 将 JSON 消息转换为对象
                return objectMapper.readValue(jsonMessage, valueType);
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null; // 接收消息失败
        }
    }

}

//    RabbitMQUtils.sendMessage("Hello, world!", "module_queue");
//RabbitMQUtils.receiveMessage("module_queue");
//RabbitMQUtils.sendJsonMessage(someObject, "another_queue");
//RabbitMQUtils.receiveJsonMessage(SomeClass.class, "another_queue");
// 需要将 someObject 替换为你要发送的对象，并将 SomeClass 替换为你要接收并转换的对象类型。

 CacheGlassModule/src/main/java/com/mes/service/RabbitMQUtils33.java

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

import com.fasterxml.jackson.databind.ObjectMapper;
import com.rabbitmq.client.*;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;

public class RabbitMQUtils33 {
    // ObjectMapper对象，用于序列化和反序列化JSON
    private static ObjectMapper objectMapper = new ObjectMapper();
    private static String host = "10.153.19.150"; // RabbitMQ 主机名
    private static Map<String, Object> args = new HashMap<>(); // 队列参数

    static {
        // 设置队列参数
        args.put("x-max-length-bytes", 1024 * 1024);
    }

    //    private static  Map<String, Object> args = new HashMap<>();
//     args.put("x-max-length-bytes",1024 * 1024);
    // 发送消息到 RabbitMQ 队列中
    public boolean sendMessage(String message, String queueName) throws Exception {
        // 创建连接工厂并设置主机名
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);

        // 使用 try-with-resources 语句创建连接和通道，并发送消息
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 声明队列
            channel.queueDeclare(queueName, false, false, false, args);

            // 发布消息到队列
            channel.basicPublish("", queueName, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "' to queue '" + queueName + "'");
            return true;
        } catch (Exception e) {
            // TODO: handle exception
            return false;
        }
        
        
    }


    // 从 RabbitMQ 队列中接收消息
    public String receiveMessage(String queueName) throws Exception {
        // 创建连接工厂并设置主机名
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);

        // 创建阻塞队列
        BlockingQueue<String> messageQueue = new ArrayBlockingQueue<>(1);

        // 使用 try-with-resources 语句创建连接和通道，并接收消息
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 声明队列
            channel.queueDeclare(queueName, false, false, false, args);

            // 设置消息接收回调
            DeliverCallback deliverCallback = (consumerTag, delivery) -> {
                String receivedMessage = new String(delivery.getBody(), "UTF-8");
               // System.out.println(" [x] Received '" + receivedMessage + "'");

                // 将接收到的消息放入阻塞队列
                try {
                    messageQueue.put(receivedMessage);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            };

            // 消费队列中的消息
            channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {

            });

            // 阻塞并等待获取消息
            return messageQueue.take();
        }
    }



    public List<String> readMessage(String queueName,boolean isDelete) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);
        List<String> messages = new ArrayList<>();
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            boolean autoAck = false;

            GetResponse response = channel.basicGet(queueName, autoAck);
            if (response != null) {
                String message = new String(response.getBody(), "UTF-8");
                messages.add(message);

                
                // 手动确认消息处理完成
                if (isDelete) {
                    long deliveryTag = response.getEnvelope().getDeliveryTag();
                    channel.basicAck(deliveryTag, false);
                }
            }
        }

        return messages;
    }

    // 发送 JSON 消息到队列
    public static boolean sendJsonMessage(Object message, String queueName) throws Exception {
        // 创建连接工厂并设置主机名
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);

        // 使用 try-with-resources 语句创建连接和通道，并发送 JSON 消息
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 声明队列
            channel.queueDeclare(queueName, false, false, false, args);

            // 将对象转换为 JSON 字符串
            String jsonMessage = objectMapper.writeValueAsString(message);

            // 发布 JSON 消息到队列
            channel.basicPublish("", queueName, null, jsonMessage.getBytes());
            System.out.println(" [x] Sent JSON message: '" + jsonMessage + "' to queue '" + queueName + "'");

            return true; // 发送消息成功
        } catch (Exception e) {
            e.printStackTrace();
            return false; // 发送消息失败
        }
    }

    // 接收 JSON 消息并转换为对象
    public static <T> T receiveJsonMessage(Class<T> valueType, String queueName) throws Exception {
        // 创建连接工厂并设置主机名
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost(host);

        // 使用 try-with-resources 语句创建连接和通道，并接收 JSON 消息
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            // 声明队列
            channel.queueDeclare(queueName, false, false, false, args);

            // 获取队列中的消息
            GetResponse response = channel.basicGet(queueName, true);
            if (response != null) {
                byte[] body = response.getBody();
                String jsonMessage = new String(body, "UTF-8");
                System.out.println(" [x] Received JSON message: '" + jsonMessage + "' from queue '" + queueName + "'");

                // 将 JSON 消息转换为对象
                return objectMapper.readValue(jsonMessage, valueType);
            } else {
                return null;
            }
        } catch (Exception e) {
            e.printStackTrace();
            return null; // 接收消息失败
        }
    }

}

//    RabbitMQUtils.sendMessage("Hello, world!", "module_queue");
//RabbitMQUtils.receiveMessage("module_queue");
//RabbitMQUtils.sendJsonMessage(someObject, "another_queue");
//RabbitMQUtils.receiveJsonMessage(SomeClass.class, "another_queue");
// 需要将 someObject 替换为你要发送的对象，并将 SomeClass 替换为你要接收并转换的对象类型。

 CacheGlassModule/src/main/java/com/mes/service/pp/SelectdppService.java

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

import cn.hutool.core.util.StrUtil;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.mes.common.CacheUtil;
import com.mes.common.Result;
import com.mes.entity.GlassInfo;
import com.mes.entity.Tempered;
import com.mes.entity.userInfo.User;
import com.mes.mapper.SelectInfo;
import com.mes.mapper.userInfo.UserMapper;
import com.mes.controller.dto.UserDTO;
import com.mes.tools.TokenTools;
import org.apache.ibatis.jdbc.Null;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.cache.annotation.CacheEvict;
import org.springframework.cache.annotation.Cacheable;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.List;

@Service
@DS("pp")
public class SelectdppService {

    @Autowired
    private SelectInfo SelectInfo;

    public GlassInfo getUserInfo(String process_id){
        return SelectInfo.SelectGlassId(process_id);
    }

    public List<Tempered> getSelectTempered(String process_id){
        return SelectInfo.SelectTempered(process_id);
    }

    
}


 CacheGlassModule/src/main/resources/application.yml

@@ -1,8 +1,8 @@

server:
  port: 8081
  port: 8080
  servlet:
   context-path: /CacheGlassModule
   context-path: /mesModuleTools

spring:
  datasource:

 CacheGlassModule/target/classes/application.yml

@@ -1,8 +1,8 @@

server:
  port: 8081
  port: 8080
  servlet:
   context-path: /CacheGlassModule
   context-path: /mesModuleTools

spring:
  datasource:

 CacheVerticalGlassModule/.vs/CacheVerticalGlassModule/v16/.suo

Binary files differ

 CacheVerticalGlassModule/.vs/ProjectSettings.json

New file
@@ -0,0 +1,3 @@
{
  "CurrentProjectSetting": null
}

 CacheVerticalGlassModule/.vs/VSWorkspaceState.json

New file
@@ -0,0 +1,6 @@
{
  "ExpandedNodes": [
    ""
  ],
  "PreviewInSolutionExplorer": false
}

 CacheVerticalGlassModule/.vs/slnx.sqlite

Binary files differ

 CacheVerticalGlassModule/src/main/java/com/mes/mapper/userInfo/UserMapper.java

@@ -16,7 +16,9 @@

    User findOne(Integer id);

    @Select("select user_name FROM `user` where login_name=#{LoginName}  ")
    User findOneLoginName(String LoginName);

    @Select("select count(id) FROM `user` where login_name=#{userName} and password=#{password}  ")
    int  checkUser(@Param("userName") String userName,@Param("password") String password);


 CacheVerticalGlassModule/target/classes/application.yml

New file
@@ -0,0 +1,32 @@

server:
  port: 8080
  servlet:
   context-path: /mesModuleTools

spring:
  datasource:
    dynamic:
      primary: user_info #设置默认的数据源或者数据源组,默认值即为master
      strict: false #设置严格模式,默认false不启动. 启动后在未匹配到指定数据源时候回抛出异常,不启动会使用默认数据源.
      datasource:
        user_info:
          url: jdbc:mysql://10.153.19.150:3306/erp_user_info?serverTimezone=GMT%2b8
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
        sd:
          url: jdbc:mysql://10.153.19.150:3306/sd?serverTimezone=GMT%2b8
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
        mm:
          url: jdbc:mysql://10.153.19.150:3306/mm?serverTimezone=GMT%2b8
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
        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

 TemperingGlassModule/target/classes/application.yml

New file
@@ -0,0 +1,32 @@

server:
  port: 8080
  servlet:
   context-path: /mesModuleTools

spring:
  datasource:
    dynamic:
      primary: user_info #设置默认的数据源或者数据源组,默认值即为master
      strict: false #设置严格模式,默认false不启动. 启动后在未匹配到指定数据源时候回抛出异常,不启动会使用默认数据源.
      datasource:
        user_info:
          url: jdbc:mysql://10.153.19.150:3306/erp_user_info?serverTimezone=GMT%2b8
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
        sd:
          url: jdbc:mysql://10.153.19.150:3306/sd?serverTimezone=GMT%2b8
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
        mm:
          url: jdbc:mysql://10.153.19.150:3306/mm?serverTimezone=GMT%2b8
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
        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

 UI-Project/src/views/TL/Temperedlayout/SelectLayout.vue

New file
@@ -0,0 +1,176 @@
<script setup>

import {reactive} from "vue";
import {useRouter} from  'vue-router'
let router=useRouter()
const getTableRow = (row,type) =>{
  switch (type) {
    case 'edit' :{
      //alert('我接收到子组件传送的编辑信息')
      router.push({path: '/main/ingredients/CreateIngredients', query: { id: row.id }})
      break
    }
    case 'delete':{
      alert('我接收到子组件传送的删除信息')
      break
    }
  }
}



//子组件接收参数

const gridOptions = reactive({
  border:  "full",//表格加边框
  keepSource: true,//保持源数据
  align: 'center',//文字居中
  stripe:true,//斑马纹
  rowConfig: {isCurrent: true, isHover: true,height: 50},//鼠标移动或选择高亮
  id: 'CustomerList',
  showFooter: true,//显示脚
  printConfig: {},
  importConfig: {},
  exportConfig: {},
  scrollY:{ enabled: true },//开启虚拟滚动
  showOverflow:true,
  columnConfig: {
    resizable: true,
    useKey: true
  },
  filterConfig: {   //筛选配置项
    remote: true
  },
  customConfig: {
    storage: true
  },
  editConfig: {
    trigger: 'click',
    mode: 'row',
    showStatus: true
  },//表头参数
  columns:[
    {type:'expand',fixed:"left",slots: { content:'content' },width: '50'},
    // { type: 'checkbox',fixed:"left", title: '选择', width: '80' },
    {title: '操作', width: '110', slots: { default: 'button_slot' },fixed:"left"},
    { type: 'seq',fixed:"left", title: '自序', width: '80' },
    {field: 'materialCode', width:'150', title: '物料编码', sortable: true,editRender: { name: 'input', attrs: { placeholder: '' } } },
    {field: 'materialName', width: '150',title: '物料名称', sortable: true,showOverflow:"ellipsis" ,filters:[{ data: '' }],slots: { filter: 'num1_filter' }},
    {field: 'origin', width: '120',title: '产地', sortable: true,filters:[{ data: '' }],slots: { filter: 'num1_filter' }},
    {field: 'width', width: '100',title: '宽度', sortable: true},
    {field: 'height',width: '100', title: '高度', sortable: true,showOverflow:"ellipsis"},
    {field: 'thickness', width: '80',title: '厚度', sortable: true},
    {field: 'model',width: '100', title: '型号', sortable: true},
    {field: 'conversionRate', width: '100',title: '换算率', sortable: true},
    {field: 'unit',width: '100', title: '单位', sortable: true},
    {field: 'conversionUnit', width: '80',title: '换算单位', sortable: true},
    {field: 'shelfLife',width: '100', title: '保质期', sortable: true},
    {field: 'weight', width: '100',title: ' 重量', sortable: true},
    {field: 'quantity',width: '110', title: '数量', sortable: true},
    {field: 'inventoryOrganization',width: '100', title: '库存组织', sortable: true},
    {field: 'remark',width: '80', title: '备注', sortable: true},

  ],//表头按钮
  toolbarConfig: {

    import: false,
    export: true,
    print: true,
    zoom: true,
    custom: true
  },
  data:  [
    {
      "materialCode": 700900000000941,
      "materialName": "丝袜防晒手套套袖",
      "origin": "00",
      "width": "00",
      "height": "00",
      "thickness":'00',
      "model": "服饰",
      "conversionRate": "1000",
      "unit": "双",
      "conversionUnit": "1",
      "shelfLife": "12个月",
      "weight": "0.0000",
      "quantity": "10000",
      "inventoryOrganization": "人工库",
      "remark": "测试",
    },
    {
      "materialCode": 700900000000941,
      "materialName": "丝袜防晒手套套袖",
      "origin": "00",
      "width": "00",
      "height": "00",
      "thickness":'00',
      "model": "服饰",
      "conversionRate": "1000",
      "unit": "双",
      "conversionUnit": "1",
      "shelfLife": "12个月",
      "weight": "0.0000",
      "quantity": "10000",
      "inventoryOrganization": "人工库",
      "remark": "测试",
    },
  ],//table body实际数据
  footerMethod ({ columns, data }) {//页脚函数
    return[
      columns.map((column, columnIndex) => {
        if (columnIndex === 0) {
          return '合计:'
        }
        // if (props.tableProp.footList.includes(column.field)) {
        //   return sumNum(data, column.field)
        // }
        return ''
      })
    ]
  }

})



</script>

<template>
  <div class="main-div-customer">
    <vxe-grid
        max-height="100%"
        @filter-change="filterChanged"
        class="mytable-scrollbar"
        ref="xGrid"
        v-bind="gridOptions"

    >
      <!--      @toolbar-button-click="toolbarButtonClickEvent"-->
      <!--      下拉显示所有信息插槽-->
      

      <!--左边固定显示的插槽-->
      <template #button_slot="{ row }">
        <el-button @click="getTableRow(row,'edit')" link type="primary" size="small">编辑</el-button>
        <el-button @click="getTableRow(row,'delete')" link type="primary" size="small">删除</el-button>
      </template>
      <!--      下拉详情循环显示中文   -->
      <template #num1_filter="{ column, $panel }">
        <div>
          <div v-for="(option, index) in column.filters" :key="index">
            <input type="type" v-model="option.data" @input="changeFilterEvent($event, option, $panel)"/>
          </div>
        </div>
      </template>


    </vxe-grid>
  </div>
</template>

<style scoped>
.main-div-customer{
  width: 99%;
  height: 100%;
}
</style>

 UI-Project/src/views/TL/Temperedlayout/Temperedlayout.vue

New file
@@ -0,0 +1,207 @@
<!--  物料资料  -->


<script setup>
import { ref } from "vue";
import { ArrowLeftBold, ArrowRight, Search } from "@element-plus/icons-vue";
import request from "@/utils/request";
import deepClone from "@/utils/deepClone";
import { ElMessage } from "element-plus";
import { useRouter } from "vue-router";
import GlassType from '@/components/basic/product/GlassType.vue'


const router = useRouter()
let indexFlag = $ref(1)
function changeRouter(index) {
  indexFlag = index
}


</script>

<script>
export default {
  mounted() {
    //获取数据
    request.get("/Temper/Tindex").then((res) => {
      if (res.code == 200) {
        var StoveCount=0;
        var temperid;
        for(var i=0;i<res.data.length;i++){
          if (temperid != res.data[i].layoutid) {
            StoveCount++;
            temperid=res.data[i].layoutid;
          }
        }   
        // console.log(res.data);
        this.CanvaDraws("mycanvas",res.data,StoveCount);
        
      } else {
        ElMessage.warning(res.msg)
        router.push("/login")
      }
    });

    

  },
  methods: {
    //Canva(id,基础数据,页面长：实际长，显示行内版图数， )
    //基础数据：实际炉长,实际炉宽, 小片X轴, 小片y轴, 小片长, 小片宽，显示数据（尺寸,ID,流程卡号,版图号）
    CanvaDraws(id,Datas,StoveCount) {
        //var StoveCount=43;//炉数
        var ArrangementMode='linefeed';//排布方式：linefeed(换行) /Wholeline  整行
        var RowMaxCount=4;//每行最多显示的图数
        var StoveWidth=3000; //实际炉宽 2850
        var StoveLength=5500;//实际炉长 5000
        var StoveColor='#CFC8C5';//炉子背景颜色
        

        var StoveIntervalX=30; //页面每一炉之间的间距X  px
        var StoveIntervalY=50; //页面每一炉之间的间距Y  px

        var HtmlWidth=1800;   //页面横向
        //var actualWidth=12000;//页面横向所对应的实际长度
        var actualWidth=StoveWidth*RowMaxCount;//页面横向所对应的实际长度

        var Bli = actualWidth / (HtmlWidth-StoveIntervalX*RowMaxCount);//比例：实际长度mm/页面长度px

        var StoveCross=StoveWidth/Bli;   //页面炉子横向 像素
        var StoveVertical=StoveLength/Bli;//页面炉子纵向 像素

        var Font1=(StoveCross*0.05);
        var Font2=(StoveCross*0.028);
        // var TerritoryWidth=dataTempered.loadwidth; //实际版图宽
        //   var TerritoryLength=dataTempered.loadlength;//实际版图长
        //   var TerritoryColor='#0DB637';//版图背景颜色

        //   var TerritoryCross=TerritoryWidth/Bli;   //页面版图横向 像素
        //   var TerritoryVertical=TerritoryLength/Bli;//页面版图纵向 像素
        console.log(Font1);
        
        var canva = this.$refs[id];
        var content = canva.getContext('2d');
        canva.width = HtmlWidth;
        canva.height = StoveCount%RowMaxCount==0?((StoveVertical+StoveIntervalY)*(StoveCount/RowMaxCount)):((StoveVertical+StoveIntervalY)*(StoveCount/RowMaxCount+1));
        //console.log(StoveCount%RowMaxCount==0?((StoveVertical+StoveIntervalY)*(StoveCount/RowMaxCount)):((StoveVertical+StoveIntervalY)*(StoveCount/RowMaxCount+1)) );
        var temperid;//初始版图
        var Xlayout = 0; //炉子X轴起点
        var Ylayout = StoveIntervalY; //炉子Y轴起点
        var layoutCount = 0;//版图数
        var row=0;
        for (var i = 0; i < Datas.length; i++) {
          var dataTempered = Datas[i];

          var TerritoryWidth=dataTempered.loadwidth; //实际版图宽
          var TerritoryLength=dataTempered.loadlength;//实际版图长
          var TerritoryColor='#0DB637';//版图背景颜色

          var TerritoryCross=TerritoryWidth/Bli;   //页面版图横向 像素
          var TerritoryVertical=TerritoryLength/Bli;//页面版图纵向 像素

          if (temperid != dataTempered.layoutid) {
            //画版图  更改基础倍数
            if(layoutCount>0){
              Xlayout += StoveCross + StoveIntervalX;
              if (layoutCount %RowMaxCount== 0) {
                //换行
                Ylayout += StoveVertical+StoveIntervalY;
                Xlayout=0;
                row++;
              }
            }
            temperid=dataTempered.layoutid;
            layoutCount++;
            content.font ='bold '+Font1+'px Arial' ; //文字样式：加粗 16像素 字体Arial
            content.fillStyle = '#000000'; //字体颜色
            content.textAlign = 'center'; //文字居中
            content.fillText((dataTempered.layoutid), (StoveCross / 2+ Xlayout), 50/2+(StoveVertical+50)*row+10);
            //炉子
            content.fillStyle = StoveColor;
            content.fillRect(Xlayout, Ylayout, StoveCross, StoveVertical);
            //版图
            content.fillStyle = TerritoryColor;
            content.fillRect(Xlayout, Ylayout, TerritoryCross, TerritoryVertical);
          }
          
          var Rx = dataTempered.xaxis / Bli + Xlayout;
          var Ry = dataTempered.yaxis / Bli + Ylayout;
          var Rwidth = dataTempered.width / Bli;
          var Rheight = dataTempered.height / Bli;
          var Xwidth;
          var Xheight;
          content.fillStyle = '#5CADFE';
          if (dataTempered.rotateangle != 0) {
            Xwidth = Rwidth;
            Xheight = Rheight;
          } else {
            Xwidth = Rheight;
            Xheight = Rwidth;
          }
          content.fillRect(Rx, Ry, Xwidth, Xheight);
          content.font = 'bold '+Font2+'px Arial' ; //文字样式：加粗 16像素 字体Arial
          content.fillStyle = '#000000'; //字体颜色
          content.textAlign = 'center'; //文字居中

          content.fillText(('版图:'+dataTempered.layoutid+'-'+dataTempered.sort), (Xwidth / 2) + Rx, (Xheight) / 2 + Ry-Font2);
          content.fillText((dataTempered.width + '  *  ' + dataTempered.height), (Xwidth / 2) + Rx, (Xheight) / 2 + Ry); //fillText里面的可填写的值(文本内容, x坐标, y坐标, 文本最大宽度)
          content.fillText((dataTempered.processid), (Xwidth / 2) + Rx, (Xheight) / 2 + Ry+Font2);
          //content.rotate(30*Math.PI/180);
          content.stroke();
        }
    }
  }
}


</script>



<template>
  <div ref="content">

  </div>
  <canvas ref="mycanvas" >

  </canvas>
</template>

<style scoped>
#main {
  width: 100%;
  height: 100%;
}



#div-title {
  height: 5%;
  width: 100%;
}

#searchButton {
  margin-top: -5px;
  margin-left: 1rem;
}

#searchButton1 {
  /* margin-left: 10rem; */
}

/*main-body样式*/
#main-body {
  width: 99%;
  height: 92%;
  margin-top: 1%;
}

#select {
  margin-left: 0.5rem;
}

:deep(.indexTag .el-breadcrumb__inner) {
  color: #5CADFE !important;
}
</style>