针筒管理系统

hx-service-api/syringe-management-api/src/main/java/com/fjhx/params/production/ProductWorkingRoute.java

@@ -0,0 +1,26 @@
+package com.fjhx.params.production;
+
+import com.fjhx.entity.working.WorkingProcedure;
+import lombok.Data;
+
+import java.util.List;
+
+@Data
+public class ProductWorkingRoute {
+
+    /**
+     * 工艺路线id
+     */
+    private Long workingRouteId;
+
+    /**
+     * 工艺路线名称
+     */
+    private String workingRouteName;
+
+    /**
+     * 工序列表
+     */
+    private List<WorkingProcedure> procedureList;
+
+}

hx-service/syringe-management/src/main/java/com/fjhx/config/LogicDeleteInterceptor.java

@@ -0,0 +1,436 @@
+package com.fjhx.config;
+
+import com.baomidou.mybatisplus.core.toolkit.CollectionUtils;
+import com.baomidou.mybatisplus.core.toolkit.PluginUtils;
+import com.baomidou.mybatisplus.core.toolkit.StringPool;
+import com.baomidou.mybatisplus.extension.plugins.inner.InnerInterceptor;
+import lombok.SneakyThrows;
+import lombok.extern.slf4j.Slf4j;
+import net.sf.jsqlparser.JSQLParserException;
+import net.sf.jsqlparser.expression.*;
+import net.sf.jsqlparser.expression.operators.conditional.AndExpression;
+import net.sf.jsqlparser.expression.operators.conditional.OrExpression;
+import net.sf.jsqlparser.expression.operators.relational.EqualsTo;
+import net.sf.jsqlparser.expression.operators.relational.ExistsExpression;
+import net.sf.jsqlparser.expression.operators.relational.ExpressionList;
+import net.sf.jsqlparser.expression.operators.relational.InExpression;
+import net.sf.jsqlparser.parser.CCJSqlParserUtil;
+import net.sf.jsqlparser.schema.Column;
+import net.sf.jsqlparser.schema.Table;
+import net.sf.jsqlparser.statement.select.*;
+import org.apache.ibatis.executor.Executor;
+import org.apache.ibatis.mapping.BoundSql;
+import org.apache.ibatis.mapping.MappedStatement;
+import org.apache.ibatis.session.ResultHandler;
+import org.apache.ibatis.session.RowBounds;
+import org.springframework.stereotype.Component;
+
+import java.util.*;
+import java.util.stream.Collectors;
+
+@Component
+@Slf4j
+public class LogicDeleteInterceptor implements InnerInterceptor {
+
+    private static final String delFlagName = "del_flag";
+    private static final Expression delFlagValue = new LongValue(0);
+    private final List<String> excludeDelFlagTableNameList;
+
+    public LogicDeleteInterceptor(List<String> excludeDelFlagTableNameList) {
+        this.excludeDelFlagTableNameList = excludeDelFlagTableNameList;
+    }
+
+    @SneakyThrows
+    @Override
+    public void beforeQuery(Executor executor, MappedStatement ms, Object parameter, RowBounds rowBounds,
+                            ResultHandler resultHandler, BoundSql boundSql) {
+
+        PluginUtils.MPBoundSql mpBs = PluginUtils.mpBoundSql(boundSql);
+        mpBs.sql(handleSql(boundSql.getSql()));
+    }
+
+    /**
+     * 改写SQL
+     * {@link com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerInterceptor  processSelect 方法}
+     *
+     * @param sql 执行的SQL语句
+     * @return 处理后的SQL
+     */
+    private String handleSql(String sql) throws JSQLParserException {
+        Select select = (Select) CCJSqlParserUtil.parse(sql);
+        processSelectBody(select.getSelectBody());
+        List<WithItem> withItemsList = select.getWithItemsList();
+        if (!CollectionUtils.isEmpty(withItemsList)) {
+            withItemsList.forEach(this::processSelectBody);
+        }
+        return select.toString();
+    }
+
+    protected void processSelectBody(SelectBody selectBody) {
+        if (selectBody == null) {
+            return;
+        }
+        if (selectBody instanceof PlainSelect) {
+            processPlainSelect((PlainSelect) selectBody);
+        } else if (selectBody instanceof WithItem) {
+            WithItem withItem = (WithItem) selectBody;
+            processSelectBody(withItem.getSubSelect().getSelectBody());
+        } else {
+            SetOperationList operationList = (SetOperationList) selectBody;
+            List<SelectBody> selectBodyList = operationList.getSelects();
+            if (CollectionUtils.isNotEmpty(selectBodyList)) {
+                selectBodyList.forEach(this::processSelectBody);
+            }
+        }
+    }
+
+    /**
+     * 处理 PlainSelect
+     */
+    protected void processPlainSelect(PlainSelect plainSelect) {
+        //#3087 github
+        List<SelectItem> selectItems = plainSelect.getSelectItems();
+        if (CollectionUtils.isNotEmpty(selectItems)) {
+            selectItems.forEach(this::processSelectItem);
+        }
+
+        // 处理 where 中的子查询
+        Expression where = plainSelect.getWhere();
+        processWhereSubSelect(where);
+
+        // 处理 fromItem
+        FromItem fromItem = plainSelect.getFromItem();
+        List<Table> list = processFromItem(fromItem);
+        List<Table> mainTables = new ArrayList<>(list);
+
+        // 处理 join
+        List<Join> joins = plainSelect.getJoins();
+        if (CollectionUtils.isNotEmpty(joins)) {
+            mainTables = processJoins(mainTables, joins);
+        }
+
+        // 当有 mainTable 时，进行 where 条件追加
+        if (CollectionUtils.isNotEmpty(mainTables) && (where == null || !where.toString().contains(delFlagName))) {
+            plainSelect.setWhere(builderExpression(where, mainTables));
+        }
+    }
+
+    /**
+     * 处理where条件内的子查询
+     * <p>
+     * 支持如下:
+     * 1. in
+     * 2. =
+     * 3. >
+     * 4. <
+     * 5. >=
+     * 6. <=
+     * 7. <>
+     * 8. EXISTS
+     * 9. NOT EXISTS
+     * <p>
+     * 前提条件:
+     * 1. 子查询必须放在小括号中
+     * 2. 子查询一般放在比较操作符的右边
+     *
+     * @param where where 条件
+     */
+    protected void processWhereSubSelect(Expression where) {
+        if (where == null) {
+            return;
+        }
+        if (where instanceof FromItem) {
+            processOtherFromItem((FromItem) where);
+            return;
+        }
+        if (where.toString().indexOf("SELECT") > 0) {
+            // 有子查询
+            if (where instanceof BinaryExpression) {
+                // 比较符号 , and , or , 等等
+                BinaryExpression expression = (BinaryExpression) where;
+                processWhereSubSelect(expression.getLeftExpression());
+                processWhereSubSelect(expression.getRightExpression());
+            } else if (where instanceof InExpression) {
+                // in
+                InExpression expression = (InExpression) where;
+                Expression inExpression = expression.getRightExpression();
+                if (inExpression instanceof SubSelect) {
+                    processSelectBody(((SubSelect) inExpression).getSelectBody());
+                }
+            } else if (where instanceof ExistsExpression) {
+                // exists
+                ExistsExpression expression = (ExistsExpression) where;
+                processWhereSubSelect(expression.getRightExpression());
+            } else if (where instanceof NotExpression) {
+                // not exists
+                NotExpression expression = (NotExpression) where;
+                processWhereSubSelect(expression.getExpression());
+            } else if (where instanceof Parenthesis) {
+                Parenthesis expression = (Parenthesis) where;
+                processWhereSubSelect(expression.getExpression());
+            }
+        }
+    }
+
+    protected void processSelectItem(SelectItem selectItem) {
+        if (selectItem instanceof SelectExpressionItem) {
+            SelectExpressionItem selectExpressionItem = (SelectExpressionItem) selectItem;
+            if (selectExpressionItem.getExpression() instanceof SubSelect) {
+                processSelectBody(((SubSelect) selectExpressionItem.getExpression()).getSelectBody());
+            } else if (selectExpressionItem.getExpression() instanceof Function) {
+                processFunction((Function) selectExpressionItem.getExpression());
+            }
+        }
+    }
+
+    private List<Table> processFromItem(FromItem fromItem) {
+        // 处理括号括起来的表达式
+        while (fromItem instanceof ParenthesisFromItem) {
+            fromItem = ((ParenthesisFromItem) fromItem).getFromItem();
+        }
+
+        List<Table> mainTables = new ArrayList<>();
+        // 无 join 时的处理逻辑
+        if (fromItem instanceof Table) {
+            Table fromTable = (Table) fromItem;
+            mainTables.add(fromTable);
+        } else if (fromItem instanceof SubJoin) {
+            // SubJoin 类型则还需要添加上 where 条件
+            List<Table> tables = processSubJoin((SubJoin) fromItem);
+            mainTables.addAll(tables);
+        } else {
+            // 处理下 fromItem
+            processOtherFromItem(fromItem);
+        }
+        return mainTables;
+    }
+
+    /**
+     * 处理子查询等
+     */
+    protected void processOtherFromItem(FromItem fromItem) {
+        // 去除括号
+        while (fromItem instanceof ParenthesisFromItem) {
+            fromItem = ((ParenthesisFromItem) fromItem).getFromItem();
+        }
+
+        if (fromItem instanceof SubSelect) {
+            SubSelect subSelect = (SubSelect) fromItem;
+            if (subSelect.getSelectBody() != null) {
+                processSelectBody(subSelect.getSelectBody());
+            }
+        } else if (fromItem instanceof ValuesList) {
+            log.debug("Perform a subQuery, if you do not give us feedback");
+        } else if (fromItem instanceof LateralSubSelect) {
+            LateralSubSelect lateralSubSelect = (LateralSubSelect) fromItem;
+            if (lateralSubSelect.getSubSelect() != null) {
+                SubSelect subSelect = lateralSubSelect.getSubSelect();
+                if (subSelect.getSelectBody() != null) {
+                    processSelectBody(subSelect.getSelectBody());
+                }
+            }
+        }
+    }
+
+    /**
+     * 处理 sub join
+     *
+     * @param subJoin subJoin
+     * @return Table subJoin 中的主表
+     */
+    private List<Table> processSubJoin(SubJoin subJoin) {
+        List<Table> mainTables = new ArrayList<>();
+        if (subJoin.getJoinList() != null) {
+            List<Table> list = processFromItem(subJoin.getLeft());
+            mainTables.addAll(list);
+            mainTables = processJoins(mainTables, subJoin.getJoinList());
+        }
+        return mainTables;
+    }
+
+
+    /**
+     * 处理函数
+     * <p>支持: 1. select fun(args..) 2. select fun1(fun2(args..),args..)<p>
+     * <p> fixed gitee pulls/141</p>
+     *
+     * @param function
+     */
+    protected void processFunction(Function function) {
+        ExpressionList parameters = function.getParameters();
+        if (parameters != null) {
+            parameters.getExpressions().forEach(expression -> {
+                if (expression instanceof SubSelect) {
+                    processSelectBody(((SubSelect) expression).getSelectBody());
+                } else if (expression instanceof Function) {
+                    processFunction((Function) expression);
+                }
+            });
+        }
+    }
+
+    /**
+     * 处理 joins
+     *
+     * @param mainTables 可以为 null
+     * @param joins      join 集合
+     * @return List<Table> 右连接查询的 Table 列表
+     */
+    private List<Table> processJoins(List<Table> mainTables, List<Join> joins) {
+        // join 表达式中最终的主表
+        Table mainTable = null;
+        // 当前 join 的左表
+        Table leftTable = null;
+
+        if (mainTables == null) {
+            mainTables = new ArrayList<>();
+        } else if (mainTables.size() == 1) {
+            mainTable = mainTables.get(0);
+            leftTable = mainTable;
+        }
+
+        // 对于 on 表达式写在最后的 join，需要记录下前面多个 on 的表名
+        Deque<List<Table>> onTableDeque = new LinkedList<>();
+        for (Join join : joins) {
+            // 处理 on 表达式
+            FromItem joinItem = join.getRightItem();
+
+            // 获取当前 join 的表，subJoint 可以看作是一张表
+            List<Table> joinTables = null;
+            if (joinItem instanceof Table) {
+                joinTables = new ArrayList<>();
+                joinTables.add((Table) joinItem);
+            } else if (joinItem instanceof SubJoin) {
+                joinTables = processSubJoin((SubJoin) joinItem);
+            }
+
+            if (joinTables != null) {
+
+                // 如果是隐式内连接
+                if (join.isSimple()) {
+                    mainTables.addAll(joinTables);
+                    continue;
+                }
+
+                // 当前表是否忽略
+                Table joinTable = joinTables.get(0);
+
+                List<Table> onTables = null;
+                // 如果不要忽略，且是右连接，则记录下当前表
+                if (join.isRight()) {
+                    mainTable = joinTable;
+                    if (leftTable != null) {
+                        onTables = Collections.singletonList(leftTable);
+                    }
+                } else if (join.isLeft()) {
+                    onTables = Collections.singletonList(joinTable);
+                } else if (join.isInner()) {
+                    if (mainTable == null) {
+                        onTables = Collections.singletonList(joinTable);
+                    } else {
+                        onTables = Arrays.asList(mainTable, joinTable);
+                    }
+                    mainTable = null;
+                }
+
+                mainTables = new ArrayList<>();
+                if (mainTable != null) {
+                    mainTables.add(mainTable);
+                }
+
+                // 获取 join 尾缀的 on 表达式列表
+                Collection<Expression> originOnExpressions = join.getOnExpressions();
+                // 正常 join on 表达式只有一个，立刻处理
+                if (originOnExpressions.size() == 1 && onTables != null) {
+                    List<Expression> onExpressions = new LinkedList<>();
+                    onExpressions.add(builderExpression(originOnExpressions.iterator().next(), onTables));
+                    join.setOnExpressions(onExpressions);
+                    leftTable = joinTable;
+                    continue;
+                }
+                // 表名压栈，忽略的表压入 null，以便后续不处理
+                onTableDeque.push(onTables);
+                // 尾缀多个 on 表达式的时候统一处理
+                if (originOnExpressions.size() > 1) {
+                    Collection<Expression> onExpressions = new LinkedList<>();
+                    for (Expression originOnExpression : originOnExpressions) {
+                        List<Table> currentTableList = onTableDeque.poll();
+                        if (CollectionUtils.isEmpty(currentTableList)) {
+                            onExpressions.add(originOnExpression);
+                        } else {
+                            onExpressions.add(builderExpression(originOnExpression, currentTableList));
+                        }
+                    }
+                    join.setOnExpressions(onExpressions);
+                }
+                leftTable = joinTable;
+            } else {
+                processOtherFromItem(joinItem);
+                leftTable = null;
+            }
+        }
+
+        return mainTables;
+    }
+
+    /**
+     * 处理条件
+     */
+    protected Expression builderExpression(Expression currentExpression, List<Table> tables) {
+        // 没有表需要处理直接返回
+        if (CollectionUtils.isEmpty(tables)) {
+            return currentExpression;
+        }
+        // 构造每张表的条件
+        List<Table> tempTables = tables.stream()
+                .filter(x -> !excludeDelFlagTableNameList.contains(x.getName()))
+                .collect(Collectors.toList());
+
+        // 没有表需要处理直接返回
+        if (CollectionUtils.isEmpty(tempTables)) {
+            return currentExpression;
+        }
+
+        List<EqualsTo> equalsTos = tempTables.stream()
+                .map(item -> new EqualsTo(getAliasColumn(item), delFlagValue))
+                .collect(Collectors.toList());
+
+        // 注入的表达式
+        Expression injectExpression = equalsTos.get(0);
+        // 如果有多表，则用 and 连接
+        if (equalsTos.size() > 1) {
+            for (int i = 1; i < equalsTos.size(); i++) {
+                injectExpression = new AndExpression(injectExpression, equalsTos.get(i));
+            }
+        }
+
+        if (currentExpression == null) {
+            return injectExpression;
+        }
+        if (currentExpression instanceof OrExpression) {
+            return new AndExpression(new Parenthesis(currentExpression), injectExpression);
+        } else {
+            return new AndExpression(currentExpression, injectExpression);
+        }
+    }
+
+    /**
+     * 租户字段别名设置
+     * <p>tenantId 或 tableAlias.tenantId</p>
+     *
+     * @param table 表对象
+     * @return 字段
+     */
+    protected Column getAliasColumn(Table table) {
+        StringBuilder column = new StringBuilder();
+        // 为了兼容隐式内连接，没有别名时条件就需要加上表名
+        if (table.getAlias() != null) {
+            column.append(table.getAlias().getName());
+        } else {
+            column.append(table.getName());
+        }
+        column.append(StringPool.DOT).append(delFlagName);
+        return new Column(column.toString());
+    }
+
+}

hx-service/syringe-management/src/main/java/com/fjhx/config/MybatisConfig.java

@@ -0,0 +1,65 @@
+package com.fjhx.config;
+
+import com.baomidou.mybatisplus.annotation.DbType;
+import com.baomidou.mybatisplus.extension.plugins.MybatisPlusInterceptor;
+import com.baomidou.mybatisplus.extension.plugins.handler.TenantLineHandler;
+import com.baomidou.mybatisplus.extension.plugins.inner.OptimisticLockerInnerInterceptor;
+import com.baomidou.mybatisplus.extension.plugins.inner.PaginationInnerInterceptor;
+import com.baomidou.mybatisplus.extension.plugins.inner.TenantLineInnerInterceptor;
+import net.sf.jsqlparser.expression.Expression;
+import net.sf.jsqlparser.expression.StringValue;
+import org.springblade.core.secure.utils.AuthUtil;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+
+import java.util.Arrays;
+import java.util.List;
+
+@Configuration
+public class MybatisConfig {
+
+    /**
+     * 排除租户表集合
+     */
+    private static final List<String> excludeTenantTableNameList = Arrays.asList("material_ex", "product_ex");
+
+    /**
+     * 排除不要拼接逻辑删除的表集合
+     */
+    private static final List<String> excludeDelFlagTableNameList = Arrays.asList("material_ex", "product_ex");
+
+    /**
+     * 租户插件
+     */
+    @Bean
+    public MybatisPlusInterceptor mybatisPlusInterceptorPage() {
+        MybatisPlusInterceptor interceptor = new MybatisPlusInterceptor();
+
+        // 拼接逻辑删除字段
+        interceptor.addInnerInterceptor(new LogicDeleteInterceptor(excludeDelFlagTableNameList));
+
+        // 拼接租户字段
+        interceptor.addInnerInterceptor(new TenantLineInnerInterceptor(new TenantLineHandler() {
+
+            @Override
+            public Expression getTenantId() {
+                return new StringValue(AuthUtil.getTenantId());
+            }
+
+            @Override
+            public boolean ignoreTable(String tableName) {
+                return excludeTenantTableNameList.contains(tableName);
+            }
+
+        }));
+
+        // 分页
+        interceptor.addInnerInterceptor(new PaginationInnerInterceptor(DbType.MYSQL));
+
+        // 乐观锁
+        interceptor.addInnerInterceptor(new OptimisticLockerInnerInterceptor());
+
+        return interceptor;
+    }
+
+}

hx-service/syringe-management/src/main/java/com/fjhx/config/TaskPoolConfig.java

@@ -0,0 +1,42 @@
+package com.fjhx.config;
+
+import com.fjhx.constants.ErrorMsgConstant;
+import org.springblade.core.log.exception.ServiceException;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.scheduling.annotation.EnableAsync;
+import org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor;
+
+/**
+ * 线程池配置
+ */
+@EnableAsync
+@Configuration
+public class TaskPoolConfig {
+
+    public static final String excelExecutor = "excelExecutor";
+
+    @Bean(name = excelExecutor)
+    public ThreadPoolTaskExecutor taskExecutor() {
+        ThreadPoolTaskExecutor threadPoolTaskExecutor = new ThreadPoolTaskExecutor();
+        // 配置核心线程数
+        threadPoolTaskExecutor.setCorePoolSize(2);
+        // 配置最大线程数
+        threadPoolTaskExecutor.setMaxPoolSize(5);
+        // 配置队列大小
+        threadPoolTaskExecutor.setQueueCapacity(10);
+        // 缓冲队列大小
+        threadPoolTaskExecutor.setKeepAliveSeconds(10);
+        // 配置线程池中的线程的名称前缀
+        threadPoolTaskExecutor.setThreadNamePrefix(excelExecutor + "：");
+        // 线程池对拒绝任务的处理策略：由调用线程（提交任务的线程）处理该任务
+        threadPoolTaskExecutor.setRejectedExecutionHandler((r, executor) -> {
+            throw new ServiceException(ErrorMsgConstant.SYSTEM_BUSY_ERROR);
+        });
+
+        // 执行初始化
+        threadPoolTaskExecutor.initialize();
+        return threadPoolTaskExecutor;
+    }
+
+}

hx-service/syringe-management/src/main/java/com/fjhx/controller/product/ProductExController.java

@@ -1,8 +1,10 @@
 package com.fjhx.controller.product;
 
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
-import com.fjhx.service.product.ProductExService;
+import com.fjhx.entity.Product;
+import com.fjhx.params.production.ProductWorkingRoute;
 import com.fjhx.service.ProductService;
+import com.fjhx.service.product.ProductExService;
 import org.springblade.core.tool.api.R;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.PostMapping;
@@ -67,5 +69,14 @@ public class ProductExController {
         return R.success(result);
     }
 
+    /**
+     * 获取产品关联工序
+     */
+    @PostMapping("getWorkingRoute")
+    public R getWorkingRoute(@RequestBody Product product) {
+        ProductWorkingRoute list = productExService.getWorkingRoute(product.getId());
+        return R.success(list);
+    }
+
 }
 

hx-service/syringe-management/src/main/java/com/fjhx/mapper/product/ProductExMapper.java

@@ -4,6 +4,8 @@ import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fjhx.entity.product.ProductEx;
+import com.fjhx.entity.working.WorkingProcedure;
+import com.fjhx.params.production.ProductWorkingRoute;
 import org.apache.ibatis.annotations.Param;
 
 import java.util.List;
@@ -23,4 +25,8 @@ public interface ProductExMapper extends BaseMapper<ProductEx> {
 
     List<Map<String, Object>> getList(@Param("ew") QueryWrapper<?> wrapper);
 
+    ProductWorkingRoute getProductWorkingRoute(@Param("productId") Long productId);
+
+    List<WorkingProcedure> getProcedureList(@Param("workingRouteId") Long workingRouteId);
+
 }

hx-service/syringe-management/src/main/java/com/fjhx/mapper/product/ProductExMapper.xml

@@ -29,4 +29,16 @@
             ${ew.customSqlSegment}
     </select>
 
+    <select id="getProductWorkingRoute" resultType="com.fjhx.params.production.ProductWorkingRoute">
+        select wr.id   workingRouteId,
+               wr.name workingRouteName
+        from product_ex pe
+                 left join working_route wr on pe.working_route_id = wr.id
+        where pe.id = #{productId}
+    </select>
+
+    <select id="getProcedureList" resultType="com.fjhx.entity.working.WorkingProcedure">
+
+    </select>
+
 </mapper>

hx-service/syringe-management/src/main/java/com/fjhx/service/bom/impl/BomDetailsServiceImpl.java

@@ -30,7 +30,6 @@ public class BomDetailsServiceImpl extends ServiceImpl<BomDetailsMapper, BomDeta
         QueryWrapper<BomDetails> wrapper = Wrappers.query();
 
         WrapperUtil.init(condition, wrapper)
-                .eqTenantId()
                 .createTimeDesc();
 
         Page<BomDetails> page = page(condition, wrapper);

hx-service/syringe-management/src/main/java/com/fjhx/service/bom/impl/BomServiceImpl.java

@@ -48,8 +48,6 @@ public class BomServiceImpl extends ServiceImpl<BomMapper, Bom> implements BomSe
         QueryWrapper<?> wrapper = WrapperUtil.init(condition)
                 .eq("p.classify_id", "classifyId") // 分类查询
                 .keyword("p.name", "p.code") // 关键字查询
-                .eqTenantId("b") // 租户id
-                .notDelete("b", "p") // 未删除
                 .getWrapper();
 
         wrapper.eq("b.type", BomTypeEnum.PRODUCT_TYPE.getCode()); // 产品bom

hx-service/syringe-management/src/main/java/com/fjhx/service/material/impl/MaterialExServiceImpl.java

@@ -43,7 +43,6 @@ public class MaterialExServiceImpl extends ServiceImpl<MaterialExMapper, Materia
     public Page<Map<String, Object>> getPage(Map<String, String> condition) {
         QueryWrapper<?> wrapper = WrapperUtil.init(condition)
                 .keyword("m.code", "m.name")
-                .eqTenantId("m")
                 .getWrapper();
 
         // 编码正序

hx-service/syringe-management/src/main/java/com/fjhx/service/product/ProductExService.java

@@ -3,6 +3,7 @@ package com.fjhx.service.product;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.fjhx.base.BaseService;
 import com.fjhx.entity.product.ProductEx;
+import com.fjhx.params.production.ProductWorkingRoute;
 
 import java.util.List;
 import java.util.Map;
@@ -26,5 +27,7 @@ public interface ProductExService extends BaseService<ProductEx> {
     void delete(Map<String, Object> map);
 
     List<Map<String, Object>> getList();
-    
+
+    ProductWorkingRoute getWorkingRoute(Long ProductId);
+
 }

hx-service/syringe-management/src/main/java/com/fjhx/service/product/impl/ProductExServiceImpl.java

@@ -3,11 +3,14 @@ package com.fjhx.service.product.impl;
 import cn.hutool.core.bean.BeanUtil;
 import cn.hutool.core.util.ObjectUtil;
 import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.toolkit.Wrappers;
 import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
 import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
 import com.fjhx.entity.Product;
 import com.fjhx.entity.product.ProductEx;
+import com.fjhx.entity.working.WorkingProcedure;
 import com.fjhx.mapper.product.ProductExMapper;
+import com.fjhx.params.production.ProductWorkingRoute;
 import com.fjhx.service.ClassifyService;
 import com.fjhx.service.ProductService;
 import com.fjhx.service.product.ProductExService;
@@ -40,8 +43,6 @@ public class ProductExServiceImpl extends ServiceImpl<ProductExMapper, ProductEx
 
         QueryWrapper<?> wrapper = WrapperUtil.init(condition)
                 .keyword("p.name", "p.code")
-                .eqTenantId("p")
-                .notDelete("p")
                 .getWrapper();
 
         // 编码正序
@@ -86,15 +87,20 @@ public class ProductExServiceImpl extends ServiceImpl<ProductExMapper, ProductEx
 
     @Override
     public List<Map<String, Object>> getList() {
-        QueryWrapper<?> wrapper = WrapperUtil.init()
-                .eqTenantId("p")
-                .notDelete("p")
-                .getWrapper();
-
         // 编码正序
-        wrapper.orderByAsc("p.code");
+        QueryWrapper<?> wrapper = Wrappers.query().orderByAsc("p.code");
 
         return baseMapper.getList(wrapper);
     }
 
+    @Override
+    public ProductWorkingRoute getWorkingRoute(Long ProductId) {
+        ProductWorkingRoute productWorkingRoute = baseMapper.getProductWorkingRoute(ProductId);
+
+        List<WorkingProcedure> procedureList = baseMapper.getProcedureList(productWorkingRoute.getWorkingRouteId());
+
+
+        return null;
+    }
+
 }

hx-service/syringe-management/src/main/java/com/fjhx/service/production/impl/ProductionLineServiceImpl.java

@@ -30,7 +30,6 @@ public class ProductionLineServiceImpl extends ServiceImpl<ProductionLineMapper,
                 .eq("pl.production_workshop_id", "productionWorkshopId") // 车间id
                 .eq("pl.status", "status") // 生产线状态
                 .keyword("pl.name") // 生产线名称
-                .eqTenantId("pl")
                 .createTimeDesc("pl")
                 .getWrapper();
         return baseMapper.getPage(createPage(condition), wrapper);

hx-service/syringe-management/src/main/java/com/fjhx/service/production/impl/ProductionWorkshopServiceImpl.java

@@ -38,7 +38,6 @@ public class ProductionWorkshopServiceImpl extends ServiceImpl<ProductionWorksho
         WrapperUtil.init(condition, wrapper)
                 .like("name", "keyword") // 关键字（目前只有车间名称）
                 .eq("status", "status") // 车间状态
-                .eqTenantId()
                 .createTimeDesc();
 
         Page<ProductionWorkshop> page = page(condition, wrapper);

hx-service/syringe-management/src/main/java/com/fjhx/service/working/impl/WorkingProcedureServiceImpl.java

@@ -35,7 +35,6 @@ public class WorkingProcedureServiceImpl extends ServiceImpl<WorkingProcedureMap
         QueryWrapper<WorkingProcedure> wrapper = Wrappers.query();
 
         WrapperUtil.init(condition, wrapper)
-                .eqTenantId()
                 .keyword("name", "name")
                 .eq("whether_packing", "whetherPacking")
                 .createTimeDesc();

hx-service/syringe-management/src/main/java/com/fjhx/service/working/impl/WorkingRouteProcedureServiceImpl.java

@@ -30,7 +30,6 @@ public class WorkingRouteProcedureServiceImpl extends ServiceImpl<WorkingRoutePr
         QueryWrapper<WorkingRouteProcedure> wrapper = Wrappers.query();
 
         WrapperUtil.init(condition, wrapper)
-                .eqTenantId()
                 .createTimeDesc();
 
         Page<WorkingRouteProcedure> page = page(condition, wrapper);

hx-service/syringe-management/src/main/java/com/fjhx/service/working/impl/WorkingRouteServiceImpl.java

@@ -53,9 +53,7 @@ public class WorkingRouteServiceImpl extends ServiceImpl<WorkingRouteMapper, Wor
     public Page<WorkingRouteEx> getPage(Map<String, String> condition) {
 
         QueryWrapper<?> wrapper = WrapperUtil.init(condition)
-                .eqTenantId("wr")
                 .keyword("wr.name", "wr.introduce")
-                .notDelete("wr", "wrp", "wp", "p")
                 .createTimeDesc("wr")
                 .getWrapper();