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

严智鑫

2024-05-22 a26b51820af00beb5ee73c821907598e2eae7178

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

# Conflicts:
#	hangzhoumesParent/common/springsecurity/src/main/java/com/mes/menu/service/impl/SysMenuServiceImpl.java

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

@@ -37,9 +37,11 @@
     * 卧式理片笼详情表玻璃状态
     * 进片任务1
     * 出片任务2
     * 出片任务2
     */
    public static final Integer GLASS_CACHE_TYPE_IN = 1;
    public static final Integer GLASS_CACHE_TYPE_OUT = 2;
    public static final Integer GLASS_CACHE_TYPE_THROUGH = 3;

    /**
     * 磨边任务玻璃状态

 hangzhoumesParent/common/springsecurity/src/main/java/com/mes/menu/service/impl/SysMenuServiceImpl.java

@@ -21,7 +21,6 @@
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@@ -58,25 +57,18 @@
    @Override
    public List<SysMenu> getMenuTree(GeneralRequest request) {
        //todo:需要先获取用户的角色，角色下的菜单权限，拿到菜单id获取所有菜单

        SysUser user = UserInfoUtils.get();
        log.info("UserDatas：{}-----{}-------{}",request.getKey(),user,StringUtils.isNotBlank(request.getKey()));
        if(user!=null){
            MPJLambdaWrapper<SysUserRole> wrapper = new MPJLambdaWrapper<>();
        MPJLambdaWrapper<SysUserRole> wrapper = new MPJLambdaWrapper<>();

            wrapper.selectAll(SysMenu.class).distinct()
                    .leftJoin(SysUser.class, SysUser::getId, SysUserRole::getUserId)
                    .leftJoin(SysRoleMenu.class, SysRoleMenu::getRoleId, SysUserRole::getRoleId)
                    .leftJoin(SysMenu.class, SysMenu::getId, SysRoleMenu::getMenuId)
                    .eq(SysUser::getId, user.getId())
                    .like(StringUtils.isNotBlank(request.getKey()), SysMenu::getMenuName, request.getKey());
        wrapper.selectAll(SysMenu.class).distinct()
                .innerJoin(SysUser.class, SysUser::getId, SysUserRole::getUserId)
                .innerJoin(SysRoleMenu.class, SysRoleMenu::getRoleId, SysUserRole::getRoleId)
                .innerJoin(SysMenu.class, SysMenu::getId, SysRoleMenu::getMenuId)
                .eq(SysUser::getId, user.getId())
                .like(StringUtils.isNotBlank(request.getKey()), SysMenu::getMenuName, request.getKey());

            List<SysMenu> menuList = sysUserRoleMapper.selectJoinList(SysMenu.class, wrapper);
            log.info("List<SysMenu> menuList：{}",menuList);
            return create(menuList);

        }
        return null;
        List<SysMenu> menuList = sysUserRoleMapper.selectJoinList(SysMenu.class, wrapper);
        return create(menuList);
    }

    @Override

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

File was deleted

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

File was deleted

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

@@ -1,10 +1,12 @@
server:
  port: 88
spring:
  profiles:
    active: prod
  application:
    name: gateway
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
    gateway:
      discovery:
        locator:

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

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

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;
@@ -33,6 +34,9 @@
    @Autowired
    private EdgStorageCageService edgStorageCageService;

    @Autowired
    private EdgStorageCageDetailsService edgStorageCageDetailsService;

    @ApiOperation("查询磨边缓存理片笼内详情 参数()")
    @PostMapping("/selectEdgStorageCage")
    @ResponseBody
@@ -54,6 +58,7 @@
        boolean isSucess=edgStorageCageService.updateEdgStorageCage(edgStorageCage);
        return Result.build(200,"【启用/禁用】成功",1);
    }

    @ApiOperation("磨边缓存理片笼信息   功能：对笼内栅格玻璃进行【清除/更换/绑定】 EdgStorageCage格子信息,EdgStorageCageDetails 玻璃信息 ")
    @PostMapping("/edgStorageCageGlass")
    @ResponseBody
@@ -62,5 +67,15 @@
        return Result.build(200,"【清除/更换/绑定】成功",1);
    }

    @ApiOperation("磨边模块汇报玻璃状态   功能：对笼内栅格玻璃进行【破损/拿走】  ")
    @PostMapping("/edgReportStatus")
    @ResponseBody
    public Result edgReportStatus(@RequestBody Map<String, String> arguments) {
        String edgStorageCageDetailsId=arguments.get("glassId");
        int controlsId=Integer.valueOf(arguments.get("controlsId"));
        boolean isSucess=edgStorageCageDetailsService.identWorn(edgStorageCageDetailsId,controlsId);
        return Result.build(200,"【破损/拿走】成功",1);
    }

}


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

@@ -49,4 +49,5 @@
    boolean updateEdgStorageCage(EdgStorageCage edgStorageCage);

    boolean updateEdgStorageCageDetails(int edgStorageCageId, EdgStorageCageDetails edgStorageCageDetails);

}

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

@@ -24,6 +24,7 @@
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
@@ -66,7 +67,7 @@
        if (edgStorageCageDetails.size() == 1) {
            EdgStorageCageDetails item = edgStorageCageDetails.get(0);
            item.setState(ControlsId);
            baseMapper.update(edgStorageCageDetails.get(0), new MPJLambdaWrapper<EdgStorageCageDetails>().selectAll(EdgStorageCageDetails.class).eq(EdgStorageCageDetails::getGlassId, glassId));
            baseMapper.update(item, new MPJLambdaWrapper<EdgStorageCageDetails>().selectAll(EdgStorageCageDetails.class).eq(EdgStorageCageDetails::getGlassId, glassId));
            return true;
        }
//            Sql版本
@@ -93,7 +94,7 @@

        if (!upPattenUsage.isEmpty()) {
            UpPattenUsage upPattenUsage1 = upPattenUsage.get(0);
            return 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::getWidth, "olHeight")
@@ -103,6 +104,20 @@
                    .eq(OptimizeDetail::getProjectNo, upPattenUsage1.getEngineeringId())
                    .eq(OptimizeDetail::getStockId, upPattenUsage1.getLayoutSequence())
            );
            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")));
//                log.info("内容：{}-------{}",cutTerritory,edgStorageCageDetails);
                if(edgStorageCageDetails!=null){
                    cutTerritory.put("glass_state",edgStorageCageDetails.getState());
                }else{
                    cutTerritory.put("glass_state",0);
                }
                ResultcutTerritorys.add(cutTerritory);
            }
            return ResultcutTerritorys;

//            Sql版本
//            return optimizeDetailMapper.selectJoinMaps(new MPJQueryWrapper<OptimizeDetail>().selectAll(OptimizeDetail.class)

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

@@ -135,10 +135,11 @@
        log.info("正常" + edgItem);
        EdgStorageCageDetails edgDItem = edgStorageCageDetailsMapper.selectById(edgStorageCageDetails.getId());
        if (edgItem != null) {
            //移除
            //移除  （破损,目前两个概念混合在一起,建议拆开）
            EdgStorageCageDetails result = edgStorageCageDetailsMapper.selectOne(new MPJLambdaWrapper<EdgStorageCageDetails>().eq(EdgStorageCageDetails::getSlot, edgStorageCageId));
            if (result != null) {
                result.setSlot(0);
                result.setState(201);
                edgStorageCageDetailsMapper.updateById(result);
            }
            //添加

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/glassinfo/entity/GlassInfo.java

@@ -35,7 +35,7 @@
    /**
     * 流程卡玻璃类型
     */
    private Integer glassType;
    private String glassType;

    /**
     * 宽
@@ -55,7 +55,7 @@
    /**
     * 膜系
     */
    private Integer filmsid;
    private String filmsid;

    /**
     * 磨前宽
@@ -133,4 +133,5 @@
    private String glassId;



}

 hangzhoumesParent/moduleService/CacheGlassModule/src/main/java/com/mes/glassinfo/mapper/GlassInfoMapper.java

@@ -1,6 +1,7 @@
package com.mes.glassinfo.mapper;

import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import com.github.yulichang.base.MPJBaseMapper;
import com.mes.glassinfo.entity.GlassInfo;

/**
@@ -11,6 +12,6 @@
 * @author zhoush
 * @since 2024-04-07
 */
public interface GlassInfoMapper extends BaseMapper<GlassInfo> {
public interface GlassInfoMapper extends MPJBaseMapper<GlassInfo> {

}

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

@@ -58,7 +58,10 @@
    @Value("${mes.ratio}")
    private int ratio;

    @Scheduled(fixedDelay = 1000)
    @Value("${mes.sequence.order}")
    private boolean sequenceOrder;

    @Scheduled(fixedDelay = 30000000)
    public void plcHomeEdgTask() {
        PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
        String taskRequestTypeValue = plcParameterObject.getPlcParameter("A06_request_word").getValue();
@@ -69,16 +72,6 @@
        String out10Glassstate = plcParameterObject.getPlcParameter("A10_glass_status").getValue();
        String confirmationWrodAddress = plcParameterObject.getPlcParameter("MES_confirmation_word").getAddress();
        String currentSlot = plcParameterObject.getPlcParameter("Current_slot").getValue();

//        String taskRequestTypeValue = "2";
//        String glassIdeValue = "2222222222";
//        String confirmationWrodValue = "0";
//        //A08  A09表示线路相同  可做等价
//        Integer out08Glassstate = 1;
//        Integer out10Glassstate = 0;
//        String confirmationWrodAddress = "DB11.38";
//        String currentSlot = "1";


        log.info("1、获取到的请求字为：{}，获取到的扫描ID为：{}，获取到的确认字为：{}，获取到的出片状态分别为：A09:{}、A10:{},当前格子号为：{}",
                taskRequestTypeValue, glassIdeValue, confirmationWrodValue, out08Glassstate, out10Glassstate, currentSlot);
@@ -93,8 +86,7 @@
            return;
        }
        if (!"0".equals(confirmationWrodValue)) {
            log.info("2、获取到的请求字不为0，将确认字改为0");
            S7object.getinstance().plccontrol.WriteWord(confirmationWrodAddress, (short) 0);
            log.info("2、获取到的请求字不为0，将确认字不为0，直接结束");
            return;
        }
        if ("1".equals(taskRequestTypeValue)) {
@@ -104,14 +96,13 @@
            //09空闲 ：1      10空闲 ：2        都空闲：3    其他0
            log.info("2、出片请求，且确认字为0，执行进片任务");
            outTo(Integer.parseInt(out08Glassstate),
                    Integer.parseInt(out10Glassstate), confirmationWrodAddress);
                    Integer.parseInt(out10Glassstate), confirmationWrodAddress, "", 0);
        } else if ("3".equals(taskRequestTypeValue)) {
            log.info("2、进片和出片都空闲，执行出片任务");
            //加笼子里面是否有玻璃，有先出，无玻璃先进
            int count = edgStorageCageDetailsService.count(new LambdaQueryWrapper<EdgStorageCageDetails>().eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));
            if (("1".equals(out08Glassstate) || "1".equals(out10Glassstate)) && count > 0) {
            if (("1".equals(out08Glassstate) || "1".equals(out10Glassstate))) {
                boolean outFlase = outTo(Integer.parseInt(out08Glassstate),
                        Integer.parseInt(out10Glassstate), confirmationWrodAddress);
                        Integer.parseInt(out10Glassstate), confirmationWrodAddress, glassIdeValue, Integer.parseInt(currentSlot));
                log.info("出片任务是否完成：{},失败且玻璃id:{}不为空则执行进片任务", outFlase, glassIdeValue);
                if (!outFlase && StringUtils.isNotBlank(glassIdeValue)) {
                    inTo(glassIdeValue, confirmationWrodAddress, currentSlot);
@@ -166,8 +157,10 @@
     * @param out08Glassstate
     * @param out10Glassstate
     * @param confirmationWrodAddress
     * @param glassId
     * @param currentSlot
     */
    private boolean outTo(int out08Glassstate, int out10Glassstate, String confirmationWrodAddress) {
    private boolean outTo(int out08Glassstate, int out10Glassstate, String confirmationWrodAddress, String glassId, int currentSlot) {
        //逻辑步骤：
//        0、A09、A10是否空闲，是否可以执行出片任务
//        1、获取钢化版图是否超过阈值
@@ -189,51 +182,84 @@
        boolean flag = queryMaxMinDiff(threshold);
        log.info("1、获取钢化版图是否超过阈值:{}", flag);
        if (flag) {
            glassInfo = queryMinGlass(0.0, 0.0);
            //获取当前最小版图需要出片的玻璃信息
            glassInfo = queryMinGlass(0.0, 0.0, glassId);
            log.info("1.1、超过阈值：获取当前最小版图需要出片的玻璃信息:{}", glassInfo);
            Integer a09Count = queryCountByTaskLine(Const.A09_OUT_TARGET_POSITION).size();
            Integer a10Count = queryCountByTaskLine(Const.A10_OUT_TARGET_POSITION).size();
            log.info("1.2、获取笼子剩余数量A09为{},A10为{}", a09Count, a10Count);

            // 假设已知 outXXGlassstate 的值只有 0 和 1 两种情况，且 0 表示某种状态，1 表示另一种状态
            int targetPositionWhenStateZero = (out08Glassstate == 0) ? Const.A10_OUT_TARGET_POSITION : Const.A09_OUT_TARGET_POSITION;
            int targetPositionWhenStateOne = (out10Glassstate == 0) ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
            endcell = (a10Count <= a09Count) ? targetPositionWhenStateZero : targetPositionWhenStateOne;
            if (glassInfo == null) {
                log.info("笼子内和待进片没有玻璃");
                return Boolean.FALSE;
            }
            EdgStorageCageDetails a09EdgGlass = queryGlassByTaskCache(Const.A09_OUT_TARGET_POSITION, Const.GLASS_CACHE_TYPE_OUT);
            EdgStorageCageDetails a10EdgGlass = queryGlassByTaskCache(Const.A10_OUT_TARGET_POSITION, Const.GLASS_CACHE_TYPE_OUT);
            endcell = queryLineByGlassInfo(a09EdgGlass, a10EdgGlass, glassInfo, out08Glassstate, out08Glassstate);
        } else {
            //当前任务出完无玻璃 更换玻璃  获取另一条线路
            //判断两条线是否都空闲
            endcell = out08Glassstate == 1 ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
            int othercell = endcell == Const.A10_OUT_TARGET_POSITION ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
            List<EdgStorageCageDetails> details = queryCountByTaskLine(endcell);
            if (details.size() > 0) {
                glassInfo = details.get(0);
            if (out08Glassstate == 1 && out10Glassstate == 1) {
                EdgStorageCageDetails a09EdgGlass = queryGlassByTaskCache(Const.A09_OUT_TARGET_POSITION, Const.GLASS_CACHE_TYPE_OUT);
                EdgStorageCageDetails a10EdgGlass = queryGlassByTaskCache(Const.A10_OUT_TARGET_POSITION, Const.GLASS_CACHE_TYPE_OUT);
                if (a09EdgGlass == null && a10EdgGlass == null) {
                    MPJLambdaWrapper<EdgStorageCageDetails> wrapper = new MPJLambdaWrapper<>();
                    wrapper.select(EdgStorageCageDetails::getWidth, EdgStorageCageDetails::getHeight)
                            .selectCount(EdgStorageCageDetails::getGlassId, EdgStorageCageDetails::getCount)
                            .groupBy(EdgStorageCageDetails::getWidth, EdgStorageCageDetails::getHeight)
                            .last("order by count(t.glass_id) desc limit 2");
                    List<EdgStorageCageDetails> list = edgStorageCageDetailsService.list(wrapper);
                    if (CollectionUtil.isEmpty(list)) {
                        GlassInfo one = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
                                .eq(GlassInfo::getGlassId, glassId));
                        EdgStorageCageDetails resultDetails = new EdgStorageCageDetails();
                        BeanUtils.copyProperties(one, resultDetails);
                        glassInfo = resultDetails;
                    } else {
                        glassInfo = queryMinGlass(list.get(0).getWidth(), list.get(0).getHeight(), glassId);
                    }
                } else if (a09EdgGlass != null && a10EdgGlass != null) {
                    List<EdgStorageCageDetails> a09Count = queryGlassByTaskLine(Const.A09_OUT_TARGET_POSITION);
                    List<EdgStorageCageDetails> a10Count = queryGlassByTaskLine(Const.A09_OUT_TARGET_POSITION);
                    endcell = a09Count.size() > a10Count.size() ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
                    glassInfo = a09Count.size() > a10Count.size() ? queryMinGlass(a09EdgGlass.getWidth(), a09EdgGlass.getHeight(), glassId)
                            : queryMinGlass(a10EdgGlass.getWidth(), a10EdgGlass.getHeight(), glassId);
                } else {
                    endcell = a09EdgGlass != null ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
                    glassInfo = a09EdgGlass != null ? queryMinGlass(a09EdgGlass.getWidth(), a09EdgGlass.getHeight(), glassId)
                            : queryMinGlass(a10EdgGlass.getWidth(), a10EdgGlass.getHeight(), glassId);
                }
            } else {
                //去理片笼里面查
                glassInfo = queryChangeGlassInfo(othercell);
                List<EdgStorageCageDetails> edgStorageCageDetails = queryGlassByTaskLine(endcell);
                if (CollectionUtil.isNotEmpty(edgStorageCageDetails)) {
                    glassInfo = edgStorageCageDetails.get(0);
                } else {
                    //获取笼内所有玻璃信息，包括待进片的
                    List<EdgStorageCageDetails> glassList = queryEdgAllGlass(glassId);
                    Assert.isTrue(CollectionUtil.isNotEmpty(glassList), "笼内和待进片都没有玻璃");
                    int othercell = endcell == Const.A10_OUT_TARGET_POSITION ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
                    glassInfo = queryChangeGlassInfo(othercell, glassId);
                }
            }
        }
        return saveOutGlassMessage(glassInfo, endcell, confirmationWrodAddress, glassId, currentSlot);
    }

        if (glassInfo != null) {
            log.info("4、添加出片任务，玻璃id：{}，任务类型：{}，起始位置：{}，结束位置：{}", glassInfo.getGlassId(),
                    2, glassInfo.getSlot(), endcell);
    /**
     * 获取笼子内所有玻璃信息，包括待进片的
     *
     * @param glassId
     */
    private List<EdgStorageCageDetails> queryEdgAllGlass(String glassId) {
        List<EdgStorageCageDetails> glassList = new ArrayList<>();
        //获取待进片玻璃
        GlassInfo one = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
                .eq(GlassInfo::getGlassId, glassId));
        EdgStorageCageDetails resultDetails = new EdgStorageCageDetails();
        BeanUtils.copyProperties(one, resultDetails);
        glassList.add(resultDetails);
        //获取笼内玻璃
        List<EdgStorageCageDetails> details = edgStorageCageDetailsService.list(new LambdaQueryWrapper<EdgStorageCageDetails>()
                .eq(EdgStorageCageDetails::getState, Const.GLASS_STATE_IN));
        glassList.addAll(details);
        return glassList;

            LambdaQueryWrapper<EdgStorageCageDetails> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(EdgStorageCageDetails::getGlassId, glassInfo.getGlassId());
            EdgStorageCageDetails updateDetail = new EdgStorageCageDetails();
            updateDetail.setState(Const.GLASS_STATE_OUT);
            edgStorageCageDetailsService.update(updateDetail, wrapper);
            log.info("5、更新出片玻璃的状态为{}", Const.GLASS_STATE_OUT);

            boolean taskCacheStatus = saveTaskCache(glassInfo.getGlassId(), glassInfo.getSlot(), endcell, Const.GLASS_CACHE_TYPE_OUT);
            log.info("6、添加出片任务是否完成：{}", taskCacheStatus);

            boolean glassSizeStatus = saveGlassSize(glassInfo);
            log.info("7、添加出片玻璃尺寸信息到磨边前玻璃表是否完成：{}", glassSizeStatus);

            S7object.getinstance().plccontrol.WriteWord(confirmationWrodAddress, (short) 1);
            log.info("8、发送确认字已完成");
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }

    /**
@@ -262,24 +288,39 @@
     * @param width
     * @param height
     */
    private EdgStorageCageDetails queryMinGlass(Double width, Double height) {
        return edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
    private EdgStorageCageDetails queryMinGlass(Double width, Double height, String glassId) {
        //获取表内版图id最小的玻璃信息
        EdgStorageCageDetails glassDetails = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                .eq(EdgStorageCageDetails::getState, 100)
                .eq(width != 0, EdgStorageCageDetails::getWidth, width)
                .eq(height != 0, EdgStorageCageDetails::getHeight, height)
                .orderByAsc(EdgStorageCageDetails::getTemperingLayoutId, EdgStorageCageDetails::getTemperingFeedSequence)
                .orderByAsc(EdgStorageCageDetails::getTemperingLayoutId)
                .orderBy(Boolean.TRUE, sequenceOrder, EdgStorageCageDetails::getTemperingFeedSequence)
                .last("limit 1"));
        if (StringUtils.isBlank(glassId)) {
            return glassDetails;
        }
        GlassInfo one = glassInfoService.getOne(new LambdaQueryWrapper<GlassInfo>()
                .eq(GlassInfo::getGlassId, glassId));
        EdgStorageCageDetails resultDetails = new EdgStorageCageDetails();
        BeanUtils.copyProperties(one, resultDetails);
        if (null == glassDetails) {
            return resultDetails;
        }
        return resultDetails.getTemperingLayoutId() <= glassDetails.getTemperingLayoutId() && resultDetails.getTemperingFeedSequence() > glassDetails.getTemperingFeedSequence() ?
                resultDetails : glassDetails;
    }

    /**
     * 获取任务表中指定线路笼子内还剩余的玻璃数量
     * 获取任务表中指定线路笼子内还剩余的玻璃信息
     */
    private List<EdgStorageCageDetails> queryCountByTaskLine(int line) {
    private List<EdgStorageCageDetails> queryGlassByTaskLine(int line) {
        //获取任务表中最后一次出片的玻璃id
        LambdaQueryWrapper<TaskCache> queryWrapper = new LambdaQueryWrapper<TaskCache>().eq(TaskCache::getTaskType, Const.GLASS_CACHE_TYPE_OUT)
                .eq(TaskCache::getEndCell, line).orderByDesc(TaskCache::getCreateTime);
        List<TaskCache> taskCacheList = taskCacheService.list(queryWrapper);
        if (CollectionUtil.isEmpty(taskCacheList)) {
            log.info("没有找到{}线任务信息", line);
            return new ArrayList<>();
        }
        TaskCache taskCache = taskCacheList.get(0);
@@ -288,7 +329,9 @@
                .innerJoin("edg_storage_cage_details t1 on t.width = t1.width and t.height = t1.height")
                .eq("t.glass_id", taskCache.getGlassId())
                .ne("t1.glass_id", taskCache.getGlassId())
                .orderByAsc("t1.tempering_layout_id", "t1.tempering_feed_sequence");
                .eq("t1.state", Const.GLASS_STATE_IN)
                .orderByAsc("t1.tempering_layout_id")
                .orderBy(Boolean.TRUE, sequenceOrder, "t1.tempering_feed_sequence");
        List<EdgStorageCageDetails> details = edgStorageCageDetailsService.selectJoinList(EdgStorageCageDetails.class, mpjLambdaWrapper);
        if (CollectionUtil.isEmpty(details)) {
            return new ArrayList<>();
@@ -297,12 +340,61 @@
    }

    /**
     * 更换出片玻璃
     * 按照任务类型、线号获取任务信息
     *
     * @param othercell
     * @param line
     * @param taskType
     * @return
     */
    private EdgStorageCageDetails queryChangeGlassInfo(int othercell) {
    private EdgStorageCageDetails queryGlassByTaskCache(int line, int taskType) {
        LambdaQueryWrapper<TaskCache> queryWrapper = new LambdaQueryWrapper<TaskCache>().eq(TaskCache::getTaskType, taskType)
                .eq(TaskCache::getEndCell, line).orderByDesc(TaskCache::getCreateTime);
        List<TaskCache> list = taskCacheService.list(queryWrapper);
        if (CollectionUtil.isEmpty(list)) {
            log.info("没有找到{}线任务信息", line);
            return null;
        }
        return edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>().eq(EdgStorageCageDetails::getGlassId, list.get(0).getGlassId()));
    }

    /**
     * 按照任务玻璃信息和待出片玻璃信息获取出片路径
     *
     * @param a08EdgStorageCageDetails 09号线出片玻璃信息
     * @param a10EdgStorageCageDetails 10号线出片玻璃信息
     * @param glassInfo                带出片玻璃信息
     * @param out08Glassstate          09号线空闲状态
     * @param out10Glassstate          10号线空闲状态
     * @return
     */
    private Integer queryLineByGlassInfo(EdgStorageCageDetails a08EdgStorageCageDetails, EdgStorageCageDetails a10EdgStorageCageDetails,
                                         EdgStorageCageDetails glassInfo, int out08Glassstate, int out10Glassstate) {
        if (a08EdgStorageCageDetails != null && a08EdgStorageCageDetails.getHeight().equals(glassInfo.getHeight())
                && a08EdgStorageCageDetails.getWidth().equals(glassInfo.getWidth()) && out08Glassstate == 1) {
            return Const.A09_OUT_TARGET_POSITION;
        }
        if (a10EdgStorageCageDetails != null && a10EdgStorageCageDetails.getHeight().equals(glassInfo.getHeight())
                && a10EdgStorageCageDetails.getWidth().equals(glassInfo.getWidth()) && out10Glassstate == 1) {
            return Const.A10_OUT_TARGET_POSITION;
        }
        if (out08Glassstate == 1) {
            return Const.A09_OUT_TARGET_POSITION;
        }
        if (out10Glassstate == 1) {
            return Const.A10_OUT_TARGET_POSITION;
        }
        Assert.isTrue(Boolean.FALSE, "没有找到出片路径");
        return 0;
    }

    /**
     * 按照尺寸出玻璃
     *
     * @param endcell endcell = out08Glassstate == 1 ? Const.A09_OUT_TARGET_POSITION : Const.A10_OUT_TARGET_POSITION;
     * @param glassId
     * @return
     */
    private EdgStorageCageDetails queryChangeGlassInfo(int endcell, String glassId) {
        //获取笼子内数量前二的玻璃数量
        MPJLambdaWrapper<EdgStorageCageDetails> wrapper = new MPJLambdaWrapper<>();
        wrapper.select(EdgStorageCageDetails::getWidth, EdgStorageCageDetails::getHeight)
@@ -311,31 +403,16 @@
                .last("order by count(t.glass_id) desc limit 2");
        List<EdgStorageCageDetails> list = edgStorageCageDetailsService.list(wrapper);
        log.info("获取笼子内数量前二的玻璃数量：{}", list);
        if (CollectionUtil.isEmpty(list)) {
            log.info("笼子里没有玻璃");
            return null;
        }
        //一片玻璃直接出
        //获取宽高拍第一的玻璃信息
        EdgStorageCageDetails firstSize = list.get(0);
        Integer firstCount = firstSize.getCount();
        Double firstWidth = firstSize.getWidth();
        Double firstHeight = firstSize.getHeight();
        if (list.size() == 1) {
            return queryMinGlass(firstWidth, firstHeight);
            return queryMinGlass(firstWidth, firstHeight, glassId);
        }
        //获取宽高拍第二的玻璃信息
        EdgStorageCageDetails secondSize = list.get(1);
        //获取任务表中最后一次出片的玻璃id
        LambdaQueryWrapper<TaskCache> queryWrapper = new LambdaQueryWrapper<TaskCache>().eq(TaskCache::getTaskType, Const.GLASS_CACHE_TYPE_OUT)
                .eq(TaskCache::getEndCell, othercell).orderByDesc(TaskCache::getCreateTime);
        List<TaskCache> taskCacheList = taskCacheService.list(queryWrapper);
        log.info("获取任务表中{}线最后一次出片的玻璃任务信息：{}", othercell, taskCacheList);
        if (CollectionUtil.isEmpty(taskCacheList)) {
            log.info("{}线没有出片任务信息，直接出片", othercell);
            return queryMinGlass(firstSize.getWidth(), firstSize.getHeight());
        }

        Integer secondCount = secondSize.getCount();
        Double secondWidth = secondSize.getWidth();
        Double secondHeight = secondSize.getHeight();
@@ -345,25 +422,82 @@

        if (mix >= 2) {
            log.info("获取玻璃数量前2的玻璃占比为{}，大于2，直接出玻璃数据的最多的，宽：{}，高：{}", mix, firstWidth, firstHeight);
            return queryMinGlass(firstWidth, firstHeight);
            return queryMinGlass(firstWidth, firstHeight, glassId);
        } else {
            log.info("获取玻璃数量前2的玻璃占比为{}，小于2", mix);
            //获取任务表中最后一次出片的玻璃id
            LambdaQueryWrapper<TaskCache> queryWrapper = new LambdaQueryWrapper<TaskCache>().eq(TaskCache::getTaskType, Const.GLASS_CACHE_TYPE_OUT)
                    .eq(TaskCache::getEndCell, endcell).orderByDesc(TaskCache::getCreateTime);
            List<TaskCache> taskCacheList = taskCacheService.list(queryWrapper);
            log.info("获取任务表中{}线最后一次出片的玻璃任务信息：{}", endcell, taskCacheList);
            if (CollectionUtil.isEmpty(taskCacheList)) {
                log.info("{}线没有出片任务信息，直接出片", endcell);
                return queryMinGlass(firstSize.getWidth(), firstSize.getHeight(), glassId);
            }
            TaskCache taskCache = taskCacheList.get(0);
            EdgStorageCageDetails outGlassInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>().eq(EdgStorageCageDetails::getGlassId, taskCache.getGlassId()));
            log.info("{}线有出片任务信息,任务信息为{}，玻璃信息为{}", othercell, taskCache, outGlassInfo);
            EdgStorageCageDetails outGlassInfo = edgStorageCageDetailsService.getOne(new LambdaQueryWrapper<EdgStorageCageDetails>()
                    .eq(EdgStorageCageDetails::getGlassId, taskCache.getGlassId()));
            log.info("{}线有出片任务信息,任务信息为{}，玻璃信息为{}", endcell, taskCache, outGlassInfo);
            if (outGlassInfo.getWidth().equals(firstWidth) && outGlassInfo.getHeight().equals(firstHeight)) {
                log.info("数量最多的宽{}高{}和{}线任务的宽{}高{}相同，出数量排第二的玻璃，宽{}高{}",
                        firstWidth, firstHeight, othercell, outGlassInfo.getWidth(), outGlassInfo.getHeight(), secondWidth, secondHeight);
                return queryMinGlass(secondWidth, secondHeight);
                        firstWidth, firstHeight, endcell, outGlassInfo.getWidth(), outGlassInfo.getHeight(), secondWidth, secondHeight);
                return queryMinGlass(secondWidth, secondHeight, glassId);
            } else {
                log.info("数量第二多的宽{}高{}和{}线任务的宽{}高{}相同，出数量排第二的玻璃，宽{}高{}",
                        secondWidth, secondHeight, othercell, outGlassInfo.getWidth(), outGlassInfo.getHeight(), firstWidth, firstHeight);
                return queryMinGlass(firstWidth, firstHeight);
                        secondWidth, secondHeight, endcell, outGlassInfo.getWidth(), outGlassInfo.getHeight(), firstWidth, firstHeight);
                return queryMinGlass(firstWidth, firstHeight, glassId);
            }
        }
    }

    /**
     * 保存出片任务相关信息
     *
     * @param glassInfo
     * @param endcell
     * @param confirmationWrodAddress
     * @param glassId
     * @return
     */
    private boolean saveOutGlassMessage(EdgStorageCageDetails glassInfo, int endcell, String confirmationWrodAddress, String glassId, Integer currentSlot) {
        if (glassInfo != null) {
            log.info("4、添加出片任务，玻璃id：{}，任务类型：{}，起始位置：{}，结束位置：{}", glassInfo.getGlassId(),
                    2, glassInfo.getSlot(), endcell);
            if (glassInfo.getGlassId().equals(glassId)) {
                log.info("5、直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo);
                EdgStorageCageDetails details = new EdgStorageCageDetails();
                BeanUtils.copyProperties(glassInfo, details);
                EdgStorageCage nearestEmpty = edgStorageCageService.selectNearestEmpty(currentSlot);
                Assert.isTrue(null != nearestEmpty, "格子已满,无法执行直通任务");
                log.info("3、查询卧式理片笼里面的空格:{}", nearestEmpty);
                details.setSlot(nearestEmpty.getSlot());
                details.setState(Const.GLASS_STATE_OUT);
                edgStorageCageDetailsService.save(details);

                boolean taskCacheStatus = saveTaskCache(glassInfo.getGlassId(), nearestEmpty.getSlot(), endcell, Const.GLASS_CACHE_TYPE_THROUGH);
                log.info("6、添加出片任务是否完成：{}", taskCacheStatus);
            } else {
                log.info("5、非直通任务,将玻璃信息插入卧式理片笼,当前玻璃信息:{}", glassInfo);
                LambdaQueryWrapper<EdgStorageCageDetails> wrapper = new LambdaQueryWrapper<>();
                wrapper.eq(EdgStorageCageDetails::getGlassId, glassInfo.getGlassId());
                EdgStorageCageDetails updateDetail = new EdgStorageCageDetails();
                updateDetail.setState(Const.GLASS_STATE_OUT);
                edgStorageCageDetailsService.update(updateDetail, wrapper);
                log.info("5、更新出片玻璃的状态为{}", Const.GLASS_STATE_OUT);

                boolean taskCacheStatus = saveTaskCache(glassInfo.getGlassId(), glassInfo.getSlot(), endcell, Const.GLASS_CACHE_TYPE_OUT);
                log.info("6、添加出片任务是否完成：{}", taskCacheStatus);
            }
            boolean glassSizeStatus = saveGlassSize(glassInfo);
            log.info("7、添加出片玻璃尺寸信息到磨边前玻璃表是否完成：{}", glassSizeStatus);
            S7object.getinstance().plccontrol.WriteWord(confirmationWrodAddress, (short) 1);
            log.info("8、发送确认字已完成");
            return Boolean.TRUE;
        }
        return Boolean.FALSE;
    }

    /**
     * 添加理片笼任务
     *
     * @param glassId

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

@@ -52,7 +52,6 @@
    @PostMapping("/identControls")
    @ResponseBody
    public Result identControls(@RequestParam(name = "identId", required = false) String identId,@RequestParam(name = "controlsId", required = false) int controlsId) {

        boolean issucess = edgStorageCageDetailsService.identWorn(identId,controlsId);
        return Result.build(200,"成功",issucess);
    }
@@ -60,7 +59,8 @@
    @ApiOperation("磨边任务 参数()")
    @PostMapping("/selectEdgTask")
    @ResponseBody
    public Result selectEdgTask(String line) {
    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);
    }

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

@@ -5,14 +5,35 @@

import java.util.Date;

@Data  //lombok 简写java代码 实体类的get与set
/**
 * 卧式理片笼任务表
 */
@Data
@TableName("task_cache")
public class TaskCache {
    private String glassId;//任务编号
    private int startCell;//起始
    private int endCell;//结束
    private int taskType;//任务类型
    private int taskStatus;//任务状态
    private Date createTime;//任务状态
    /**
     * 任务编号
     */
    private String glassId;
    /**
     * 起始
     */
    private int startCell;
    /**
     * 结束
     */
    private int endCell;
    /**
     * 任务类型
     */
    private int taskType;
    /**
     * 任务状态
     */
    private int taskStatus;
    /**
     * 创建时间
     */
    private Date createTime;

}

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

@@ -5,6 +5,8 @@
import com.github.yulichang.wrapper.MPJLambdaWrapper;
import com.mes.edgstoragecage.entity.EdgStorageCageDetails;
import com.mes.edgstoragecage.mapper.EdgStorageCageDetailsMapper;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.taskcache.entity.TaskCache;
import com.mes.taskcache.mapper.TaskCacheMapper;
import com.mes.taskcache.service.TaskCacheService;
@@ -29,6 +31,9 @@

    @Autowired
    EdgStorageCageDetailsMapper edgStorageCageDetailsMapper;

    @Autowired
    GlassInfoMapper glassInfoMapper;
    /**
     * 添加理片笼任务
     * @param taskCache
@@ -49,25 +54,30 @@
    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::getEndCell, line)
                .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<>();
            EdgStorageCageDetails edgStorageCageDetails=edgStorageCageDetailsMapper.selectOne(new MPJLambdaWrapper<EdgStorageCageDetails>()
                    .selectAll(EdgStorageCageDetails.class)
                    .eq(EdgStorageCageDetails::getGlassId,taskCache1.getGlassId()));
            if(edgStorageCageDetails!=null){
                map.put("Line",line);
                map.put("Width",edgStorageCageDetails.getWidth());
                map.put("Height",edgStorageCageDetails.getHeight());
                map.put("Thickness",edgStorageCageDetails.getThickness());
                map.put("GlassId",edgStorageCageDetails.getGlassId());
                map.put("FlowCardId",edgStorageCageDetails.getFlowCardId());
                map.put("TemperingLayoutId",edgStorageCageDetails.getTemperingLayoutId());
                map.put("TemperingFeedSequence",edgStorageCageDetails.getTemperingFeedSequence());
            GlassInfo glassInfo=glassInfoMapper.selectOne(new MPJLambdaWrapper<GlassInfo>()
                    .selectAll(GlassInfo.class)
                    .eq(GlassInfo::getGlassId,taskCache1.getGlassId()));
            if(glassInfo!=null){
                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);
            }
            serialNumber++;
        }

        return result;

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

@@ -4,36 +4,36 @@
      primary: hangzhoumes #设置默认的数据源或者数据源组,默认值即为master
      strict: false #设置严格模式,默认false不启动. 启动后在未匹配到指定数据源时候回抛出异常,不启动会使用默认数据源.
      datasource:
        hangzhoumes:
          url: jdbc:mysql://127.0.0.1:3306/hangzhoumes?serverTimezone=GMT%2b8
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
        pp:
          url: jdbc:mysql://127.0.0.1:3306/pp?serverTimezone=GMT%2b8
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
        salve_hangzhoumes:
          url: jdbc:sqlserver://127.0.0.1:1433;databasename=hangzhoumes
          username: sa
          password: beibo.123/
          driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
#        hangzhoumes:
#          url: jdbc:mysql://10.153.19.150:3306/hangzhoumes?serverTimezone=GMT%2b8
#          url: jdbc:mysql://127.0.0.1:3306/hangzhoumes?serverTimezone=GMT%2b8
#          username: root
#          password: beibo.123/
#          driver-class-name: com.mysql.cj.jdbc.Driver
#        pp:
#          url: jdbc:mysql://10.153.19.150:3306/pp?serverTimezone=GMT%2b8
#          url: jdbc:mysql://127.0.0.1:3306/pp?serverTimezone=GMT%2b8
#          username: root
#          password: beibo.123/
#          driver-class-name: com.mysql.cj.jdbc.Driver
#        salve_hangzhoumes:
#          url: jdbc:sqlserver://10.153.19.150:1433;databasename=hangzhoumes
#          url: jdbc:sqlserver://127.0.0.1:1433;databasename=hangzhoumes
#          username: sa
#          password: beibo.123/
#          driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
        hangzhoumes:
          url: jdbc:mysql://10.153.19.150:3306/hangzhoumes?serverTimezone=GMT%2b8
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
        pp:
          url: jdbc:mysql://10.153.19.150:3306/pp?serverTimezone=GMT%2b8
          username: root
          password: beibo.123/
          driver-class-name: com.mysql.cj.jdbc.Driver
        salve_hangzhoumes:
          url: jdbc:sqlserver://10.153.19.150:1433;databasename=hangzhoumes
          username: sa
          password: beibo.123/
          driver-class-name: com.microsoft.sqlserver.jdbc.SQLServerDriver
  cloud:
    nacos:
      discovery:

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

@@ -13,3 +13,5 @@
mes:
  threshold: 3
  ratio: 10
  sequence:
    order: true