Merge branch 'mdc_hyjs_master'

zhangherong

2025-06-25 23855599412c4d61b38d78f0f3abd3430a48b5b1

 lxzn-module-dnc/src/main/java/org/jeecg/modules/dnc/service/impl/CutterServiceImpl.java

¶Ô±ÈÐÂÎļþ
@@ -0,0 +1,330 @@
package org.jeecg.modules.dnc.service.impl;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.dnc.entity.Cutter;
import org.jeecg.modules.dnc.entity.DocFile;
import org.jeecg.modules.dnc.entity.DocInfo;
import org.jeecg.modules.dnc.entity.GuideCardBatch;
import org.jeecg.modules.dnc.exception.ExceptionCast;
import org.jeecg.modules.dnc.mapper.CutterMapper;
import org.jeecg.modules.dnc.response.CommonCode;
import org.jeecg.modules.dnc.service.ICutterService;
import org.jeecg.modules.dnc.service.IDocFileService;
import org.jeecg.modules.dnc.service.IDocInfoService;
import org.jeecg.modules.dnc.service.IGuideCardBatchService;
import org.jeecg.modules.dnc.utils.ValidateUtil;
import org.jeecg.modules.dnc.utils.file.FileUtilS;
import org.jeecg.modules.tms.entity.PreparationOrderDetail;
import org.jeecg.modules.tms.entity.dto.PreparationOrderAndDetailDto;
import org.jeecg.modules.tms.service.IPreparationOrderService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.util.ArrayList;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;

@Service
@Slf4j
public class CutterServiceImpl extends ServiceImpl<CutterMapper, Cutter> implements ICutterService {

    @Autowired
    private IDocInfoService docInfoService;

    @Autowired
    private IDocFileService docFileService;

    @Autowired
    private IGuideCardBatchService guideCardBatchService;

    @Autowired
    private IPreparationOrderService preparationOrderService;
    /**
     * æ–°å¢žåˆ€å…·ä¿¡æ¯
     * @param cutter
     * @return
     */
    @Override
    public Result<?> add(Cutter cutter){
        if(cutter == null)
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        if(!ValidateUtil.validateString(cutter.getAttributionId()))
            Result.error("无效的刀具");
        List<Cutter> cutterList =this.checkCutterNo(cutter);
        if (cutterList != null && !cutterList.isEmpty()) {
            return Result.error("已存在相同的刀具编号");
        }
        boolean save = this.save(cutter);
        if(save){
            return Result.OK("添加刀具成功");
        }
        return Result.error("新增刀具失败");
    }

    /**
     * ç¼–辑刀具信息
     * @param cutter
     * @return
     */
    @Override
    public Result<?> edit(Cutter cutter){
        // æ£€æŸ¥ä¼ å…¥çš„刀具对象是否为空
        if (cutter == null) {
           return Result.OK("刀具对象不能为空");
        }
        // æ£€æŸ¥åˆ€å…·åç§°æ˜¯å¦æœ‰æ•ˆ
        if (!ValidateUtil.validateString(cutter.getCutterName())) {
            return Result.OK("刀具名称无效");
        }
        // æ ¹æ®åˆ€å…· ID èŽ·å–刀具信息
        Cutter existingCutter = super.getById(cutter.getId());
        if (existingCutter == null) {
            return Result.OK("刀具不存在");
        }
        // è¿‡æ»¤æŽ‰å½“前要编辑的刀具，检查是否有其他刀具存在相同编号
        List<Cutter> otherCuttersWithSameNo = this.checkCutterNo(cutter).stream()
                .filter(cut -> !cut.getId().equals(cutter.getId()))
                .collect(Collectors.toList());
        if (!otherCuttersWithSameNo.isEmpty()) {
            // å¦‚果存在除当前刀具外的其他刀具编号重复
            return Result.error("已存在相同的刀具编号");
        }
        // å°è¯•æ›´æ–°åˆ€å…·ä¿¡æ¯
        boolean updated = this.updateById(cutter);
        if (updated) {
            return Result.OK("刀具信息编辑成功");
        } else {
            return Result.error("刀具信息编辑失败");
        }
    }

    /**
     * åˆ é™¤åˆ€å…·ä¿¡æ¯
     * @param id
     * @return
     */
    @Override
    public Result<?> delete(String id){
        if(!ValidateUtil.validateString(id))
            ExceptionCast.cast(CommonCode.INVALID_PARAM);
        Cutter en = super.getById(id);
        if(en == null)
            return Result.error("无效的刀具");
        boolean b=super.removeById(id);
        if(!b) {
            return Result.error("删除刀具失败");
        }
        return Result.OK("删除刀具成功");
    }

    /**
     * éªŒè¯åŒç»“构下刀具编号是否重复
     * @param cutter
     * @return
     */
    public List<Cutter> checkCutterNo(Cutter cutter){
        QueryWrapper<Cutter> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(StrUtil.isNotEmpty(cutter.getAttributionId()),"attribution_id",cutter.getAttributionId());
        queryWrapper.eq("attribution_type",cutter.getAttributionType());
        queryWrapper.eq(StrUtil.isNotEmpty(cutter.getCutterCode()),"cutter_code",cutter.getCutterCode());
        queryWrapper.eq(StrUtil.isNotEmpty(cutter.getCutterType()),"cutter_type",cutter.getCutterType());
        queryWrapper.eq(StrUtil.isNotEmpty(cutter.getCutterSpacing()),"cutter_spacing",cutter.getCutterSpacing());
        return baseMapper.selectList(queryWrapper);
    }

    /**
     * èŽ·å–业务id下的刀具列表
     * @param cutter
     * @return
     */
    @Override
    public Result<?> query(Cutter cutter, Integer pageNo, Integer pageSize){
        QueryWrapper<Cutter> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq(StrUtil.isNotEmpty(cutter.getAttributionId()),"attribution_id",cutter.getAttributionId());
        if (cutter.getAttributionType() != null){
            queryWrapper.eq("attribution_type",cutter.getAttributionType());
        }
        queryWrapper.eq(StrUtil.isNotEmpty(cutter.getDocId()),"doc_id",cutter.getDocId());
        queryWrapper.like(StrUtil.isNotEmpty(cutter.getCutterCode()),"cutter_code",cutter.getCutterCode());
        queryWrapper.like(StrUtil.isNotEmpty(cutter.getCutterName()),"cutter_name",cutter.getCutterName());
        queryWrapper.orderByDesc("create_time");
        Page<Cutter> page = new Page<>(pageNo,pageSize);
        IPage<Cutter> cutterIPage = baseMapper.selectPage(page, queryWrapper);
        return Result.OK(cutterIPage);
    }

    /**
     * ä»ŽNC文件内容提取刀具信息并保存
     */
    @Override
    @Transactional
    public Result<?> extractAndSaveFromContent(String docId,String attributionId,Integer attributionType){
        DocInfo docInfo=docInfoService.getById(docId);
        if (docInfo == null) {
            return Result.error("未找到对应文档信息，无法提取刀具信息");
        }
        docInfo.setAttributionId(attributionId);
        docInfo.setAttributionType(attributionType);
        DocFile docFile=docFileService.getById(docInfo.getPublishFileId());
        if (docFile == null) {
            return Result.error("未找到对应文件信息，无法提取刀具信息");
        }
        String filePath = docFile.getFilePath();
        String fileEncodeName = docFile.getFileEncodeName();
        //文档内容
        List<String> list = FileUtilS.readFile(fileEncodeName, filePath);
        if (list == null || list.isEmpty()) {
            return Result.error("文档内容为空，无法提取刀具信息");
        }
        List<Cutter> cutterList = extractToolAfterM6(docInfo,list);
        // ä¿å­˜åˆ€å…·
        if (!cutterList.isEmpty()) {
            List<Cutter> newCutterList = new ArrayList<>();
            //验证刀具是否已经存在
            cutterList.forEach(item -> {
                List<Cutter> otherCuttersWithSameNo = checkCutterNo(item);
                if (otherCuttersWithSameNo == null || otherCuttersWithSameNo.isEmpty()) {
                    newCutterList.add(item);
                }
            });
            if (newCutterList.isEmpty()) {
                return Result.error("未发现刀具的参数信息注释，无法提取刀具信息");
            }
            this.saveBatch(newCutterList);
            return Result.OK("提取刀具信息成功");
        }else {
            return Result.error("未发现刀具的参数信息注释，无法提取刀具信息");
        }
    }

    @Override
    public Result<?> sendToCutterSystem(String docId,String attributionId,Integer attributionType){
        List<Cutter> cutterList = this.list(new QueryWrapper<Cutter>()
                .eq("doc_id", docId)
                .eq(StrUtil.isNotEmpty(attributionId),"attribution_id",attributionId)
                .eq("attribution_type",attributionType));
        if (cutterList == null || cutterList.isEmpty()) {
            return Result.error("未发现刀具信息，无法发送到刀具系统");
        }
        if (cutterList.stream().anyMatch(item -> item.getCutterCode() == null)) {
            return Result.error("未发现刀具编号信息，无法发送到刀具系统");
        }
        //获取最新数控程序加工确认表
        List<GuideCardBatch> guideCardBatchList = guideCardBatchService.list(new QueryWrapper<GuideCardBatch>()
                .eq("doc_id", docId)
                .isNotNull("serial_number")
                .orderByDesc("SUBSTRING(serial_number, LEN(serial_number)-3, 4)"));
        if (guideCardBatchList == null || guideCardBatchList.isEmpty()) {
            return Result.error("未发现程序加工确认表信息，无法发送到刀具系统");
        }
        GuideCardBatch guideCardBatch = guideCardBatchList.get(0);
        PreparationOrderAndDetailDto dto = new PreparationOrderAndDetailDto();
        dto.setPartDrawingNo(guideCardBatch.getPartsCode());
        dto.setPartName(guideCardBatch.getPartsName());
        dto.setPartMaterial(guideCardBatch.getMaterielDesp());
        dto.setProductionProcessesNo(guideCardBatch.getProcessWorkCode());
        dto.setBatchCode(guideCardBatch.getProcessingBatch());
        dto.setMachiningCount(guideCardBatch.getProcessingQuantity());
        dto.setEquipmentCode(guideCardBatch.getProcessingEquipment());
        dto.setNcName(guideCardBatch.getDocName());
        List<PreparationOrderDetail> detailList = new ArrayList<>();
        cutterList.forEach(item -> {
            PreparationOrderDetail detail = new PreparationOrderDetail();
            detail.setToolCode(item.getCutterCode());
            detail.setToolId(item.getToolsId());
            detailList.add(detail);
        });
        dto.setPreparationOrderDetailList(detailList);
        preparationOrderService.addPreparationOrderFromDnc(dto);
        return Result.OK("发送到刀具系统成功");
    }

    public List<Cutter> extractToolAfterM6(DocInfo docInfo, List<String> ncLines) {
        List<Cutter> cutterList = new ArrayList<>();
        String currentToolCode = null; // ç”¨äºŽè¿½è¸ªå½“前换刀指令的刀具号

        for (String line : ncLines) {
            String trimmedLine = line.trim();

            // 1. åŒ¹é… M6 æ¢åˆ€æŒ‡ä»¤ï¼Œæå– T代码（如 T01 M06 æˆ– T 02 M06）
            if (trimmedLine.contains("M6")||trimmedLine.contains("M06")) {
                currentToolCode = extractToolCodeFromM6Line(trimmedLine);
            }

            // 2. åŒ¹é…åˆ€å…·å‚数注释（紧跟在 M6 åŽçš„括号内容）
            if (currentToolCode != null && trimmedLine.startsWith("(") && trimmedLine.endsWith(")")) {
                String toolDescription = trimmedLine.substring(1, trimmedLine.length() - 1).trim();
                if (!toolDescription.isEmpty()) {
                    Cutter cutter = new Cutter();
                    cutter.setDocId(docInfo.getDocId());
                    cutter.setAttributionId(docInfo.getAttributionId());
                    cutter.setAttributionType(docInfo.getAttributionType());
                    cutter.setDescription(toolDescription);

                    // ä»Žåˆ€å…·æè¿°ä¸­æå– cutterCode (例如从 "90E-10A" ä¸­æå– "E")
                    extractToolInfoFromDescription(toolDescription, cutter);

                    // è®¾ç½®åˆ€å…·é—´è·ï¼ˆä½¿ç”¨T代码或其他逻辑）
                    cutter.setCutterSpacing(currentToolCode);

                    // æ‹†åˆ†åˆ€å…·åç§°ä¸Žè§„格（简单按空格分割，前部分为名称，后部分为规格）
                    String[] parts = toolDescription.split(" ", 2);
                    if (parts.length >= 1) {
                        cutter.setCutterName(parts[0]);
                    }
                    cutterList.add(cutter);
                    currentToolCode = null; // é‡ç½®ï¼Œé¿å…é‡å¤åŒ¹é…
                }
            }
        }

        return cutterList;
    }

    /**
     * ä»Žåˆ€å…·æè¿°ä¸­æå– cutterType å’Œ cutterCode
     * ä¾‹å¦‚: "8CH-90A" -> cutterType="CH", cutterCode="90A"
     */
    private void extractToolInfoFromDescription(String description, Cutter cutter) {
        // æå–刀具型号（一个或多个连续的大写字母）
        String cutterType = extractCutterType(description);
        cutter.setCutterType(cutterType);
        // æå–破折号后的规格部分
        String cutterSpec = "";
        int dashIndex = description.indexOf('-');
        if (dashIndex != -1 && dashIndex < description.length() - 1) {
            cutterSpec = description.substring(dashIndex + 1).trim();
            cutter.setCutterSpec(cutterSpec);
        }
    }

    /**
     * æå–刀具型号（一个或多个连续的大写字母）
     */
    private String extractCutterType(String description) {
        Pattern pattern = Pattern.compile("[A-Z]+");
        Matcher matcher = pattern.matcher(description);

        if (matcher.find()) {
            return matcher.group();
        }

        return description;
    }

    // è¾…助方法：从 M6 è¡Œæå– T代码（支持 T01 æˆ– T 01 æ ¼å¼ï¼‰
    private String extractToolCodeFromM6Line(String line) {
        Matcher matcher = Pattern.compile("T(\\d+)").matcher(line);
        return matcher.find() ? "T" + matcher.group(1).trim() : null;
    }
}