瑞利声电固定资产管理系统
ycq
2026-10-16 dbbadb021c2fc171466cc82bd9a7a82cc47165f5
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
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
package zbooksoft.fams.service;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import zbooksoft.fams.common.BusinessException;
import zbooksoft.fams.common.FormDataUtils;
import zbooksoft.fams.dao.AssetBaseDao;
import zbooksoft.fams.dao.PurchaseDao;
 
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.sql.Timestamp;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
 
/**
 * 采购业务:采购申请(含明细、审批)→ 到货入库单(含明细)→ 确认入库生成资产卡片
 * @author ycq
 * @date 2026-10-16
 */
@Service
public class PurchaseService {
 
    public static final String STATE_DRAFT = "草稿";
    public static final String STATE_IN_APPROVAL = "审批中";
    public static final String STATE_APPROVED = "已通过";
    public static final String STATE_TERMINATED = "已终止";
    public static final String STATE_STOCKED = "已入库";
    public static final String RECEIVE_NONE = "未到货";
    public static final String RECEIVE_PART = "部分到货";
    public static final String RECEIVE_ALL = "已到货";
    public static final String ACCEPT_OK = "合格";
    public static final String ACCEPT_NG = "不合格";
    public static final String SOURCE_PURCHASE = "采购入库";
    public static final String ASSET_IN_USE = "在用";
    public static final String ASSET_IDLE = "闲置";
 
    /** 一张入库单一次最多生成的资产卡片数,避免一次事务过大 */
    public static final int MAX_CARDS_PER_RECEIPT = 500;
    /** 入库明细上直接列出全部资产编号的上限,超过则只记首尾 */
    private static final int MAX_LISTED_ASSET_NOS = 20;
    private static final int DATE_TEXT_LENGTH = 10;
    private static final DateTimeFormatter BILL_DATE = DateTimeFormatter.ofPattern("yyyyMMdd");
    private static final Set<String> DELETABLE_STATES = new LinkedHashSet<>(Arrays.asList("", STATE_DRAFT, STATE_TERMINATED));
 
    @Autowired
    private PurchaseDao purchaseDao;
 
    @Autowired
    private AssetBaseDao assetBaseDao;
 
    @Autowired
    private AssetBaseService assetBaseService;
 
    // ================= 采购申请 =================
 
    /**
     * 采购申请保存前:校验用途,新单补编号与申请人,已有单据按明细刷新合计
     * @param keyId 采购申请ID,新增时为0
     * @param form 表单数据,结果直接写回
     * @param userId 当前用户ID
     * @param userName 当前用户姓名
     * @param deptId 当前用户部门ID
     * @param deptName 当前用户部门名称
     */
    public void preparePurchase(Long keyId, Map<String, Object> form, Long userId, String userName, Long deptId, String deptName) {
        if (FormDataUtils.isBlank(form, "PURPOSE")) {
            throw new BusinessException("请填写采购用途");
        }
        boolean isNew = keyId == null || keyId <= 0;
        if (isNew) {
            if (FormDataUtils.isBlank(form, "BILL_NO")) {
                FormDataUtils.put(form, "BILL_NO", nextBillNo("CG"));
            }
            FormDataUtils.put(form, "APPLY_USER_ID", userId);
            FormDataUtils.put(form, "APPLY_USER_NAME", userName);
            FormDataUtils.put(form, "APPLY_DEPT_ID", deptId);
            FormDataUtils.put(form, "APPLY_DEPT_NAME", deptName);
            FormDataUtils.put(form, "APPLY_DATE", LocalDate.now().toString());
            FormDataUtils.put(form, "BILL_STATE", STATE_DRAFT);
            FormDataUtils.put(form, "ITEM_COUNT", 0);
            FormDataUtils.put(form, "TOTAL_BUDGET", BigDecimal.ZERO.setScale(2));
            return;
        }
        if (purchaseDao.findPurchase(keyId) == null) {
            throw new BusinessException("采购申请不存在");
        }
        Map<String, Object> totals = purchaseTotals(keyId);
        FormDataUtils.put(form, "ITEM_COUNT", totals.get("ITEM_COUNT"));
        FormDataUtils.put(form, "TOTAL_BUDGET", totals.get("TOTAL_BUDGET"));
    }
 
    private Map<String, Object> purchaseTotals(Long purchaseId) {
        List<Map<String, Object>> items = purchaseDao.findPurchaseItems(purchaseId);
        BigDecimal total = BigDecimal.ZERO;
        for (Map<String, Object> item : items) {
            total = total.add(amount(item.get("QUANTITY"), item.get("BUDGET_PRICE")));
        }
        Map<String, Object> totals = new HashMap<>();
        totals.put("ITEM_COUNT", items.size());
        totals.put("TOTAL_BUDGET", total.setScale(2, RoundingMode.HALF_UP));
        return totals;
    }
 
    /**
     * 采购明细保存前:所属采购申请须为草稿,校验数量单价并计算预算金额
     * @param keyId 明细ID,新增时为0
     * @param item 表单数据,结果直接写回
     */
    public void preparePurchaseItem(Long keyId, Map<String, Object> item) {
        Long purchaseId = FormDataUtils.getLong(item, "APPLY_ID");
        if (purchaseId == null) {
            throw new BusinessException("请在采购申请单的「采购明细」页签中添加明细");
        }
        requireDraftPurchase(purchaseId);
        if (FormDataUtils.isBlank(item, "ITEM_NAME")) {
            throw new BusinessException("请填写资产名称");
        }
        int quantity = requireQuantity(item, "QUANTITY", "采购数量", 1);
        BigDecimal price = optionalAmount(item, "BUDGET_PRICE", "预算单价");
        FormDataUtils.put(item, "QUANTITY", quantity);
        FormDataUtils.put(item, "BUDGET_AMOUNT", price == null ? null : amount(quantity, price));
        fillCategoryName(item, false);
        if (keyId == null || keyId <= 0) {
            FormDataUtils.put(item, "RECEIVED_QTY", 0);
        }
    }
 
    /**
     * 采购明细保存后:刷新采购申请的明细数与预算合计
     * @param itemId 已保存的明细ID
     */
    public void afterSavePurchaseItem(Long itemId) {
        Map<String, Object> item = purchaseDao.findPurchaseItem(itemId);
        if (item != null) {
            Long purchaseId = FormDataUtils.toLong(item.get("APPLY_ID"));
            purchaseDao.updatePurchase(purchaseId, purchaseTotals(purchaseId));
        }
    }
 
    private Map<String, Object> requireDraftPurchase(Long purchaseId) {
        Map<String, Object> purchase = purchaseDao.findPurchase(purchaseId);
        if (purchase == null) {
            throw new BusinessException("所属采购申请不存在");
        }
        String state = FormDataUtils.toText(purchase.get("BILL_STATE"));
        if (!state.isEmpty() && !STATE_DRAFT.equals(state)) {
            throw new BusinessException("采购申请 " + FormDataUtils.toText(purchase.get("BILL_NO")) + " 当前为" + state + ",不能再修改明细");
        }
        return purchase;
    }
 
    /**
     * 采购申请提交审批时:至少要有一条明细,刷新合计并改为审批中
     * @param keyId 采购申请ID
     */
    @Transactional(rollbackFor = Exception.class)
    public void submitPurchase(Long keyId) {
        requirePurchase(keyId);
        if (purchaseDao.findPurchaseItems(keyId).isEmpty()) {
            throw new BusinessException("请先在「采购明细」中添加要采购的资产");
        }
        Map<String, Object> values = purchaseTotals(keyId);
        values.put("BILL_STATE", STATE_IN_APPROVAL);
        purchaseDao.updatePurchase(keyId, values);
    }
 
    /**
     * 采购申请审批通过:改为已通过、未到货,可开始办理到货入库
     * @param keyId 采购申请ID
     */
    public void approvePurchase(Long keyId) {
        Map<String, Object> purchase = requirePurchase(keyId);
        if (STATE_APPROVED.equals(FormDataUtils.toText(purchase.get("BILL_STATE")))) {
            return;
        }
        Map<String, Object> values = new HashMap<>();
        values.put("BILL_STATE", STATE_APPROVED);
        values.put("RECEIVE_STATE", RECEIVE_NONE);
        values.put("APPROVE_TIME", new Timestamp(System.currentTimeMillis()));
        purchaseDao.updatePurchase(keyId, values);
    }
 
    /**
     * 采购申请流程终止
     * @param keyId 采购申请ID
     */
    public void terminatePurchase(Long keyId) {
        requirePurchase(keyId);
        Map<String, Object> values = new HashMap<>();
        values.put("BILL_STATE", STATE_TERMINATED);
        purchaseDao.updatePurchase(keyId, values);
    }
 
    /**
     * 删除采购申请前:只允许草稿或已终止,并一并删除其明细
     * @param ids 采购申请ID
     */
    @Transactional(rollbackFor = Exception.class)
    public void deletePurchases(List<Long> ids) {
        checkDeletable(ids, true);
        for (Long id : ids) {
            purchaseDao.deletePurchaseItems(id);
        }
    }
 
    /**
     * 删除采购明细前:所属采购申请须为草稿
     * @param itemIds 明细ID
     */
    public void checkPurchaseItemsDeletable(List<Long> itemIds) {
        for (Long itemId : itemIds) {
            Map<String, Object> item = purchaseDao.findPurchaseItem(itemId);
            if (item != null) {
                requireDraftPurchase(FormDataUtils.toLong(item.get("APPLY_ID")));
            }
        }
    }
 
    private Map<String, Object> requirePurchase(Long keyId) {
        Map<String, Object> purchase = keyId == null ? null : purchaseDao.findPurchase(keyId);
        if (purchase == null) {
            throw new BusinessException("采购申请不存在");
        }
        return purchase;
    }
 
    // ================= 到货入库 =================
 
    /**
     * 到货入库单保存前:校验所选采购申请,新单补编号、验收人、到货日期
     * @param keyId 入库单ID,新增时为0
     * @param form 表单数据,结果直接写回
     * @param userId 当前用户ID
     * @param userName 当前用户姓名
     */
    public void prepareReceipt(Long keyId, Map<String, Object> form, Long userId, String userName) {
        boolean isNew = keyId == null || keyId <= 0;
        Map<String, Object> existing = isNew ? null : purchaseDao.findReceipt(keyId);
        if (existing != null && STATE_STOCKED.equals(FormDataUtils.toText(existing.get("BILL_STATE")))) {
            throw new BusinessException("入库单已确认入库,不能再修改");
        }
        Long purchaseId = FormDataUtils.getLong(form, "PURCHASE_ID");
        if (purchaseId == null) {
            throw new BusinessException("请选择采购申请");
        }
        if (existing != null && !purchaseId.equals(FormDataUtils.toLong(existing.get("PURCHASE_ID"))) && purchaseDao.countReceiptItems(keyId) > 0) {
            throw new BusinessException("本单已生成入库明细,不能更换采购申请;如需更换请删除本单后重新新建");
        }
        Map<String, Object> purchase = purchaseDao.findPurchase(purchaseId);
        if (purchase == null || !STATE_APPROVED.equals(FormDataUtils.toText(purchase.get("BILL_STATE")))) {
            throw new BusinessException("只能选择审批已通过的采购申请");
        }
        if (RECEIVE_ALL.equals(FormDataUtils.toText(purchase.get("RECEIVE_STATE")))) {
            throw new BusinessException("采购申请 " + FormDataUtils.toText(purchase.get("BILL_NO")) + " 已全部到货");
        }
        if (FormDataUtils.isBlank(form, "SUPPLIER")) {
            throw new BusinessException("请填写供应商");
        }
        FormDataUtils.put(form, "PURCHASE_NO", FormDataUtils.toText(purchase.get("BILL_NO")));
        if (FormDataUtils.isBlank(form, "RECEIPT_DATE")) {
            FormDataUtils.put(form, "RECEIPT_DATE", LocalDate.now().toString());
        }
        if (isNew) {
            if (FormDataUtils.isBlank(form, "BILL_NO")) {
                FormDataUtils.put(form, "BILL_NO", nextBillNo("RK"));
            }
            FormDataUtils.put(form, "ACCEPT_USER_ID", userId);
            FormDataUtils.put(form, "ACCEPT_USER_NAME", userName);
            FormDataUtils.put(form, "BILL_STATE", STATE_DRAFT);
        }
    }
 
    /**
     * 到货入库单保存后:还没有明细时,按采购申请未到货的数量自动生成明细,并刷新合计
     * @param keyId 入库单ID
     */
    public void afterSaveReceipt(Long keyId) {
        Map<String, Object> receipt = purchaseDao.findReceipt(keyId);
        if (receipt == null || !STATE_DRAFT.equals(FormDataUtils.toText(receipt.get("BILL_STATE")))) {
            return;
        }
        if (purchaseDao.countReceiptItems(keyId) == 0) {
            for (Map<String, Object> item : purchaseDao.findPurchaseItems(FormDataUtils.toLong(receipt.get("PURCHASE_ID")))) {
                int remaining = remainingQty(item);
                if (remaining <= 0) {
                    continue;
                }
                Map<String, Object> row = new LinkedHashMap<>();
                row.put("RECEIPT_ID", keyId);
                row.put("PURCHASE_ITEM_ID", FormDataUtils.toLong(item.get("ID")));
                row.put("ITEM_NAME", item.get("ITEM_NAME"));
                row.put("SPEC_MODEL", item.get("SPEC_MODEL"));
                row.put("CATEGORY_ID", FormDataUtils.toLong(item.get("CATEGORY_ID")));
                row.put("CATEGORY_NAME", item.get("CATEGORY_NAME"));
                row.put("UNIT", item.get("UNIT"));
                row.put("QUANTITY", remaining);
                row.put("UNIT_PRICE", item.get("BUDGET_PRICE"));
                row.put("AMOUNT", item.get("BUDGET_PRICE") == null ? null : amount(remaining, item.get("BUDGET_PRICE")));
                row.put("ACCEPT_RESULT", ACCEPT_OK);
                purchaseDao.insertReceiptItem(row);
            }
        }
        refreshReceiptTotals(keyId);
    }
 
    /**
     * 入库明细保存前:入库单须为草稿,校验数量不超过采购剩余、类别为启用的末级类别,计算金额
     * @param keyId 明细ID,新增时为0
     * @param item 表单数据,结果直接写回
     */
    public void prepareReceiptItem(Long keyId, Map<String, Object> item) {
        Long receiptId = FormDataUtils.getLong(item, "RECEIPT_ID");
        if (receiptId == null) {
            throw new BusinessException("请在到货入库单的「入库明细」页签中添加明细");
        }
        Map<String, Object> receipt = purchaseDao.findReceipt(receiptId);
        if (receipt == null || !STATE_DRAFT.equals(FormDataUtils.toText(receipt.get("BILL_STATE")))) {
            throw new BusinessException("入库单已确认入库或不存在,不能再修改明细");
        }
        if (FormDataUtils.isBlank(item, "ITEM_NAME")) {
            throw new BusinessException("请填写资产名称");
        }
        int quantity = requireQuantity(item, "QUANTITY", "到货数量", 0);
        String result = FormDataUtils.getString(item, "ACCEPT_RESULT");
        if (result.isEmpty()) {
            result = ACCEPT_OK;
        } else if (!ACCEPT_OK.equals(result) && !ACCEPT_NG.equals(result)) {
            throw new BusinessException("验收结果只能是合格或不合格");
        }
        Long purchaseItemId = FormDataUtils.getLong(item, "PURCHASE_ITEM_ID");
        if (purchaseItemId != null) {
            Map<String, Object> purchaseItem = purchaseDao.findPurchaseItem(purchaseItemId);
            int remaining = purchaseItem == null ? 0 : remainingQty(purchaseItem);
            if (quantity > remaining) {
                throw new BusinessException("到货数量不能超过采购剩余未到货数量 " + remaining);
            }
        }
        BigDecimal price = optionalAmount(item, "UNIT_PRICE", "单价");
        fillCategoryName(item, true);
        FormDataUtils.put(item, "QUANTITY", quantity);
        FormDataUtils.put(item, "ACCEPT_RESULT", result);
        FormDataUtils.put(item, "AMOUNT", price == null ? null : amount(quantity, price));
    }
 
    /**
     * 入库明细保存后:刷新入库单的资产数与金额合计
     * @param itemId 已保存的明细ID
     */
    public void afterSaveReceiptItem(Long itemId) {
        Map<String, Object> item = purchaseDao.findReceiptItem(itemId);
        if (item != null) {
            refreshReceiptTotals(FormDataUtils.toLong(item.get("RECEIPT_ID")));
        }
    }
 
    private void refreshReceiptTotals(Long receiptId) {
        int count = 0;
        BigDecimal total = BigDecimal.ZERO;
        for (Map<String, Object> item : purchaseDao.findReceiptItems(receiptId)) {
            if (isAccepted(item)) {
                count += quantityOf(item);
                total = total.add(amount(item.get("QUANTITY"), item.get("UNIT_PRICE")));
            }
        }
        Map<String, Object> values = new HashMap<>();
        values.put("ASSET_COUNT", count);
        values.put("TOTAL_AMOUNT", total.setScale(2, RoundingMode.HALF_UP));
        purchaseDao.updateReceipt(receiptId, values);
    }
 
    /**
     * 确认入库:按合格明细的数量逐件生成资产卡片并写入库记录,回写采购到货数量与到货状态
     * @param receiptIds 入库单ID
     * @param operatorId 操作人ID
     * @param operatorName 操作人姓名
     * @return 生成的资产卡片数
     */
    @Transactional(rollbackFor = Exception.class)
    public int confirmReceipts(List<Long> receiptIds, Long operatorId, String operatorName) {
        if (receiptIds == null || receiptIds.isEmpty()) {
            throw new BusinessException("请先选择入库单");
        }
        int created = 0;
        for (Long receiptId : receiptIds) {
            created += confirmReceipt(receiptId, operatorId, operatorName);
        }
        return created;
    }
 
    private int confirmReceipt(Long receiptId, Long operatorId, String operatorName) {
        Map<String, Object> receipt = purchaseDao.findReceipt(receiptId);
        if (receipt == null) {
            throw new BusinessException("入库单不存在");
        }
        String billNo = FormDataUtils.toText(receipt.get("BILL_NO"));
        if (!STATE_DRAFT.equals(FormDataUtils.toText(receipt.get("BILL_STATE")))) {
            throw new BusinessException("入库单 " + billNo + " 当前为" + FormDataUtils.toText(receipt.get("BILL_STATE")) + ",不能重复入库");
        }
        List<Map<String, Object>> accepted = new ArrayList<>();
        int units = 0;
        for (Map<String, Object> item : purchaseDao.findReceiptItems(receiptId)) {
            if (isAccepted(item) && quantityOf(item) > 0) {
                accepted.add(item);
                units += quantityOf(item);
            }
        }
        if (accepted.isEmpty()) {
            throw new BusinessException("入库单 " + billNo + " 没有验收合格且数量大于0的明细");
        }
        if (units > MAX_CARDS_PER_RECEIPT) {
            throw new BusinessException("入库单 " + billNo + " 一次最多生成 " + MAX_CARDS_PER_RECEIPT + " 件资产,请拆分入库单");
        }
        BigDecimal total = BigDecimal.ZERO;
        for (Map<String, Object> item : accepted) {
            int quantity = quantityOf(item);
            List<String> assetNos = new ArrayList<>();
            for (int i = 0; i < quantity; i++) {
                assetNos.add(createCard(receipt, item, operatorId, operatorName));
            }
            Map<String, Object> itemValues = new HashMap<>();
            itemValues.put("ASSET_NOS", describeAssetNos(assetNos));
            purchaseDao.updateReceiptItem(FormDataUtils.toLong(item.get("ID")), itemValues);
            Long purchaseItemId = FormDataUtils.toLong(item.get("PURCHASE_ITEM_ID"));
            if (purchaseItemId != null) {
                purchaseDao.addReceivedQty(purchaseItemId, quantity);
            }
            total = total.add(amount(quantity, item.get("UNIT_PRICE")));
        }
        Long purchaseId = FormDataUtils.toLong(receipt.get("PURCHASE_ID"));
        if (purchaseId != null) {
            Map<String, Object> purchaseValues = new HashMap<>();
            purchaseValues.put("RECEIVE_STATE", receiveState(purchaseDao.findPurchaseItems(purchaseId)));
            purchaseDao.updatePurchase(purchaseId, purchaseValues);
        }
        Map<String, Object> values = new HashMap<>();
        values.put("BILL_STATE", STATE_STOCKED);
        values.put("CONFIRM_TIME", new Timestamp(System.currentTimeMillis()));
        values.put("CONFIRM_USER_NAME", operatorName);
        values.put("ASSET_COUNT", units);
        values.put("TOTAL_AMOUNT", total.setScale(2, RoundingMode.HALF_UP));
        purchaseDao.updateReceipt(receiptId, values);
        return units;
    }
 
    private String createCard(Map<String, Object> receipt, Map<String, Object> item, Long operatorId, String operatorName) {
        boolean hasUser = FormDataUtils.toLong(receipt.get("USER_ID")) != null;
        String receiptDate = dateText(receipt.get("RECEIPT_DATE"));
        Map<String, Object> card = new LinkedHashMap<>();
        card.put("ASSET_NAME", FormDataUtils.toText(item.get("ITEM_NAME")));
        card.put("SPEC_MODEL", FormDataUtils.toText(item.get("SPEC_MODEL")));
        card.put("CATEGORY_ID", FormDataUtils.toLong(item.get("CATEGORY_ID")));
        card.put("BRAND", FormDataUtils.toText(item.get("BRAND")));
        card.put("UNIT", FormDataUtils.toText(item.get("UNIT")));
        card.put("ORIGINAL_VALUE", item.get("UNIT_PRICE"));
        card.put("PURCHASE_DATE", receiptDate);
        card.put("SUPPLIER", FormDataUtils.toText(receipt.get("SUPPLIER")));
        card.put("CONTRACT_NO", FormDataUtils.toText(receipt.get("CONTRACT_NO")));
        card.put("SOURCE_TYPE", SOURCE_PURCHASE);
        card.put("SOURCE_BILL_ID", FormDataUtils.toLong(receipt.get("ID")));
        card.put("SOURCE_BILL_NO", FormDataUtils.toText(receipt.get("BILL_NO")));
        // 入库时指定了使用人即视为直接领用(在用),否则进库存(闲置)
        card.put("ASSET_STATE", hasUser ? ASSET_IN_USE : ASSET_IDLE);
        card.put("START_USE_DATE", hasUser ? receiptDate : null);
        card.put("USE_DEPT_ID", FormDataUtils.toLong(receipt.get("USE_DEPT_ID")));
        card.put("USE_DEPT_NAME", FormDataUtils.toText(receipt.get("USE_DEPT_NAME")));
        card.put("USER_ID", FormDataUtils.toLong(receipt.get("USER_ID")));
        card.put("USER_NAME", FormDataUtils.toText(receipt.get("USER_NAME")));
        card.put("LOCATION_ID", FormDataUtils.toLong(receipt.get("LOCATION_ID")));
        card.put("LOCATION_NAME", FormDataUtils.toText(receipt.get("LOCATION_NAME")));
        card.put("CREATE_USER_ID", operatorId);
        card.put("CREATE_USER_NAME", operatorName);
        assetBaseService.prepareNewCard(card);
        Long cardId = assetBaseDao.insertCard(card);
        assetBaseService.recordCardInbound(cardId, card, operatorId, operatorName);
        return FormDataUtils.toText(card.get("ASSET_NO"));
    }
 
    private static String describeAssetNos(List<String> assetNos) {
        if (assetNos.size() <= MAX_LISTED_ASSET_NOS) {
            return String.join("、", assetNos);
        }
        return assetNos.get(0) + " ~ " + assetNos.get(assetNos.size() - 1) + "(共" + assetNos.size() + "件)";
    }
 
    private static String receiveState(List<Map<String, Object>> purchaseItems) {
        boolean all = true;
        boolean any = false;
        for (Map<String, Object> item : purchaseItems) {
            Integer received = FormDataUtils.toInteger(item.get("RECEIVED_QTY"));
            int receivedQty = received == null ? 0 : received;
            any |= receivedQty > 0;
            all &= remainingQty(item) <= 0;
        }
        if (all) {
            return RECEIVE_ALL;
        }
        return any ? RECEIVE_PART : RECEIVE_NONE;
    }
 
    /**
     * 删除到货入库单前:只允许草稿,并一并删除其明细
     * @param ids 入库单ID
     */
    @Transactional(rollbackFor = Exception.class)
    public void deleteReceipts(List<Long> ids) {
        checkDeletable(ids, false);
        for (Long id : ids) {
            purchaseDao.deleteReceiptItems(id);
        }
    }
 
    /**
     * 删除入库明细前:所属入库单须为草稿
     * @param itemIds 明细ID
     */
    public void checkReceiptItemsDeletable(List<Long> itemIds) {
        for (Long itemId : itemIds) {
            Map<String, Object> item = purchaseDao.findReceiptItem(itemId);
            if (item == null) {
                continue;
            }
            Map<String, Object> receipt = purchaseDao.findReceipt(FormDataUtils.toLong(item.get("RECEIPT_ID")));
            if (receipt != null && !STATE_DRAFT.equals(FormDataUtils.toText(receipt.get("BILL_STATE")))) {
                throw new BusinessException("入库单已确认入库,不能删除明细");
            }
        }
    }
 
    private void checkDeletable(List<Long> ids, boolean purchase) {
        List<String> blocked = new ArrayList<>();
        for (Long id : ids) {
            Map<String, Object> bill = purchase ? purchaseDao.findPurchase(id) : purchaseDao.findReceipt(id);
            if (bill == null) {
                continue;
            }
            String state = FormDataUtils.toText(bill.get("BILL_STATE"));
            boolean deletable = purchase ? DELETABLE_STATES.contains(state) : (state.isEmpty() || STATE_DRAFT.equals(state));
            if (!deletable) {
                blocked.add(FormDataUtils.toText(bill.get("BILL_NO")) + "(" + state + ")");
            }
        }
        if (!blocked.isEmpty()) {
            throw new BusinessException("只能删除" + (purchase ? "草稿或已终止" : "草稿") + "的单据:" + String.join("、", blocked));
        }
    }
 
    // ================= 工具 =================
 
    private void fillCategoryName(Map<String, Object> item, boolean required) {
        Long categoryId = FormDataUtils.getLong(item, "CATEGORY_ID");
        if (categoryId == null) {
            if (required) {
                throw new BusinessException("请选择资产类别(生成资产卡片需要)");
            }
            FormDataUtils.put(item, "CATEGORY_NAME", "");
            return;
        }
        Map<String, Object> category = assetBaseDao.findCategory(categoryId);
        if (category == null) {
            throw new BusinessException("所选资产类别不存在,请重新选择");
        }
        if (assetBaseDao.hasChildCategory(categoryId)) {
            throw new BusinessException("请选择末级资产类别");
        }
        String state = FormDataUtils.toText(category.get("ENABLE_STATE"));
        if (!state.isEmpty() && !AssetBaseService.ENABLED.equals(state)) {
            throw new BusinessException("资产类别「" + FormDataUtils.toText(category.get("CATEGORY_NAME")) + "」已停用");
        }
        FormDataUtils.put(item, "CATEGORY_NAME", FormDataUtils.toText(category.get("CATEGORY_NAME")));
    }
 
    private static int requireQuantity(Map<String, Object> form, String column, String title, int min) {
        String text = FormDataUtils.getString(form, column);
        if (!text.matches("\\d{1,6}")) {
            throw new BusinessException(title + "必须是整数");
        }
        int quantity = Integer.parseInt(text);
        if (quantity < min) {
            throw new BusinessException(title + "不能小于 " + min);
        }
        return quantity;
    }
 
    private static BigDecimal optionalAmount(Map<String, Object> form, String column, String title) {
        String text = FormDataUtils.getString(form, column);
        if (text.isEmpty()) {
            return null;
        }
        BigDecimal value;
        try {
            value = new BigDecimal(text);
        } catch (NumberFormatException e) {
            throw new BusinessException(title + "必须是数字");
        }
        if (value.signum() < 0) {
            throw new BusinessException(title + "不能为负数");
        }
        return value;
    }
 
    private static BigDecimal amount(Object quantity, Object price) {
        Integer qty = FormDataUtils.toInteger(quantity);
        if (qty == null || price == null || FormDataUtils.toText(price).isEmpty()) {
            return BigDecimal.ZERO.setScale(2);
        }
        return new BigDecimal(FormDataUtils.toText(price)).multiply(BigDecimal.valueOf(qty)).setScale(2, RoundingMode.HALF_UP);
    }
 
    private static int quantityOf(Map<String, Object> item) {
        Integer quantity = FormDataUtils.toInteger(item.get("QUANTITY"));
        return quantity == null ? 0 : quantity;
    }
 
    private static int remainingQty(Map<String, Object> purchaseItem) {
        Integer received = FormDataUtils.toInteger(purchaseItem.get("RECEIVED_QTY"));
        return quantityOf(purchaseItem) - (received == null ? 0 : received);
    }
 
    private static boolean isAccepted(Map<String, Object> item) {
        String result = FormDataUtils.toText(item.get("ACCEPT_RESULT"));
        return result.isEmpty() || ACCEPT_OK.equals(result);
    }
 
    private String nextBillNo(String prefix) {
        String code = prefix + LocalDate.now().format(BILL_DATE);
        return code + String.format("%03d", assetBaseDao.nextSerialNo(code));
    }
 
    private static String dateText(Object value) {
        String text = FormDataUtils.toText(value);
        return text.length() >= DATE_TEXT_LENGTH ? text.substring(0, DATE_TEXT_LENGTH) : text;
    }
}