新火炬后端单体项目初始化代码
lixiangyu
昨天 2795789b148bd40ecd03fb4d44f5fcd203c268b6
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
package org.jeecg.modules.cms.service.impl;
 
import io.micrometer.core.annotation.Timed;
import lombok.extern.slf4j.Slf4j;
import org.jeecg.common.api.vo.Result;
import org.jeecg.modules.cms.entity.CuttingInbound;
import org.jeecg.modules.cms.entity.CuttingInboundDetail;
import org.jeecg.modules.cms.entity.CuttingInboundInventory;
import org.jeecg.modules.cms.entity.CuttingInventory;
import org.jeecg.modules.cms.mapper.CuttingInboundMapper;
import org.jeecg.modules.cms.service.ICuttingInboundInventoryService;
import org.jeecg.modules.cms.service.ICuttingInboundService;
import org.jeecg.modules.cms.service.ICuttingInboundDetailService;
import org.jeecg.modules.cms.service.ICuttingInventoryService;
import org.jeecg.modules.cms.vo.CuttingInboundExportVo;
import org.springframework.stereotype.Service;
 
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.transaction.annotation.Transactional;
 
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;
 
import org.springframework.beans.factory.annotation.Autowired;
 
/**
 * @Description: 刀具入库单
 * @Author: jeecg-boot
 * @Date:   2025-07-28
 * @Version: V1.0
 */
 
@Slf4j
@Service
public class CuttingInboundServiceImpl extends ServiceImpl<CuttingInboundMapper, CuttingInbound> implements ICuttingInboundService {
    @Autowired
    private ICuttingInboundDetailService cuttingInboundDetailService; // 注入从表服务
 
    @Autowired
    private ICuttingInventoryService cuttingInventoryService;
 
    @Autowired
    private ICuttingInboundInventoryService cuttingInboundInventoryService;
    /**
     * 通过Excel导入刀具入库单数据
     *
     * @param list 待导入的数据列表
     * @return 导入结果
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Result<?> importExcelData(List<CuttingInboundExportVo> list) {
 
        for (CuttingInboundExportVo exportVo : list) {
            // 保存主表数据
            CuttingInbound cuttingInbound = new CuttingInbound();
            cuttingInbound.setReceiver(exportVo.getReceiver());
            cuttingInbound.setReceiveTime(exportVo.getReceiveTime());
            cuttingInbound.setReceiveComment(exportVo.getReceiveComment());
            cuttingInbound.setConfirmer(exportVo.getConfirmer());
            cuttingInbound.setConfirmTime(exportVo.getConfirmTime());
            cuttingInbound.setConfirmComment(exportVo.getConfirmComment());
            cuttingInbound.setOrderStatus(exportVo.getOrderStatus());
 
            // 保存主表数据以获取ID
            this.save(cuttingInbound);
 
            // 获取主表ID
            String orderId = cuttingInbound.getId();
 
            // 处理从表数据
            List<CuttingInboundDetail> detailList = exportVo.getDetailList();
            if (detailList != null && !detailList.isEmpty()) {
                for (CuttingInboundDetail detail : detailList) {
                    detail.setOrderId(orderId); // 设置外键关联
                    cuttingInboundDetailService.save(detail);
                }
            }
        }
        return Result.ok("导入成功");
    }
 
 
    /*
     * 生成唯一条码的方法(确定编码生成规则后在此处重写)
     */
    private String generateUniqueBarcode(String cuttingId, int index) {
        // 条码生成规则示例:刀具ID + 序号(4位) + 随机数
        return cuttingId + String.format("%04d", index + 1) + (int) (Math.random() * 10000);
    }
    @Override
    @Timed(value = "cutting.inbound.submit", description = "刀具入库提交耗时")
    public synchronized Result<?> submit(String orderId) {
        long startTime = System.currentTimeMillis();
        try {
            // 1. 更新入库单状态
            CuttingInbound cuttingInbound = this.getById(orderId);
            if (cuttingInbound == null) {
                return Result.error("未找到对应的入库单");
            }
 
            // 检查入库单状态,只允许状态为"1"的入库单提交
            if (!"1".equals(cuttingInbound.getOrderStatus())) {
                return Result.error("只有状态为未提交的入库单才能执行提交操作");
            }
 
            cuttingInbound.setOrderStatus("2");
            boolean updateResult = this.updateById(cuttingInbound);
            if (!updateResult) {
                return Result.error("更新入库单状态失败,可能已被其他用户处理");
            }
 
            // 2. 获取入库明细
            List<CuttingInboundDetail> detailList = cuttingInboundDetailService.lambdaQuery()
                    .eq(CuttingInboundDetail::getOrderId, orderId)
                    .list();
 
            // 3. 收集所有需要保存的数据
            List<CuttingInventory> inventoryList = new ArrayList<>();
            List<CuttingInboundInventory> inboundInventoryList = new ArrayList<>();
 
            for (CuttingInboundDetail detail : detailList) {
                int quantity = detail.getReceiveNumber() != null ? detail.getReceiveNumber().intValue() : 0;
 
                for (int i = 0; i < quantity; i++) {
                    // 生成库存记录
                    CuttingInventory cuttingInventory = new CuttingInventory();
                    cuttingInventory.setCuttingId(detail.getCuttingId());
                    cuttingInventory.setCuttingBarcode(generateUniqueBarcode(detail.getCuttingId(), i));
                    cuttingInventory.setInventoryStatus("正常");
                    cuttingInventory.setCurrentLife(BigDecimal.valueOf(100));
                    inventoryList.add(cuttingInventory);
                }
            }
 
            // 4. 批量保存库存记录(一次性操作)
            if (!inventoryList.isEmpty()) {
                cuttingInventoryService.saveBatch(inventoryList);
 
                // 5. 为每个保存的库存记录创建关联关系
                for (CuttingInventory inventory : inventoryList) {
                    CuttingInboundInventory cuttingInboundInventory = new CuttingInboundInventory();
                    cuttingInboundInventory.setOrderId(orderId);
                    cuttingInboundInventory.setInventoryId(inventory.getId());
                    inboundInventoryList.add(cuttingInboundInventory);
                }
 
                // 6. 批量保存关联关系(一次性操作)
                cuttingInboundInventoryService.saveBatch(inboundInventoryList);
            }
 
            long endTime = System.currentTimeMillis();
            log.info("刀具入库提交完成,耗时: {} ms", (endTime - startTime));
            return Result.ok("提交成功");
 
        } catch (Exception e) {
            long endTime = System.currentTimeMillis();
            log.error("提交入库单失败,orderId: " + orderId + ",耗时: " + (endTime - startTime) + " ms", e);
            return Result.error("提交失败: " + e.getMessage());
        }
    }
 
 
 
 
}