refactor(cms): 优化刀具入库提交流程并添加性能计时

lixiangyu

2 天以前 747d8ed2f6926581f2ead16d13478914728a9ffa

refactor(cms): 优化刀具入库提交流程并添加性能计时

- 重构了 CuttingInboundController 中的 submit 方法，优化了入库提交逻辑
- 添加了 @Timed 注解，用于监控入库提交的性能
- 在 CuttingInventoryMapper.xml 中增加了正常库存、出库库存和总库存的统计字段

 src/main/java/org/jeecg/modules/cms/controller/CuttingInboundController.java

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

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import io.micrometer.core.annotation.Timed;
import org.jeecg.common.api.vo.Result;
import org.jeecg.common.system.query.QueryGenerator;
import org.jeecg.modules.cms.entity.CuttingInbound;
@@ -284,77 +285,155 @@
        // 条码生成规则示例：刀具ID + 序号(4位) + 随机数
        return cuttingId + String.format("%04d", index + 1) + (int) (Math.random() * 10000);
    }
//    @GetMapping("/submit")
//    public Result<?> submit(@RequestParam("orderId") String orderId) {
//        //         cuttingInboundService.submit(orderId);
//        //         return Result.ok("提交成功");
//        try {
//            // 1. 更新入库单状态
//            CuttingInbound cuttingInbound = cuttingInboundService.getById(orderId);
//            if (cuttingInbound == null) {
//                return Result.error("未找到对应的入库单");
//            }
//
//            // 检查入库单状态，只允许状态为"1"的入库单提交
//            if (!"1".equals(cuttingInbound.getOrderStatus())) {
//                return Result.error("只有状态为未提交的入库单才能执行提交操作");
//            }
//
//            // 2. 更新状态为已提交
//            cuttingInbound.setOrderStatus("2");
//            boolean updateResult = cuttingInboundService.updateById(cuttingInbound);
//            if (!updateResult) {
//                return Result.error("更新入库单状态失败");
//            }
//
//            // 3. 获取入库明细
//            List<CuttingInboundDetail> detailList = cuttingInboundDetailService.lambdaQuery()
//                    .eq(CuttingInboundDetail::getOrderId, orderId)
//                    .list();
//
//            // 用于统计总数量
//            int totalSubmitted = 0;
//
//            // 批量保存的列表
//            List<CuttingInventory> inventoryList = new ArrayList<>();
//            List<CuttingInboundInventory> inboundInventoryList = new ArrayList<>();
//
//            // 4. 根据明细数量生成库存记录和条码
//            for (CuttingInboundDetail detail : detailList) {
//                // 根据明细中的数量生成对应数量的库存记录receive_number
//                int quantity = detail.getReceiveNumber() != null ? detail.getReceiveNumber() : 0;
//                for (int i = 0; i < quantity; i++) {
//                    totalSubmitted++;
//                    // 为每个刀具生成独立的库存记录
//                    CuttingInventory cuttingInventory = new CuttingInventory();
//                    String inventoryId = UUID.randomUUID().toString().replace("-", "");
//                    cuttingInventory.setId(inventoryId);
//                    cuttingInventory.setCuttingId(detail.getCuttingId());
//                    // 为每个刀具生成唯一条码
//                    cuttingInventory.setCuttingBarcode(generateUniqueBarcode(detail.getCuttingId(), i));
//                    // 设置库存状态为在库
//                    cuttingInventory.setInventoryStatus("正常");
//                    // 设置当前寿命为100
//                    cuttingInventory.setCurrentLife(BigDecimal.valueOf(100));
//                    // 添加到批量保存列表
//                    inventoryList.add(cuttingInventory);
//
//                    // 建立入库单与库存的关联关系
//                    CuttingInboundInventory cuttingInboundInventory = new CuttingInboundInventory();
//                    cuttingInboundInventory.setOrderId(orderId);
//                    cuttingInboundInventory.setInventoryId(inventoryId);
//                    // 添加到批量保存列表
//                    inboundInventoryList.add(cuttingInboundInventory);
//                }
//            }
//
//            // 批量保存库存记录
//            if (!inventoryList.isEmpty()) {
//                boolean saveResult = cuttingInventoryService.saveBatch(inventoryList);
//                if (!saveResult) {
//                    throw new RuntimeException("保存库存记录失败");
//                }
//            }
//
//            // 批量保存关联关系
//            if (!inboundInventoryList.isEmpty()) {
//                boolean relationSaveResult = cuttingInboundInventoryService.saveBatch(inboundInventoryList);
//                if (!relationSaveResult) {
//                    throw new RuntimeException("保存关联关系失败");
//                }
//            }
//
//            Map<String, Object> result = new HashMap<>();
//            result.put("message", "提交成功");
//            result.put("totalSubmitted", totalSubmitted);
//            return Result.ok(result);
//        } catch (Exception e) {
//            log.error("提交入库单失败，orderId: " + orderId, e);
//            throw new RuntimeException("提交失败: " + e.getMessage(), e);
//        }
//    }

    @GetMapping("/submit")
    @Timed(value = "cutting.inbound.submit", description = "刀具入库提交耗时")
    public Result<?> submit(@RequestParam("orderId") String orderId) {
        //         cuttingInboundService.submit(orderId);
        //         return Result.ok("提交成功");
        long startTime = System.currentTimeMillis();
        try {
            // 1. 更新入库单状态
            CuttingInbound cuttingInbound = cuttingInboundService.getById(orderId);
            if (cuttingInbound == null) {
                return Result.error("未找到对应的入库单");
            }

            // 检查入库单状态，只允许状态为"1"的入库单提交
            if (!"1".equals(cuttingInbound.getOrderStatus())) {
                return Result.error("只有状态为未提交的入库单才能执行提交操作");
            }

            // 2. 更新状态为已提交
            cuttingInbound.setOrderStatus("2");
            boolean updateResult = cuttingInboundService.updateById(cuttingInbound);
            if (!updateResult) {
                return Result.error("更新入库单状态失败");
            }
            cuttingInboundService.updateById(cuttingInbound);

            // 3. 获取入库明细
            // 2. 获取入库明细
            List<CuttingInboundDetail> detailList = cuttingInboundDetailService.lambdaQuery()
                    .eq(CuttingInboundDetail::getOrderId, orderId)
                    .list();

            // 用于统计总数量
            // 3. 收集所有需要保存的数据
            List<CuttingInventory> inventoryList = new ArrayList<>();
            List<CuttingInboundInventory> inboundInventoryList = new ArrayList<>();

            // 4. 根据明细数量生成库存记录和条码
            int totalSubmitted = 0;
            for (CuttingInboundDetail detail : detailList) {
                // 根据明细中的数量生成对应数量的库存记录receive_number
                int quantity = detail.getReceiveNumber() != null ? detail.getReceiveNumber() : 0;
                totalSubmitted = 0;
                int quantity = detail.getReceiveNumber() != null ? detail.getReceiveNumber().intValue() : 0;

                for (int i = 0; i < quantity; i++) {
                    totalSubmitted += quantity;
                    // 为每个刀具生成独立的库存记录
                    // 生成库存记录
                    CuttingInventory cuttingInventory = new CuttingInventory();
                    cuttingInventory.setCuttingId(detail.getCuttingId());
                    // 为每个刀具生成唯一条码
                    cuttingInventory.setCuttingBarcode(generateUniqueBarcode(detail.getCuttingId(), i));
                    // 设置库存状态为在库
                    cuttingInventory.setInventoryStatus("正常");
                    // 设置当前寿命为100
                    cuttingInventory.setCurrentLife(BigDecimal.valueOf(100));
                    // 保存到库存表
                    boolean saveResult = cuttingInventoryService.save(cuttingInventory);
                    if (!saveResult) {
                        return Result.error("保存库存记录失败");
                    inventoryList.add(cuttingInventory);
                }
                    }

                    // 建立入库单与库存的关联关系
            // 4. 批量保存库存记录（一次性操作）
            if (!inventoryList.isEmpty()) {
                cuttingInventoryService.saveBatch(inventoryList);

                // 5. 为每个保存的库存记录创建关联关系
                for (CuttingInventory inventory : inventoryList) {
                    CuttingInboundInventory cuttingInboundInventory = new CuttingInboundInventory();
                    cuttingInboundInventory.setOrderId(orderId);
                    cuttingInboundInventory.setInventoryId(cuttingInventory.getId());
                    cuttingInboundInventory.setInventoryId(inventory.getId());
                    inboundInventoryList.add(cuttingInboundInventory);
                }

                    // 保存关联关系
                    boolean relationSaveResult = cuttingInboundInventoryService.save(cuttingInboundInventory);
                    if (!relationSaveResult) {
                        return Result.error("保存关联关系失败");
                // 6. 批量保存关联关系（一次性操作）
                cuttingInboundInventoryService.saveBatch(inboundInventoryList);
                    }
                }
            }
            Map<String, Object> result = new HashMap<>();
            result.put("message", "提交成功");
            result.put("totalSubmitted", totalSubmitted);

            long endTime = System.currentTimeMillis();
            log.info("刀具入库提交完成，耗时: {} s", (endTime - startTime)/1000);
            return Result.ok("提交成功");

        } catch (Exception e) {
            log.error("提交入库单失败，orderId: " + orderId, e);
            long endTime = System.currentTimeMillis();
            log.error("提交入库单失败，orderId: " + orderId + "，耗时: " + (endTime - startTime) + " ms", e);
            return Result.error("提交失败: " + e.getMessage());
        }
    }

 src/main/java/org/jeecg/modules/cms/mapper/xml/CuttingInventoryMapper.xml

@@ -6,7 +6,10 @@
            t1.cutting_id as cuttingId,
            count(*) AS cuttingIdNumber,
            t1.inventory_status as inventoryStatus,
            t2.cutting_code AS cuttingCode
            t2.cutting_code AS cuttingCode,
            SUM(SUM(CASE WHEN t1.inventory_status = '正常' THEN 1 ELSE 0 END)) OVER() AS normalTotal,
            SUM(SUM(CASE WHEN t1.inventory_status = '已出库' THEN 1 ELSE 0 END)) OVER() AS outboundTotal,
            SUM(count(*)) OVER() AS totalNumber
        FROM
            cms_cutting_inventory t1
        LEFT JOIN cms_cutting_tool t2 ON t1.cutting_id = t2.id AND t2.del_flag = 0