1、补充丢失的开始任务方法

ZengTao

2025-10-14 74be79541a69a064305ae1d5554d47cedab9f642

 hangzhoumesParent/moduleService/LoadGlassModule/src/main/java/com/mes/uppattenusage/service/impl/UpPattenUsageServiceImpl.java

@@ -1,20 +1,321 @@
package com.mes.uppattenusage.service.impl;

import cn.hutool.core.collection.CollectionUtil;
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.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.github.yulichang.base.MPJBaseServiceImpl;
import com.github.yulichang.query.MPJQueryWrapper;
import com.mes.common.config.Const;
import com.mes.damage.entity.request.DamageRequest;
import com.mes.damage.service.DamageService;
import com.mes.engineering.entity.Engineering;
import com.mes.engineering.service.EngineeringService;
import com.mes.pp.entity.OptimizeProject;
import com.mes.pp.mapper.OptimizeProjectMapper;
import com.mes.rawglassdetails.entity.RawGlassStorageDetails;
import com.mes.rawglassdetails.service.RawGlassStorageDetailsService;
import com.mes.uppattenusage.entity.OptimizeUpPattenUsage;
import com.mes.uppattenusage.entity.UpPattenUsage;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.mes.uppattenusage.mapper.UpPattenUsageMapper;
import com.mes.uppattenusage.service.UpPattenUsageService;
import com.mes.utils.RedisUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;

/**
 * <p>
 *  服务实现类
 * 服务实现类
 * </p>
 *
 * @author zhoush
 * @since 2024-04-07
 * @since 2024-04-18
 */
@Service
public class UpPattenUsageServiceImpl extends ServiceImpl<UpPattenUsageMapper, UpPattenUsage> implements UpPattenUsageService {
@Slf4j
public class UpPattenUsageServiceImpl extends MPJBaseServiceImpl<UpPattenUsageMapper, UpPattenUsage> implements UpPattenUsageService {

    @Autowired
    OptimizeProjectMapper optimizeProjectMapper;
    @Autowired
    EngineeringService engineeringService;
    @Autowired
    DamageService damageService;
    @Autowired
    RedisUtil redisUtil;
    @Resource
    RawGlassStorageDetailsService rawGlassStorageDetailsService;

    @Override
    public List<UpPattenUsage> prioritylist() {
        //获取正在上片的任务id
        Engineering engineering = engineeringService.selectInitiate(1);
        //log.info("将参数传入到查询类里{}",engineering);
        if (engineering != null) {
            LambdaQueryWrapper<UpPattenUsage> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(UpPattenUsage::getEngineeringId, engineering.getEngineerId());
            return this.list(wrapper);
        } else {
            return null;
        }

    }

    @Override
    public List<UpPattenUsage> selectLoadTask(Engineering cell) {
        //获取正在上片的任务id
        Engineering engineering = engineeringService.selectInitiates(1, cell.getStationCell());
        //log.info("将参数传入到查询类里{}",engineering);
        if (engineering != null) {
            LambdaQueryWrapper<UpPattenUsage> wrapper = new LambdaQueryWrapper<>();
            wrapper.eq(UpPattenUsage::getEngineeringId, engineering.getEngineerId());
            if (cell.getState() != null) {
                wrapper.eq(UpPattenUsage::getState, cell.getState());
            }
            return this.list(wrapper);
        } else {
            return null;
        }
    }

    @Override
    public List<UpPattenUsage> selectUpPattenUsage(UpPattenUsage upPattenUsage) {
        LambdaQueryWrapper<UpPattenUsage> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(UpPattenUsage::getEngineeringId, upPattenUsage.getEngineeringId());
//                .eq(UpPattenUsage::getStationCell, upPattenUsage.getStationCell())
//                .eq(UpPattenUsage::getFilmRemove, upPattenUsage.getFilmRemove());

        return this.list(wrapper);
    }

    @Override
    @DS("pp")
    public List<UpPattenUsage> selectSaveUpPattenUsage(String engineeringId) {

        List<OptimizeUpPattenUsage> upPattenUsageList = null;
        if (engineeringId != null) {
            upPattenUsageList = optimizeProjectMapper.selectJoinList(OptimizeUpPattenUsage.class, new MPJQueryWrapper<OptimizeProject>()
                    .select("t.project_no,t.glass_type,b.realwidth as width,b.realheight as 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));
        }
        // 创建一个 List 用于保存映射后的实体对象
        List<UpPattenUsage> resultList = new ArrayList<>();

// 遍历查询结果中的每个 Map 对象
        if (upPattenUsageList != null) {
            for (OptimizeUpPattenUsage map : upPattenUsageList) {
                // 创建一个新的 OptimizeProject 对象
                UpPattenUsage optimizeProject = new UpPattenUsage();
                // 将 Map 中的每个键值对映射到 OptimizeProject 对象的相应字段上
                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);
            }
        }
        log.info("查询出上片顺序集合保存到实体类{}", resultList);
        return resultList;
    }

    @Override
    public void saveUpPattenUsage(List<UpPattenUsage> upPattenUsage) {
        if (CollectionUtil.isEmpty(upPattenUsage)) {
            return;
        }
        String engineerId = upPattenUsage.get(0).getEngineeringId();
        int count = this.count(new LambdaQueryWrapper<UpPattenUsage>().eq(UpPattenUsage::getEngineeringId, engineerId));
        if (count <= 0) {
            //保存原片使用详情表
            this.saveBatch(upPattenUsage);
        }
    }

    @Override
    public void updateUpPattenUsageState(UpPattenUsage upPattenUsage, Integer state) {
        upPattenUsage.setState(state);
        boolean updateSuccess = this.updateById(upPattenUsage);
        log.info("更新状态{}", updateSuccess);
        //更新状态
    }

    @Override
    public UpPattenUsage selectedTaskEngineering(String engineeringId) {
        return null;
    }

    @Override
    public UpPattenUsage selectedEngineering(String engineerId) {
        QueryWrapper<UpPattenUsage> wrapper = new QueryWrapper<>();
        wrapper.eq("engineering_id", engineerId)
//                .eq("station_cell", stationCell)
//                .eq("film_remove", filmRemove)
                .last("limit 1");
        log.info("查询预览参数");
        log.info("查询预览参数{}", this.getOne(wrapper));
        return this.getOne(wrapper);
    }

    @Override
    public void deleteTask(String engineerId) {
        QueryWrapper<UpPattenUsage> wrapper = new QueryWrapper<>();
        wrapper.eq("engineering_id", engineerId);
        this.remove(wrapper);
    }


    @Override
    public UpPattenUsage selectOverTask() {
        QueryWrapper<UpPattenUsage> wrapper = new QueryWrapper<>();
        wrapper.gt("state", 0)
                .lt("state", 99)
                .last("limit 1");
        return this.getOne(wrapper);
    }

    @Override
    //获取最后一块玻璃
    public UpPattenUsage selectSequence(UpPattenUsage upPattenUsage) {
        QueryWrapper<UpPattenUsage> wrapper = new QueryWrapper<>();
        wrapper.eq("engineering_id", upPattenUsage.getEngineeringId())
                .orderByDesc("layout_sequence")
                .last("limit 1");
        return this.getOne(wrapper);
    }

    @Override
    public Boolean updateGlassState(UpPattenUsage upPattenUsage) {
        UpdateWrapper<UpPattenUsage> updateWrapper = new UpdateWrapper<>();
        updateWrapper.eq("id", upPattenUsage.getId())
                .set("state", upPattenUsage.getState());
        return this.update(updateWrapper);
    }

    @Override
    public String setRawGlassTaskRequest(Engineering request) {
        // 调用 RedisUtil 保存 loadGlass
        if (request == null) {
            redisUtil.deleteObject("loadGlassRequestOne");
        } else {
            redisUtil.setCacheObject("loadGlassRequestOne", request);
        }
        return "success";
    }

    @Override
    public String setRawGlassTaskRequest2(Engineering request) {
        // 调用 RedisUtil 保存 loadGlass
        if (request == null) {
            redisUtil.deleteObject("loadGlassRequestTwo");
        } else {
            redisUtil.setCacheObject("loadGlassRequestTwo", request);
        }
        return "success";
    }


    public Object Engineering(Engineering request) {
        return null;
    }

    @Override
    public String identControls(DamageRequest request) {
        //将识别破损的玻璃直接加入破损表
        damageService.autoSubmitReport(request.getGlassId(), request.getLine(), request.getWorkingProcedure(), "上片机", request.getState());
        return "success";
    }

    @Override
    public Boolean insertTask(Integer quantity, Integer slot) {
        engineeringService.update(
                new LambdaUpdateWrapper<Engineering>()
                        .eq(Engineering::getState, Const.ENGINEERING_RUNNING)
                        .set(Engineering::getState, Const.ENGINEERING_SUCCESS)
        );


        Calendar calendar = Calendar.getInstance();
        // 当天 00:00:00
        calendar.set(Calendar.HOUR_OF_DAY, 0);
        calendar.set(Calendar.MINUTE, 0);
        calendar.set(Calendar.SECOND, 0);
        calendar.set(Calendar.MILLISECOND, 0);
        Date todayStart = calendar.getTime();

        // 当天 23:59:59
        calendar.set(Calendar.HOUR_OF_DAY, 23);
        calendar.set(Calendar.MINUTE, 59);
        calendar.set(Calendar.SECOND, 59);
        calendar.set(Calendar.MILLISECOND, 999);
        Date todayEnd = calendar.getTime();

        // 2. 构建查询条件：状态为“运行中” + 时间在当天范围内
        Integer count = engineeringService.count(
                new LambdaQueryWrapper<Engineering>()
                        .eq(Engineering::getState, Const.ENGINEERING_RUNNING) // 原状态条件
                        // 核心：createTime 大于等于当天开始，小于等于当天结束
                        .ge(Engineering::getCreateTime, todayStart)
                        .le(Engineering::getCreateTime, todayEnd)
        );
        RawGlassStorageDetails rawGlassStorageDetails = rawGlassStorageDetailsService.getOne(
                new LambdaQueryWrapper<RawGlassStorageDetails>()
                        .eq(RawGlassStorageDetails::getSlot, slot)
                        .eq(RawGlassStorageDetails::getState, 100)
        );
        String engineerId = generateSingleProjectNo(count);
        Engineering engineering = new Engineering();
        engineering.setEngineerId(engineerId);
        engineering.setEngineerName(rawGlassStorageDetails.getFilmsId());
        engineering.setState(5);
        engineering.setPlanPatternTotal(slot);
        engineering.setFilmsId(rawGlassStorageDetails.getFilmsId());
        engineeringService.save(engineering);

        for (int i = 1; i <= quantity; i++) {
            UpPattenUsage saveDetails = new UpPattenUsage();
            saveDetails.setEngineeringId(engineerId);
            saveDetails.setFilmsId(rawGlassStorageDetails.getFilmsId());
            saveDetails.setWidth(rawGlassStorageDetails.getPatternWidth());
            saveDetails.setHeight(rawGlassStorageDetails.getPatternHeight());
            saveDetails.setThickness(rawGlassStorageDetails.getPatternThickness());
            saveDetails.setLayoutSequence(i);
            saveDetails.setState(0);
            this.save(saveDetails);
        }
        return Boolean.TRUE;
    }

    private static String generateSingleProjectNo(int currentCount) {
        // 1. 固定前缀 "P"
        final String PREFIX = "P";

        // 2. 格式化当前日期为「年2位+月2位+日2位」（如2025-05-08 → "250508"）
        DateTimeFormatter dateFormatter = DateTimeFormatter.ofPattern("yyMMdd");
        String dateStr = LocalDate.now().format(dateFormatter);

        // 3. 计算新序号（已有数量+1），并处理“小于10补0”
        int newSequence = currentCount + 1;
        // 关键：%02d 表示固定2位数字，不足则补0（1→"01"，9→"09"，10→"10"）
        String formattedSequence = String.format("%02d", newSequence);

        // 4. 拼接工程号（前缀+日期+补0后的序号）
        return PREFIX + dateStr + formattedSequence;
    }
}