Merge remote-tracking branch 'origin/master'

zhoushihao

2024-05-10 69e3dd71185b1cdaf524a4d2a25bf9648bd02ff4

Merge remote-tracking branch 'origin/master'

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/engineering/controller/EngineeringController.java

File was renamed from hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/engineering/controller/EngineeringController.java
@@ -2,9 +2,7 @@


import com.mes.engineering.entity.Engineering;
import com.mes.engineering.service.impl.EngineeringServiceImpl;
import com.mes.utils.Result;
import com.mes.workstation.service.UpWorkstationService;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/engineering/entity/Engineering.java

File was renamed from hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/engineering/entity/Engineering.java
@@ -89,7 +89,7 @@
    /**
     * 膜系id
     */
    private Integer filmsId;
    private String filmsId;

    /**
     * 备注

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/engineering/entity/OptimizeEngineering.java

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

import lombok.Getter;
import lombok.Setter;

/**
 * @author SNG-010
 */
@Setter
@Getter
public class OptimizeEngineering {

    // Getter methods
    // Setter methods
    /**
     * 工程号
     */
    private String projectNo;

    /**
     * 工程名
     */
    private String projectName;

    /**
     * 平均利用率
     */
    private Double avgCutPct;

    /**
     * 有效利用率
     */
    private Double validCutPct;

    /**
     * 尾片利用率
     */
    private Double lastCutPct;

    /**
     * 状态
     */
    private Integer state;

    /**
     * 小片总数
     */
    private Integer glassTotal;
    /**
     * 小片总面积
     */
    private Double glassTotalArea;
    /**
     * 计划原片总数
     */
    private Integer rawStockQty;
    /**
     * 计划原片总面积
     */
    private Double rawStockArea;
    /**
     * 实际原片总数
     */
    private Integer actualStockQty;
    /**
     * 实际原片总面积
     */
    private Double actualStockArea;
    /**
     * 膜系
     */
    private  String glassType;
    /**
     * 备注
     */
    private  String remark;

}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/engineering/mapper/EngineeringMapper.java

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/engineering/mapper/xml/EngineeringMapper.xml

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/engineering/service/EngineeringService.java

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

import com.mes.engineering.entity.Engineering;
import com.baomidou.mybatisplus.extension.service.IService;

import java.util.List;

/**
 * <p>
 *  服务类
 * </p>
 *
 * @author wu
 * @since 2024-04-22
 */
public interface EngineeringService extends IService<Engineering> {



    boolean  changeTask(String projectId, Integer state);


    List<Engineering> selectEngineering(String engineeringId);

    void saveEngineering(List<Engineering> engineerings);

    Engineering selectInitiate(Integer state);
}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/engineering/service/impl/EngineeringServiceImpl.java

New file
@@ -0,0 +1,95 @@
package com.mes.engineering.service.impl;
import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.conditions.update.LambdaUpdateChainWrapper;
import com.mes.engineering.entity.Engineering;
import com.mes.engineering.mapper.EngineeringMapper;
import com.mes.engineering.service.EngineeringService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.pp.entity.OptimizeProject;
import com.mes.pp.mapper.OptimizeProjectMapper;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author wu
 * @since 2024-04-22
 */
@Service
@Slf4j
public class EngineeringServiceImpl extends ServiceImpl<EngineeringMapper, Engineering> implements EngineeringService {

    @Autowired
    OptimizeProjectMapper optimizeProjectMapper;
    //开始/暂停任务
    @Override
    public  boolean  changeTask(String projectId, Integer state) {
        //使用projectId作为条件修改state字段
        LambdaUpdateChainWrapper<Engineering> wrapper = new LambdaUpdateChainWrapper<>(this.getBaseMapper());
        wrapper.set(Engineering::getState,state);
        wrapper.eq(Engineering::getEngineerId,projectId);
        return  wrapper.update();
    }

    @Override
    @DS("pp")
    public List<Engineering> selectEngineering(String engineeringId) {
        //查询钢化工程信息
        List<OptimizeProject> optimizeEngineerings = null;
        if (engineeringId != null) {
            QueryWrapper<OptimizeProject> wrapper = new QueryWrapper<>();
            wrapper.select("project_no,project_name,avg_cut_pct,valid_cut_pct,last_cut_pct,glass_total,glass_total_area,raw_stock_qty,raw_stock_area,glass_type,remark ")
                    .eq("project_no", engineeringId);
            optimizeEngineerings = optimizeProjectMapper.selectList(wrapper);

        }
        List<Engineering> resultList=new ArrayList<>();
// 遍历查询结果赋值
        if (optimizeEngineerings != null) {
            for (OptimizeProject map : optimizeEngineerings) {
                // 创建一个新的 OptimizeProject 对象
                Engineering engineering = new Engineering();
                // 将 Map 中的每个键值对映射到 OptimizeProject 对象的相应字段上
                engineering.setEngineerId( map.getProjectNo());//工程id
                engineering.setEngineerName( map.getProjectName());//工程名称
                engineering.setAvgAvailability( map.getAvgCutPct());//平均优化率
                engineering.setValidAvailability( map.getValidCutPct());//有效优化率
                engineering.setLastAvailability( map.getLastCutPct());//尾片优化率
                engineering.setState(0);//状态
                engineering.setGlassTotal( map.getGlassTotal());//小片玻璃总数
                engineering.setGlassTotalArea( map.getGlassTotalArea());//小片总面积
                engineering.setPlanPatternTotal( map.getRawStockQty());//计划原片总数
                engineering.setPlanPatternTotalArea( map.getRawStockArea());//计划原片总面积
                engineering.setFilmsId( map.getGlassType());//膜系
                engineering.setNotes( map.getRemark());//备注
                // 将映射后的对象添加到结果列表中
                resultList.add(engineering);
            }
        }
        log.info("查询出钢化工程集合保存到实体类{}",resultList);
        return resultList;
    }

    @Override
    public void saveEngineering(List<Engineering> engineerings) {
        this.saveBatch(engineerings);
        //保存钢化工程信息
    }

    @Override
    public  Engineering selectInitiate(Integer state) {
        //查询是否有开始上片的工程任务
        QueryWrapper<Engineering> wrapper = new QueryWrapper<>();
            wrapper.eq("state", state);
        return this.getOne(wrapper);
    }

}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/glassinfo/entity/GlassInfo.java

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

    /**
     * 宽

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/glassinfo/entity/OptimizeGlassinfo.java

@@ -15,7 +15,7 @@
    /**
     * 流程卡号
     */
    private String projectId;
    private String processId;

    /**
     * 工程种类

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/glassinfo/service/GlassInfoService.java

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

import com.mes.glassinfo.entity.GlassInfo;
import com.baomidou.mybatisplus.extension.service.IService;
import com.github.yulichang.base.MPJBaseService;
import java.util.List;

@@ -16,4 +15,7 @@
public interface GlassInfoService extends MPJBaseService<GlassInfo> {

      List<GlassInfo> selectGlassInfo(String engineeringId);

      void saveGlassInfo(List<GlassInfo> glassinfo);
}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/glassinfo/service/impl/GlassInfoServiceImpl.java

@@ -6,17 +6,14 @@
import com.mes.glassinfo.entity.OptimizeGlassinfo;
import com.mes.glassinfo.mapper.GlassInfoMapper;
import com.mes.glassinfo.service.GlassInfoService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.pp.entity.OptimizeProject;
import com.mes.pp.mapper.OptimizeProjectMapper;
import com.mes.uppattenusage.entity.UpPattenUsage;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.github.yulichang.base.MPJBaseServiceImpl;

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

/**
@@ -34,14 +31,13 @@
    OptimizeProjectMapper optimizeProjectMapper;
    @Override
    @DS("pp")

    public List<GlassInfo> selectGlassInfo(String engineeringId) {
        List<OptimizeGlassinfo> optimizeGlassinfos=null;
        if (engineeringId != null) {
            optimizeGlassinfos = optimizeProjectMapper.selectJoinList(OptimizeGlassinfo.class, new MPJQueryWrapper<OptimizeProject>()
                    .select("b.process_id,t.type,b.width,b.height,t.glass_thickness,t.glass_type,b.p_width,b.p_height,b.stock_id,b.heat_layout_id,b.heat_layout_sort,b.x_axis,b.y_axis,b.project_no,b.glass_id")
                    .leftJoin("optimize_detail b on t.project_no=b.project_no")
                    .eq("t.state",200)
                    .eq("t.state",100)
                    .eq("t.project_no", engineeringId));
        }

@@ -54,10 +50,13 @@
                GlassInfo glassInfo = new GlassInfo();
                // 将 Map 中的每个键值对映射到 OptimizeGlassinfo 对象的相应字段上
                glassInfo.setEngineerId(map.getProjectNo());
                glassInfo.setFlowCardId(map.getProjectId());
                glassInfo.setFlowCardId(map.getProcessId());
                glassInfo.setFilmsid(map.getGlassType());
                glassInfo.setGlassType(map.getType());
                glassInfo.setWidth(map.getWidth());
                glassInfo.setHeight(map.getHeight());
                glassInfo.setEdgWidth(map.getPWidth());
                glassInfo.setEdgHeight(map.getPHeight());
                glassInfo.setThickness(map.getGlassThickness());
                glassInfo.setPatternSequence(map.getStockId());//
                glassInfo.setTemperingLayoutId(map.getHeatLayoutId());//钢化版图id
@@ -74,4 +73,9 @@
        log.info("查询出glassinfopro的数据{}:",optimizeGlassinfos);
        return resultList;
    }

    @Override
    public void saveGlassInfo(List<GlassInfo> glassinfo) {
        this.saveBatch(glassinfo);
    }
}

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

@@ -41,16 +41,16 @@
        return Result.build(200, "", glass);
    }

    @ApiOperation("保存工程信息")
    @PostMapping("/saveProject") //显示工程选择信息
    public Result<List<OptimizeProject>> saveProject(@RequestBody OptimizeRequest optimizeRequest) {
        log.info("获取选择好的工程id进行查询数据后保存");
        List<OptimizeProject> glass = optimizeProjectService.selectSaveProject(optimizeRequest);
        log.info("显示工程选择信息后保存到upPattenUsage表:{}", glass);
        optimizeProjectService.insetupPattenUsage(glass);
        //void insetProject(glass);
        return Result.build(200, "", glass);
    }
//    @ApiOperation("保存工程信息")
//    @PostMapping("/saveProject") //显示工程选择信息
//    public Result<List<OptimizeProject>> saveProject(@RequestBody OptimizeRequest optimizeRequest) {
//        log.info("获取选择好的工程id进行查询数据后保存");
//        List<OptimizeProject> glass = optimizeProjectService.selectSaveProject(optimizeRequest);
//        log.info("显示工程选择信息后保存到upPattenUsage表:{}", glass);
//        optimizeProjectService.insetupPattenUsage(glass);
//        //void insetProject(glass);
//        return Result.build(200, "", glass);
//    }

}


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

@@ -87,7 +87,7 @@
    /**
     * 第一次平均切裁率
     */
    private String fristCutPct;
    private Double fristCutPct;

    /**
     * 使用的原料数
@@ -97,22 +97,22 @@
    /**
     * 使用的原料面积
     */
    private String rawStockArea;
    private Double rawStockArea;

    /**
     * 平均切裁率
     */
    private String avgCutPct;
    private Double avgCutPct;

    /**
     * 有效切裁率
     */
    private String validCutPct;
    private Double validCutPct;

    /**
     * 尾片切裁率
     */
    private String lastCutPct;
    private Double lastCutPct;

    /**
     * g混排程度
@@ -137,27 +137,27 @@
    /**
     * g上片宽
     */
    private Float loadWidth;
    private Double loadWidth;

    /**
     * g上片长
     */
    private Float loadLength;
    private Double loadLength;

    /**
     * x间隔
     */
    private Float xSpace;
    private Double xSpace;

    /**
     * y间隔
     */
    private Float ySpace;
    private Double ySpace;

    /**
     * g平均装载率
     */
    private Float loadRate;
    private Double loadRate;

    /**
     * 流程卡集合

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

@@ -23,13 +23,13 @@
     */
    List<OptimizeProject> listByState(OptimizeRequest optimizeRequest);
    /**
     * 查询保存到原片使用详情表的数据
     * @return
     */
    List<OptimizeProject> selectSaveProject(OptimizeRequest optimizeRequest);
    /**
     * 将工程信息保存到原片使用详情表
     * @return
     */
    void insetupPattenUsage(List<OptimizeProject> glass);
    /**
     * 将工程信息更新状态为已领取
     * @return
     */
    void changeTask(String engineeringId, int i);
}

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

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

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.core.toolkit.StringUtils;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.mes.pp.entity.OptimizeProject;
import com.mes.pp.entity.request.OptimizeRequest;
@@ -15,7 +15,6 @@
import org.springframework.stereotype.Service;

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

/**
@@ -59,11 +58,15 @@
    }

    @Override
    public List<OptimizeProject> selectSaveProject(OptimizeRequest optimizeRequest) {
        log.info("将参数传入到查询类里,工程号做非空判断模糊查询");
    public void changeTask(String engineeringId, int state) {
        UpdateWrapper<OptimizeProject> wrapper = new UpdateWrapper<>();
        wrapper.eq("project_no",engineeringId)
                .set("state",state);
        boolean updateSuccess = this.update(wrapper);
        log.info("工程表更新状态{}",updateSuccess);

        log.info("返回工程信息");
        return this.baseMapper.saveProject(optimizeRequest);
    }



}

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/uppattenusage/controller/UpPattenUsageController.java

@@ -1,56 +1,74 @@
package com.mes.uppattenusage.controller;
import com.mes.engineering.entity.Engineering;
import com.mes.engineering.service.EngineeringService;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.pp.entity.OptimizeProject;
import com.mes.pp.service.OptimizeProjectService;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.uppattenusage.service.UpPattenUsageService;
import com.mes.utils.Result;
import io.swagger.annotations.ApiOperation;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

//
//import com.mes.uppattenusage.service.GlassInfoService;
//import com.mes.uppattenusage.entity.OptimizeUpPattenUsage;
//import com.mes.uppattenusage.entity.UpPattenUsage;
//import com.mes.glassinfo.entity.GlassInfo;
//import com.mes.uppattenusage.service.UpPattenUsageService;
//import com.mes.utils.Result;
//import io.swagger.annotations.ApiOperation;
//import lombok.extern.slf4j.Slf4j;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.web.bind.annotation.GetMapping;
//import org.springframework.web.bind.annotation.RequestBody;
//import org.springframework.web.bind.annotation.RequestMapping;
//import org.springframework.web.bind.annotation.RestController;
//
//import java.util.List;
//
///**
// * <p>
// *  前端控制器
// * </p>
// *
// * @author zhoush
// * @since 2024-04-18
// */
//@RestController
//@RequestMapping("/up-patten-usage")
//@Slf4j
//public class UpPattenUsageController {
//
//    @Autowired
//    private UpPattenUsageService upPattenUsageService;
//    @Autowired
//    private  GlassInfoService glassInfoService;
//    @ApiOperation("显示正在出片的工程信息")
//    @GetMapping("/prioritylist") //查询现在上片机的玻璃信息
//    public Result<List<UpPattenUsage>> prioritylist() {
//        List<UpPattenUsage> glass = upPattenUsageService.prioritylist(1);
//        log.info("显示工位上的玻璃信息:{}", glass);
//        return Result.build(200, "", glass);
//    }
//
//    @ApiOperation("点击选择工程保存后进行调用,传入工程号")
//    @GetMapping("/saveUpPattenUsage") //查询现在上片机的玻璃信息
//    public Result<Integer> saveUpPattenUsage(String engineeringId) {
//        List<UpPattenUsage> upPattenUsages = upPattenUsageService.selectSaveUpPattenUsage(engineeringId);
//        log.info("将查询出的UpPattenUsage数据保存到数据库表里");
//        upPattenUsageService.saveUpPattenUsage(upPattenUsages);
//        log.info("从PP表查询glassinfo的数据并保存到表里");
//        List<GlassInfo> glassinfo=glassInfoService.selectGlassInfo(engineeringId);
//        return Result.build(200, "", 200);
//    }
//}
import java.util.List;

/**
 * <p>
 *  前端控制器
 * </p>
 *
 * @author zhoush
 * @since 2024-04-18
 */
@RestController
@RequestMapping("/up-patten-usage")
@Slf4j
public class UpPattenUsageController {

    @Autowired
    private UpPattenUsageService upPattenUsageService;
    @Autowired
    private  GlassInfoService glassInfoService;
    @Autowired
    private  EngineeringService engineeringService;
    @Autowired
    private OptimizeProjectService optimizeProjectService;
    @ApiOperation("显示正在出片的工程信息")
    @GetMapping("/prioritylist") //查询现在上片机的玻璃信息
    public Result<List<UpPattenUsage>> prioritylist() {
        List<UpPattenUsage> glass = upPattenUsageService.prioritylist(1);
        log.info("显示工位上的玻璃信息:{}", glass);
        return Result.build(200, "", glass);
    }

    @ApiOperation("点击选择工程保存后进行调用,传入工程号")
    @GetMapping("/saveUpPattenUsage") //查询现在上片机的玻璃信息
    public Result<Integer> saveUpPattenUsage(String engineeringId) {
        log.info("传入工程号判断是否已保存:{}", engineeringId);
        UpPattenUsage upPattenUsage= upPattenUsageService.selectedEngineering(engineeringId);
        if (upPattenUsage!=null){
            log.info("已保存过");
            return Result.build(200, "已保存过", 200);
        }else {
            List<UpPattenUsage> upPattenUsages = upPattenUsageService.selectSaveUpPattenUsage(engineeringId);
            log.info("将查询出的UpPattenUsage数据保存到数据库表里");
            upPattenUsageService.saveUpPattenUsage(upPattenUsages);
            log.info("从PP表查询glassinfo的数据并保存到表里");
            List<GlassInfo> glassinfo=glassInfoService.selectGlassInfo(engineeringId);
            glassInfoService.saveGlassInfo(glassinfo);
            log.info("从PP表查询engineering的数据并保存到表里");
            List<Engineering> engineerings= engineeringService.selectEngineering(engineeringId);
            engineeringService.saveEngineering(engineerings);
            log.info("更改pp表状态为已领取");
            optimizeProjectService.changeTask(engineeringId, 200);
            return Result.build(200, "", 200);
        }

    }
}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/uppattenusage/entity/OptimizeUpPattenUsage.java

@@ -40,7 +40,7 @@
    /**
     * 原片版图片序
     */
    private Integer heatLayoutSort;
    private Integer stockId;

    /**
     * 状态

 hangzhoumesParent/common/servicebase/src/main/java/com/mes/uppattenusage/service/UpPattenUsageService.java

@@ -19,5 +19,10 @@
     List<UpPattenUsage> selectSaveUpPattenUsage(String engineeringId);

     void saveUpPattenUsage(List<UpPattenUsage> upPattenUsages);

     void updateupPattenUsageState(UpPattenUsage upPattenUsage, Integer state);

     UpPattenUsage selectedEngineering(String engineeringId);

}


 hangzhoumesParent/common/servicebase/src/main/java/com/mes/uppattenusage/service/impl/UpPattenUsageServiceImpl.java

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

import com.baomidou.dynamic.datasource.annotation.DS;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.query.MPJQueryWrapper;
import com.mes.pp.entity.OptimizeProject;
@@ -46,7 +47,7 @@
        List<OptimizeUpPattenUsage> upPattenUsageList = null;
        if (engineeringId != null) {
            upPattenUsageList = optimizeProjectMapper.selectJoinList(OptimizeUpPattenUsage.class, new MPJQueryWrapper<OptimizeProject>()
                    .select("t.project_no,t.glass_type,b.width,b.height,REGEXP_REPLACE(t.glass_thickness,'\\D','')as glass_thickness,b.heat_layout_sort")
                    .select("t.project_no,t.glass_type,b.width,b.height,REGEXP_REPLACE(t.glass_thickness,'\\D','')as glass_thickness,b.stock_id")
                    .leftJoin("optimize_layout b on t.project_no=b.project_no")
                    .eq("b.project_no", engineeringId));
        }
@@ -59,12 +60,12 @@
                // 创建一个新的 OptimizeProject 对象
                UpPattenUsage optimizeProject = new UpPattenUsage();
                // 将 Map 中的每个键值对映射到 OptimizeProject 对象的相应字段上
                optimizeProject.setEngineeringId((String) map.getProjectNo());
                optimizeProject.setFilmsId((String) map.getGlassType());
                optimizeProject.setWidth((Double) map.getWidth());
                optimizeProject.setHeight((Double) map.getHeight());
                optimizeProject.setThickness((Double)map.getHeight());
                optimizeProject.setLayoutSequence((Integer) map.getHeatLayoutSort());
                optimizeProject.setEngineeringId(map.getProjectNo());
                optimizeProject.setFilmsId( map.getGlassType());
                optimizeProject.setWidth(map.getWidth());
                optimizeProject.setHeight( map.getHeight());
                optimizeProject.setThickness(map.getGlassThickness());
                optimizeProject.setLayoutSequence( map.getStockId());
                optimizeProject.setState(0);
                // 将映射后的对象添加到结果列表中
                resultList.add(optimizeProject);
@@ -80,10 +81,20 @@
        //保存原片使用详情表
    }

    //@Override
    public void selectSaveGlassinfo(String engineeringId) {
        //保存玻璃信息表
        //optimizeProjectMapper.selectJoinList();
    @Override
    public void updateupPattenUsageState(UpPattenUsage upPattenUsage, Integer state) {
        upPattenUsage.setState(state);
        boolean updateSuccess=this.updateById(upPattenUsage);
        log.info("更新状态{}",updateSuccess);
        //更新状态
    }

    @Override
    public UpPattenUsage selectedEngineering(String engineeringId) {
        QueryWrapper<UpPattenUsage>wrapper = new QueryWrapper<>();
        wrapper.eq("engineering_id",engineeringId)
                .last("limit 1");
        return this.getOne(wrapper);
    }



 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/AppRunnerConfig.java

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

import com.mes.common.S7object;
import com.mes.job.PlcLoadGlassTask;
import lombok.extern.slf4j.Slf4j;
import org.springframework.boot.ApplicationArguments;
import org.springframework.boot.ApplicationRunner;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;

@Slf4j
@Component
@Order(1)

public class AppRunnerConfig implements ApplicationRunner {

    private final PlcLoadGlassTask plcLoadGlassTask;

    public AppRunnerConfig(PlcLoadGlassTask plcLoadGlassTask) {
        this.plcLoadGlassTask = plcLoadGlassTask;
    }

    @Override
    public void run(ApplicationArguments args) throws Exception {
        log.info("启动完成");
        S7object.getinstance().start();

    }
}

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/LoadGlassModuleApplication.java

@@ -5,6 +5,7 @@
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;
import org.springframework.scheduling.annotation.EnableScheduling;
import springfox.documentation.swagger2.annotations.EnableSwagger2;

/**
@@ -16,6 +17,7 @@
@SpringBootApplication
@EnableSwagger2
@EnableDiscoveryClient
@EnableScheduling
@MapperScan(basePackages = "com.mes.*.mapper")
public class LoadGlassModuleApplication {
    public static void main(String[] args) {

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/common/JsonFile/PlcLoadGlass.json

File was deleted

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/common/S7object.java

@@ -1,24 +1,34 @@
package com.mes.common;

import com.github.xingshuangs.iot.protocol.s7.enums.EPlcType;
import com.mes.device.PlcParameterObject;
import com.mes.tools.InitUtil;
import com.mes.tools.S7control;



/**
 * @Author : zhoush
 * @Date: 2024/4/9 15:13
 * @Description:
 */
public class S7object {
public class S7object extends Thread {
    public S7control plccontrol; // PLC通讯类实例
    private EPlcType plcType = EPlcType.S1500; // 西门子PLC类型
    private EPlcType plcType = EPlcType.S1200; // 西门子PLC类型
    private String ip = "192.168.10.1"; // plc ip地址
    private int port = 102; // plc 端口号


    public PlcParameterObject PlcMesObject;
    private static volatile S7object instance = null;

    private S7object() {
        if (plccontrol == null) {
            plccontrol = new S7control(plcType, ip, port, 0, 0);

            String PlcLoadGlass=S7object.class.getResource("/JsonFile/PlcLoadGlass.json").getPath();
            //log.info(PLCAutoMes.class.getResource("").getPath());
            PlcMesObject = InitUtil.initword(PlcLoadGlass);
        }
    }

@@ -33,4 +43,20 @@
        }
        return instance;
    }

    @Override
    public void run() {
        while (this != null) {
            try {
                Thread.sleep(100);

            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            byte[] getplcvlues=   plccontrol.ReadByte(PlcMesObject.getPlcAddressBegin(),PlcMesObject.getPlcAddressLength());
            PlcMesObject.setPlcParameterList(getplcvlues);

        }
    }
}

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/common/WebSocketServer.java

New file
@@ -0,0 +1,160 @@
package com.mes.common;

import cn.hutool.json.JSONObject;
import cn.hutool.json.JSONUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ConfigurableApplicationContext;
import org.springframework.stereotype.Component;

import javax.websocket.*;
import javax.websocket.server.PathParam;
import javax.websocket.server.ServerEndpoint;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

@ServerEndpoint(value = "/api/talk/{username}")
@Component("webSocketServer")
public class WebSocketServer {


    public static ConfigurableApplicationContext applicationContext;

    // 解决无法注入mapper问题 //使用方法
    // homeMapper=WebSocketServer.applicationContext.getBean(HomeMapper.class);
    public static void setApplicationContext(ConfigurableApplicationContext configurableApplicationContext) {
        WebSocketServer.applicationContext = configurableApplicationContext;
    }

    private static final Logger log = LoggerFactory.getLogger(WebSocketServer.class);
    private List<String> messages;
    /**
     * 记录当前在线连接数
     */
    public static final Map<String, ArrayList<WebSocketServer>> sessionMap = new ConcurrentHashMap<>();

    String username;
    Session session;

    public WebSocketServer() {
        this.messages = new ArrayList<>();
    }

    /**
     * 连接建立成功调用的方法
     */
    @OnOpen
    public void onOpen(Session session, @PathParam("username") String username) {
        this.username = username;
        this.session = session;
        List<WebSocketServer> webSocketServers = sessionMap.get(username);
        if (webSocketServers == null) {
            ArrayList<WebSocketServer> arrayListwebserver = new ArrayList<WebSocketServer>();
            arrayListwebserver.add(this);
            sessionMap.put(username, arrayListwebserver);
        } else {
            webSocketServers.add(this);
        }

        log.info("有新用户加入，username={}, 当前在线人数为：{}", username, sessionMap.get(username).size());

        // JSONObject result = new JSONObject();
        // JSONArray array = new JSONArray();
        // result.set("users", array);
        // for (Object key : sessionMap.keySet()) {
        // JSONObject jsonObject = new JSONObject();
        // jsonObject.set("username", key);
        // array.add(jsonObject);
        // }

        // sendAllMessage(JSONUtil.toJsonStr(result)); // 后台发送消息给所有的客户端
    }

    /**
     * 连接关闭调用的方法
     */
    @OnClose
    public void onClose(Session session, @PathParam("username") String username) {
        List<WebSocketServer> webSocketServers = sessionMap.get(username);
        ArrayList<WebSocketServer> arrayListwebserver = new ArrayList<WebSocketServer>();
        if (webSocketServers.size() > 1) {
            for (WebSocketServer webSocketServer : webSocketServers) {
                if (webSocketServer != this) {
                    arrayListwebserver.add(webSocketServer);
                }
            }
            sessionMap.put(username, arrayListwebserver);
            log.info("移除username={}一名用户session, {}的当前在线人数为：{}", username, username, sessionMap.get(username).size());
        } else {
            sessionMap.remove(username);
            log.info("移除username={}一名用户session, {}连接关闭, 当前连接数为：{}", username, username, sessionMap.size());
        }

    }

    /**
     * 收到客户端消息后调用的方法
     * 后台收到客户端发送过来的消息
     * onMessage 是一个消息的中转站
     * 接受 浏览器端 socket.send 发送过来的 json数据
     *
     * @param message 客户端发送过来的消息
     */
    @OnMessage
    public void onMessage(String message, Session session, @PathParam("username") String username) {
        log.info("服务端收到用户username={}的消息:{}", username, message);
        JSONObject obj = JSONUtil.parseObj(message);
        String text = obj.getStr("data");

        JSONObject jsonObject = new JSONObject();
        jsonObject.set("message", text);
        this.messages.add(text);
        this.sendMessage(jsonObject.toString()); // JSONUtil.toJsonStr(jsonObject)

    }

    @OnError
    public void onError(Session session, Throwable error) {
        log.error("发生错误");
        error.printStackTrace();
    }

    /**
     * 服务端发送消息给客户端
     */
    public void sendMessage(String message) {
        try {
            // log.info("服务端给客户端[{}]发送消息{}", this.session.getId(), message);
            this.session.getBasicRemote().sendText(message);
        } catch (Exception e) {
            log.error("服务端发送消息给客户端失败", e);
        }
    }

    // /**
    //  * 服务端发送消息给所有客户端
    //  */
    // public void sendAllMessage(String message) {
    //     try {
    //         for (WebSocketServer webSocketServer : sessionMap.values()) {
    //             // log.info("服务端给客户端[{}]发送消息{}", this.session.getId(), message);
    //             webSocketServer.sendMessage(message);
    //         }
    //     } catch (Exception e) {
    //         log.error("服务端发送消息给客户端失败", e);
    //     }
    // }

    public List<String> getMessages() {
        return messages;

    }

    public void clearMessages() {
        messages.clear();
    }


}

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/engineering/service/EngineeringService.java

File was deleted

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/engineering/service/impl/EngineeringServiceImpl.java

File was deleted

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/job/PlcLoadGlassTask.java

@@ -1,33 +1,113 @@
package com.mes.job;

import cn.hutool.json.JSONObject;
import com.mes.common.S7object;
import com.mes.device.PlcParameterObject;
import com.mes.engineering.entity.Engineering;
import com.mes.engineering.service.EngineeringService;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.uppattenusage.service.UpPattenUsageService;
import com.mes.workstation.entity.UpWorkstation;
import com.mes.workstation.service.UpWorkstationService;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Component;

/**
 * @author SNG-010
 */
@Component
@Slf4j
public class PlcLoadGlassTask {

    @Autowired
    private UpWorkstationService upWorkstationService;
    @Autowired
    private EngineeringService  engineeringService;
    @Autowired
    private UpPattenUsageService upPattenUsageService;


    PlcParameterObject plcParameterObject = S7object.getinstance().PlcMesObject;
    /**
     * fixedRate : 上一个调用开始后再次调用的延时（不用等待上一次调用完成）
     * fixedDelay : 上一个调用结束后再次调用的延时
     */

    @Scheduled(fixedDelay = 300)
    public void plcLoadGlassTask() throws InterruptedException {
        JSONObject jsonObject = new JSONObject();
        try {
            Thread.sleep(300);
            upWorkstationService.selectPriority();
            log.info("开始上片");
            //获取是否有上片请求
            String loadRequest = plcParameterObject.getPlcParameter("loadRequest").getValue();
            //判断开始上片的工程号
            Engineering engineering=engineeringService.selectInitiate(1);
            if("1".equals(loadRequest)&&engineering!=null){
                UpPattenUsage upPattenUsage=upWorkstationService.selectPriority(engineering);
                log.info("当有请求时查询当前上片顺序的玻璃信息{}",upPattenUsage);
                UpWorkstation upwork=upWorkstationService.selectworkstation(upPattenUsage);
                log.info("符合的尺寸的工位玻璃：{}",upwork);
                if(upwork!=null){
                    int workId=upwork.getWorkstationId();//工位id
                    double width=upwork.getPatternWidth();//宽度
                    double height=upwork.getPatternHeight();//高度
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("WorkId").getAddress(),workId);
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("GlassWidth").getAddress(), (long) width);
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("GlassHeight").getAddress(), (long) height);
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlc").getAddress(),1);
                    //减少工位数量
                    upWorkstationService.reduceWorkstationNumber(upwork);
                    //完成上片表状态
                    upPattenUsageService.updateupPattenUsageState(upPattenUsage,1);

                }
            }
            //获取是否有汇报
            String loadStatus = plcParameterObject.getPlcParameter("PlcStatus").getValue();
            if (loadStatus!=null) {
                log.info(loadStatus);
                if ("1".equals(loadStatus)) {
                    log.info("收到汇报任务完成");
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(), 1);
                } else if ("2".equals(loadStatus)) {
                    log.info("收到汇报未完成任务");
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(), 1);
                } else if ("3".equals(loadStatus)) {
                    log.info("收到汇报玻璃破损");
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(), 1);
                } else {
                    log.info("收到汇报清0状态");
                    S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(), 0);
                }
            }
            //执行后休眠300毫秒
            //Thread.sleep(300);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
//    @Scheduled(fixedDelay = 300)
//    public void plcLoadGlassOver() throws InterruptedException {
//        try {
//            //获取是否有汇报
//            String loadStatus = plcParameterObject.getPlcParameter("PlcStatus").getValue();
//            if ("1".equals(loadStatus)){
//                log.info("收到汇报任务完成");
//                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(),1);
//            }else if ("2".equals(loadStatus)) {
//                log.info("收到汇报未完成任务");
//                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(),1);
//            }else if("3".equals(loadStatus)){
//                log.info("收到汇报玻璃破损");
//                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(),1);
//            }else {
//                log.info("收到汇报清0状态");
//                S7object.getinstance().plccontrol.writetime(plcParameterObject.getPlcParameter("MesToPlcStatus").getAddress(),0);
//            }
//
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }

}

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/workstation/entity/UpWorkstation.java

@@ -56,7 +56,7 @@
    /**
     * 原片高
     */
    private Double patternHeigth;
    private Double patternHeight;

    /**
     * 原片厚度

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/workstation/service/UpWorkstationService.java

@@ -1,6 +1,8 @@
package com.mes.workstation.service;

import com.baomidou.mybatisplus.extension.service.IService;
import com.mes.engineering.entity.Engineering;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.workstation.entity.UpWorkSequence;
import com.mes.workstation.entity.UpWorkstation;

@@ -17,10 +19,12 @@



    //判断优先吸片位置后发送出片任务
    UpWorkSequence selectPriority();

    //查询正在进行的工程
    //判断优先吸片玻璃
    UpPattenUsage selectPriority(Engineering engineering);
    //查询正在进行的单片信息
    UpWorkstation selectworkstation(UpPattenUsage upPattenUsage);
    //减少工位数量
    void reduceWorkstationNumber(UpWorkstation upwork);


    /**

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/workstation/service/impl/UpWorkstationServiceImpl.java

@@ -1,7 +1,9 @@
package com.mes.workstation.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.engineering.entity.Engineering;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.uppattenusage.mapper.UpPattenUsageMapper;
import com.mes.workstation.entity.UpWorkSequence;
@@ -27,36 +29,47 @@
public class UpWorkstationServiceImpl extends ServiceImpl<UpWorkstationMapper, UpWorkstation> implements UpWorkstationService {
    @Resource
    UpPattenUsageMapper upPattenUsageMapper;
    public static final String DB_100_10 = "DB_100_10";

    //判断是否可以吸片进行任务
    public boolean isCanLoadGlass() {
        String loadstart = "吸片信号";//plcmes.getPlcParameter("吸片信号").getValue();
        return "1".equals(loadstart);

    }
    //显示正在进行任务的工程信息
    @Resource
    UpWorkstationMapper upWorkstationMapper;


    //判断优先吸片位置后发送出片任务

    public UpWorkSequence selectPriority() {
        UpWorkSequence upwork= this.baseMapper.selectPriority(1);
        String start = "1";//plcmes.getPlcParameter("吸片信号").getValue();
        UpPattenUsage uplist=new UpPattenUsage();
        if(start.equals("1")){
            //发送出片任务
            UpdateWrapper<UpPattenUsage> updateWrapper = new UpdateWrapper<>();
            updateWrapper.eq("state",1).last("LIMIT 1");
            uplist= upPattenUsageMapper.selectOne(updateWrapper);
            log.info("查询出本次出片的玻璃信息[]",uplist);
        }
        return upwork;
    public UpPattenUsage selectPriority(Engineering engineering) {
        QueryWrapper<UpPattenUsage> wrapper=new QueryWrapper<>();
        wrapper.eq("state", 0)
                .eq("engineering_id",engineering.getEngineerId())
                .orderByAsc("layout_sequence")
                .last("limit 1");
        return upPattenUsageMapper.selectOne(wrapper);
    }

    //判断工位是否有符合条件的玻璃
    @Override
    public UpWorkstation selectworkstation(UpPattenUsage upPattenUsage) {
        QueryWrapper<UpWorkstation> wrapper = new QueryWrapper<>();
        wrapper.eq("pattern_width", upPattenUsage.getWidth())
                .eq("pattern_height", upPattenUsage.getHeight())
                .eq("pattern_thickness", upPattenUsage.getThickness())
                .eq("films_id", upPattenUsage.getFilmsId())
                .gt("number", 0)
                .orderByAsc("number")
                .last("limit 1");
        return this.baseMapper.selectOne(wrapper);
    }

    @Override
    public void reduceWorkstationNumber(UpWorkstation upwork) {
        UpdateWrapper<UpWorkstation> wrapper = new UpdateWrapper<>();
        wrapper.eq("id", upwork.getWorkstationId())
                .setSql("number = number - 1");
        boolean updateResult = upWorkstationMapper.update(null, wrapper) > 0;
        log.info("减少工位数量{}",updateResult);

    }

    /**
     * 增加人工输入的工位玻璃信息/删除人工搬走的玻璃信息
     * @param upwork
     */
    @Override
    public void updateGlassMessage(UpWorkstation upwork) {

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/resources/JsonFile/PlcLoadGlass.json

New file
@@ -0,0 +1,71 @@
{
  "plcAddressBegin":"DB14.0",
  "plcAddressLenght":"98",
  "dataType":"word",
  "parameteInfor":[
    {
      "codeId": "loadRequest",
      "addressIndex":"0",
      "addressLenght":"2",
      "ratio":"1",
      "unit":"m/min"
    },
    {
      "codeId": "PlcStatus",
      "addressIndex":"10",
      "addressLenght":"2",
      "ratio":"1",
      "unit":""
    },
    {
      "codeId": "MesToPlc",
      "addressIndex":"20",
      "addressLenght":"2",
      "ratio":"1",
      "unit":""
    },
    {
      "codeId": "WorkId",
      "addressIndex":"24",
      "addressLenght":"2",
      "ratio":"1",
      "unit":""
    },
    {
      "codeId": "GlassWidth",
      "addressIndex":"26",
      "addressLenght":"2",
      "ratio":"1",
      "unit":""
    },
    {
      "codeId": "GlassHeight",
      "addressIndex":"28",
      "addressLenght":"2",
      "ratio":"1",
      "unit":""
    }
  ,
    {
      "codeId": "MesToPlcStatus",
      "addressIndex":"40",
      "addressLenght":"2",
      "ratio":"1",
      "unit":""
    },
    {
      "codeId": "MesToPlcStatusId",
      "addressIndex":"42",
      "addressLenght":"2",
      "ratio":"1",
      "unit":""
    },
    {
      "codeId": "MesTaskStatus",
      "addressIndex":"56",
      "addressLenght":"2",
      "ratio":"1",
      "unit":""
    }
  ]
}

 hangzhoumesParent/moduleService/LoadGlassModule/src/test/java/com/mes/LoadGlassModuleApplicationTest.java

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

import com.mes.engineering.entity.Engineering;
import com.mes.engineering.service.EngineeringService;
import com.mes.glassinfo.entity.GlassInfo;
import com.mes.glassinfo.service.GlassInfoService;
import com.mes.pp.mapper.OptimizeProjectMapper;
import com.mes.uppattenusage.entity.OptimizeUpPattenUsage;
import com.mes.pp.service.OptimizeProjectService;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.mes.uppattenusage.service.impl.UpPattenUsageServiceImpl;
import com.mes.workstation.entity.UpWorkstation;
import com.mes.workstation.service.UpWorkstationService;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -16,24 +20,27 @@
import javax.annotation.Resource;
import java.util.Arrays;
import java.util.List;
import java.util.Map;

/**
 * @Author : zhoush
 * @Date: 2024/3/27 16:37
 * @Description:

 */
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest(classes = LoadGlassModuleApplication.class)
public class LoadGlassModuleApplicationTest {

    @Resource
    private OptimizeProjectMapper optimizeProjectMapper;
//    @Resource
//    private OptimizeProjectMapper optimizeProjectMapper;
    @Autowired
    private UpPattenUsageServiceImpl upPattenUsageService;
    @Autowired
    private GlassInfoService glassInfoService;
    @Autowired
    private EngineeringService engineeringService;
    @Autowired
    private UpWorkstationService workstationService;
    @Autowired
    private OptimizeProjectService optimizeProjectService;
    @Test
    public void test() {
//        List<OptimizeProject> list = optimizeProjectMapper.saveProject("P24032204");
@@ -48,12 +55,38 @@

    @Test
    public void testFindPa() {
        List<UpPattenUsage> glass = upPattenUsageService.selectSaveUpPattenUsage("P24032204");
        log.info("完整路径：{}", Arrays.asList(glass));
        Engineering  engineering= engineeringService.selectInitiate(1);
        log.info("开始上片的工程：{}", Arrays.asList(engineering));
        UpPattenUsage upPattenUsage = workstationService.selectPriority(engineering);
        log.info("上片顺序：{}", Arrays.asList(upPattenUsage));
        UpWorkstation glass2=workstationService.selectworkstation(upPattenUsage);
        log.info("符合的工位玻璃{}",glass2);
        workstationService.reduceWorkstationNumber(glass2);
        //减少数量
        upPattenUsageService.updateupPattenUsageState(upPattenUsage,1);
        //更新状态
    }

    @Test
    public  void  textglassinfo(){
        List<GlassInfo> glass= glassInfoService.selectGlassInfo("P24032204");
        log.info("glassinfo：{}", Arrays.asList(glass));
        glassInfoService.saveGlassInfo(glass);
    }
    @Test
    public  void  textengineering(){
        List<Engineering> glass= engineeringService.selectEngineering("P24032204");
        engineeringService.saveEngineering(glass);
        log.info("glassinfo：{}", Arrays.asList(glass));
    }
    @Test
    public  void  textengineering2(){
        //更新工程表状态为已领取
        optimizeProjectService.changeTask("P24050801",200);
    }
    @Test
    public  void  textengineering3(){
        //判断是否已保存过工程号到上片表
        upPattenUsageService.selectedEngineering("P24050801");
    }
}