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;
|
}
|
}
|