Merge branch 'master' of http://10.153.19.25:10101/r/HangZhouMes

wangfei

2024-08-27 7f4ae8816d0df23ec4e31b72a9a961a5d49d365d

Merge branch 'master' of http://10.153.19.25:10101/r/HangZhouMes

 UI-Project/config.js

@@ -1,10 +1,10 @@
export default {
 serverUrl: "10.153.19.150:88/api",
//  serverUrl: "10.153.19.150:88/api",
//  serverUrl: "192.168.1.199:88/api",
//  serverUrl: "127.0.0.1:88/api",
  serverUrl2: "10.153.19.150:88"
 serverUrl: "127.0.0.1:88/api",
  // serverUrl2: "10.153.19.150:88"
  // serverUrl2: "192.168.1.199:88"
    // serverUrl2: "127.0.0.1:88"
    serverUrl2: "127.0.0.1:88"

  //serverUrl:"res.abeim.cn"
}

 UI-Project/src/utils/constants.js

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

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/order/controller/OrderController.java

@@ -26,7 +26,7 @@
    //获取待选择的工程号
    private OrdersService ordersService;

    @ApiOperation("显示订单详细1")
    @ApiOperation("显示订单详细")
    @PostMapping("/selectOrderdetail") //显示工程选择信息
    @ResponseBody
    public Result<List<Orderdetail>> listByState(@RequestBody Orders orders) {

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

@@ -31,6 +31,10 @@
     * 次破时间
     */
    private String reportingWorkTime;
    /**
     * 次破时间2
     */
    private String reportingWorkTime2;


}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/temperingglass/service/impl/TemperingGlassInfoServiceImpl.java

@@ -65,7 +65,7 @@
        if(glass != null) {
            return temperingMapper.selectByEngineerIdAndLayoutId(glass.getEngineerId(),glass.getTemperingLayoutId());
        }
            return  null;
        return  null;
    }

    @Override
@@ -93,7 +93,7 @@
    }

    @Override
        public List<TemperingGlassInfo> selectTaskType() {
    public List<TemperingGlassInfo> selectTaskType() {
        QueryWrapper<TemperingGlassInfo> wrapper = new QueryWrapper<>();
        wrapper.select("state")
                .groupBy("state");

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgglasstask/controller/EdgGlassTaskInfoController.java

@@ -1,12 +1,19 @@
package com.mes.edgglasstask.controller;


import com.mes.edgglasstask.entity.request.EdgGlassInfoRequest;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import com.mes.utils.Result;
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.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * <p>
 *  前端控制器
 * 前端控制器
 * </p>
 *
 * @author wu
@@ -16,5 +23,21 @@
@RequestMapping("/edgGlassTaskInfo")
public class EdgGlassTaskInfoController {

    @Autowired
    EdgGlassTaskInfoService edgGlassTaskInfoService;

    /**
     * 设置磨边队列查询参数
     *
     * @param request
     * @return
     */
    @PostMapping("/setEdgGlassInfoRequest")
    @ApiOperation(value = "设置磨边队列查询参数", notes = "设置磨边队列查询参数")
    public Result<String> setEdgGlassInfoRequest(@RequestBody EdgGlassInfoRequest request) {
        edgGlassTaskInfoService.setEdgGlassInfoRequest(request);
        return Result.build(200, "查询成功", "1");
    }

}


 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgglasstask/entity/EdgGlassTaskInfo.java

@@ -1,5 +1,6 @@
package com.mes.edgglasstask.entity;

import com.baomidou.mybatisplus.annotation.TableLogic;
import lombok.Data;
import lombok.EqualsAndHashCode;

@@ -36,4 +37,7 @@

    private Date time;

    @TableLogic
    private int deleted;

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgglasstask/entity/request/EdgGlassInfoRequest.java

New file
@@ -0,0 +1,40 @@
package com.mes.edgglasstask.entity.request;

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import org.springframework.format.annotation.DateTimeFormat;

import java.util.Date;
import java.util.List;

/**
 * @Author : zhoush
 * @Date: 2024/8/7 16:16
 * @Description:
 */
@Data
public class EdgGlassInfoRequest {

    /**
     * 磨边线 2001   2002
     */
    private List<Integer> cellList;
    /**
     * 状态  0 待处理  1 处理中  2 处理完成
     */
    private List<Integer> stateList;

    /**
     * 开始时间
     */
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date beginDate;

    /**
     * 结束时间
     */
    @DateTimeFormat(pattern = "yyyy-MM-dd")
    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date endDate;
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgglasstask/entity/request/IdentWornRequest.java

New file
@@ -0,0 +1,28 @@
package com.mes.edgglasstask.entity.request;

import lombok.Data;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;


/**
 * @Author : zhoush
 * @Date: 2024/8/10 13:34
 * @Description:
 */
@Data
public class IdentWornRequest {

    @NotBlank(message = "玻璃ID不能为空")
    private String glassId;

    @NotNull(message = "状态不能为空")
    private int state;

    @NotNull(message = "线路不能为空")
    private int line;

    @NotBlank(message = "工序不能为空")
    private String workingProcedure;
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgglasstask/service/EdgGlassTaskInfoService.java

@@ -2,12 +2,13 @@

import com.baomidou.mybatisplus.extension.service.IService;
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgglasstask.entity.request.EdgGlassInfoRequest;

import java.util.List;

/**
 * <p>
 *  服务类
 * 服务类
 * </p>
 *
 * @author wu
@@ -15,9 +16,9 @@
 */
public interface EdgGlassTaskInfoService extends IService<EdgGlassTaskInfo> {

  //  List<EdgGlassTaskInfo> selectEdgInfo();
    List<EdgGlassTaskInfo> selectEdgInfo();

//    String setEdgGlassInfoRequest(EdgGlassInfoRequest request);
    String setEdgGlassInfoRequest(EdgGlassInfoRequest request);
    /**
     * 查询判断磨边线是否有玻璃运行
     * @param

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgglasstask/service/impl/EdgGlassTaskInfoServiceImpl.java

@@ -1,11 +1,15 @@
package com.mes.edgglasstask.service.impl;

import cn.smallbun.screw.core.util.CollectionUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.common.utils.RedisUtil;
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgglasstask.entity.request.EdgGlassInfoRequest;
import com.mes.edgglasstask.mapper.EdgGlassTaskInfoMapper;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import com.mes.tools.DateUtil;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@@ -13,7 +17,7 @@

/**
 * <p>
 *  服务实现类
 * 服务实现类
 * </p>
 *
 * @author wu
@@ -25,34 +29,34 @@
    @Autowired
    RedisUtil redisUtil;

    //@Override
//    public List<EdgGlassTaskInfo> selectEdgInfo() {
//        EdgGlassInfoRequest request = redisUtil.getCacheObject("edgGlassRequest");
//
//        if (null == request) {
//            request = new EdgGlassInfoRequest();
//        }
//        if (null == request.getBeginDate()) {
//            request.setBeginDate(DateUtil.getBeginDate());
//            request.setEndDate(DateUtil.getEndDate());
//        }
//        LambdaQueryWrapper<EdgGlassTaskInfo> edgGlassWrapper = new LambdaQueryWrapper<EdgGlassTaskInfo>()
//                .in(CollectionUtils.isNotEmpty(request.getCellList()), EdgGlassTaskInfo::getLine, request.getCellList())
//                .in(CollectionUtils.isNotEmpty(request.getStateList()), EdgGlassTaskInfo::getStatus, request.getStateList())
//                .between(null != request.getBeginDate(), EdgGlassTaskInfo::getTime, request.getBeginDate(), request.getEndDate())
//                .orderByDesc(EdgGlassTaskInfo::getTime);
//        return this.list(edgGlassWrapper);
//    }
//
//    @Override
//    public String setEdgGlassInfoRequest(EdgGlassInfoRequest request) {
//        if (request == null) {
//            redisUtil.deleteObject("edgGlassRequest");
//        } else {
//            redisUtil.setCacheObject("edgGlassRequest", request);
//        }
//        return "success";
//    }
    @Override
    public List<EdgGlassTaskInfo> selectEdgInfo() {
        EdgGlassInfoRequest request = redisUtil.getCacheObject("edgGlassRequest");

        if (null == request) {
            request = new EdgGlassInfoRequest();
        }
        if (null == request.getBeginDate()) {
            request.setBeginDate(DateUtil.getBeginDate());
            request.setEndDate(DateUtil.getEndDate());
        }
        LambdaQueryWrapper<EdgGlassTaskInfo> edgGlassWrapper = new LambdaQueryWrapper<EdgGlassTaskInfo>()
                .in(CollectionUtils.isNotEmpty(request.getCellList()), EdgGlassTaskInfo::getLine, request.getCellList())
                .in(CollectionUtils.isNotEmpty(request.getStateList()), EdgGlassTaskInfo::getStatus, request.getStateList())
                .between(null != request.getBeginDate(), EdgGlassTaskInfo::getTime, request.getBeginDate(), request.getEndDate())
                .orderByDesc(EdgGlassTaskInfo::getTime);
        return this.list(edgGlassWrapper);
    }

    @Override
    public String setEdgGlassInfoRequest(EdgGlassInfoRequest request) {
        if (request == null) {
            redisUtil.deleteObject("edgGlassRequest");
        } else {
            redisUtil.setCacheObject("edgGlassRequest", request);
        }
        return "success";
    }

    /**
     * 查询判断磨边线是否有玻璃运行

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/controller/EdgStorageCageController.java

@@ -1,26 +1,23 @@
package com.mes.edgstoragecage.controller;

import com.mes.edgglasstask.entity.request.IdentWornRequest;
import com.mes.edgstoragecage.entity.EdgStorageCage;
import com.mes.edgstoragecage.entity.EdgStorageCageDetails;
import com.mes.edgstoragecage.service.EdgStorageCageDetailsService;
import com.mes.edgstoragecage.service.EdgStorageCageService;
import com.mes.edgstoragecage.service.impl.EdgStorageCageServiceImpl;
import com.mes.taskcache.entity.TaskCache;
import com.mes.taskcache.service.impl.TaskCacheServiceImpl;
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.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

import java.awt.image.ImageProducer;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/**
 * <p>
 *  前端控制器
 * 前端控制器
 * </p>
 *
 * @author zhoush
@@ -40,44 +37,33 @@
    @ApiOperation("查询磨边缓存理片笼内详情 参数()")
    @PostMapping("/selectEdgStorageCage")
    @ResponseBody
    public Result selectEdgStorageCage () {
        List<Map<String, Object>> list=edgStorageCageService.selectEdgStorageCages();
        return Result.build(200,"成功",list);
    public Result selectEdgStorageCage() {
        List<Map<String, Object>> list = edgStorageCageService.selectEdgStorageCages();
        return Result.build(200, "成功", list);
    }
//    @ApiOperation("添加磨边缓存理片笼信息   功能：笼内绑定玻璃  参数(EdgStorageCage edgStorageCage)")
//    @PostMapping("/insertEdgStorageCage")
//    @ResponseBody
//    public Result insertEdgStorageCage(@RequestBody EdgStorageCage edgStorageCage) {
//        boolean isSucess=edgStorageCageService.updateEdgStorageCage(edgStorageCage);
//        return Result.build(200,"添加成功",1);
//    }

    @ApiOperation("修改磨边缓存理片笼信息   功能：对笼内栅格进行【启用/禁用】")
    @PostMapping("/updateEdgStorageCage")
    @ResponseBody
    public Result updateEdgStorageCage(@RequestBody EdgStorageCage edgStorageCage) {
        String isSucess=edgStorageCageService.updateEdgStorageCage(edgStorageCage)?"成功":"失败";
        return Result.build(200,"【启用/禁用】"+isSucess,1);
        String isSucess = edgStorageCageService.updateEdgStorageCage(edgStorageCage) ? "成功" : "失败";
        return Result.build(200, "【启用/禁用】" + isSucess, 1);
    }

    @ApiOperation("磨边缓存理片笼信息   功能：对笼内栅格玻璃进行【清除/更换/绑定】 EdgStorageCage格子信息,EdgStorageCageDetails 玻璃信息 ")
    @PostMapping("/edgStorageCageGlass")
    @ResponseBody
    public Result edgStorageCageGlass(@RequestBody EdgStorageCageDetails edgStorageCageDetails,int edgStorageCageId) {
    public Result edgStorageCageGlass(@RequestBody EdgStorageCageDetails edgStorageCageDetails, int edgStorageCageId) {

        String isSucess=edgStorageCageService.updateEdgStorageCageDetails(edgStorageCageId,edgStorageCageDetails)?"成功":"失败";
        return Result.build(200,"【清除/更换/绑定】"+isSucess,1);
        String isSucess = edgStorageCageService.updateEdgStorageCageDetails(edgStorageCageId, edgStorageCageDetails) ? "成功" : "失败";
        return Result.build(200, "【清除/更换/绑定】" + isSucess, 1);
    }



    @ApiOperation("磨边模块汇报玻璃状态   功能：对笼内栅格玻璃进行【破损/拿走】  ")
    @PostMapping("/edgReportStatus")
    @ResponseBody
    public Result edgReportStatus(@RequestBody Map<String, Object> arguments) {
        /*arguments.put("line","1002");
        arguments.put("machine","卧式理片");*/
        String isSucess=edgStorageCageDetailsService.identWorn(arguments)?"成功":"失败";
        return Result.build(200,"【破损/拿走】"+isSucess,1);
    public Result edgReportStatus(@RequestBody @Validated IdentWornRequest request) {
        return Result.build(200, "【破损/拿走】" + edgStorageCageDetailsService.edgReportStatus(request), 1);
    }

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/service/EdgStorageCageDetailsService.java

@@ -1,6 +1,7 @@
package com.mes.edgstoragecage.service;

import com.github.yulichang.base.MPJBaseService;
import com.mes.edgglasstask.entity.request.IdentWornRequest;
import com.mes.edgstoragecage.entity.EdgStorageCageDetails;

import java.util.List;
@@ -15,13 +16,6 @@
 * @since 2024-04-07
 */
public interface EdgStorageCageDetailsService extends MPJBaseService<EdgStorageCageDetails> {

    /**
     * 识别 破损/拿走
     * @param arguments
     * @return
     */
    boolean identWorn(Map<String, Object> arguments);

    /**
     * 获取 切割当前版图
@@ -46,9 +40,26 @@

    /**
     * 获取出片信息数据
     *
     * @param glassId
     * @param threshold
     * @return
     */
    EdgStorageCageDetails selectOutGlass(String glassId, int threshold);

    /**
     * 识别   拿走:9/破损:8
     *
     * @param request
     * @return
     */
    String identControls(IdentWornRequest request);

    /**
     * 磨边模块汇报玻璃状态   功能：对笼内栅格玻璃进行【破损/拿走】
     *
     * @param request
     * @return
     */
    String edgReportStatus(IdentWornRequest request);
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/service/impl/EdgStorageCageDetailsServiceImpl.java

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

import cn.hutool.core.lang.Assert;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.query.MPJLambdaQueryWrapper;
@@ -9,16 +10,15 @@
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.mapper.DamageMapper;
import com.mes.damage.service.DamageService;
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgglasstask.entity.request.IdentWornRequest;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import com.mes.edgstoragecage.entity.EdgStorageCage;
import com.mes.edgstoragecage.entity.EdgStorageCageDetails;
import com.mes.edgstoragecage.mapper.EdgStorageCageDetailsMapper;
import com.mes.edgstoragecage.mapper.EdgStorageCageMapper;
import com.mes.edgstoragecage.service.EdgStorageCageDetailsService;
import com.mes.engineering.entity.Engineering;
import com.mes.engineering.mapper.EngineeringMapper;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.pp.entity.OptimizeDetail;
import com.mes.pp.entity.OptimizeLayout;
@@ -29,12 +29,11 @@
import com.mes.uppattenusage.mapper.UpPattenUsageMapper;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.print.attribute.standard.MediaSize;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@@ -60,12 +59,6 @@
    @Autowired
    EdgStorageCageMapper edgStorageCageMapper;
    @Autowired
    DamageMapper damageMapper;

    @Autowired
    EngineeringMapper engineeringMapper;

    @Autowired
    GlassInfoMapper glassInfoMapper;

    @Autowired
@@ -74,47 +67,8 @@
    @Autowired
    DamageService damageService;


    /**
     * 识别   拿走:200/破损:201
     *
     * @param arguments
     * @return
     */
    @Override
    public boolean identWorn(Map<String,Object> arguments) {
        String glassId=arguments.get("glassId").toString();
        int state=arguments.get("state").toString().isEmpty()?0:Integer.parseInt(arguments.get("state").toString());
        int line=arguments.get("line").toString().isEmpty()?0:Integer.parseInt(arguments.get("line").toString());
        String workingProcedure=arguments.get("workingProcedure").toString();
        if(state==0||line==0||workingProcedure==null||glassId==null||glassId.isEmpty()){
            log.info("前端传递数据不全:{}",arguments);
            return false;
        }
        List<GlassInfo> GlassInfos = glassInfoMapper.selectList(new MPJLambdaQueryWrapper<GlassInfo>()
                .selectAll(GlassInfo.class)
                .eq(GlassInfo::getGlassId, glassId));
        if (GlassInfos.size() == 1) {
            Damage damage =new Damage();
            damage.setGlassId(glassId);
            damage.setLine(line);
            damage.setWorkingProcedure(workingProcedure);
            damage.setRemark("");
            damage.setStatus(state);//8破损，9拿走
            damageService.insertDamage(damage);
        }else{
            return false;
        }
        List<EdgStorageCageDetails> edgStorageCageDetails = baseMapper.selectList(new MPJLambdaQueryWrapper<EdgStorageCageDetails>()
                .selectAll(EdgStorageCageDetails.class)
                .eq(EdgStorageCageDetails::getGlassId, glassId));
        if (edgStorageCageDetails.size() == 1) {
            EdgStorageCageDetails item = edgStorageCageDetails.get(0);
            item.setState(state);
            baseMapper.update(item, new MPJLambdaWrapper<EdgStorageCageDetails>().selectAll(EdgStorageCageDetails.class).eq(EdgStorageCageDetails::getGlassId, glassId));
        }
        return true;
    }
    @Autowired
    EdgGlassTaskInfoService edgGlassTaskInfoService;

    /**
     * 获取 切割当前版图
@@ -123,17 +77,13 @@
     */
    @Override
    public List<Map<String, Object>> selectCutTerritory() {
        List<UpPattenUsage> upPattenUsage=upPattenUsageMapper.selectJoinList(UpPattenUsage.class, new MPJLambdaWrapper<UpPattenUsage>()
        List<UpPattenUsage> upPattenUsage = upPattenUsageMapper.selectList(new MPJLambdaWrapper<UpPattenUsage>()
                .selectAll(UpPattenUsage.class)
                .innerJoin(Engineering.class, on -> on
                        .eq(Engineering::getEngineerId, UpPattenUsage::getEngineeringId))
                .eq(Engineering::getState,1)
                .orderByDesc(UpPattenUsage::getState)
                .orderByDesc(UpPattenUsage::getId)
        );
                .orderByDesc(UpPattenUsage::getId));
        if (!upPattenUsage.isEmpty()) {
            UpPattenUsage upPattenUsage1 = upPattenUsage.get(0);
            List<Map<String, Object>> cutTerritorys=optimizeDetailMapper.selectJoinMaps(JoinWrappers.lambda(OptimizeDetail.class)
            List<Map<String, Object>> cutTerritorys = optimizeDetailMapper.selectJoinMaps(JoinWrappers.lambda(OptimizeDetail.class)
                    .selectAll(OptimizeDetail.class)
                    .selectAs(OptimizeLayout::getWidth, "olWidth")
                    .selectAs(OptimizeLayout::getHeight, "olHeight")
@@ -143,34 +93,29 @@
                    .eq(OptimizeDetail::getProjectNo, upPattenUsage1.getEngineeringId())
                    .eq(OptimizeDetail::getStockId, upPattenUsage1.getLayoutSequence())
            );
            Map<String, EdgStorageCageDetails> edgMaps=baseMapper.selectList(new MPJLambdaQueryWrapper<EdgStorageCageDetails>()
                    .selectAll(EdgStorageCageDetails.class)
                    .eq(EdgStorageCageDetails::getEngineerId,upPattenUsage1.getEngineeringId())
                    .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
            ).stream().collect(Collectors.toMap(EdgStorageCageDetails::getGlassId,EdgStorageCageDetails->EdgStorageCageDetails));

            Map<String, Damage> damageMaps=damageMapper.selectList(new MPJLambdaQueryWrapper<Damage>()
                    .selectAll(Damage.class)
                    .eq(Damage::getEngineerId,upPattenUsage1.getEngineeringId())
            ).stream().collect(Collectors.toMap(Damage::getGlassId,Damage->Damage,(V1,V2)->V2));

            List<Map<String, Object>> resultCutTerritory=new ArrayList<>();
            List<Map<String, Object>> ResultcutTerritorys = new ArrayList<>();
            for (Map<String, Object> cutTerritory : cutTerritorys) {
                EdgStorageCageDetails edgStorageCageDetails = baseMapper.selectOne(new MPJLambdaQueryWrapper<EdgStorageCageDetails>()
                        .selectAll(EdgStorageCageDetails.class)
                        .eq(EdgStorageCageDetails::getGlassId, cutTerritory.get("glass_id"))
                        .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));
//                log.info("内容：{}-------{}",cutTerritory,edgStorageCageDetails);
                if(cutTerritory.get("glass_id")==null||"".equals(cutTerritory.get("glass_id"))){
                    log.info("优化数据中glassId存在空值-----内容：{}",cutTerritorys);
                    return new ArrayList<>();
                }else if(edgMaps.get(cutTerritory.get("glass_id"))!=null){
                    cutTerritory.put("glass_state",edgMaps.get(cutTerritory.get("glass_id")).getState());
                }else if(damageMaps.get(cutTerritory.get("glass_id"))!=null){
                    //log.info("玻璃已破损/拿走-----内容：{}",damageMaps.get(item.get("glass_id")));
                    cutTerritory.put("glass_state",damageMaps.get(cutTerritory.get("glass_id")).getStatus());
                }else{
                    cutTerritory.put("glass_state",0);
                if (edgStorageCageDetails != null) {
                    cutTerritory.put("glass_state", edgStorageCageDetails.getState());
                } else {
                    cutTerritory.put("glass_state", 0);
                }
                resultCutTerritory.add(cutTerritory);
                ResultcutTerritorys.add(cutTerritory);
            }
            return resultCutTerritory;
            return ResultcutTerritorys;

//            Sql版本
//            return optimizeDetailMapper.selectJoinMaps(new MPJQueryWrapper<OptimizeDetail>().selectAll(OptimizeDetail.class)
//                    .select("ol.width as olwidth","ol.height as olheight")
//                    .leftJoin("optimize_layout ol on t.project_no=ol.project_no and t.stock_id=ol.stock_id")
//                    .eq("t.project_no", upPattenUsage1.getEngineeringId())
//                    .eq("t.stock_id",upPattenUsage1.getLayoutSequence())
//            );
        }
        return null;
    }
@@ -184,9 +129,9 @@
    @Override
    public List<List<Map<String, Object>>> selectCurrentCutTerritory(String current) {
        //结果
        List<Map<String, Object>> resultCutTerritory=new ArrayList<>();
        List<Map<String, Object>> ResultcutTerritorys = new ArrayList<>();
        //此工程的所有优化数据
        List<Map<String, Object>> cutTerritory=optimizeDetailMapper.selectJoinMaps(JoinWrappers.lambda(OptimizeDetail.class)
        List<Map<String, Object>> cutTerritorys = optimizeDetailMapper.selectJoinMaps(JoinWrappers.lambda(OptimizeDetail.class)
                .selectAll(OptimizeDetail.class)
                .selectAs(OptimizeLayout::getWidth, "olWidth")
                .selectAs(OptimizeLayout::getHeight, "olHeight")
@@ -196,35 +141,32 @@
                .eq(OptimizeDetail::getProjectNo, current)
        );

        Map<String, EdgStorageCageDetails> edgMaps=baseMapper.selectList(new MPJLambdaQueryWrapper<EdgStorageCageDetails>()
        Map<String, EdgStorageCageDetails> edgMaps = baseMapper.selectList(new MPJLambdaQueryWrapper<EdgStorageCageDetails>()
                .selectAll(EdgStorageCageDetails.class)
                .eq(EdgStorageCageDetails::getEngineerId,current)
                .eq(EdgStorageCageDetails::getEngineerId, current)
                .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN)
        ).stream().collect(Collectors.toMap(EdgStorageCageDetails::getGlassId,EdgStorageCageDetails->EdgStorageCageDetails,(V1,V2)->V2));

        Map<String, Damage> damageMaps=damageMapper.selectList(new MPJLambdaQueryWrapper<Damage>()
                .selectAll(Damage.class)
                .eq(Damage::getEngineerId,current)
        ).stream().collect(Collectors.toMap(Damage::getGlassId,Damage->Damage));

        for (Map<String, Object> item : cutTerritory) {
        ).stream().collect(Collectors.toMap(EdgStorageCageDetails::getGlassId, EdgStorageCageDetails -> EdgStorageCageDetails));
        for (Map<String, Object> cutTerritory : cutTerritorys) {
//                log.info("内容：{}-------{}",cutTerritory,edgStorageCageDetails);
            if(item.get("glass_id")==null||"".equals(item.get("glass_id"))){
                log.info("优化数据中glassId存在空值-----内容：{}",cutTerritory);
            if (cutTerritory.get("glass_id") == null || "".equals(cutTerritory.get("glass_id"))) {
                log.info("优化数据中glassId存在空值-----内容：{}", cutTerritorys);
                return new ArrayList<>();
            }else if(edgMaps.get(item.get("glass_id"))!=null){
                item.put("glass_state",edgMaps.get(item.get("glass_id")).getState());
            }else if(damageMaps.get(item.get("glass_id"))!=null){
                //log.info("玻璃已破损/拿走-----内容：{}",damageMaps.get(item.get("glass_id")));
                item.put("glass_state",damageMaps.get(item.get("glass_id")).getStatus());
            }else{
                item.put("glass_state",0);
            } else if (edgMaps.get(cutTerritory.get("glass_id")) != null) {
                cutTerritory.put("glass_state", edgMaps.get(cutTerritory.get("glass_id")).getState());
            } else {
                cutTerritory.put("glass_state", 0);
            }
            resultCutTerritory.add(item);
            ResultcutTerritorys.add(cutTerritory);
        }
        Map<String, List<Map<String, Object>>> groupBy=resultCutTerritory.stream().collect(Collectors.groupingBy(item->item.get("stock_id").toString()));
        Map<String, List<Map<String, Object>>> groupBy = ResultcutTerritorys.stream().collect(Collectors.groupingBy(item -> item.get("stock_id").toString()));
//        List<List<Map<String, Object>>> Result=groupBy.values().stream().collect(Collectors.toList());
        return new ArrayList<>(groupBy.values());
//Sql版本
//        return optimizeDetailMapper.selectJoinMaps(new MPJQueryWrapper<OptimizeDetail>().selectAll(OptimizeDetail.class)
//                .select("ol.width as olwidth","ol.height as olheight")
//                .leftJoin("optimize_layout ol on t.project_no=ol.project_no and t.stock_id=ol.stock_id")
//                .eq("t.project_no",current)
//        );
    }

    /**
@@ -315,22 +257,49 @@
        EdgStorageCageDetails outEdgStorageCageDetails = null;

//        if (queryMaxMinDiff(threshold))
            //todo:逻辑1：获取两条线已出最后一块玻璃在笼内相同尺寸所剩数量，优先走数量少的线
            //todo:需要在卧式理片笼详情表中新增状态，用来表示玻璃进出理片笼情况
            if (oldEdgStorageCageDetails != null && minTemperingLayoutId != null) {
                log.info("按照上一片已出玻璃宽度{}，高度{}，及版图id区间{}到{}获取出片任务玻璃信息", oldEdgStorageCageDetails.getWidth()
                        , oldEdgStorageCageDetails.getHeight(), minTemperingLayoutId.getTemperingLayoutId(), minTemperingLayoutId.getTemperingLayoutId() + threshold);
                outEdgStorageCageDetails = this.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                        .notIn(CollectionUtils.isNotEmpty(glassIds), EdgStorageCageDetails::getGlassId, glassIds)
                        .eq(EdgStorageCageDetails::getWidth, oldEdgStorageCageDetails.getWidth())
                        .eq(EdgStorageCageDetails::getHeight, oldEdgStorageCageDetails.getHeight())
                        .orderByAsc(EdgStorageCageDetails::getTemperingLayoutId, EdgStorageCageDetails::getTemperingFeedSequence)
                        .last("limit 1"));
                log.info("出片任务的玻璃信息：{}", outEdgStorageCageDetails);
            }
        //todo:逻辑1：获取两条线已出最后一块玻璃在笼内相同尺寸所剩数量，优先走数量少的线
        //todo:需要在卧式理片笼详情表中新增状态，用来表示玻璃进出理片笼情况
        if (oldEdgStorageCageDetails != null && minTemperingLayoutId != null) {
            log.info("按照上一片已出玻璃宽度{}，高度{}，及版图id区间{}到{}获取出片任务玻璃信息", oldEdgStorageCageDetails.getWidth()
                    , oldEdgStorageCageDetails.getHeight(), minTemperingLayoutId.getTemperingLayoutId(), minTemperingLayoutId.getTemperingLayoutId() + threshold);
            outEdgStorageCageDetails = this.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                    .notIn(CollectionUtils.isNotEmpty(glassIds), EdgStorageCageDetails::getGlassId, glassIds)
                    .eq(EdgStorageCageDetails::getWidth, oldEdgStorageCageDetails.getWidth())
                    .eq(EdgStorageCageDetails::getHeight, oldEdgStorageCageDetails.getHeight())
                    .orderByAsc(EdgStorageCageDetails::getTemperingLayoutId, EdgStorageCageDetails::getTemperingFeedSequence)
                    .last("limit 1"));
            log.info("出片任务的玻璃信息：{}", outEdgStorageCageDetails);
        }
        if (outEdgStorageCageDetails == null) {
            outEdgStorageCageDetails = minTemperingLayoutId;
        }
        return outEdgStorageCageDetails;
    }

    @Override
    public String identControls(IdentWornRequest request) {
        //将识别破损的玻璃直接加入破损表
        Damage damage = new Damage();
        BeanUtils.copyProperties(request, damage);
        damage.setType(request.getState());
        damage.setRemark("");
        damage.setStatus(0);
        damageService.insertDamage(damage);
        return "success";
    }

    @Override
    public String edgReportStatus(IdentWornRequest request) {
        //将磨边队列破损的玻璃直接加入破损表
        Damage damage = new Damage();
        BeanUtils.copyProperties(request, damage);
        damage.setType(request.getState());
        damage.setRemark("");
        damage.setStatus(0);
        damageService.insertDamage(damage);
        //修改磨边队列数据状态
        edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                .set(EdgGlassTaskInfo::getStatus, request.getState()).eq(EdgGlassTaskInfo::getGlassId, request.getGlassId()));
        return "success";
    }
}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/edgstoragecage/service/impl/EdgStorageCageServiceImpl.java

@@ -153,17 +153,15 @@
        EdgStorageCageDetails edgDItem = edgStorageCageDetailsMapper.selectById(edgStorageCageDetails.getId());
        if (edgItem != null) {
            //移除  （破损,目前两个概念混合在一起,建议拆开）
            EdgStorageCageDetails result = edgStorageCageDetailsMapper.selectOne(new MPJLambdaWrapper<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getSlot, edgStorageCageId));
            EdgStorageCageDetails result = edgStorageCageDetailsMapper.selectOne(new MPJLambdaWrapper<EdgStorageCageDetails>().eq(EdgStorageCageDetails::getSlot, edgStorageCageId));
            if (result != null) {
                int state=8;
                result.setSlot(0);
                result.setState(state);
                result.setState(201);
                Damage damage =new Damage();
                damage.setGlassId(edgStorageCageDetails.getGlassId());
                damage.setLine(1002);
                damage.setWorkingProcedure("卧式理片");
                damage.setStatus(state);
                damage.setStatus(2);
                damageService.insertDamage(damage);
                edgStorageCageDetailsMapper.updateById(result);
            }

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

@@ -737,8 +737,8 @@
        jsonObject.append("currentCutTerritory", currentCutTerritorys);
        //log.info("本次识别版图{},++++{}",engineerId,currentCutTerritorys);
        //磨边信息
//        List<EdgGlassTaskInfo> edgTasks = edgGlassTaskInfoService.selectEdgInfo();
//        jsonObject.append("edgTasks", edgTasks);
        List<EdgGlassTaskInfo> edgTasks = edgGlassTaskInfoService.selectEdgInfo();
        jsonObject.append("edgTasks", edgTasks);

        //卧室缓存笼内信息
        List<Map<String, Object>> EdgStorageCageinfos = edgStorageCageService.selectEdgStorageCages();

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/taskcache/controller/TaskCacheController.java

@@ -1,23 +1,21 @@
package com.mes.taskcache.controller;

import com.mes.edgglasstask.entity.request.IdentWornRequest;
import com.mes.edgstoragecage.service.EdgStorageCageDetailsService;
import com.mes.edgstoragecage.service.EdgStorageCageService;
import com.mes.taskcache.entity.TaskCache;
import com.mes.taskcache.service.TaskCacheService;
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.validation.annotation.Validated;
import org.springframework.web.bind.annotation.*;

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

import static com.mes.job.CacheGlassTask.engineerId;

/**
 * <p>
 *  前端控制器
 * 前端控制器
 * </p>
 *
 * @author zhoush
@@ -32,8 +30,6 @@
    private EdgStorageCageDetailsService edgStorageCageDetailsService;

    @Autowired
    private EdgStorageCageService edgStorageCageService;
    @Autowired
    private TaskCacheService taskCacheService;

    @ApiOperation("查询切割版图信息-根据 工程号   参数(工程号)")
@@ -42,30 +38,31 @@
    public Result cutTerritory(String current) {
        //engineerId=current;
        List<List<Map<String, Object>>> h = edgStorageCageDetailsService.selectCurrentCutTerritory(current);
        return Result.build(200,"成功",h);
        return Result.build(200, "成功", h);
    }

    @ApiOperation("识别显示  当前版图   参数()")
    @PostMapping("/currentCutTerritory")
    @ResponseBody
    public Result currentCutTerritory() {
        List<Map<String, Object>> h = edgStorageCageDetailsService.selectCutTerritory();
        return Result.build(200,"成功",h);
        return Result.build(200, "成功", h);
    }
    @ApiOperation("识别操作：   破损/拿走     参数（ID,功能[200：拿走，201:破损]）")

    @ApiOperation("识别操作：   破损/拿走     参数（ID,功能[9：拿走，8:破损]）")
    @PostMapping("/identControls")
    @ResponseBody
    public Result identControls(@RequestBody Map<String, Object> arguments) {
        boolean issucess = edgStorageCageDetailsService.identWorn(arguments);
        return Result.build(200,"成功",issucess);
    public Result<String> identControls(@RequestBody @Validated IdentWornRequest request) {
        return Result.build(200, "成功", edgStorageCageDetailsService.identControls(request));
    }

    @ApiOperation("磨边任务 参数()")
    @PostMapping("/selectEdgTask")
    @ResponseBody
    public Result selectEdgTask(@RequestBody Map<String, String> arguments) {
        String line=arguments.get("line");
        List<Map<String,Object>> EdgTasks = taskCacheService.selectEdgInfo(line);
        return Result.build(200,"成功",EdgTasks);
        String line = arguments.get("line");
        List<Map<String, Object>> EdgTasks = taskCacheService.selectEdgInfo(line);
        return Result.build(200, "成功", EdgTasks);
    }

}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/taskcache/entity/TaskCache.java

@@ -1,5 +1,6 @@
package com.mes.taskcache.entity;

import com.baomidou.mybatisplus.annotation.TableLogic;
import com.baomidou.mybatisplus.annotation.TableName;
import lombok.Data;

@@ -36,4 +37,7 @@
     */
    private Date createTime;

    @TableLogic
    private int deleted;

}

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

@@ -73,11 +73,6 @@
     * @return
     */
    TaskCache selectLastOutCacheInfo(int line);
    /**
     * 查询判断磨边线是否有玻璃运行
     * @param
     * @return
     */
    List<TaskCache> selectTaskCacheIsRun();


}

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

@@ -1,5 +1,6 @@
package com.mes.taskcache.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.yulichang.base.MPJBaseServiceImpl;
@@ -7,6 +8,7 @@
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgstoragecage.entity.EdgStorageCage;
import com.mes.edgstoragecage.entity.EdgStorageCageDetails;
import com.mes.edgstoragecage.mapper.EdgStorageCageDetailsMapper;
@@ -23,7 +25,7 @@

/**
 * <p>
 *  服务实现类
 * 服务实现类
 * </p>
 *
 * @author zhoush
@@ -44,57 +46,59 @@

    /**
     * 添加理片笼任务
     *
     * @param taskCache
     * @return
     */
    @Override
    public boolean insertTaskCache(TaskCache taskCache){
    public boolean insertTaskCache(TaskCache taskCache) {
        baseMapper.insert(taskCache);
        return true;
    }

    /**
     * 查询磨边任务
     *
     * @param line
     * @return
     */
    @Override
    public List<Map<String,Object>> selectEdgInfo(String line) {
        List<TaskCache> taskCache=baseMapper.selectList(new MPJLambdaWrapper<TaskCache>()
    public List<Map<String, Object>> selectEdgInfo(String line) {
        List<TaskCache> taskCache = baseMapper.selectList(new MPJLambdaWrapper<TaskCache>()
                .selectAll(TaskCache.class)
                .eq(TaskCache::getEndCell, line)
                .eq(TaskCache::getTaskStatus,1)
                .eq(TaskCache::getTaskStatus, 1)
                .orderByAsc(TaskCache::getCreateTime));
        List<Map<String,Object>> result=new ArrayList<>();
        int serialNumber=1;
        for(TaskCache taskCache1:taskCache){
            Map<String,Object> map=new HashMap<>();
        List<Map<String, Object>> result = new ArrayList<>();
        int serialNumber = 1;
        for (TaskCache taskCache1 : taskCache) {
            Map<String, Object> map = new HashMap<>();
//            GlassInfo glassInfo=glassInfoMapper.selectOne(new MPJLambdaWrapper<GlassInfo>()
//                    .selectAll(GlassInfo.class)
//                    .eq(GlassInfo::getGlassId,taskCache1.getGlassId()));
            List<GlassInfo> glassInfos=glassInfoMapper.selectJoinList(GlassInfo.class, new MPJLambdaWrapper<GlassInfo>()
            List<GlassInfo> glassInfos = glassInfoMapper.selectJoinList(GlassInfo.class, new MPJLambdaWrapper<GlassInfo>()
                    .selectAll(GlassInfo.class)
                    .innerJoin(EdgStorageCageDetails.class, on -> on
                            .eq(EdgStorageCageDetails::getGlassId, GlassInfo::getGlassId)
                            .eq(EdgStorageCageDetails::getEngineerId, GlassInfo::getEngineerId))
                    .eq(GlassInfo::getGlassId,taskCache1.getGlassId())
                    .eq(EdgStorageCageDetails::getState,Const.GLASS_STATE_OUT)
                    .eq(GlassInfo::getGlassId, taskCache1.getGlassId())
                    .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_OUT)
            );
            if(glassInfos.size()==1){
                GlassInfo glassInfo=glassInfos.get(0);
                map.put("Line",line);//线路   2001  1线， 2002 2线
                map.put("Width",glassInfo.getWidth());//宽
                map.put("Height",glassInfo.getHeight());//高
                map.put("Thickness",glassInfo.getThickness());//厚
                map.put("GlassId",glassInfo.getGlassId());//玻璃ID
                map.put("FlowCardId",glassInfo.getFlowCardId());//流程卡号
                map.put("TemperingLayoutId",glassInfo.getTemperingLayoutId());// 暂不显示  钢化版图ID
                map.put("TemperingFeedSequence",glassInfo.getTemperingFeedSequence());// 暂不显示  钢化版图ID内的序号
                map.put("FilmsId",glassInfo.getFilmsid());//膜系
                map.put("SerialNumber",serialNumber);//出片顺序
            if (glassInfos.size() == 1) {
                GlassInfo glassInfo = glassInfos.get(0);
                map.put("Line", line);//线路   2001  1线， 2002 2线
                map.put("Width", glassInfo.getWidth());//宽
                map.put("Height", glassInfo.getHeight());//高
                map.put("Thickness", glassInfo.getThickness());//厚
                map.put("GlassId", glassInfo.getGlassId());//玻璃ID
                map.put("FlowCardId", glassInfo.getFlowCardId());//流程卡号
                map.put("TemperingLayoutId", glassInfo.getTemperingLayoutId());// 暂不显示  钢化版图ID
                map.put("TemperingFeedSequence", glassInfo.getTemperingFeedSequence());// 暂不显示  钢化版图ID内的序号
                map.put("FilmsId", glassInfo.getFilmsid());//膜系
                map.put("SerialNumber", serialNumber);//出片顺序
                result.add(map);
            }else if(glassInfos.size()>1){
                log.info("数据不符合逻辑--磨边队列glassId重复:",glassInfos);
            } else if (glassInfos.size() > 1) {
                log.info("数据不符合逻辑--磨边队列glassId重复:", glassInfos);
                return new ArrayList<>();
            }
            serialNumber++;
@@ -111,16 +115,18 @@

    /**
     * 查询待理片工作的任务
     *
     * @return
     */
    @Override
    public List<TaskCache> selectCacheInfo(){
        return baseMapper.selectList(new MPJLambdaWrapper<TaskCache>().selectAll(TaskCache.class).eq(TaskCache::getTaskStatus,0));
    public List<TaskCache> selectCacheInfo() {
        return baseMapper.selectList(new MPJLambdaWrapper<TaskCache>().selectAll(TaskCache.class).eq(TaskCache::getTaskStatus, 0));
//        return baseMapper.selectList(new QueryWrapper<TaskCache>().eq("task_status",0));
    }

    /**
     * 查询全部任务
     *
     * @return
     */
    @Override
@@ -130,61 +136,51 @@

    /**
     * 查询待进片任务
     *
     * @return
     */
    @Override
    public List<TaskCache> selectInputTaskCache(){
        return baseMapper.selectList(new MPJLambdaWrapper<TaskCache>().selectAll(TaskCache.class).eq(TaskCache::getTaskStatus,0).eq(TaskCache::getTaskType,1));
    public List<TaskCache> selectInputTaskCache() {
        return baseMapper.selectList(new MPJLambdaWrapper<TaskCache>().selectAll(TaskCache.class).eq(TaskCache::getTaskStatus, 0).eq(TaskCache::getTaskType, 1));

//        return baseMapper.selectList(new QueryWrapper<TaskCache>().eq("task_status",0).eq("task_type",1));
    }

    /**
     * 查询待出片任务
     *
     * @return
     */
    @Override
    public List<TaskCache> selectOutTaskCache(){
        return baseMapper.selectList(new MPJLambdaWrapper<TaskCache>().selectAll(TaskCache.class).eq(TaskCache::getTaskStatus,0).eq(TaskCache::getTaskType,2));
    public List<TaskCache> selectOutTaskCache() {
        return baseMapper.selectList(new MPJLambdaWrapper<TaskCache>().selectAll(TaskCache.class).eq(TaskCache::getTaskStatus, 0).eq(TaskCache::getTaskType, 2));
//        return baseMapper.selectList(new QueryWrapper<TaskCache>().eq("task_status",0).eq("task_type",2));
    }

    /**
     * 查询  A09  或 A10 最新的一片 出片任务
     *
     * @param line
     * @return
     */
    @Override
    public List<TaskCache> selectLastOutCacheInfos(int line){
        return baseMapper.selectList(new MPJLambdaWrapper<TaskCache>().selectAll(TaskCache.class).eq(TaskCache::getEndCell,line).eq(TaskCache::getTaskStatus,1).orderByDesc(TaskCache::getCreateTime));
    public List<TaskCache> selectLastOutCacheInfos(int line) {
        return baseMapper.selectList(new MPJLambdaWrapper<TaskCache>().selectAll(TaskCache.class).eq(TaskCache::getEndCell, line).eq(TaskCache::getTaskStatus, 1).orderByDesc(TaskCache::getCreateTime));
//        return baseMapper.selectList(new QueryWrapper<TaskCache>().eq("end_cell",line).eq("task_status",1).orderByDesc("ID"));
    }

    /**
     * 查询  A09  或 A10 最新的一片 出片任务
     *
     * @param line
     * @return
     */
    @Override
    public TaskCache selectLastOutCacheInfo(int line){
        return baseMapper.selectOne(new MPJLambdaWrapper<TaskCache>().selectAll(TaskCache.class).eq(TaskCache::getEndCell,line).eq(TaskCache::getTaskStatus,1).orderByDesc(TaskCache::getCreateTime));
    public TaskCache selectLastOutCacheInfo(int line) {
        return baseMapper.selectOne(new MPJLambdaWrapper<TaskCache>().selectAll(TaskCache.class).eq(TaskCache::getEndCell, line).eq(TaskCache::getTaskStatus, 1).orderByDesc(TaskCache::getCreateTime));
    }
    /**
     * 查询判断磨边线是否有玻璃运行
     * @param
     * @return
     */
    @Override
    public List<TaskCache> selectTaskCacheIsRun() {
        List<TaskCache> taskCaches=null;
        taskCaches=taskCacheMapper.selectJoinList(TaskCache.class, new MPJLambdaWrapper<TaskCache>()
                .select("top 4   t.end_cell,ISNULL(b.glass_id, 0)as glass_id")
                .leftJoin("big_storage_cage_feed_task as b on t.glass_id=b.glass_id ")
                .groupBy("t.end_cell,b.glass_id,t.create_time")
                .orderByDesc("t.create_time")
        );
        return taskCaches;
    }




}

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

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

spring:
  profiles:
    active: prod
    active: dev
  application:
    name: cacheGlass
mybatis-plus:
@@ -18,11 +18,11 @@
    secondLength: 2500
  min:
    one: #第一条磨边线的最小尺寸信息
      firstLength: 600
      secondLength: 350
      firstLength: 500
      secondLength: 400
    two: #第二条磨边线的最小尺寸信息
      firstLength: 400
      secondLength: 300
      secondLength: 400
  sequence:
    order: false


 hangzhoumesParent/moduleService/CacheGlassModule/src/test/java/com/mes/CacheGlassModuleApplicationTest.java

@@ -149,7 +149,7 @@
        arguments.put("state","8");        //拿走：200/破损：201
        arguments.put("line","1001");             //线路：
        arguments.put("workingProcedure","识别");           //设备名称：
        edgStorageCageDetailsService.identWorn(arguments);
//        edgStorageCageDetailsService.identWorn(arguments);
        log.info("识别台【破损/拿走】：{}", 1);
    }


 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/main/java/com/mes/bigstorage/entity/BigStorageCageDetails.java

@@ -94,20 +94,26 @@
    /**
     * 工程号
     */
    @ApiModelProperty(value = "工程号")
    @ApiModelProperty(value = "工程号", position = 16)
    private String engineerId;

    /**
     * 工程号
     */
    @ApiModelProperty(value = "层", position = 17)
    private String layer;

    /**
     * 进片任务
     */
    @ApiModelProperty(value = "进片任务", position = 16)
    @ApiModelProperty(value = "进片任务", position = 18)
    @TableField(exist = false)
    private BigStorageCageFeedTask bigStorageCageFeedTask;

    /**
     * 出片任务
     */
    @ApiModelProperty(value = "出片任务", position = 17)
    @ApiModelProperty(value = "出片任务", position = 19)
    @TableField(exist = false)
    private BigStorageCageOutTask bigStorageCageOutTask;


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

@@ -276,10 +276,9 @@
                .gt(BigStorageCage::getRemainWidth, Math.max(glassInfo.getWidth(), glassInfo.getHeight()))
                .last("limit 1");
        if (glassInfo.getTemperingLayoutId() == 0) {
            //todo:同流程进同一格
//            wrapper.eq(BigStorageCageDetails::getFlowCardId,glassInfo.getFlowCardId())
//                    .eq(BigStorageCageDetails::get)
            wrapper.eq(BigStorageCageDetails::getWidth, glassInfo.getWidth()).eq(BigStorageCageDetails::getHeight, glassInfo.getHeight());
            wrapper.eq(BigStorageCageDetails::getFlowCardId,glassInfo.getFlowCardId())
                    .eq(BigStorageCageDetails::getLayer,glassInfo.getLayer());
//            wrapper.eq(BigStorageCageDetails::getWidth, glassInfo.getWidth()).eq(BigStorageCageDetails::getHeight, glassInfo.getHeight());
        } else {
            wrapper.eq(BigStorageCageDetails::getTemperingFeedSequence, glassInfo.getTemperingFeedSequence() + 1);
        }

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

@@ -221,12 +221,12 @@
        LambdaQueryWrapper<BigStorageCageDetails> bigStorageCageDetailsWrapper = new LambdaQueryWrapper();
        bigStorageCageDetailsWrapper
                .eq(BigStorageCageDetails::getSlot, slot)
                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN, Const.GLASS_STATE_ARTIFICIAL);
                .in(BigStorageCageDetails::getState, Const.GLASS_STATE_IN_ALL);

        List<BigStorageCageDetails> bigStorageCageDetailsList = bigStorageCageDetailsMapper.selectList(bigStorageCageDetailsWrapper);
        for (BigStorageCageDetails bigStorageCageDetails : bigStorageCageDetailsList
        ) {
            double widths = bigStorageCageDetails.getWidth();
            double widths = Math.max(bigStorageCageDetails.getWidth(),bigStorageCageDetails.getHeight()) ;
            width = width - widths - glassGap;
        }
        //修改格子剩余宽度
@@ -266,7 +266,7 @@
    @Override
    public List<Map<String, Object>> selectBigStorageCageUsage() {
        QueryWrapper<BigStorageCage> wrapper = new QueryWrapper<>();
        wrapper.select("device_id,ROUND(1 - SUM(CASE WHEN remain_width = 5000 THEN 1 ELSE 0 END) / COUNT(device_id), 2) AS percentage,SUM(CASE WHEN remain_width = 5000 THEN 1 ELSE 0 END) AS count")
        wrapper.select("device_id,ROUND(1 - SUM(CASE WHEN remain_width = 5000 THEN 1 ELSE 0 END) / COUNT(device_id), 2)*100 AS percentage,SUM(CASE WHEN remain_width = 5000 THEN 1 ELSE 0 END) AS count")

                .groupBy("device_id");
        List<Map<String, Object>> bigStorageCageUsages = baseMapper.selectMaps(wrapper);
@@ -289,8 +289,8 @@
        return baseMapper.queryFreeDeviceByUsed(thickness);
    }

    @Override
    public List<Integer> queryFreeDeviceByNotUsed(double thickness) {
        return baseMapper.queryFreeDeviceByNotUsed(thickness);
    }
//    @Override
//    public List<Integer> queryFreeDeviceByNotUsed(double thickness) {
//        return baseMapper.queryFreeDeviceByNotUsed(thickness);
//    }
}

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

@@ -2,7 +2,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.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
@@ -128,6 +130,8 @@
        if (!REQUEST_WORD.equals(mesD01Value) && REQUEST_WORD.equals(d01ToMES) && (StringUtils.isBlank(d02State) || !REQUEST_WORD.equals(d03State))) {
            if (!d01GlassId.equals(d01Id)) {
                judgeGlassTypeStatus(d01Id, Const.A09_OUT_TARGET_POSITION, mesD01Address);
                edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                        .set(EdgGlassTaskInfo::getStatus, Const.EDG_GLASS_SUCCESS).eq(EdgGlassTaskInfo::getGlassId, d01Id));
                d01GlassId = d01Id;
            }
        }
@@ -135,6 +139,8 @@
        if (!REQUEST_WORD.equals(mesD04Value) && REQUEST_WORD.equals(d04ToMES) && !REQUEST_WORD.equals(d05State)) {
            if (!d04GlassId.equals(d04Id)) {
                judgeGlassTypeStatus(d04Id, Const.A10_OUT_TARGET_POSITION, mesD04Address);
                edgGlassTaskInfoService.update(new LambdaUpdateWrapper<EdgGlassTaskInfo>()
                        .set(EdgGlassTaskInfo::getStatus, Const.EDG_GLASS_SUCCESS).eq(EdgGlassTaskInfo::getGlassId, d04Id));
                d04GlassId = d04Id;
            }
        }
@@ -277,8 +283,12 @@
                return;
            }
            //是否有人工下片任务   有直接出
//            List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
//                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL).orderByDesc(BigStorageCageDetails::getWidth));
            List<BigStorageCageDetails> artificialList = bigStorageCageDetailsService.list(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL).orderByDesc(BigStorageCageDetails::getWidth));
                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_ARTIFICIAL)
                    .orderByAsc(BigStorageCageDetails::getSlot)
                    .orderByDesc(BigStorageCageDetails::getId));
            if (CollectionUtils.isNotEmpty(artificialList)) {
                computeOutMoreGlassInfo(artificialList, Boolean.FALSE, mesToPLCAddress);
                Date endDate = new Date();
@@ -346,15 +356,15 @@
                    }
                }
            }
            //向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);
            }
//            //向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;
@@ -476,10 +486,10 @@
        log.info("大理片笼破损玻璃清除任务开始执行时间：{}", startDate);
        //获取进片任务表中状态为破损的数据
        List<BigStorageCageFeedTask> inDamageTaskInfoList = bigStorageCageFeedTaskService.list(new LambdaQueryWrapper<BigStorageCageFeedTask>()
                .eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_DAMAGE));
                .in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
        if (CollectionUtils.isNotEmpty(inDamageTaskInfoList)) {
            log.info("获取进片任务表中破损的玻璃信息{}", inDamageTaskInfoList);
            bigStorageCageFeedTaskService.remove(new LambdaQueryWrapper<BigStorageCageFeedTask>().eq(BigStorageCageFeedTask::getTaskState, Const.BIG_STORAGE_IN_DAMAGE));
            bigStorageCageFeedTaskService.remove(new LambdaQueryWrapper<BigStorageCageFeedTask>().in(BigStorageCageFeedTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
            //理片笼详情表数据状态更新
            bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>()
                    .eq(BigStorageCageDetails::getState, Const.GLASS_STATE_NEW).in(BigStorageCageDetails::getGlassId, inDamageTaskInfoList.stream().map(BigStorageCageFeedTask::getGlassId).collect(Collectors.toList())));
@@ -491,7 +501,8 @@
                damage.setLine(bigStorageCageFeedTask.getLine());
                damage.setWorkingProcedure("冷加工");
                damage.setRemark("进笼前卧转立");
                damage.setStatus(2);
                damage.setStatus(0);
                damage.setType(bigStorageCageFeedTask.getTaskState());
                damageService.insertDamage(damage);
                slotList.add(bigStorageCageFeedTask.getTargetSlot());
            }
@@ -501,16 +512,15 @@
        }
        //获取出片任务表中状态为破损的数据
        List<BigStorageCageOutTask> outDamageTaskInfoList = bigStorageCageOutTaskService.list(new LambdaQueryWrapper<BigStorageCageOutTask>()
                .eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_DAMAGE));
                .in(BigStorageCageOutTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
        if (CollectionUtils.isNotEmpty(outDamageTaskInfoList)) {
            log.info("获取出片任务表中破损的玻璃信息{}", outDamageTaskInfoList);
            bigStorageCageOutTaskService.remove(new LambdaQueryWrapper<BigStorageCageOutTask>().eq(BigStorageCageOutTask::getTaskState, Const.BIG_STORAGE_OUT_DAMAGE));
            bigStorageCageOutTaskService.remove(new LambdaQueryWrapper<BigStorageCageOutTask>().in(BigStorageCageOutTask::getTaskState, Const.GLASS_STATE_DAMAGE_TAKE));
            List<String> glassIdList = outDamageTaskInfoList.stream().map(BigStorageCageOutTask::getGlassId).collect(Collectors.toList());
            //移除钢化下片表数据
            temperingGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().in(TemperingGlassInfo::getGlassId, glassIdList));
            //理片笼详情表数据状态删除
            bigStorageCageDetailsService.remove(new LambdaQueryWrapper<BigStorageCageDetails>().in(BigStorageCageDetails::getGlassId, glassIdList));

            //将破损信息新增入破损表
            List<Integer> slotList = new ArrayList<>();
            for (BigStorageCageOutTask bigStorageCageOutTask : outDamageTaskInfoList) {
@@ -519,7 +529,8 @@
                damage.setLine(bigStorageCageOutTask.getEndSlot());
                damage.setWorkingProcedure("冷加工");
                damage.setRemark("出片后卧转立");
                damage.setStatus(2);
                damage.setStatus(0);
                damage.setType(bigStorageCageOutTask.getTaskState());
                damageService.insertDamage(damage);
                slotList.add(bigStorageCageOutTask.getStartSlot());
            }
@@ -537,10 +548,20 @@
     */
    public Boolean judgeGlassTypeStatus(String glassId, Integer line, String mesAddress) {
        //1、获取任务表中相邻玻璃
        List<EdgGlassTaskInfo> edgGlassTaskInfoList = edgGlassTaskInfoService.list(new LambdaQueryWrapper<EdgGlassTaskInfo>()
        List<EdgGlassTaskInfo> edgGlassTaskInfoList;
        edgGlassTaskInfoList = edgGlassTaskInfoService.list(new LambdaQueryWrapper<EdgGlassTaskInfo>()
                .eq(EdgGlassTaskInfo::getLine, line)
                .apply("time >= (select time from edg_glass_task_info where glass_id = '" + glassId + "')")
                .apply("time >= (select time from edg_glass_task_info where line='" + line + "' and glass_id = '" + glassId + "' and deleted = 0)")
                .orderByAsc(EdgGlassTaskInfo::getTime));
        if (edgGlassTaskInfoList == null) {
            log.info("线路：{}识别玻璃信息未出现在尺寸表中,获取相邻两块玻璃失败", line);
        } else {
            edgGlassTaskInfoList = edgGlassTaskInfoService.list(new QueryWrapper<EdgGlassTaskInfo>()
                    .select("Top 1 *")
                    .eq("glass_id", glassId)
            );
            log.info("在尺寸表中获取玻璃信息{}", edgGlassTaskInfoList);
        }
        Assert.isFalse(CollectionUtils.isEmpty(edgGlassTaskInfoList), "识别玻璃信息未出现在尺寸表中,获取相邻两块玻璃失败");
        //2、获取卧转立剩余宽度
        BigStorageDTO sitToUpRemainWidth = bigStorageCageFeedTaskService.querySitToUpRemainWidth(line);
@@ -708,7 +729,7 @@
        while (returnData == 0) {
            s7control.writeWord(outLine, 2);
            returnData = s7control.readWord(outLine, 1).get(0);
            log.info("已向plc第{}次发送出片任务确认，地址为：{},写入的内容为{}", count++, outLine, returnData);
            log.info("已向plc第{}次发送进片任务确认，地址为：{},写入的内容为{}", count++, outLine, returnData);
        }
    }

@@ -818,13 +839,13 @@
        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);
        }
//        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;
    }


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

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

spring:
  profiles:
    active: dev
    active: cz
  application:
    name: cacheVerticalGlass
mybatis-plus:
@@ -16,7 +16,7 @@
  minCount: 20
  carWidth: 5000   #大车宽度
  slotWidth: 5000   #大车宽度
  inCarMaxSize: 1     #进片大车最大存放玻璃数量
  inCarMaxSize: 1    #进片大车最大存放玻璃数量
  outCarMaxSize: 2     #出片大车最大存放玻璃数量
  glassGap: 350  #玻璃间距
  xMaxSize: 2800

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

@@ -11,7 +11,8 @@
        WHERE T.MAX_THICKNESS >= #{thickness}
          AND T.ENABLE_STATE = 1
        GROUP BY T.DEVICE_ID
        ORDER BY COUNT(DISTINCT T1.ENGINEER_ID), COUNT(DISTINCT T1.TEMPERING_LAYOUT_ID),
        ORDER BY T.MAX_THICKNESS,
                 COUNT(DISTINCT T1.ENGINEER_ID), COUNT(DISTINCT T1.TEMPERING_LAYOUT_ID),
                 COUNT(DISTINCT T1.SLOT)
    </select>


 hangzhoumesParent/moduleService/CacheVerticalGlassModule/src/test/java/com/mes/CacheVerticalGlassModuleApplicationTest.java

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

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.mes.bigstorage.entity.BigStorageCage;
import com.mes.bigstorage.service.BigStorageCageDetailsService;
import com.mes.bigstorage.service.BigStorageCageService;
@@ -7,7 +9,10 @@
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.edgglasstask.entity.EdgGlassTaskInfo;
import com.mes.edgglasstask.service.EdgGlassTaskInfoService;
import com.mes.job.PlcStorageCageTask;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -37,6 +42,8 @@
    BigStorageCageDetailsService bigStorageCageDetailsService;
    @Autowired
    DamageService damageService;
    @Autowired
    EdgGlassTaskInfoService edgGlassTaskInfoService;

//    @Autowired
//    BigStorageCageFeedTaskMapper bigStorageCageFeedTaskMapper;
@@ -167,4 +174,13 @@
        plcStorageCageTask.updateOutGlassStateTask();
    }

    @Test
    public void chaxun(){
        List<EdgGlassTaskInfo> edgGlassTaskInfoList = edgGlassTaskInfoService.list(new QueryWrapper<EdgGlassTaskInfo>()
                .select("Top 1 *")
                .eq("glass_id", "P24072402|1|13")
        );
        log.info("在尺寸表中获取玻璃信息{}", edgGlassTaskInfoList);
    }

}

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/job/PlcScreenTask.java

@@ -36,11 +36,10 @@
     * fixedDelay : 上一个调用结束后再次调用的延时
     */

    @Scheduled(fixedDelay = 5000)
    @Scheduled(fixedDelay = 10000)
    public void screenHome() {
        JSONObject jsonObject = new JSONObject();
        Reportingdamage reportingdamage = new Reportingdamage();
        //reportingdamage.setReportingWorkTime("2024-05-11");
        // 获取当前日期
        LocalDate today = LocalDate.now();
        // 计算最近七天的开始日期
@@ -52,8 +51,9 @@
        String startOfPeriodStr = startOfPeriod.format(formatter);
        String endOfPeriodStr = endOfPeriod.format(formatter);
        // 设置为最近七天的时间范围
        reportingdamage.setReportingWorkTime("2024-05-11" + " to " + endOfPeriodStr);
        //reportingdamage.setReportingWorkTime(startOfPeriodStr + " to " + endOfPeriodStr);
        reportingdamage.setReportingWorkTime("2024-05-11");
        //reportingdamage.setReportingWorkTime("2024-05-11");
        reportingdamage.setReportingWorkTime2(endOfPeriodStr);
        //扇形图各设备的加工破损数量
        List<Reportingdamage> device = reportingWorkService.selectDamage(reportingdamage);
        jsonObject.append("device", device);

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/job/PlcTemperingGlassTask.java

@@ -86,6 +86,8 @@
        //正在进行的任务
        List<TemperingGlassInfo> temperingTaskType = temperingAgoService.selectTaskType();
        jsonObject.append("temperingTaskType", temperingTaskType);


        ArrayList<WebSocketServer> sendwServer = WebSocketServer.sessionMap.get("temperingIsRun");
        if (sendwServer != null) {
            for (WebSocketServer webserver : sendwServer) {

 hangzhoumesParent/moduleService/TemperingGlassModule/src/main/java/com/mes/job/TemperingTask.java

@@ -5,6 +5,8 @@
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.mes.common.S7object;
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.device.PlcParameterObject;
import com.mes.temperingglass.entity.TemperingGlassInfo;
import com.mes.temperingglass.service.TemperingGlassInfoService;
@@ -33,6 +35,10 @@

    @Autowired
    private TemperingGlassInfoService temporaryGlassInfoService;

    @Autowired
    private DamageService damageService;

    private static final String ALONE_STATE = "0";


@@ -54,6 +60,10 @@
        List<Object> temperRecordIdListObj = temporalRecordService.listObjs(new QueryWrapper<TemperingRecord>().select("distinct tempering_layout_id"));

        List<String> temperRecordIdList = temperRecordIdListObj.stream().map(String::valueOf).collect(Collectors.toList());
        if (CollectionUtils.isEmpty(temperRecordIdList)) {
            log.info("当前系统没有需要钢化的玻璃信息");
            return;
        }
        List<TemperingGlassInfo> list = temporaryGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>()
                .eq(TemperingGlassInfo::getState, Const.TEMPERING_START).notIn(TemperingGlassInfo::getTemperingLayoutId, temperRecordIdList));
        if (CollectionUtils.isEmpty(list)) {
@@ -77,4 +87,30 @@
    public void temperingGlassAfter() {

    }

    @Scheduled(fixedDelay = 1000)
    public void dealDamageTask() {
        Date startDate = new Date();
        log.info("钢化破损玻璃清除任务开始执行时间：{}", startDate);
        List<TemperingGlassInfo> temperingGlassInfoList = temporaryGlassInfoService.list(new LambdaQueryWrapper<TemperingGlassInfo>().in(TemperingGlassInfo::getState, Const.GLASS_STATE_DAMAGE_TAKE));
        if (CollectionUtils.isNotEmpty(temperingGlassInfoList)) {
            //获取破损/拿走玻璃id
            List<String> glassList = temperingGlassInfoList.stream().map(TemperingGlassInfo::getGlassId).collect(Collectors.toList());
            //将任务表中的数据删除
            temporaryGlassInfoService.remove(new LambdaQueryWrapper<TemperingGlassInfo>().in(TemperingGlassInfo::getGlassId, glassList));
            List<Damage> damageList = temperingGlassInfoList.stream().map(e -> {
                Damage damage = new Damage();
                damage.setGlassId(e.getGlassId());
                damage.setLine(Const.TEMPERING_OUT_TARGET_POSITION);
                damage.setWorkingProcedure("钢化");
                damage.setRemark("钢化");
                damage.setStatus(0);
                damage.setType(e.getState());
                return damage;
            }).collect(Collectors.toList());
            damageService.batchInsertDamage(damageList);
        }
        Date endDate = new Date();
        log.info("本次任务结束时间：{}，共耗时：{}ms", endDate, endDate.getTime() - startDate.getTime());
    }
}

 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/downglassinfo/entity/request/DownGlassInfoRequest.java

New file
@@ -0,0 +1,48 @@
package com.mes.downglassinfo.entity.request;

import com.fasterxml.jackson.annotation.JsonFormat;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.format.annotation.DateTimeFormat;

import java.io.Serializable;
import java.util.Date;

/**
 * <p>
 *
 * </p>
 *
 * @author zhoush
 * @since 2024-03-27
 */
@Data
@EqualsAndHashCode(callSuper = false)
public class DownGlassInfoRequest implements Serializable {

    /**
     * 工位id
     */
    private Integer workStationId;

    /**
     * 工程id
     */
    private String engineerId;

    /**
     * 开始时间
     */
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date beginDate;

    /**
     * 结束时间
     */
    @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
    @JsonFormat(pattern = "yyyy-MM-dd")
    private Date endDate;


}

 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/downglassinfo/service/impl/DownGlassInfoServiceImpl.java

@@ -1,24 +1,39 @@
package com.mes.downglassinfo.service.impl;

import cn.smallbun.screw.core.util.CollectionUtils;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.common.config.Const;
import com.mes.common.utils.RedisUtil;
import com.mes.downglassinfo.entity.DownGlassInfo;
import com.mes.downglassinfo.entity.request.DownGlassInfoRequest;
import com.mes.downglassinfo.mapper.DownGlassInfoMapper;
import com.mes.downglassinfo.service.DownGlassInfoService;
import com.mes.downstorage.entity.DownStorageCageDetails;
import com.mes.downstorage.service.DownStorageCageDetailsService;
import com.mes.downworkstation.entity.DownWorkstation;
import com.mes.downworkstation.entity.dto.DownGlassInfoDTO;
import com.mes.downworkstation.service.DownWorkstationService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.job.DownLoadCacheGlassTask;
import com.mes.pp.service.FlowCardService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

@Slf4j
@Service
public class DownGlassInfoServiceImpl extends ServiceImpl<DownGlassInfoMapper, DownGlassInfo> implements DownGlassInfoService {

@@ -27,6 +42,16 @@

    @Autowired
    DownStorageCageDetailsService downStorageCageDetailsService;


    @Autowired
    DownWorkstationService downWorkstationService;

    @Autowired
    RedisUtil redisUtil;

    @Autowired
    FlowCardService flowCardService;

    /**
     * 根据流程卡号查询最大序号
@@ -60,8 +85,15 @@
    }

    @Override
    public List<DownGlassInfoDTO> queryWorkStationIsIn(Boolean isDownload) {
        return baseMapper.queryWorkStationIsIn(isDownload);
    public List<DownGlassInfoDTO> queryWorkStationIsIn(List<Integer> workList, Boolean isDownload) {
        //按照要求获取已落架/未落架的玻璃信息
        return baseMapper.queryWorkStationIsIn(workList, isDownload);
    }

    @Override
    public List<DownGlassInfoDTO> queryWorkStationFlowCard(List<Integer> workList) {
        //获取已绑定流程卡的架子未落玻璃的数据信息
        return baseMapper.queryWorkStationFlowCard(workList);
    }

    @Override
@@ -76,10 +108,179 @@
        BeanUtils.copyProperties(details, downGlassInfo);
        //获取当前流程卡最大片序
        downGlassInfo.setSequence(this.getMaxSequenceByFlowCardId(details.getFlowCardId(), details.getLayer()) + 1);
        downGlassInfo.setWorkStationId(Const.G13_WORK_STATION);
        this.save(downGlassInfo);
        //生成任务信息 并向plc发送出片任务
        GlassInfo glassInfo = new GlassInfo();
        BeanUtils.copyProperties(details, glassInfo);
        return downLoadCacheGlassTask.initDownGlassTask(glassInfo, details.getSlot(), Const.G13_WORK_STATION, 2);
    }

    @Override
    public String setDownGlassInfoRequest(DownGlassInfoRequest request) {
        if (request == null) {
            redisUtil.deleteObject("downGlassRequest");
        } else {
            redisUtil.setCacheObject("downGlassRequest", request);
        }
        return "success";
    }

    @Override
    public List<DownWorkstation> queryWorkStationIsFull() {
        //查询可以落架的玻璃信息且已绑定流程卡的工位信息
        List<DownWorkstation> list = downWorkstationService.list(new LambdaQueryWrapper<DownWorkstation>().eq(DownWorkstation::getEnableState, Const.SLOT_ON)
                .isNotNull(DownWorkstation::getFlowCardId).ne(DownWorkstation::getFlowCardId, ""));
        List<DownWorkstation> workstationFull = new ArrayList<>();
        if (CollectionUtils.isNotEmpty(list)) {
            //都有玻璃的工位信息（包括绑定流程卡）
            List<Integer> workstationList = list.stream().map(DownWorkstation::getWorkstationId).collect(Collectors.toList());
            //按照符合条件的工位获取未落架的流程卡玻璃，如果返回为空，则表明所有都已落架完成
            List<DownGlassInfoDTO> downGlassInfoDTOList = queryWorkStationIsIn(workstationList, Boolean.FALSE);
            //获取工位上的未满的流程卡及层数
            List<String> flowCardIdList = downGlassInfoDTOList.stream().map(item -> item.getFlowCardId() + ":" + item.getLayer()).collect(Collectors.toList());
            //可以落架的玻璃信息且已绑定流程卡的所有的工位 - 玻璃未满流程卡及层数的工位  =  已满工位
            workstationFull = list.stream().filter(item -> !flowCardIdList.contains(item.getFlowCardId() + ":" + item.getLayer())).collect(Collectors.toList());
            //是否需要将已满的工位置为不可落架
            if (CollectionUtils.isNotEmpty(workstationFull)) {
                List<Integer> workstationIds = workstationFull.stream().map(DownWorkstation::getWorkstationId).collect(Collectors.toList());
                downWorkstationService.update(new LambdaUpdateWrapper<DownWorkstation>().set(DownWorkstation::getEnableState, Const.SLOT_OFF)
                        .in(DownWorkstation::getWorkstationId, workstationIds));
            }
        }
        return workstationFull;
    }

    @Override
    public List<Map<String, List<Map<String, Object>>>> downGlassPrint(DownGlassInfo downGlassInfo) {
        log.info("打印参数:{}", downGlassInfo);
        QueryWrapper<DownGlassInfo> queryWrapper = Wrappers.query();
        queryWrapper.eq("flow_card_id", downGlassInfo.getFlowCardId())
                .eq("layer", downGlassInfo.getLayer())
                .select("flow_card_id", "layer", "width", "height", "filmsid", "thickness", "glass_type", "COUNT(*) AS quantity")
                .groupBy("flow_card_id", "layer", "width", "height", "filmsid", "thickness", "glass_type", "id")
                .orderByAsc("id");
        List<Map<String, Object>> resultList = baseMapper.selectMaps(queryWrapper);

        log.info("MES落架数据:{}", resultList);

        List<Map<String, Object>> projectInfo = flowCardService.selectProject(downGlassInfo.getFlowCardId(), downGlassInfo.getLayer());
        log.info("流程卡头部数据:{}", projectInfo);
        List<Map<String, Object>> flowCardInfo = flowCardService.selectFlowCard(downGlassInfo.getFlowCardId(), downGlassInfo.getLayer());
        log.info("流程卡玻璃数据:{}", flowCardInfo);
        for (Map<String, Object> row : flowCardInfo) {
            int order_number = (int) row.get("order_number");
            int technology_number = (int) row.get("technology_number");
            int quantity1 = 0;
            for (Map<String, Object> row1 : resultList) {
                int glass_type = (int) row1.get("glass_type");
                int layer = (int) row1.get("layer");
//                String child_width = (String) row1.get("child_width");
//                Long quantity = (Long) row1.get("quantity");
//                BigDecimal total_area = (BigDecimal) row1.get("total_area");
//                String separation = (String) row1.get("separation");
//                String perimeter = (String) row1.get("perimeter");
//                BigDecimal width = (BigDecimal) row1.get("width");
//                String other_columns = (String) row1.get("other_columns");
//                String remarks = (String) row1.get("remarks");
//                BigDecimal height = (BigDecimal) row1.get("height");
                if (order_number == glass_type && technology_number == layer) {
                    quantity1+=1;
//                    row.put("quantity", quantity);
//                    row.put("order_number", order_number);
//                    row.put("technology_number", technology_number);
//                    row.put("child_width", child_width);
//                    row.put("total_area", total_area);
//                    row.put("separation", separation);
//                    row.put("perimeter", perimeter);
//                    row.put("width", width);
//                    row.put("other_columns", other_columns);
//                    row.put("remarks", remarks);
//                    row.put("height", height);
                }
            }
            row.put("quantity1", quantity1);
        }
        log.info("流程卡玻璃数据2:{}", flowCardInfo);
        List<Map<String, List<Map<String, Object>>>> listMap = new ArrayList<>();
        Map<String, List<Map<String, Object>>> result = new HashMap<>();
        result.put("detail", projectInfo);
        result.put("detailList", flowCardInfo);
        for (Map<String, Object> row : projectInfo) {
            String order_number = (String) row.get("process");
            String[] processes = order_number.split("->");
            List<Map<String, Object>> processList = new ArrayList<>();
            for (int i = 0; i < processes.length; i++) {
                Map<String, Object> processMap = new JSONObject();
                processMap.put("process", processes[i]);
                processMap.put("id", i);
                processList.add(processMap);
            }
            result.put("processList", processList);
        }
        listMap.add(result);
        return listMap;
    }


    @Override
    public List<Map<String, Object>> downGlassLabelPrint(DownGlassInfo downGlassInfo) {
        //获取下片玻璃的顺序
//        QueryWrapper<DownGlassInfo> queryWrapper = Wrappers.query();
//        queryWrapper
//                .eq("flow_card_id", downGlassInfo.getFlowCardId())
//                .eq("layer", downGlassInfo.getLayer())
//                .select("flow_card_id", "layer", "width", "height", "filmsid", "thickness", "glass_type", "COUNT(*) AS quantity")
//                .groupBy("flow_card_id", "layer", "width", "height", "filmsid", "thickness", "glass_type", "id")
//                .orderByAsc("id");
//        List<Map<String, Object>> resultList = baseMapper.selectMaps(queryWrapper);
        List<Map<String, Object>> resultList = baseMapper.downGlassLabelPrint(downGlassInfo.getFlowCardId(), downGlassInfo.getLayer());
        log.info("MES落架数据:{}", resultList);
        //获取ERP标签所需的信息
        List<Map<String, Object>> labelInfo = flowCardService.selectLabel(downGlassInfo.getFlowCardId(), downGlassInfo.getLayer());
        log.info("标签数据:{}", labelInfo);

        for (Map<String, Object> row : resultList) {
            int glass_type = (int) row.get("glass_type");
            int layer = (int) row.get("layer");
            for (Map<String, Object> row1 : labelInfo) {
                int orderNumber = (int) row1.get("orderNumber");
                int technologyNumber = (int) row1.get("technologyNumber");
                if (orderNumber == glass_type && technologyNumber == layer) {

                    String order_id = (String) row1.get("order_id");
                    String project = (String) row1.get("project");
                    Long customer_id = (Long) row1.get("customer_id");
                    BigDecimal width = (BigDecimal) row1.get("width");
                    BigDecimal height = (BigDecimal) row1.get("height");
                    Long quantity = (Long) row1.get("quantity");
                    String glass_child = (String) row1.get("glass_child");
                    String process = (String) row1.get("process");
                    String customer_name = (String) row1.get("customer_name");
                    String processing_note = (String) row1.get("processing_note");
                    String other_colunmns = (String) row1.get("other_colunmns");
                    String building_number = (String) row1.get("building_number");
                    String bend_radius = (String) row1.get("bend_radius");

                    row.put("orderNumber", orderNumber);
                    row.put("technology_number", technologyNumber);
                    row.put("order_id", order_id);
                    row.put("project", project);
                    row.put("customer_id", customer_id);
                    row.put("width", width);
                    row.put("height", height);
                    row.put("quantity", quantity);
                    row.put("glass_child", glass_child);
                    row.put("process", process);
                    row.put("customer_name", customer_name);
                    row.put("processing_note", processing_note);
                    row.put("other_colunmns", other_colunmns);
                    row.put("building_number", building_number);
                    row.put("bend_radius", bend_radius);
                }
            }
        }
        return resultList;
    }

}

 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/downstorage/entity/request/CacheWornRequest.java

New file
@@ -0,0 +1,28 @@
package com.mes.downstorage.entity.request;

import lombok.Data;

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.NotNull;


/**
 * @Author : zhoush
 * @Date: 2024/8/10 13:34
 * @Description:
 */
@Data
public class CacheWornRequest {

    @NotBlank(message = "玻璃ID不能为空")
    private String glassId;

    @NotNull(message = "状态不能为空")
    private int state;

    @NotNull(message = "线路不能为空")
    private int line;

    @NotBlank(message = "工序不能为空")
    private String workingProcedure;
}

 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/downstorage/service/impl/DownStorageCageServiceImpl.java

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

import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.yulichang.toolkit.JoinWrappers;
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.downglassinfo.entity.DownGlassTask;
import com.mes.downglassinfo.service.DownGlassTaskService;
import com.mes.downstorage.entity.DownStorageCage;
import com.mes.downstorage.entity.DownStorageCageDetails;
import com.mes.downstorage.entity.request.CacheWornRequest;
import com.mes.downstorage.mapper.DownStorageCageDetailsMapper;
import com.mes.downstorage.mapper.DownStorageCageMapper;
import com.mes.downstorage.service.DownStorageCageDetailsService;
@@ -46,6 +50,8 @@
    private DownStorageCageDetailsService downStorageCageDetailsService;
    @Autowired
    private DownStorageCageDetailsMapper downStorageCageDetailsMapper;
    @Autowired
    DamageService damageService;

    @Override
    public DownGlassTask createDownGlassTask(GlassInfo glassInfo, Integer startCell, Integer endCell, Integer taskType) {
@@ -128,7 +134,6 @@
    }



    @Override
    public List<Map<String, Object>> selectDownStorageCages() {
        return baseMapper.selectJoinMaps(JoinWrappers.lambda(DownStorageCage.class)
@@ -190,7 +195,10 @@

        if (downItem != null) {
            //移除
            DownStorageCageDetails result = downStorageCageDetailsMapper.selectOne(new MPJLambdaWrapper<DownStorageCageDetails>().eq(DownStorageCageDetails::getSlot, downStorageCageId));
            DownStorageCageDetails result = downStorageCageDetailsMapper
                    .selectOne(new MPJLambdaWrapper<DownStorageCageDetails>()
                            .eq(DownStorageCageDetails::getSlot, downStorageCageId)
                    );
            if (result != null) {
                result.setSlot(0);
                downStorageCageDetailsMapper.updateById(result);
@@ -200,4 +208,19 @@
        return true;
    }

    @Override
    public void deleteDownStorageCage(CacheWornRequest cacheWornRequest) {
        Damage damage = new Damage();
        BeanUtils.copyProperties(cacheWornRequest, damage);
        damage.setType(cacheWornRequest.getState());
        damage.setRemark("");
        damage.setStatus(0);
        damageService.insertDamage(damage);
        downStorageCageDetailsService.update(new LambdaUpdateWrapper<DownStorageCageDetails>()
                .set(DownStorageCageDetails::getState, Const.GLASS_STATE_OUT)
                .eq(DownStorageCageDetails::getGlassId, cacheWornRequest.getGlassId())
                .eq(DownStorageCageDetails::getState,Const.GLASS_STATE_IN));

    }

}

 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/downworkstation/controller/DownWorkstationController.java

@@ -137,6 +137,26 @@
        return Result.build(200, "修改成功", redisUtil.getCacheObject("autoPrint"));
    }

    @ApiOperation("新增虚拟工位")
    @PostMapping("/insertDownWorkstation")
    public Result insertDownWorkstation() {
        DownWorkstation downWorkstation = new DownWorkstation();
        downWorkstation.setTotalQuantity(0);
        downWorkstation.setRacksNumber(0);
        downWorkstation.setOtherNumber(0);
        downWorkstation.setDeviceId(3);
        downWorkstation.setEnableState(1);
        downWorkstation.setWorkState(1);
        downWorkstationService.save(downWorkstation);
        return Result.build(200, "新增成功", 1);
    }

    @ApiOperation("删除虚拟工位")
    @PostMapping("/deleteDownWorkstation")
    public Result deleteDownWorkstation(DownWorkstation downWorkstation) {
        downWorkstationService.removeById(downWorkstation.getWorkstationId());
        return Result.build(200, "删除成功", 1);
    }

}


 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/downworkstation/service/impl/DownWorkstationServiceImpl.java

@@ -4,12 +4,13 @@
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.yulichang.query.MPJQueryWrapper;
import com.mes.common.S7object;
import com.mes.common.utils.RedisUtil;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.device.PlcParameterObject;
import com.mes.downglassinfo.entity.DownGlassInfo;
import com.mes.downglassinfo.mapper.DownGlassInfoMapper;
import com.mes.downglassinfo.service.DownGlassInfoService;
import com.mes.downglassinfo.service.DownGlassTaskService;
import com.mes.downworkstation.entity.DownWorkstation;
import com.mes.downworkstation.entity.DownWorkstationTask;
import com.mes.downworkstation.entity.DownWorkstionAndDownGlassinfo;
@@ -23,6 +24,7 @@
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
@@ -37,11 +39,7 @@
    @Autowired(required = false)
    private DownWorkstationTaskMapper downWorkstationTaskMapper;
    @Autowired
    private DownGlassInfoService downGlassInfoService;
    @Autowired
    private DownGlassInfoMapper downGlassInfoMapper;
    @Autowired
    private DownGlassTaskService downGlassTaskService;
    @Autowired
    private GlassInfoService glassInfoService;
    @Autowired
@@ -49,6 +47,8 @@

    @Autowired
    private DownWorkstationTaskService downWorkstationTaskService;
    @Resource
    private RedisUtil redisUtil;

    //    @Override
//    public List<DownWorkstation> gettwoDownWorkstations() {
@@ -69,7 +69,7 @@
    @Override
    public List<Map<String, Object>> getTotalGlassDimensionsByWorkstation(int start, int end) {
        MPJQueryWrapper<DownWorkstation> queryWrapper = new MPJQueryWrapper<>();
        queryWrapper.select("t.workstation_id", "t.flow_card_id", "COALESCE(SUM(b.width), 0) AS totalwidth", "COALESCE(SUM(b.height), 0) AS totalheight")
        queryWrapper.select("t.workstation_id", "t.flow_card_id", "COALESCE(SUM(b.width), 0) AS totalwidth", "COALESCE(SUM(b.height), 0) AS totalheight,total_quantity,racks_number,other_number")
                .leftJoin("down_glass_info b on t.flow_card_id = b.flow_card_id")
                .groupBy("t.workstation_id", "t.flow_card_id")
                .orderByAsc("t.workstation_id").between("t.workstation_id", start, end)
@@ -86,6 +86,11 @@
            item.put("width", downWorkstionAndDownGlassinfo.getTotalwidth());
            item.put("fillColor", "yellow");
            item.put("content", downWorkstionAndDownGlassinfo.getFlowCardId());
            if (downWorkstionAndDownGlassinfo.getFlowCardId() != "" && downWorkstionAndDownGlassinfo.getFlowCardId() != null && downWorkstionAndDownGlassinfo.getTotalQuantity() == downWorkstionAndDownGlassinfo.getRacksNumber() + downWorkstionAndDownGlassinfo.getRacksNumber()) {
                item.put("fullCardColor", "red");
            } else {
                item.put("fullCardColor", "blue");
            }

            // 查询 DownGlassInfo 并添加到 item 中
            MPJQueryWrapper<DownGlassInfo> glassInfoQueryWrapper = new MPJQueryWrapper<>();
@@ -165,6 +170,8 @@
        updateWrapper.set("flow_card_id", null)
                .set("total_quantity", 0)
                .set("racks_number", 0)
                .set("other_number", 0)
                .set("layer", null)
                .eq("workstation_id", workstationId);

        baseMapper.update(new DownWorkstation(), updateWrapper);
@@ -209,5 +216,16 @@
        }
    }

    @Override
    public String closeAlarmSignal() {
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        S7object.getinstance().plccontrol.writeWord(plcParameterObject.getPlcParameter("alarm_signal").getAddress(), 0);
        return "success";
    }

    @Override
    public void autoPrint(Boolean flag) {
        redisUtil.setCacheObject("autoPrint", flag);
    }

}

 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/job/DownLoadCacheGlassTask.java

@@ -3,10 +3,13 @@
import cn.hutool.core.lang.Assert;
import cn.smallbun.screw.core.util.CollectionUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.mes.common.S7object;
import com.mes.common.config.Const;
import com.mes.damage.entity.Damage;
import com.mes.damage.service.DamageService;
import com.mes.device.PlcParameterObject;
import com.mes.downglassinfo.entity.DownGlassInfo;
import com.mes.downglassinfo.entity.DownGlassTask;
@@ -54,9 +57,8 @@
    DownWorkstationService downWorkstationService;
    @Autowired
    DownGlassInfoService downGlassInfoService;

    @Value("${mes.threshold}")
    private Integer threshold;
    @Autowired
    DamageService damageService;

    @Value("${mes.throughWidth}")
    private Integer throughWidth;
@@ -126,6 +128,68 @@
        }
    }

    @Scheduled(fixedDelay = 300)
    public void plcShelfFull() {
        List<DownWorkstation> list = downGlassInfoService.queryWorkStationIsFull();
        if (CollectionUtils.isNotEmpty(list)) {
            S7control s7control = S7object.getinstance().plccontrol;
            PlcParameterObject plcMesObject = S7object.getinstance().PlcMesObject;
            s7control.writeWord(plcMesObject.getPlcParameter("alarm_signal").getAddress(), 1);
        }
    }

    @Scheduled(fixedDelay = 1000)
    public void dealDamageTask() {
        Date startDate = new Date();
        log.info("下片破损玻璃清除任务开始执行时间：{}", startDate);
        List<DownGlassTask> downGlassTaskList = downGlassTaskService.list(new LambdaQueryWrapper<DownGlassTask>()
                .in(DownGlassTask::getTaskType, Const.GLASS_CACHE_TYPE_OUT_ALL).in(DownGlassTask::getTaskStatus, Const.GLASS_STATE_DAMAGE_TAKE));
        if (CollectionUtils.isNotEmpty(downGlassTaskList)) {
            //获取破损/拿走玻璃id
            List<String> glassList = downGlassTaskList.stream().map(DownGlassTask::getGlassId).collect(Collectors.toList());
            //将任务表中的数据删除
            downGlassTaskService.remove(new LambdaQueryWrapper<DownGlassTask>().in(DownGlassTask::getTaskType, Const.GLASS_CACHE_TYPE_OUT_ALL).in(DownGlassTask::getGlassId, glassList));
            List<Damage> damageList = downGlassTaskList.stream().map(e -> {
                Damage damage = new Damage();
                damage.setGlassId(e.getGlassId());
                damage.setLine(Const.TEMPERING_OUT_TARGET_POSITION);
                damage.setWorkingProcedure("下片");
                damage.setRemark("下片");
                damage.setStatus(0);
                damage.setType(e.getTaskStatus());
                return damage;
            }).collect(Collectors.toList());
            damageService.batchInsertDamage(damageList);
        }
        Date endDate = new Date();
        log.info("本次任务结束时间：{}，共耗时：{}ms", endDate, endDate.getTime() - startDate.getTime());
    }

    /**
     * 更新已绑定工位流程卡的破损/拿走的数量信息
     */
    @Scheduled(fixedDelay = 1000)
    public void updateWorkStationOtherCount() {
        Date startDate = new Date();
        log.info("下片破更新损玻璃数量任务开始执行时间：{}", startDate);
        //获取已绑定流程卡的工位信息
        List<DownWorkstation> downWorkstationList = downWorkstationService.list(new LambdaQueryWrapper<DownWorkstation>()
                .isNotNull(DownWorkstation::getFlowCardId)
                .ne(DownWorkstation::getFlowCardId, "")
                .orderByDesc(DownWorkstation::getWorkstationId));
        for (DownWorkstation downWorkstation : downWorkstationList) {
            //更新工位其他玻璃信息的数量
            QueryWrapper<Damage> queryWrapper = new QueryWrapper<>();
            queryWrapper.eq("process_id", downWorkstation.getFlowCardId());
            queryWrapper.eq("technology_number", downWorkstation.getLayer());
            int otherNumber = damageService.count(queryWrapper);
            downWorkstationService.update(new LambdaUpdateWrapper<DownWorkstation>().set(DownWorkstation::getOtherNumber, otherNumber)
                    .eq(DownWorkstation::getWorkstationId, downWorkstation.getWorkstationId()));
        }
        Date endDate = new Date();
        log.info("下片破更新损玻璃数量任务结束时间：{}，共耗时：{}ms", endDate, endDate.getTime() - startDate.getTime());
    }

    public void inTo(String glassId, String requestWord, String currentSlot) {
        log.info("1、按照玻璃id:{}获取玻璃小片信息,当前格子为:{}", glassId, currentSlot);
        //添加进片任务  查找空格
@@ -170,7 +234,7 @@
            }
            if (!checkFlag) {
                log.info("无空架子,获取已绑定架子的流程卡信息,查看玻璃信息是否可被对调");
                List<DownGlassInfoDTO> downGlassInfoDTOList = downGlassInfoService.queryWorkStationIsIn(Boolean.FALSE);
                List<DownGlassInfoDTO> downGlassInfoDTOList = downGlassInfoService.queryWorkStationIsIn(Const.WORK_STATION_ALL, Boolean.FALSE);
                log.info("获取架子上已绑定流程卡落架的数量及未落架的玻璃数据：{}", downGlassInfoDTOList);
                if (CollectionUtils.isEmpty(downGlassInfoDTOList)) {
                    log.info("已绑定流程卡均无未落架玻璃，请及时处理架子上的玻璃，清除流程卡,执行进片任务");
@@ -215,6 +279,7 @@
        BeanUtils.copyProperties(glassInfo, downStorageCageDetails);
        downStorageCageDetails.setState(Const.GLASS_STATE_IN);
        downStorageCageDetails.setSlot(nearestEmpty.getSlot());
        downStorageCageDetails.setDeviceId(nearestEmpty.getDeviceId());
        downStorageCageDetailsService.save(downStorageCageDetails);
        //        生成进片任务
        initDownGlassTask(glassInfo, 0, nearestEmpty.getSlot(), Const.GLASS_CACHE_TYPE_IN);
@@ -237,6 +302,7 @@
            //获取当前笼子空格信息
            DownStorageCage empty = downStorageCageService.selectCacheEmpty(Integer.parseInt(currentSlot), Boolean.TRUE);
            cageDetails.setSlot(empty.getSlot());
            cageDetails.setDeviceId(empty.getDeviceId());
            tempList.add(cageDetails);
        }
        log.info("出片2：笼内玻璃的数据(包括待进片)有：{}", tempList);
@@ -309,6 +375,7 @@
            }
        }
        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:无
@@ -339,8 +406,15 @@
                            .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());
                    if (CollectionUtils.isEmpty(list) && 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 {
                    log.info("存在未绑定流程卡架子，直接获取笼内所有玻璃,且未绑定架子的玻璃信息");
                    log.info("存在未绑定流程卡架子，直接获取笼内所有玻璃,且未绑定架子的玻璃信息（都可以出的玻璃）");
                    //获取禁用及非本机械臂的架子的流程号及层数对应的玻璃信息
                    List<DownWorkstation> downWorkstationOffList = downWorkstationService.list(new LambdaQueryWrapper<DownWorkstation>()
                            .and(i -> i.in(DownWorkstation::getWorkstationId, offWorkStationList).or().eq(DownWorkstation::getEnableState, Const.SLOT_OFF)));
@@ -370,6 +444,8 @@
            log.info("笼内玻璃无法执行出片");
            return Boolean.FALSE;
        }
        //获取具体出那一片玻璃
        //tao:人工--> 所有架子都未绑定时进行绑定 --->有未绑定架子时进行绑定 --->绑定过流程卡的玻璃-->玻璃流程卡多层--->玻璃流程卡单层
        String tempGlassId = null;
        Boolean isNeedBind = Boolean.FALSE;

@@ -387,16 +463,17 @@
        loop:
        if (StringUtils.isBlank(tempGlassId)) {
            //获取正在落架的绑定流程卡的信息(流程卡、层数、落架数量)
            List<DownGlassInfoDTO> downGlassInfoDTOList = downGlassInfoService.queryWorkStationIsIn(Boolean.TRUE);
            //落架玻璃数为0，即使绑定了流程卡，也无法找到对应的架子信息，只能重新绑定
            List<DownGlassInfoDTO> downGlassInfoDTOList = downGlassInfoService.queryWorkStationFlowCard(workList);
            List<String> downGlassFlowList = downGlassInfoDTOList.stream().map(item -> item.getFlowCardId() + ":" + item.getLayer()).collect(Collectors.toList());
            if (CollectionUtils.isEmpty(downGlassFlowList)) {
                //架子都未绑定流程卡，出笼内子数量最多尺寸最大的玻璃id,无  则返回扫描扫到的玻璃id进行出片
                tempGlassId = downStorageCageDetailsService.getGlassInfoMaxCount(glassId, offWorkStationList);

                isNeedBind = Boolean.TRUE;
                break loop;
            }
            //将笼子内的玻璃进行过滤，仅获取无法落架的流程卡玻璃
            //tao:当有空架时优先对笼内可出片且未绑架子的玻璃进出绑架并出片
            List<DownStorageCageDetails> noDownLoadList = list.stream().filter(item -> !downGlassFlowList.contains(item.getFlowCardId() + ":" + item.getLayer()))
                    .collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(noDownLoadList)) {
@@ -417,7 +494,7 @@
                return Boolean.FALSE;
            }
            //将笼内玻璃的流程卡+层号 和落架的流程卡 去重，得出展示无法落架的玻璃，判断玻璃数是否超过阈值
            //笼内玻璃是否可落架:笼内是否有需要中空的
            //笼内玻璃是否可落架:笼内是否有需要中空
            List<DownStorageCageDetails> multiLayerList = list.stream().filter(item -> item.getTotalLayer() >= 2).collect(Collectors.toList());
            if (CollectionUtils.isNotEmpty(multiLayerList)) {
                for (DownStorageCageDetails item : multiLayerList) {
@@ -434,7 +511,7 @@
                        break loop;
                    }
                    Integer sequence = downGlassInfoService.queryMaxSequence(item.getFlowCardId(), item.getLayer());
                    log.info("获取当前玻璃需要放的次序：笼内同流程 同层数的通达次序+1:{}", sequence);
                    log.info("获取当前玻璃需要放的次序：笼内同流程 同层数的落架次序+1:{}", sequence);
                    DownGlassInfo downGlassInfo = downGlassInfoService.getOne(new LambdaQueryWrapper<DownGlassInfo>()
                            .eq(DownGlassInfo::getFlowCardId, downGlassInfoDTO.getFlowCardId())
                            .eq(DownGlassInfo::getLayer, downGlassInfoDTO.getLayer()).eq(DownGlassInfo::getSequence, sequence));
@@ -456,6 +533,7 @@
                        if (CollectionUtils.isNotEmpty(downStorageCageDetails)) {
                            tempGlassId = downStorageCageDetails.get(0).getGlassId();
                            break;

                        }
                    }
                }
@@ -527,6 +605,7 @@
        //落架片序
        downGlassInfo.setSequence(downGlassInfoService.queryMaxSequence(downGlassInfo.getFlowCardId(), downGlassInfo.getLayer()));
        downGlassInfo.setWorkStationId(endCell);
        downGlassInfo.setGmtCreate(new Date());
        downGlassInfoService.save(downGlassInfo);
        //生成任务信息
        GlassInfo glassInfo = new GlassInfo();

 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/java/com/mes/job/Downpush.java

@@ -2,13 +2,21 @@


import cn.hutool.json.JSONObject;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;

import com.mes.common.config.Const;

import com.mes.common.utils.RedisUtil;

import com.mes.downglassinfo.entity.DownGlassInfo;

import com.mes.downglassinfo.entity.DownGlassTask;

import com.mes.downglassinfo.entity.request.DownGlassInfoRequest;

import com.mes.downglassinfo.service.DownGlassInfoService;

import com.mes.downglassinfo.service.DownGlassTaskService;

import com.mes.downstorage.service.DownStorageCageService;

import com.mes.downworkstation.entity.DownWorkstation;

import com.mes.downworkstation.service.DownWorkstationService;

import com.mes.tools.DateUtil;

import com.mes.tools.WebSocketServer;

import lombok.extern.slf4j.Slf4j;

import org.apache.commons.lang.StringUtils;

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

import org.springframework.scheduling.annotation.Scheduled;

import org.springframework.stereotype.Component;

@@ -28,19 +36,25 @@
    private DownStorageCageService downStorageCageService;

    @Autowired

    private DownGlassInfoService downGlassInfoService;

    @Autowired

    private DownGlassTaskService downGlassTaskService;





    @Autowired

    private RedisUtil redisUtil;



    @Scheduled(fixedDelay = 2000)

    public void sendDownWorkstations() {

        log.info("发送工位玻璃信息");

        JSONObject jsonObject = new JSONObject();



        List<DownWorkstation> data = downWorkstationService.getoneDownWorkstations(1, 6);

        List<DownWorkstation> data = downWorkstationService.list();

        jsonObject.append("params", data);

        log.info(jsonObject.toString());

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

        if (sendwServer != null) {

            for (WebSocketServer webserver : sendwServer) {

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

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

                    log.info("已发送");

                    webserver.sendMessage(jsonObject.toString());

                }

@@ -52,13 +66,13 @@
    public void sendGlassInfoData() {

        log.info("发送工位显示图信息1");

        JSONObject jsonObject2 = new JSONObject();

        List<Map<String, Object>> glassinfodata = downWorkstationService.getTotalGlassDimensionsByWorkstation(1,3);

        jsonObject2.append("glassinfo",glassinfodata);

        List<Map<String, Object>> glassinfodata = downWorkstationService.getTotalGlassDimensionsByWorkstation(1, 3);

        jsonObject2.append("glassinfo", glassinfodata);

        log.info(jsonObject2.toString());

        ArrayList<WebSocketServer> sendwServer2 = WebSocketServer.sessionMap.get("unloadglass2");

        if (sendwServer2 != null) {

            for (WebSocketServer webserver : sendwServer2) {

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

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

                    webserver.sendMessage(jsonObject2.toString());

                }

            }

@@ -69,46 +83,27 @@
    public void sendGlassInfoData2() {

        log.info("发送工位显示图信息2");

        JSONObject jsonObject3 = new JSONObject();

        List<Map<String, Object>> glassinfodata2 = downWorkstationService.getTotalGlassDimensionsByWorkstation(4,6);

        jsonObject3.append("glassinfo2",glassinfodata2);

        List<Map<String, Object>> glassinfodata2 = downWorkstationService.getTotalGlassDimensionsByWorkstation(4, 6);

        jsonObject3.append("glassinfo2", glassinfodata2);

        log.info(jsonObject3.toString());

        ArrayList<WebSocketServer> sendwServer3 = WebSocketServer.sessionMap.get("unloadglass3");

        if (sendwServer3 != null) {

            for (WebSocketServer webserver : sendwServer3) {

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

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

                    webserver.sendMessage(jsonObject3.toString());

                }

            }

        }

    }



   @Scheduled(fixedDelay = 2000)

    @Scheduled(fixedDelay = 2000)

    public void sendDownStorageCages() {

        log.info("发送缓存玻璃信息");

        JSONObject jsonObject4 = new JSONObject();

        List<Map<String, Object>> list=downStorageCageService.selectDownStorageCages();

        jsonObject4.append("params2",list);

       log.info(jsonObject4.toString());

       ArrayList<WebSocketServer> sendwServer4 = WebSocketServer.sessionMap.get("downcache");

       if (sendwServer4 != null) {

           for (WebSocketServer webserver : sendwServer4) {

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

                   webserver.sendMessage(jsonObject4.toString());

               }

           }

       }

   }



    @Scheduled(fixedDelay = 2000)

    public void sendDownGlassInfo() {

        log.info("发送当前正在执行工程已落架的玻璃信息");

        List<DownGlassInfo> downGlassInfos = downGlassInfoService.list(new LambdaQueryWrapper<DownGlassInfo>()

                .inSql(DownGlassInfo::getEngineerId, "select engineer_id from engineering where state = 1"));

        Map<Integer, List<DownGlassInfo>> listMap = downGlassInfos.stream().collect(Collectors.groupingBy(DownGlassInfo::getWorkStationId));

        JSONObject jsonObject4 = new JSONObject();

        List<Map<String, Object>> list = downStorageCageService.selectDownStorageCages();

        jsonObject4.append("params", listMap);

        ArrayList<WebSocketServer> sendwServer4 = WebSocketServer.sessionMap.get("sendDownGlass");

        jsonObject4.append("params2", list);

        log.info(jsonObject4.toString());

        ArrayList<WebSocketServer> sendwServer4 = WebSocketServer.sessionMap.get("downcache");

        if (sendwServer4 != null) {

            for (WebSocketServer webserver : sendwServer4) {

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

@@ -117,4 +112,80 @@
            }

        }

    }



    @Scheduled(fixedDelay = 2000)

    public void sendDownGlassInfo() {

        DownGlassInfoRequest request = redisUtil.getCacheObject("downGlassRequest");

        if (null == request) {

            request = new DownGlassInfoRequest();

        }

        if (request.getBeginDate() == null) {

            request.setBeginDate(DateUtil.getBeginDate());

            request.setEndDate(DateUtil.getEndDate());

        }

        log.info("发送当前正在执行工程已落架的玻璃信息");

        LambdaQueryWrapper<DownGlassInfo> wrapper = new LambdaQueryWrapper<DownGlassInfo>()

                .between(null != request.getBeginDate(), DownGlassInfo::getGmtCreate, request.getBeginDate(), request.getEndDate())

                .eq(StringUtils.isNotBlank(request.getEngineerId()), DownGlassInfo::getEngineerId, request.getEngineerId());

        if (null == request.getWorkStationId() || 0 == request.getWorkStationId()) {

            wrapper.in(DownGlassInfo::getWorkStationId, Const.WORK_STATION_ALL);

        } else {

            wrapper.eq(DownGlassInfo::getWorkStationId, request.getWorkStationId());

        }

        List<DownGlassInfo> downGlassInfos = downGlassInfoService.list(wrapper);

//        Map<Integer, List<DownGlassInfo>> listMap = downGlassInfos.stream().collect(Collectors.groupingBy(DownGlassInfo::getWorkStationId));

        List<Object> engineerIdListTemp = downGlassInfoService.listObjs(new QueryWrapper<DownGlassInfo>().select("distinct engineer_id"));

        List<String> engineerIdList = engineerIdListTemp.stream().map(String::valueOf).collect(Collectors.toList());

        JSONObject jsonObject4 = new JSONObject();

        jsonObject4.append("downGlassInfos", downGlassInfos);

        jsonObject4.append("engineerIdList", engineerIdList);



        //钢化开关

        boolean autoPrint = false;

        if (redisUtil.getCacheObject("autoPrint") == null) {

            redisUtil.setCacheObject("autoPrint", false);

        } else {

            autoPrint = redisUtil.getCacheObject("autoPrint");

        }

        jsonObject4.append("autoPrint", autoPrint);

        //人工下片位置最后一片

        DownGlassTask takeGlass = downGlassTaskService.getOne(

                new QueryWrapper<DownGlassTask>()

                        .select("Top 1 *")

                        .eq("end_cell", Const.G13_WORK_STATION)

                        .orderByDesc("id")



        );

        jsonObject4.append("takeGlass", takeGlass);





        ArrayList<WebSocketServer> sendwServer4 = WebSocketServer.sessionMap.get("unloadglass");

        if (sendwServer4 != null) {

            for (WebSocketServer webserver : sendwServer4) {

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

                    webserver.sendMessage(jsonObject4.toString());

                }

            }

        }

    }



    @Scheduled(fixedDelay = 1000)

    public void isRun() {

        JSONObject jsonObject = new JSONObject();

        //正在进行的任务

        List<DownWorkstation> downWorkstation = downWorkstationService.getoneDownWorkstations(1, 6);

        jsonObject.append("downWorkstation", downWorkstation);

        List<DownGlassTask> downGlassTask = downGlassTaskService.selectOutTaskCache();

        jsonObject.append("downGlassTask", downGlassTask);

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

        if (sendwServer != null) {

            for (WebSocketServer webserver : sendwServer) {

                if (webserver != null) {

                    webserver.sendMessage(jsonObject.toString());

                } else {

                    log.info("unLoadGlassIsRun is closed");

                }

            }

        }

    }

}


 hangzhoumesParent/moduleService/UnLoadGlassModule/src/main/resources/JsonFile/PlcdownGlass.json