Merge remote-tracking branch 'origin/master'

Houjie

2025-06-13 ac8e03a06d463aafcbe810af31e2da5037491a07

Merge remote-tracking branch 'origin/master'

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/controller/ToolsToDncController.java

@@ -1,15 +1,14 @@
package org.jeecg.modules.tms.controller;

import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import io.swagger.annotations.ApiOperation;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.constant.CommonConstant;
import org.jeecg.modules.tms.entity.ToolsClassify;
import org.jeecg.modules.tms.entity.dto.ToolQueryParamDto;
import org.jeecg.modules.tms.entity.vo.ParaHolesToolsVo;
import org.jeecg.modules.tms.entity.vo.ParaMillToolVo;
import org.jeecg.modules.tms.entity.vo.ParaTurningToolsVo;
import org.jeecg.modules.tms.entity.vo.*;
import org.jeecg.modules.tms.enums.ToolParaType;
import org.jeecg.modules.tms.service.*;
import org.springframework.beans.factory.annotation.Autowired;
@@ -18,9 +17,10 @@
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

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

@RestController
@RequestMapping("/tms/toolsToDnc")
@@ -34,41 +34,108 @@
    private IParaMillToolService paraMillToolService;
    @Autowired
    private IParaTurningToolsService paraTurningToolsService;
    @Autowired
    private IParaThreadingToolService paraThreadingToolService;
    @Autowired
    private IParaBladeService paraBladeService;

    @ApiOperation(value = "通过工具简称查询工具分类信息，选刀页面工具类型下拉框用", notes = "通过工具简称查询工具分类信息，选刀页面工具类型下拉框用")
    @GetMapping("/queryToolClassifyByParam")
    public Result<?> queryToolClassifyByParam(@RequestParam("aliasLabel") String aliasLabel) {
        List<ToolsClassify> classifyList = toolsClassifyService.list(new LambdaQueryWrapper<ToolsClassify>()
                .eq(ToolsClassify::getAliasLabel, aliasLabel)
                .eq(ToolsClassify::getStatus, CommonConstant.STATUS_1));
        List<Map<String, String>> list = classifyList.stream()
                .map(classify -> new HashMap<String, String>() {{
                    put("value", classify.getId());
                    put("label", classify.getTypeName());
                }})
                .collect(Collectors.toList());
        return Result.ok(list);
    }
    /**
     * 通过工具简称/直径参数查询具体工具参数信息(给DNC提供接口)，参数示例：3E（3为工具直径参数、E为加工中心刀具简称）
     *
     * @param queryParam
     * @return
     */
    @ApiOperation(value = "通过工具简称/直径参数查询具体工具参数信息(给DNC提供接口)", notes = "通过工具简称/直径参数查询具体工具参数信息(给DNC提供接口)")
    @GetMapping("/queryToolByParam")
    public Result<?> queryToolByParam(@RequestParam("param") ToolQueryParamDto queryParam){
        String param = queryParam.getParam();
        // 正则表达式：前半部分为数字（支持小数），后半部分为大写或小写字母
        String regex = "^([\\d.]+)([A-Za-z]+)$";
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(param);
        if (matcher.find()) {
            String diameter = matcher.group(1);
            String toolAliasName = matcher.group(2);
    public Result<?> queryToolByParam(ToolQueryParamDto queryParam) {
        String aliasLabel = queryParam.getAliasLabel();
        String diameter = queryParam.getDiameter();
        if (StrUtil.isBlank(aliasLabel)) {
            return Result.error("缺少必要参数");
        }

        Result<Object> res = Result.OK();
        Map<String, Object> result = new HashMap<>();
        int pageNo = Objects.isNull(queryParam.getPageNo()) || queryParam.getPageNo() < 1 ? 1 : queryParam.getPageNo();
        int pageSize = Objects.isNull(queryParam.getPageSize()) || queryParam.getPageSize() < 1 ? 10 : queryParam.getPageSize();

        List<Object> toolList = CollectionUtil.newArrayList();
        String classifyId = queryParam.getClassifyId();
        if (StrUtil.isNotBlank(classifyId)) {
            //已经进入了选刀页面，工具分类已经确定
            ToolsClassify toolsClassify = toolsClassifyService.getById(classifyId);
            ToolParaType toolParaType = ToolParaType.fromValue(toolsClassify.getParaTypeFlag());
            matchTypeSelectTools(queryParam, toolList, toolParaType);
        } else {
            //第一次进入选刀页面，根据刀具简称和直径参数查询工具分类
            List<ToolsClassify> classifyList = toolsClassifyService.list(new LambdaQueryWrapper<ToolsClassify>()
                    .eq(ToolsClassify::getAliasLabel, toolAliasName)
                    .eq(ToolsClassify::getAliasLabel, aliasLabel)
                    .eq(ToolsClassify::getStatus, CommonConstant.STATUS_1));
            if (CollectionUtil.isEmpty(classifyList)) {
                return Result.error("未找到匹配的工具分类");
                result.put("records", CollectionUtil.newArrayList());
                result.put("total", 0);
                result.put("current", pageNo);
                result.put("size", pageSize);
                res.setResult(result);
                return res;
            }
            List<Object> toolList = CollectionUtil.newArrayList();
            for (ToolsClassify classify : classifyList) {
                String paraTypeFlag = classify.getParaTypeFlag();
                queryParam.setClassifyId(classify.getId());
                queryParam.setDiameter(diameter);
                ToolParaType toolParaType = ToolParaType.fromValue(paraTypeFlag);
                matchTypeSelectTools(queryParam, toolList, toolParaType);
            }
        }

        // ====== 分页逻辑 start ======
        int total = toolList.size();
        int fromIndex = (pageNo - 1) * pageSize;
        int toIndex = Math.min(fromIndex + pageSize, total);

        List<Object> pagedList;
        if (fromIndex > total) {
            pagedList = Collections.emptyList();
        } else {
            pagedList = toolList.subList(fromIndex, toIndex);
        }

        result.put("records", pagedList);
        result.put("total", total);
        result.put("current", pageNo);
        result.put("size", pageSize);
        res.setResult(result);
        return res;
        // ====== 分页逻辑 end ======
    }

    private void matchTypeSelectTools(ToolQueryParamDto queryParam, List<Object> toolList, ToolParaType toolParaType) {
                if (toolParaType != null) {
            String diameter = queryParam.getDiameter();
                    switch (toolParaType) {
                        case HOLE:
                            List<ParaHolesToolsVo> paraHoleToolsList = paraHoleToolsService.selectByClassifyAndDiameter(queryParam);
                            toolList.addAll(paraHoleToolsList);
                    break;
                case THREADING://螺纹刀具没有直径参数，如果传入直径，直接略过
                    if (StrUtil.isBlank(diameter)) {
                        List<ParaThreadingToolVo> paraThreadingToolList = paraThreadingToolService.selectByClassifyAndParam(queryParam);
                        toolList.addAll(paraThreadingToolList);
                    }
                            break;
                        case MILL:
                            List<ParaMillToolVo> paraMillToolList = paraMillToolService.selectByClassifyAndDiameter(queryParam);
@@ -78,13 +145,14 @@
                            List<ParaTurningToolsVo> paraTurningToolsList = paraTurningToolsService.selectByClassifyAndDiameter(queryParam);
                            toolList.addAll(paraTurningToolsList);
                            break;
                case BLADE://刀片没有直径参数，如果传入直径，直接略过
                    if (StrUtil.isBlank(diameter)) {
                        List<ParaBladeVo> paraBladeToolsList = paraBladeService.selectByClassifyAndParam(queryParam);
                        toolList.addAll(paraBladeToolsList);
                    }
                    break;
                        default:
                    }
                }
            }
            return Result.OK(toolList);
        } else {
            return Result.error("参数格式不正确");
        }
    }


 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/entity/dto/ToolQueryParamDto.java

@@ -9,13 +9,23 @@
 */
@Data
public class ToolQueryParamDto {
    /**复合参数(工具简称/直径参数)，例如：3E*/
    @ApiModelProperty(value = "复合参数(工具简称/直径参数)，例如：3E")
    private String param;
    /**工具简称*/
    @ApiModelProperty(value = "工具简称")
    private String aliasLabel;
    /**刀具直径*/
    @ApiModelProperty(value = "刀具直径")
    private String diameter;
    /**刀具分类ID(不用前端传，后台记录参数用)*/
    private String classifyId;
    /**刀具直径(不用前端传，后台记录参数用)*/
    private String diameter;
    /**工具编码*/
    @ApiModelProperty(value = "工具编码(tms_base_tool表tool_code字段)")
    private String toolCode;
    /**型号/图号*/
    @ApiModelProperty(value = "型号/图号")
    private String toolModel;
    /**中文名称*/
    @ApiModelProperty(value = "中文名称")
    private String chineseName;
    /**刀具总长*/
    @ApiModelProperty(value = "刀具总长")
    private String totalLength;
@@ -23,7 +33,7 @@
    @ApiModelProperty(value = "刀具材料")
    private String toolMaterial;
    /**切削刃长*/
    @ApiModelProperty(value = "切削刃长(孔加工刀具、铣削刀具)")
    @ApiModelProperty(value = "切削刃长(孔加工刀具、铣削刀具、螺纹刀具)")
    private String edgeLength;
    /**刃数(孔加工刀具)*/
    @ApiModelProperty(value = "刃数(孔加工刀具)")
@@ -69,7 +79,7 @@
    @ApiModelProperty(value = "悬伸长度(铣削刀具)")
    private String overhangingLength;
    /**螺距*/
    @ApiModelProperty(value = "螺距(铣削刀具)")
    @ApiModelProperty(value = "螺距(铣削刀具、螺纹刀具、刀片)")
    private String pitch;
    /**最小加工直径*/
    @ApiModelProperty(value = "最小加工直径(铣削刀具)")
@@ -78,7 +88,7 @@
    @ApiModelProperty(value = "配套刀片号(车削刀具)")
    private String matchingNumber;
    /**切削方向*/
    @ApiModelProperty(value = "切削方向(车削刀具)")
    @ApiModelProperty(value = "切削方向(车削刀具、刀片)")
    private String cuttingDirection;
    /**刀片尺寸*/
    @ApiModelProperty(value = "刀片尺寸(车削刀具)")
@@ -87,7 +97,7 @@
    @ApiModelProperty(value = "镗杆直径(车削刀具)")
    private String boringBarDiameter;
    /**刀杆长度*/
    @ApiModelProperty(value = "刀杆长度(车削刀具)")
    @ApiModelProperty(value = "刀杆长度(车削刀具、刀片)")
    private String bladeLength;
    /**刀杆方向*/
    @ApiModelProperty(value = "刀杆方向(车削刀具)")
@@ -96,7 +106,7 @@
    @ApiModelProperty(value = "刀杆高度(车削刀具)")
    private String bladeHeight;
    /**刀杆宽度*/
    @ApiModelProperty(value = "刀杆宽度(车削刀具)")
    @ApiModelProperty(value = "刀杆宽度(车削刀具、刀片)")
    private String bladeWide;
    /**刀片槽宽*/
    @ApiModelProperty(value = "刀片槽宽(车削刀具)")
@@ -108,9 +118,81 @@
    @ApiModelProperty(value = "最大切槽深度(车削刀具)")
    private String maxDepth;
    /**刀板厚度*/
    @ApiModelProperty(value = "刀板厚度(车削刀具)")
    @ApiModelProperty(value = "刀板厚度(车削刀具、刀片厚度)")
    private String bladeThickness;
    /**最小加工直径*/
    @ApiModelProperty(value = "最小加工直径(车削刀具)")
    private String minDiameter;
    /**螺纹代号*/
    @ApiModelProperty(value = "螺纹代号(螺纹刀具)")
    private String threadCode;
    /**螺纹旋向*/
    @ApiModelProperty(value = "螺纹旋向(螺纹刀具)")
    private String rotationDirection;
    /**螺纹公差带代号/精度等级*/
    @ApiModelProperty(value = "螺纹公差带代号/精度等级(螺纹刀具)")
    private String tolerancezoneLevel;
    /**外型尺寸*/
    @ApiModelProperty(value = "外型尺寸(螺纹刀具)")
    private String externalDimensions;
    /**柄部规格*/
    @ApiModelProperty(value = "柄部规格(螺纹刀具)")
    private String handleSpecifications;
    /**螺孔类型*/
    @ApiModelProperty(value = "螺孔类型(螺纹刀具)")
    private String screwHoleType;
    /**螺纹标准*/
    @ApiModelProperty(value = "螺纹标准(螺纹刀具、刀片)")
    private String threadStandard;
    /**排屑槽型*/
    @ApiModelProperty(value = "排屑槽型(螺纹刀具)")
    private String fluteSoltType;
    /**螺纹类型*/
    @ApiModelProperty(value = "螺纹类型(螺纹刀具)")
    private String threadType;
    /**导向尺寸*/
    @ApiModelProperty(value = "导向尺寸(螺纹刀具)")
    private String guidingSize;
    /**连接孔径*/
    @ApiModelProperty(value = "连接孔径(螺纹刀具)")
    private String connectionAperture;
    /**连接键槽*/
    @ApiModelProperty(value = "连接键槽(螺纹刀具)")
    private String connectingKeyway;
    /**刀片形状*/
    @ApiModelProperty(value = "刀片形状(刀片)")
    private String bladeShape;
    /**切削刃数*/
    @ApiModelProperty(value = "切削刃数(刀片)")
    private String cuttingEdgeCount;
    /**夹固型式*/
    @ApiModelProperty(value = "夹固型式(刀片)")
    private String clampingType;
    /**刀尖R*/
    @ApiModelProperty(value = "刀尖R(刀片)")
    private String noseAngleR;
    /**加工分类*/
    @ApiModelProperty(value = "加工分类(刀片)")
    private String processingClassify;
    /**刀片后角*/
    @ApiModelProperty(value = "刀片后角(刀片)")
    private String bladePosterior;
    /**刀片尺寸*/
    @ApiModelProperty(value = "刀片尺寸(刀片)")
    private String bladeSize;
    /**内外螺纹*/
    @ApiModelProperty(value = "内外螺纹(刀片)")
    private String inOutThread;
    /**牙型角度*/
    @ApiModelProperty(value = "牙型角度(刀片)")
    private String dentalAngle;
    /**最小加工内螺纹公称直径*/
    @ApiModelProperty(value = "最小加工内螺纹公称直径(刀片)")
    private String minInternalThread;

    //分页参数
    @ApiModelProperty(value = "页码")
    private Integer pageNo = 1;   // 当前页码，默认第一页
    @ApiModelProperty(value = "每页数量")
    private Integer pageSize = 10; // 每页数量，默认10条
}

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/mapper/ParaBladeMapper.java

@@ -2,9 +2,14 @@

import java.util.List;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.commons.math3.analysis.function.Constant;
import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.tms.entity.ParaBlade;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.jeecg.modules.tms.entity.vo.ParaBladeVo;

/**
 * @Description: tms_para_blade
@@ -14,4 +19,5 @@
 */
public interface ParaBladeMapper extends BaseMapper<ParaBlade> {

    List<ParaBladeVo> selectByClassifyAndParam(@Param(Constants.WRAPPER) Wrapper<ParaBlade> queryWrapper);
}

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/mapper/ParaHoleToolsMapper.java

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

import java.util.List;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Param;
@@ -18,5 +19,5 @@
public interface ParaHoleToolsMapper extends BaseMapper<ParaHoleTools> {

    List<ParaHolesToolsVo> selectByClassifyAndDiameter(@Param(Constants.WRAPPER)
                                                       LambdaQueryWrapper<ParaHolesToolsVo> queryWrapper);
                                                       Wrapper<ParaHoleTools> queryWrapper);
}

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/mapper/ParaMillToolMapper.java

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

import java.util.List;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.tms.entity.ParaMillTool;
@@ -18,5 +18,5 @@
public interface ParaMillToolMapper extends BaseMapper<ParaMillTool> {

    List<ParaMillToolVo> selectByClassifyAndDiameter(@Param(Constants.WRAPPER)
                                                     LambdaQueryWrapper<ParaMillTool> queryWrapper);
                                                     Wrapper<ParaMillTool> queryWrapper);
}

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/mapper/ParaThreadingToolMapper.java

@@ -2,9 +2,13 @@

import java.util.List;

import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.tms.entity.ParaThreadingTool;
import com.baomidou.mybatisplus.core.mapper.BaseMapper;
import org.jeecg.modules.tms.entity.vo.ParaThreadingToolVo;

/**
 * @Description: tms_para_threading_tool
@@ -14,4 +18,5 @@
 */
public interface ParaThreadingToolMapper extends BaseMapper<ParaThreadingTool> {

    List<ParaThreadingToolVo> selectByClassifyAndParam(@Param(Constants.WRAPPER) Wrapper<ParaThreadingTool> queryWrapper);
}

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/mapper/ParaTurningToolsMapper.java

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

import java.util.List;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.Wrapper;
import com.baomidou.mybatisplus.core.toolkit.Constants;
import org.apache.ibatis.annotations.Param;
import org.jeecg.modules.tms.entity.ParaTurningTools;
@@ -18,5 +18,5 @@
public interface ParaTurningToolsMapper extends BaseMapper<ParaTurningTools> {

    List<ParaTurningToolsVo> selectByClassifyAndDiameter(@Param(Constants.WRAPPER)
                                                         LambdaQueryWrapper<ParaTurningTools> queryWrapper);
                                                         Wrapper<ParaTurningTools> queryWrapper);
}

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/mapper/xml/ParaBladeMapper.xml

@@ -2,4 +2,43 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.jeecg.modules.tms.mapper.ParaBladeMapper">

    <select id="selectByClassifyAndParam" resultType="org.jeecg.modules.tms.entity.vo.ParaBladeVo">
        SELECT
            t.id,
            t.classify_id AS classifyId,
            t2.classify_id AS classifyNum,
            t2.type_name AS classifyName,
            t1.id AS toolId,
            t1.tool_code AS toolCode,
            t1.parama_table_name AS paramaTableName,
            t.sign_code AS signCode,
            t.chinese_name AS chineseName,
            t.foreign_language_name AS foreignLanguageName,
            t.standard_level AS standardLevel,
            t.standard_code AS standardCode,
            t.position_code AS positionCode,
            t.tool_model AS toolModel,
            t.tool_material AS toolMaterial,
            t.part_material AS partMaterial,
            t.technical_conditions AS technicalConditions,
            t.conditions_info AS conditionsInfo,
            t.brand,
            t.types,
            <!-- 刀片特有字段 -->
            t.blade_shape AS bladeShape,
            t.cutting_edge_count AS cuttingEdgeCount,
            t.clamping_type AS clampingType,
            t.nose_angle_r AS noseAngleR,
            t.processing_classify AS processingClassify,
            t.blade_posterior AS bladePosterior,
            t.blade_size AS bladeSize,
            t.in_out_thread AS inOutThread,
            t.dental_angle AS dentalAngle,
            t.min_internal_thread AS minInternalThread,
            t.thread_standard AS threadStandard
        FROM tms_para_blade t
        LEFT JOIN tms_base_tools t1 ON t.tool_code = t1.id
        LEFT JOIN tms_tools_classify t2 ON t.classify_id = t2.id
        ${ew.customSqlSegment}
    </select>
</mapper>

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/mapper/xml/ParaHoleToolsMapper.xml

@@ -10,6 +10,7 @@
            t2.type_name AS classifyName,
            t1.id AS toolId,
            t1.tool_code AS toolCode,
            t1.parama_table_name AS paramaTableName,
            t.sign_code AS signCode,
            t.chinese_name AS chineseName,
            t.foreign_language_name AS foreignLanguageName,

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/mapper/xml/ParaMillToolMapper.xml

@@ -9,7 +9,8 @@
            t2.classify_id AS classifyNum,
            t2.type_name AS classifyName,
            t1.id AS toolId,
            t.tool_code AS toolCode,
            t1.tool_code AS toolCode,
            t1.parama_table_name AS paramaTableName,
            t.sign_code AS signCode,
            t.chinese_name AS chineseName,
            t.foreign_language_name AS foreignLanguageName,

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/mapper/xml/ParaThreadingToolMapper.xml

@@ -2,4 +2,49 @@
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.jeecg.modules.tms.mapper.ParaThreadingToolMapper">

    <select id="selectByClassifyAndParam" resultType="org.jeecg.modules.tms.entity.vo.ParaThreadingToolVo">
        SELECT
            t.id,
            t.classify_id AS classifyId,
            t2.classify_id AS classifyNum,
            t2.type_name AS classifyName,
            t1.id AS toolId,
            t1.tool_code AS toolCode,
            t1.parama_table_name AS paramaTableName,
            t.sign_code AS signCode,
            t.chinese_name AS chineseName,
            t.foreign_language_name AS foreignLanguageName,
            t.standard_level AS standardLevel,
            t.standard_code AS standardCode,
            t.position_code AS positionCode,
            t.tool_model AS toolModel,
            t.edge_length AS edgeLength,
            t.total_length AS totalLength,
            t.tool_material AS toolMaterial,
            t.part_material AS partMaterial,
            t.paintcoat_flag AS paintcoatFlag,
            t.handle_specifications AS handleSpecifications,
            t.cooling_method AS coolingMethod,
            t.technical_conditions AS technicalConditions,
            t.conditions_info AS conditionsInfo,
            t.brand,
            t.types,
            <!-- 螺纹刀具特有字段 -->
            t.thread_code AS threadCode,
            t.rotation_direction AS rotationDirection,
            t.tolerancezone_level AS tolerancezoneLevel,
            t.external_dimensions AS externalDimensions,
            t.handle_specifications AS handleSpecifications,
            t.screw_hole_type AS screwHoleType,
            t.thread_standard AS threadStandard,
            t.flute_solt_type AS fluteSoltType,
            t.thread_type AS threadType,
            t.guiding_size AS guidingSize,
            t.connection_aperture AS connectionAperture,
            t.connecting_keyway AS connectingKeyway
        FROM tms_para_threading_tool t
        LEFT JOIN tms_base_tools t1 ON t.tool_code = t1.id
        LEFT JOIN tms_tools_classify t2 ON t.classify_id = t2.id
        ${ew.customSqlSegment}
    </select>
</mapper>

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/mapper/xml/ParaTurningToolsMapper.xml

@@ -10,6 +10,7 @@
            t2.type_name AS classifyName,
            t1.id AS toolId,
            t1.tool_code AS toolCode,
            t1.parama_table_name AS paramaTableName,
            t.sign_code AS signCode,
            t.chinese_name AS chineseName,
            t.foreign_language_name AS foreignLanguageName,

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/service/IParaBladeService.java

@@ -2,6 +2,10 @@

import org.jeecg.modules.tms.entity.ParaBlade;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.tms.entity.dto.ToolQueryParamDto;
import org.jeecg.modules.tms.entity.vo.ParaBladeVo;

import java.util.List;

/**
 * @Description: tms_para_blade
@@ -11,4 +15,5 @@
 */
public interface IParaBladeService extends IService<ParaBlade> {

    List<ParaBladeVo> selectByClassifyAndParam(ToolQueryParamDto queryParam);
}

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/service/IParaThreadingToolService.java

@@ -2,6 +2,10 @@

import org.jeecg.modules.tms.entity.ParaThreadingTool;
import com.baomidou.mybatisplus.extension.service.IService;
import org.jeecg.modules.tms.entity.dto.ToolQueryParamDto;
import org.jeecg.modules.tms.entity.vo.ParaThreadingToolVo;

import java.util.List;

/**
 * @Description: tms_para_threading_tool
@@ -11,4 +15,5 @@
 */
public interface IParaThreadingToolService extends IService<ParaThreadingTool> {

    List<ParaThreadingToolVo> selectByClassifyAndParam(ToolQueryParamDto queryParam);
}

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/service/impl/ParaBladeServiceImpl.java

@@ -1,11 +1,19 @@
package org.jeecg.modules.tms.service.impl;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.jeecg.modules.tms.entity.ParaBlade;
import org.jeecg.modules.tms.entity.dto.ToolQueryParamDto;
import org.jeecg.modules.tms.entity.vo.ParaBladeVo;
import org.jeecg.modules.tms.mapper.ParaBladeMapper;
import org.jeecg.modules.tms.service.IParaBladeService;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

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

/**
 * @Description: tms_para_blade
@@ -16,4 +24,32 @@
@Service
public class ParaBladeServiceImpl extends ServiceImpl<ParaBladeMapper, ParaBlade> implements IParaBladeService {

    @Override
    public List<ParaBladeVo> selectByClassifyAndParam(ToolQueryParamDto paramDto) {
        QueryWrapper<ParaBlade> queryWrapper = Wrappers.query();
        if (paramDto != null) {
            // 刀片相关参数字段
            queryWrapper
                    .like(StrUtil.isNotBlank(paramDto.getToolCode()), "t1.tool_code", paramDto.getToolCode())
                    .like(StrUtil.isNotBlank(paramDto.getToolModel()), "t.tool_model", paramDto.getToolModel())
                    .like(StrUtil.isNotBlank(paramDto.getChineseName()), "t.chinese_name", paramDto.getChineseName())
                    .eq(StrUtil.isNotBlank(paramDto.getClassifyId()), "t.classify_id", paramDto.getClassifyId())
                    .eq(StrUtil.isNotBlank(paramDto.getPitch()), "t.pitch", paramDto.getPitch())
                    .eq(StrUtil.isNotBlank(paramDto.getCuttingDirection()), "t.cutting_direction", paramDto.getCuttingDirection())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeLength()), "t.blade_length", paramDto.getBladeLength())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeWide()), "t.blade_wide", paramDto.getBladeWide())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeShape()), "t.blade_shape", paramDto.getBladeShape())
                    .eq(StrUtil.isNotBlank(paramDto.getCuttingEdgeCount()), "t.cutting_edge_count", paramDto.getCuttingEdgeCount())
                    .eq(StrUtil.isNotBlank(paramDto.getClampingType()), "t.clamping_type", paramDto.getClampingType())
                    .eq(StrUtil.isNotBlank(paramDto.getNoseAngleR()), "t.nose_angle_r", paramDto.getNoseAngleR())
                    .eq(StrUtil.isNotBlank(paramDto.getProcessingClassify()), "t.processing_classify", paramDto.getProcessingClassify())
                    .eq(StrUtil.isNotBlank(paramDto.getBladePosterior()), "t.blade_posterior", paramDto.getBladePosterior())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeSize()), "t.blade_size", paramDto.getBladeSize())
                    .eq(StrUtil.isNotBlank(paramDto.getInOutThread()), "t.in_out_thread", paramDto.getInOutThread())
                    .eq(StrUtil.isNotBlank(paramDto.getDentalAngle()), "t.dental_angle", paramDto.getDentalAngle())
                    .eq(StrUtil.isNotBlank(paramDto.getMinInternalThread()), "t.min_internal_thread", paramDto.getMinInternalThread())
                    .eq(StrUtil.isNotBlank(paramDto.getThreadStandard()), "t.thread_standard", paramDto.getThreadStandard());
        }
        return this.baseMapper.selectByClassifyAndParam(queryWrapper);
    }
}

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/service/impl/ParaHoleToolsServiceImpl.java

@@ -27,23 +27,26 @@

    @Override
    public List<ParaHolesToolsVo> selectByClassifyAndDiameter(ToolQueryParamDto paramDto) {
        LambdaQueryWrapper<ParaHolesToolsVo> queryWrapper = new LambdaQueryWrapper<>();
        QueryWrapper<ParaHoleTools> queryWrapper = Wrappers.query();
        if (paramDto != null) {
            // 孔加工刀具相关参数字段
            queryWrapper
                    .eq(StrUtil.isNotBlank(paramDto.getClassifyId()), ParaHolesToolsVo::getClassifyId, paramDto.getClassifyId())
                    .eq(StrUtil.isNotBlank(paramDto.getDiameter()), ParaHolesToolsVo::getDiameter, paramDto.getDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getTotalLength()), ParaHolesToolsVo::getTotalLength, paramDto.getTotalLength())
                    .eq(StrUtil.isNotBlank(paramDto.getToolMaterial()), ParaHolesToolsVo::getToolMaterial, paramDto.getToolMaterial())
                    .eq(StrUtil.isNotBlank(paramDto.getEdgeLength()), ParaHolesToolsVo::getEdgeLength, paramDto.getEdgeLength())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeCount()), ParaHolesToolsVo::getBladeCount, paramDto.getBladeCount())
                    .eq(StrUtil.isNotBlank(paramDto.getEffectiveLength()), ParaHolesToolsVo::getEffectiveLength, paramDto.getEffectiveLength())
                    .eq(StrUtil.isNotBlank(paramDto.getLatestBoringDiameter()), ParaHolesToolsVo::getLatestBoringDiameter, paramDto.getLatestBoringDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getMaxBoringDiameter()), ParaHolesToolsVo::getMaxBoringDiameter, paramDto.getMaxBoringDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getKnifeDiameter()), ParaHolesToolsVo::getKnifeDiameter, paramDto.getKnifeDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getBoreDiameter()), ParaHolesToolsVo::getBoreDiameter, paramDto.getBoreDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getHeadsNumber()), ParaHolesToolsVo::getHeadsNumber, paramDto.getHeadsNumber())
                    .eq(StrUtil.isNotBlank(paramDto.getSmallDiameter()), ParaHolesToolsVo::getSmallDiameter, paramDto.getSmallDiameter());
                    .like(StrUtil.isNotBlank(paramDto.getToolCode()), "t1.tool_code", paramDto.getToolCode())
                    .like(StrUtil.isNotBlank(paramDto.getToolModel()), "t.tool_model", paramDto.getToolModel())
                    .like(StrUtil.isNotBlank(paramDto.getChineseName()), "t.chinese_name", paramDto.getChineseName())
                    .eq(StrUtil.isNotBlank(paramDto.getClassifyId()), "t.classify_id", paramDto.getClassifyId())
                    .eq(StrUtil.isNotBlank(paramDto.getDiameter()), "t.diameter", paramDto.getDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getTotalLength()), "t.total_length", paramDto.getTotalLength())
                    .eq(StrUtil.isNotBlank(paramDto.getToolMaterial()), "t.tool_material", paramDto.getToolMaterial())
                    .eq(StrUtil.isNotBlank(paramDto.getEdgeLength()), "t.edge_length", paramDto.getEdgeLength())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeCount()), "t.blade_count", paramDto.getBladeCount())
                    .eq(StrUtil.isNotBlank(paramDto.getEffectiveLength()), "t.effective_length", paramDto.getEffectiveLength())
                    .eq(StrUtil.isNotBlank(paramDto.getLatestBoringDiameter()), "t.latest_boring_diameter", paramDto.getLatestBoringDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getMaxBoringDiameter()), "t.max_boring_diameter", paramDto.getMaxBoringDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getKnifeDiameter()), "t.knife_diameter", paramDto.getKnifeDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getBoreDiameter()), "t.bore_diameter", paramDto.getBoreDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getHeadsNumber()), "t.heads_number", paramDto.getHeadsNumber())
                    .eq(StrUtil.isNotBlank(paramDto.getSmallDiameter()), "t.small_diameter", paramDto.getSmallDiameter());
        }
        return this.baseMapper.selectByClassifyAndDiameter(queryWrapper);
    }

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/service/impl/ParaMillToolServiceImpl.java

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

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.jeecg.modules.tms.entity.ParaMillTool;
import org.jeecg.modules.tms.entity.dto.ToolQueryParamDto;
import org.jeecg.modules.tms.entity.vo.ParaMillToolVo;
@@ -25,24 +27,27 @@

    @Override
    public List<ParaMillToolVo> selectByClassifyAndDiameter(ToolQueryParamDto paramDto) {
        LambdaQueryWrapper<ParaMillTool> queryWrapper = new LambdaQueryWrapper<>();
        QueryWrapper<ParaMillTool> queryWrapper = Wrappers.query();
        if (paramDto != null) {
            //铣削刀具相关参数字段
            queryWrapper
                    .eq(StrUtil.isNotBlank(paramDto.getClassifyId()), ParaMillTool::getClassifyId, paramDto.getClassifyId())
                    .eq(StrUtil.isNotBlank(paramDto.getDiameter()), ParaMillTool::getDiameter, paramDto.getDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getTotalLength()), ParaMillTool::getTotalLength, paramDto.getTotalLength())
                    .eq(StrUtil.isNotBlank(paramDto.getToolMaterial()), ParaMillTool::getToolMaterial, paramDto.getToolMaterial())
                    .eq(StrUtil.isNotBlank(paramDto.getEdgeLength()), ParaMillTool::getEdgeLength, paramDto.getEdgeLength())
                    .eq(StrUtil.isNotBlank(paramDto.getNumberOfTeeth()), ParaMillTool::getNumberOfTeeth, paramDto.getNumberOfTeeth())
                    .eq(StrUtil.isNotBlank(paramDto.getNeckDiameter()), ParaMillTool::getNeckDiameter, paramDto.getNeckDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getSmallDiameter()), ParaMillTool::getSmallDiameter, paramDto.getSmallDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getHandleLength()), ParaMillTool::getHandleLength, paramDto.getHandleLength())
                    .eq(StrUtil.isNotBlank(paramDto.getDeepestDepth()), ParaMillTool::getDeepestDepth, paramDto.getDeepestDepth())
                    .eq(StrUtil.isNotBlank(paramDto.getHandleNeckLength()), ParaMillTool::getHandleNeckLength, paramDto.getHandleNeckLength())
                    .eq(StrUtil.isNotBlank(paramDto.getOverhangingLength()), ParaMillTool::getOverhangingLength, paramDto.getOverhangingLength())
                    .eq(StrUtil.isNotBlank(paramDto.getPitch()), ParaMillTool::getPitch, paramDto.getPitch())
                    .eq(StrUtil.isNotBlank(paramDto.getRecentlyDiameter()), ParaMillTool::getRecentlyDiameter, paramDto.getRecentlyDiameter());
                    .like(StrUtil.isNotBlank(paramDto.getToolCode()), "t1.tool_code", paramDto.getToolCode())
                    .like(StrUtil.isNotBlank(paramDto.getToolModel()), "t.tool_model", paramDto.getToolModel())
                    .like(StrUtil.isNotBlank(paramDto.getChineseName()), "t.chinese_name", paramDto.getChineseName())
                    .eq(StrUtil.isNotBlank(paramDto.getClassifyId()), "t.classify_id", paramDto.getClassifyId())
                    .eq(StrUtil.isNotBlank(paramDto.getDiameter()), "t.diameter", paramDto.getDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getTotalLength()), "t.total_length", paramDto.getTotalLength())
                    .eq(StrUtil.isNotBlank(paramDto.getToolMaterial()), "t.tool_material", paramDto.getToolMaterial())
                    .eq(StrUtil.isNotBlank(paramDto.getEdgeLength()), "t.edge_length", paramDto.getEdgeLength())
                    .eq(StrUtil.isNotBlank(paramDto.getNumberOfTeeth()), "t.number_of_teeth", paramDto.getNumberOfTeeth())
                    .eq(StrUtil.isNotBlank(paramDto.getNeckDiameter()), "t.neck_diameter", paramDto.getNeckDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getSmallDiameter()), "t.small_diameter", paramDto.getSmallDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getHandleLength()), "t.handle_length", paramDto.getHandleLength())
                    .eq(StrUtil.isNotBlank(paramDto.getDeepestDepth()), "t.deepest_depth", paramDto.getDeepestDepth())
                    .eq(StrUtil.isNotBlank(paramDto.getHandleNeckLength()), "t.handle_neck_length", paramDto.getHandleNeckLength())
                    .eq(StrUtil.isNotBlank(paramDto.getOverhangingLength()), "t.overhanging_length", paramDto.getOverhangingLength())
                    .eq(StrUtil.isNotBlank(paramDto.getPitch()), "t.pitch", paramDto.getPitch())
                    .eq(StrUtil.isNotBlank(paramDto.getRecentlyDiameter()), "t.recently_diameter", paramDto.getRecentlyDiameter());
        }
        return this.baseMapper.selectByClassifyAndDiameter(queryWrapper);
    }

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/service/impl/ParaThreadingToolServiceImpl.java

@@ -1,11 +1,19 @@
package org.jeecg.modules.tms.service.impl;

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.jeecg.modules.tms.entity.ParaThreadingTool;
import org.jeecg.modules.tms.entity.dto.ToolQueryParamDto;
import org.jeecg.modules.tms.entity.vo.ParaThreadingToolVo;
import org.jeecg.modules.tms.mapper.ParaThreadingToolMapper;
import org.jeecg.modules.tms.service.IParaThreadingToolService;
import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;

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

/**
 * @Description: tms_para_threading_tool
@@ -16,4 +24,30 @@
@Service
public class ParaThreadingToolServiceImpl extends ServiceImpl<ParaThreadingToolMapper, ParaThreadingTool> implements IParaThreadingToolService {

    @Override
    public List<ParaThreadingToolVo> selectByClassifyAndParam(ToolQueryParamDto paramDto) {
        QueryWrapper<ParaThreadingTool> queryWrapper = Wrappers.query();
        if (paramDto != null) {
            // 螺纹刀具相关参数字段
            queryWrapper
                    .like(StrUtil.isNotBlank(paramDto.getToolCode()), "t1.tool_code", paramDto.getToolCode())
                    .like(StrUtil.isNotBlank(paramDto.getToolModel()), "t.tool_model", paramDto.getToolModel())
                    .like(StrUtil.isNotBlank(paramDto.getChineseName()), "t.chinese_name", paramDto.getChineseName())
                    .eq(StrUtil.isNotBlank(paramDto.getClassifyId()), "t.classify_id", paramDto.getClassifyId())
                    .eq(StrUtil.isNotBlank(paramDto.getThreadCode()), "t.thread_code", paramDto.getThreadCode())
                    .eq(StrUtil.isNotBlank(paramDto.getPitch()), "t.pitch", paramDto.getPitch())
                    .eq(StrUtil.isNotBlank(paramDto.getRotationDirection()), "t.rotation_direction", paramDto.getRotationDirection())
                    .eq(StrUtil.isNotBlank(paramDto.getTolerancezoneLevel()), "t.tolerancezone_level", paramDto.getTolerancezoneLevel())
                    .eq(StrUtil.isNotBlank(paramDto.getExternalDimensions()), "t.external_dimensions", paramDto.getExternalDimensions())
                    .eq(StrUtil.isNotBlank(paramDto.getHandleSpecifications()), "t.handle_specifications", paramDto.getHandleSpecifications())
                    .eq(StrUtil.isNotBlank(paramDto.getScrewHoleType()), "t.screw_hole_type", paramDto.getScrewHoleType())
                    .eq(StrUtil.isNotBlank(paramDto.getThreadStandard()), "t.thread_standard", paramDto.getThreadStandard())
                    .eq(StrUtil.isNotBlank(paramDto.getFluteSoltType()), "t.flute_solt_type", paramDto.getFluteSoltType())
                    .eq(StrUtil.isNotBlank(paramDto.getThreadType()), "t.thread_type", paramDto.getThreadType())
                    .eq(StrUtil.isNotBlank(paramDto.getGuidingSize()), "t.guiding_size", paramDto.getGuidingSize())
                    .eq(StrUtil.isNotBlank(paramDto.getConnectionAperture()), "t.connection_aperture", paramDto.getConnectionAperture())
                    .eq(StrUtil.isNotBlank(paramDto.getConnectingKeyway()), "t.connecting_keyway", paramDto.getConnectingKeyway());
        }
        return this.baseMapper.selectByClassifyAndParam(queryWrapper);
    }
}

 lxzn-module-tms/src/main/java/org/jeecg/modules/tms/service/impl/ParaTurningToolsServiceImpl.java

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

import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import org.jeecg.modules.tms.entity.ParaTurningTools;
import org.jeecg.modules.tms.entity.dto.ToolQueryParamDto;
import org.jeecg.modules.tms.entity.vo.ParaTurningToolsVo;
@@ -25,28 +27,31 @@

    @Override
    public List<ParaTurningToolsVo> selectByClassifyAndDiameter(ToolQueryParamDto paramDto) {
        LambdaQueryWrapper<ParaTurningTools> queryWrapper = new LambdaQueryWrapper<>();
        QueryWrapper<ParaTurningTools> queryWrapper = Wrappers.query();
        if (paramDto != null) {
            //车削刀具相关参数字段
            queryWrapper
                    .eq(StrUtil.isNotBlank(paramDto.getClassifyId()), ParaTurningTools::getClassifyId, paramDto.getClassifyId())
                    .eq(StrUtil.isNotBlank(paramDto.getDiameter()), ParaTurningTools::getToolDiameter, paramDto.getDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getTotalLength()), ParaTurningTools::getTotalLength, paramDto.getTotalLength())
                    .eq(StrUtil.isNotBlank(paramDto.getToolMaterial()), ParaTurningTools::getToolMaterial, paramDto.getToolMaterial())
                    .eq(StrUtil.isNotBlank(paramDto.getSmallDiameter()), ParaTurningTools::getSmallDiameter, paramDto.getSmallDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getCuttingDirection()), ParaTurningTools::getCuttingDirection, paramDto.getCuttingDirection())
                    .eq(StrUtil.isNotBlank(paramDto.getKnifeSize()), ParaTurningTools::getKnifeSize, paramDto.getKnifeSize())
                    .eq(StrUtil.isNotBlank(paramDto.getBoringBarDiameter()), ParaTurningTools::getBoringBarDiameter, paramDto.getBoringBarDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeLength()), ParaTurningTools::getBladeLength, paramDto.getBladeLength())
                    .eq(StrUtil.isNotBlank(paramDto.getBarDirection()), ParaTurningTools::getBarDirection, paramDto.getBarDirection())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeHeight()), ParaTurningTools::getBladeHeight, paramDto.getBladeHeight())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeWide()), ParaTurningTools::getBladeWide, paramDto.getBladeWide())
                    .eq(StrUtil.isNotBlank(paramDto.getSlotWidth()), ParaTurningTools::getSlotWidth, paramDto.getSlotWidth())
                    .eq(StrUtil.isNotBlank(paramDto.getMaxDiameter()), ParaTurningTools::getMaxDiameter, paramDto.getMaxDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getMaxDepth()), ParaTurningTools::getMaxDepth, paramDto.getMaxDepth())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeThickness()), ParaTurningTools::getBladeThickness, paramDto.getBladeThickness())
                    .eq(StrUtil.isNotBlank(paramDto.getMinDiameter()), ParaTurningTools::getMinDiameter, paramDto.getMinDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getMatchingNumber()), ParaTurningTools::getMatchingNumber, paramDto.getMatchingNumber());
                    .like(StrUtil.isNotBlank(paramDto.getToolCode()), "t1.tool_code", paramDto.getToolCode())
                    .like(StrUtil.isNotBlank(paramDto.getToolModel()), "t.tool_model", paramDto.getToolModel())
                    .like(StrUtil.isNotBlank(paramDto.getChineseName()), "t.chinese_name", paramDto.getChineseName())
                    .eq(StrUtil.isNotBlank(paramDto.getClassifyId()), "t.classify_id", paramDto.getClassifyId())
                    .eq(StrUtil.isNotBlank(paramDto.getDiameter()), "t.tool_diameter", paramDto.getDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getTotalLength()), "t.total_length", paramDto.getTotalLength())
                    .eq(StrUtil.isNotBlank(paramDto.getToolMaterial()), "t.tool_material", paramDto.getToolMaterial())
                    .eq(StrUtil.isNotBlank(paramDto.getSmallDiameter()), "t.small_diameter", paramDto.getSmallDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getCuttingDirection()), "t.cutting_direction", paramDto.getCuttingDirection())
                    .eq(StrUtil.isNotBlank(paramDto.getKnifeSize()), "t.knife_size", paramDto.getKnifeSize())
                    .eq(StrUtil.isNotBlank(paramDto.getBoringBarDiameter()), "t.boring_bar_diameter", paramDto.getBoringBarDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeLength()), "t.blade_length", paramDto.getBladeLength())
                    .eq(StrUtil.isNotBlank(paramDto.getBarDirection()), "t.bar_direction", paramDto.getBarDirection())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeHeight()), "t.blade_height", paramDto.getBladeHeight())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeWide()), "t.blade_wide", paramDto.getBladeWide())
                    .eq(StrUtil.isNotBlank(paramDto.getSlotWidth()), "t.slot_width", paramDto.getSlotWidth())
                    .eq(StrUtil.isNotBlank(paramDto.getMaxDiameter()), "t.max_diameter", paramDto.getMaxDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getMaxDepth()), "t.max_depth", paramDto.getMaxDepth())
                    .eq(StrUtil.isNotBlank(paramDto.getBladeThickness()), "t.blade_thickness", paramDto.getBladeThickness())
                    .eq(StrUtil.isNotBlank(paramDto.getMinDiameter()), "t.min_diameter", paramDto.getMinDiameter())
                    .eq(StrUtil.isNotBlank(paramDto.getMatchingNumber()), "t.matching_number", paramDto.getMatchingNumber());
        }
        return this.baseMapper.selectByClassifyAndDiameter(queryWrapper);
    }