package cn.iocoder.yudao.module.trade.service.foreign;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.hutool.core.util.StrUtil;
|
import cn.iocoder.yudao.framework.common.pojo.PageResult;
|
import cn.iocoder.yudao.framework.common.util.number.MoneyUtils;
|
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
|
import cn.iocoder.yudao.module.bpm.api.task.BpmProcessInstanceApi;
|
import cn.iocoder.yudao.module.bpm.api.task.dto.BpmProcessInstanceCreateReqDTO;
|
import cn.iocoder.yudao.module.bpm.dal.dataobject.definition.BpmProcessDefinitionInfoDO;
|
import cn.iocoder.yudao.module.bpm.enums.task.BpmTaskStatusEnum;
|
import cn.iocoder.yudao.module.bpm.service.definition.BpmCategoryService;
|
import cn.iocoder.yudao.module.bpm.service.definition.BpmProcessDefinitionService;
|
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
|
import cn.iocoder.yudao.module.mes.api.productsales.MesWmProductSalesApi;
|
import cn.iocoder.yudao.module.mes.api.productsales.dto.MesWmProductSalesOutboundReqDTO;
|
import cn.iocoder.yudao.module.mes.api.wms.MesWmStockApi;
|
import cn.iocoder.yudao.module.mes.api.wms.dto.MesWmMaterialStockRecordDTO;
|
import cn.iocoder.yudao.module.mdm.api.item.MdmItemApi;
|
import cn.iocoder.yudao.module.mdm.api.item.dto.MdmItemRespDTO;
|
import cn.iocoder.yudao.module.system.api.storage.StorageAttachmentApi;
|
import cn.iocoder.yudao.module.trade.controller.admin.foreign.vo.TradeForeignOrderOutboundReqVO;
|
import cn.iocoder.yudao.module.trade.controller.admin.foreign.vo.TradeForeignOrderPageReqVO;
|
import cn.iocoder.yudao.module.trade.controller.admin.foreign.vo.TradeForeignOrderSaveReqVO;
|
import cn.iocoder.yudao.module.trade.controller.admin.foreign.vo.TradeForeignReceiveSaveReqVO;
|
import cn.iocoder.yudao.module.trade.dal.dataobject.foreign.TradeForeignOrderDO;
|
import cn.iocoder.yudao.module.trade.dal.dataobject.foreign.TradeForeignOrderItemDO;
|
import cn.iocoder.yudao.module.trade.dal.dataobject.foreign.TradeForeignReceiveDO;
|
import cn.iocoder.yudao.module.trade.dal.mysql.foreign.TradeForeignOrderItemMapper;
|
import cn.iocoder.yudao.module.trade.dal.mysql.foreign.TradeForeignOrderMapper;
|
import cn.iocoder.yudao.module.trade.dal.mysql.foreign.TradeForeignReceiveMapper;
|
import cn.iocoder.yudao.module.trade.dal.redis.no.TradeNoRedisDAO;
|
import cn.iocoder.yudao.module.trade.enums.foreign.TradeForeignDeliveryModeEnum;
|
import cn.iocoder.yudao.module.trade.enums.foreign.TradeForeignOrderStatusEnum;
|
import com.mzt.logapi.context.LogRecordContext;
|
import com.mzt.logapi.starter.annotation.LogRecord;
|
import jakarta.annotation.Resource;
|
import lombok.extern.slf4j.Slf4j;
|
import org.flowable.engine.repository.ProcessDefinition;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.validation.annotation.Validated;
|
|
import java.math.BigDecimal;
|
import java.time.LocalDateTime;
|
import java.util.*;
|
|
import static cn.iocoder.yudao.framework.common.exception.util.ServiceExceptionUtil.exception;
|
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.*;
|
import static cn.iocoder.yudao.module.trade.enums.ErrorCodeConstants.*;
|
import static cn.iocoder.yudao.module.trade.enums.LogRecordConstants.*;
|
|
/**
|
* 外贸订单 Service 实现类
|
*
|
* @author mom
|
*/
|
@Service
|
@Validated
|
@Slf4j
|
public class TradeForeignOrderServiceImpl implements TradeForeignOrderService {
|
|
private static final String FOREIGN_ORDER_APPROVE_CATEGORY_CODE = "foreign_order_approve";
|
private static final String ATTACHMENT_RECORD_TYPE = "trade_foreign_order";
|
private static final String FOREIGN_ORDER_NO_PREFIX = "WMDD";
|
private static final String RECEIVE_NO_PREFIX = "SHHK";
|
|
@Resource
|
private TradeForeignOrderMapper orderMapper;
|
@Resource
|
private TradeForeignOrderItemMapper orderItemMapper;
|
@Resource
|
private TradeForeignReceiveMapper receiveMapper;
|
@Resource
|
private TradeNoRedisDAO noRedisDAO;
|
|
@Resource
|
private MdmItemApi mdmItemApi;
|
@Resource
|
private CrmCustomerApi customerApi;
|
@Resource
|
private StorageAttachmentApi storageAttachmentApi;
|
@Resource
|
private BpmProcessInstanceApi bpmProcessInstanceApi;
|
@Resource
|
private BpmProcessDefinitionService bpmProcessDefinitionService;
|
@Resource
|
private BpmCategoryService bpmCategoryService;
|
@Resource
|
private MesWmProductSalesApi mesProductSalesApi;
|
@Resource
|
private MesWmStockApi mesStockApi;
|
@Resource
|
private TradePortBatchService portBatchService;
|
@Resource
|
private TradeForeignDocumentService documentService;
|
@Resource
|
private TradeForeignDocNotifyService documentNotifyService;
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
@LogRecord(type = TRADE_FOREIGN_ORDER_TYPE, subType = TRADE_FOREIGN_ORDER_CREATE_SUB_TYPE,
|
bizNo = "{{#order.id}}", success = TRADE_FOREIGN_ORDER_CREATE_SUCCESS)
|
public Long createOrder(TradeForeignOrderSaveReqVO reqVO, Long userId) {
|
if (customerApi.validateCustomer(reqVO.getCustomerId()) == null) {
|
throw exception(FOREIGN_ORDER_CUSTOMER_NOT_EXISTS);
|
}
|
List<TradeForeignOrderItemDO> items = validateAndBuildItems(reqVO);
|
|
String no = noRedisDAO.generate(FOREIGN_ORDER_NO_PREFIX);
|
if (orderMapper.selectByNo(no) != null) {
|
throw exception(FOREIGN_ORDER_NO_EXISTS);
|
}
|
|
TradeForeignOrderDO order = BeanUtils.toBean(reqVO, TradeForeignOrderDO.class);
|
order.setNo(no).setStatus(TradeForeignOrderStatusEnum.DRAFT.getStatus())
|
.setOutStatus(0).setOutCount(BigDecimal.ZERO)
|
.setSaleUserId(reqVO.getSaleUserId() != null ? reqVO.getSaleUserId() : userId);
|
calculateTotal(order, items);
|
orderMapper.insert(order);
|
items.forEach(i -> i.setOrderId(order.getId()));
|
orderItemMapper.insertBatch(items);
|
storageAttachmentApi.bindAttachments("file", ATTACHMENT_RECORD_TYPE, order.getId(), reqVO.getBlobIds());
|
// 港口前置备货:占用港口入库批次
|
occupyPortBatch(order);
|
|
LogRecordContext.putVariable("order", order);
|
return order.getId();
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
@LogRecord(type = TRADE_FOREIGN_ORDER_TYPE, subType = TRADE_FOREIGN_ORDER_UPDATE_SUB_TYPE,
|
bizNo = "{{#order.id}}", success = TRADE_FOREIGN_ORDER_UPDATE_SUCCESS)
|
public void updateOrder(TradeForeignOrderSaveReqVO reqVO) {
|
TradeForeignOrderDO old = validateOrderExists(reqVO.getId());
|
if (!TradeForeignOrderStatusEnum.DRAFT.getStatus().equals(old.getStatus())) {
|
throw exception(FOREIGN_ORDER_UPDATE_FAIL_NOT_DRAFT, old.getNo());
|
}
|
if (customerApi.validateCustomer(reqVO.getCustomerId()) == null) {
|
throw exception(FOREIGN_ORDER_CUSTOMER_NOT_EXISTS);
|
}
|
List<TradeForeignOrderItemDO> items = validateAndBuildItems(reqVO);
|
TradeForeignOrderDO updateObj = BeanUtils.toBean(reqVO, TradeForeignOrderDO.class);
|
calculateTotal(updateObj, items);
|
// 批次占用:先释放旧批次,再占用新批次
|
releasePortBatch(old);
|
orderMapper.updateById(updateObj);
|
occupyPortBatch(updateObj);
|
updateOrderItemList(reqVO.getId(), items);
|
storageAttachmentApi.updateAttachments("file", ATTACHMENT_RECORD_TYPE, reqVO.getId(), reqVO.getBlobIds());
|
LogRecordContext.putVariable("order", old);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
@LogRecord(type = TRADE_FOREIGN_ORDER_TYPE, subType = TRADE_FOREIGN_ORDER_DELETE_SUB_TYPE,
|
bizNo = "{{#order.id}}", success = TRADE_FOREIGN_ORDER_DELETE_SUCCESS)
|
public void deleteOrder(Long id) {
|
TradeForeignOrderDO order = validateOrderExists(id);
|
if (!TradeForeignOrderStatusEnum.DRAFT.getStatus().equals(order.getStatus())) {
|
throw exception(FOREIGN_ORDER_DELETE_FAIL_NOT_DRAFT, order.getNo());
|
}
|
storageAttachmentApi.deleteAttachmentsByRecord(ATTACHMENT_RECORD_TYPE, id);
|
orderMapper.deleteById(id);
|
orderItemMapper.deleteByOrderId(id);
|
releasePortBatch(order);
|
LogRecordContext.putVariable("order", order);
|
}
|
|
@Override
|
public TradeForeignOrderDO getOrder(Long id) {
|
return orderMapper.selectById(id);
|
}
|
|
@Override
|
public PageResult<TradeForeignOrderDO> getOrderPage(TradeForeignOrderPageReqVO reqVO) {
|
return orderMapper.selectPage(reqVO);
|
}
|
|
@Override
|
public List<TradeForeignOrderItemDO> getOrderItemListByOrderId(Long orderId) {
|
return orderItemMapper.selectListByOrderId(orderId);
|
}
|
|
@Override
|
public List<TradeForeignOrderItemDO> getOrderItemListByOrderIds(Collection<Long> orderIds) {
|
if (CollUtil.isEmpty(orderIds)) {
|
return Collections.emptyList();
|
}
|
return orderItemMapper.selectListByOrderIds(orderIds);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
@LogRecord(type = TRADE_FOREIGN_ORDER_TYPE, subType = TRADE_FOREIGN_ORDER_SUBMIT_SUB_TYPE,
|
bizNo = "{{#order.id}}", success = TRADE_FOREIGN_ORDER_SUBMIT_SUCCESS)
|
public void submitOrder(Long id, String processDefinitionKey, Long userId) {
|
TradeForeignOrderDO order = validateOrderExists(id);
|
if (!TradeForeignOrderStatusEnum.DRAFT.getStatus().equals(order.getStatus())
|
&& !TradeForeignOrderStatusEnum.REJECTED.getStatus().equals(order.getStatus())) {
|
throw exception(FOREIGN_ORDER_SUBMIT_FAIL_STATUS, order.getNo());
|
}
|
// 需求6:按出货模式校验必填单据,缺件则推送补件提醒并拦截提交
|
// 说明:报关/出运类单据(装箱单/成品出库单等)需审批通过后才可登记,此处忽略这些单据,避免死锁
|
List<String> submitMissingDocs = documentService.getMissingRequiredDocNames(id, true);
|
if (CollUtil.isNotEmpty(submitMissingDocs)) {
|
documentNotifyService.sendDocMissingNotify(order, submitMissingDocs, "提交审批");
|
throw exception(FOREIGN_ORDER_DOC_MISSING, String.join("、", submitMissingDocs));
|
}
|
validateApproveCategoryAndProcessDefinition();
|
ProcessDefinition processDefinition = bpmProcessDefinitionService.getActiveProcessDefinition(processDefinitionKey);
|
if (processDefinition == null) {
|
throw exception(FOREIGN_ORDER_BPM_PROCESS_DEFINITION_NOT_EXISTS);
|
}
|
String processInstanceId = bpmProcessInstanceApi.createProcessInstance(userId, new BpmProcessInstanceCreateReqDTO()
|
.setProcessDefinitionKey(processDefinitionKey).setBusinessKey(String.valueOf(id)));
|
orderMapper.updateById(new TradeForeignOrderDO().setId(id).setProcessInstanceId(processInstanceId)
|
.setStatus(TradeForeignOrderStatusEnum.APPROVING.getStatus()));
|
LogRecordContext.putVariable("order", order);
|
}
|
|
@Override
|
public void updateOrderAuditStatus(Long id, Integer bpmResult) {
|
TradeForeignOrderDO order = validateOrderExists(id);
|
if (!TradeForeignOrderStatusEnum.APPROVING.getStatus().equals(order.getStatus())) {
|
log.warn("[updateOrderAuditStatus][外贸订单({}) 不处于审批中,无法更新审批结果({})]", id, bpmResult);
|
throw exception(FOREIGN_ORDER_UPDATE_AUDIT_STATUS_FAIL_NOT_PROCESS, order.getNo());
|
}
|
orderMapper.updateById(new TradeForeignOrderDO().setId(id).setStatus(convertBpmResultToStatus(bpmResult)));
|
}
|
|
@Override
|
public List<Map<String, Object>> getApproveProcessDefinitionList() {
|
validateApproveCategoryAndProcessDefinition();
|
List<BpmProcessDefinitionInfoDO> definitionInfoList = bpmProcessDefinitionService
|
.getProcessDefinitionInfoListByCategory(FOREIGN_ORDER_APPROVE_CATEGORY_CODE);
|
Set<String> processDefinitionIds = convertSet(definitionInfoList, BpmProcessDefinitionInfoDO::getProcessDefinitionId);
|
List<ProcessDefinition> processDefinitions = bpmProcessDefinitionService.getProcessDefinitionList(processDefinitionIds);
|
Map<String, ProcessDefinition> latestVersionMap = new HashMap<>();
|
for (ProcessDefinition pd : processDefinitions) {
|
if (pd.isSuspended()) {
|
continue;
|
}
|
ProcessDefinition existing = latestVersionMap.get(pd.getKey());
|
if (existing == null || pd.getVersion() > existing.getVersion()) {
|
latestVersionMap.put(pd.getKey(), pd);
|
}
|
}
|
List<Map<String, Object>> result = new ArrayList<>();
|
for (ProcessDefinition pd : latestVersionMap.values()) {
|
Map<String, Object> item = new HashMap<>();
|
item.put("id", pd.getId());
|
item.put("key", pd.getKey());
|
item.put("name", pd.getName());
|
item.put("version", pd.getVersion());
|
result.add(item);
|
}
|
return result;
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
@LogRecord(type = TRADE_FOREIGN_ORDER_TYPE, subType = TRADE_FOREIGN_ORDER_COMPLETE_SUB_TYPE,
|
bizNo = "{{#order.id}}", success = TRADE_FOREIGN_ORDER_COMPLETE_SUCCESS)
|
public void completeOrder(Long id) {
|
TradeForeignOrderDO order = validateOrderExists(id);
|
if (!TradeForeignOrderStatusEnum.APPROVED.getStatus().equals(order.getStatus())) {
|
throw exception(FOREIGN_ORDER_COMPLETE_FAIL_NOT_APPROVE, order.getNo());
|
}
|
// 需求6:完结前必须齐全该出货模式下的全部必填单据,缺件则推送补件提醒并拦截完结
|
List<String> completeMissingDocs = documentService.getMissingRequiredDocNames(id, false);
|
if (CollUtil.isNotEmpty(completeMissingDocs)) {
|
documentNotifyService.sendDocMissingNotify(order, completeMissingDocs, "完结");
|
throw exception(FOREIGN_ORDER_DOC_MISSING, String.join("、", completeMissingDocs));
|
}
|
orderMapper.updateById(new TradeForeignOrderDO().setId(id)
|
.setStatus(TradeForeignOrderStatusEnum.COMPLETED.getStatus()));
|
archiveOrder(id);
|
LogRecordContext.putVariable("order", order);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
@LogRecord(type = TRADE_FOREIGN_ORDER_TYPE, subType = TRADE_FOREIGN_ORDER_UPLOAD_DOC_SUB_TYPE,
|
bizNo = "{{#order.id}}", success = TRADE_FOREIGN_ORDER_UPLOAD_DOC_SUCCESS)
|
public void uploadDocuments(Long id, List<Long> blobIds) {
|
TradeForeignOrderDO order = validateOrderExists(id);
|
if (CollUtil.isNotEmpty(blobIds)) {
|
storageAttachmentApi.bindAttachments("file", ATTACHMENT_RECORD_TYPE, id, blobIds);
|
}
|
LogRecordContext.putVariable("order", order);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
@LogRecord(type = TRADE_FOREIGN_ORDER_TYPE, subType = TRADE_FOREIGN_ORDER_RECEIVE_SUB_TYPE,
|
bizNo = "{{#order.id}}", success = TRADE_FOREIGN_ORDER_RECEIVE_SUCCESS)
|
public Long createReceive(TradeForeignReceiveSaveReqVO reqVO) {
|
TradeForeignOrderDO order = validateOrderExists(reqVO.getOrderId());
|
// 校验不超收(按外币口径)
|
BigDecimal received = getSumValue(receiveMapper.selectListByOrderId(order.getId()),
|
TradeForeignReceiveDO::getForeignAmount, BigDecimal::add, BigDecimal.ZERO);
|
BigDecimal receivableTotal = order.getTotalForeignPrice() == null ? BigDecimal.ZERO : order.getTotalForeignPrice();
|
if (received.add(reqVO.getForeignAmount()).compareTo(receivableTotal) > 0) {
|
throw exception(FOREIGN_ORDER_RECEIVE_EXCEED);
|
}
|
TradeForeignReceiveDO receive = BeanUtils.toBean(reqVO, TradeForeignReceiveDO.class);
|
receive.setNo(noRedisDAO.generate(RECEIVE_NO_PREFIX));
|
BigDecimal rate = reqVO.getExchangeRate() != null ? reqVO.getExchangeRate() : order.getExchangeRate();
|
receive.setExchangeRate(rate);
|
if (rate != null && reqVO.getForeignAmount() != null) {
|
receive.setSettledAmount(MoneyUtils.priceMultiply(reqVO.getForeignAmount(), rate));
|
}
|
receiveMapper.insert(receive);
|
LogRecordContext.putVariable("order", order);
|
return receive.getId();
|
}
|
|
@Override
|
public List<TradeForeignReceiveDO> getReceiveListByOrderId(Long orderId) {
|
return receiveMapper.selectListByOrderId(orderId);
|
}
|
|
@Override
|
public void archiveOrder(Long id) {
|
// TODO 【预留】依赖「全系统统一电子档案库」(需求11)
|
log.info("[archiveOrder][外贸订单({}) 归档为预留接口,待接入统一电子档案库]", id);
|
}
|
|
@Override
|
public void syncToK3(Long id) {
|
// TODO 【预留】依赖「金蝶 K3 对接」
|
log.info("[syncToK3][外贸订单({}) K3 同步为预留接口,待接入金蝶 K3]", id);
|
}
|
|
@Override
|
@Transactional(rollbackFor = Exception.class)
|
@LogRecord(type = TRADE_FOREIGN_ORDER_TYPE, subType = TRADE_FOREIGN_ORDER_OUTBOUND_SUB_TYPE,
|
bizNo = "{{#order.id}}", success = TRADE_FOREIGN_ORDER_OUTBOUND_SUCCESS)
|
public void outbound(TradeForeignOrderOutboundReqVO reqVO, Long userId) {
|
// 1. 校验:已审批通过 + 厂区订单直发 + 未出库过(一对一)
|
TradeForeignOrderDO order = validateOrderExists(reqVO.getId());
|
if (!TradeForeignOrderStatusEnum.APPROVED.getStatus().equals(order.getStatus())) {
|
throw exception(FOREIGN_ORDER_OUTBOUND_FAIL_NOT_APPROVE, order.getNo());
|
}
|
if (!TradeForeignDeliveryModeEnum.FACTORY_DIRECT.getMode().equals(order.getDeliveryMode())) {
|
throw exception(FOREIGN_ORDER_OUTBOUND_FAIL_NOT_FACTORY, order.getNo());
|
}
|
if (order.getOutProductSalesId() != null) {
|
throw exception(FOREIGN_ORDER_OUTBOUND_EXISTS, order.getNo());
|
}
|
if (CollUtil.isEmpty(reqVO.getItems())) {
|
throw exception(FOREIGN_ORDER_OUTBOUND_ITEMS_EMPTY);
|
}
|
// 2. 组装 MES 成品出库请求(客户=CRM 客户)
|
List<TradeForeignOrderItemDO> orderItems = orderItemMapper.selectListByOrderId(order.getId());
|
Map<Long, TradeForeignOrderItemDO> itemMap = convertMap(orderItems, TradeForeignOrderItemDO::getItemId);
|
MesWmProductSalesOutboundReqDTO mesReq = new MesWmProductSalesOutboundReqDTO();
|
mesReq.setCode(noRedisDAO.generate("CKCK"));
|
mesReq.setName("外贸订单出库-" + order.getNo());
|
mesReq.setClientId(order.getCustomerId());
|
mesReq.setSalesDate(LocalDateTime.now());
|
mesReq.setCarrier(reqVO.getCarrier());
|
mesReq.setShippingNumber(reqVO.getShippingNumber());
|
mesReq.setRemark("外贸订单(厂区直发)出库:" + order.getNo());
|
List<MesWmProductSalesOutboundReqDTO.Line> mesLines = new ArrayList<>();
|
for (TradeForeignOrderOutboundReqVO.Item it : reqVO.getItems()) {
|
if (it.getQuantity() == null || it.getQuantity().compareTo(BigDecimal.ZERO) <= 0) {
|
throw exception(FOREIGN_ORDER_OUTBOUND_ITEMS_EMPTY);
|
}
|
TradeForeignOrderItemDO oi = itemMap.get(it.getItemId());
|
BigDecimal ordered = oi != null && oi.getCount() != null ? oi.getCount() : BigDecimal.ZERO;
|
if (it.getQuantity().compareTo(ordered) > 0) {
|
throw exception(FOREIGN_ORDER_OUTBOUND_QTY_EXCEED, order.getNo(), it.getItemId());
|
}
|
MesWmProductSalesOutboundReqDTO.Line ml = new MesWmProductSalesOutboundReqDTO.Line();
|
ml.setItemId(it.getItemId());
|
ml.setQuantity(it.getQuantity());
|
ml.setMaterialStockId(it.getMaterialStockId());
|
ml.setWarehouseId(it.getWarehouseId());
|
ml.setBatchId(it.getBatchId());
|
ml.setBatchCode(it.getBatchCode());
|
ml.setLocationId(it.getLocationId());
|
ml.setAreaId(it.getAreaId());
|
mesLines.add(ml);
|
}
|
mesReq.setLines(mesLines);
|
// 3. 调 MES 成品出库(扣库存),并一对一绑定厂区出库单
|
Long salesId = mesProductSalesApi.createAndFinishProductSales(mesReq);
|
BigDecimal totalOut = getSumValue(reqVO.getItems(), TradeForeignOrderOutboundReqVO.Item::getQuantity, BigDecimal::add, BigDecimal.ZERO);
|
BigDecimal orderedTotal = order.getTotalCount() == null ? BigDecimal.ZERO : order.getTotalCount();
|
int outStatus = totalOut.compareTo(orderedTotal) >= 0 ? 2 : 1;
|
orderMapper.updateById(new TradeForeignOrderDO().setId(order.getId())
|
.setOutProductSalesId(salesId).setOutProductSalesCode(mesReq.getCode())
|
.setOutCount(totalOut).setOutStatus(outStatus));
|
LogRecordContext.putVariable("order", order);
|
}
|
|
@Override
|
public List<MesWmMaterialStockRecordDTO> getAvailableStock(Long itemId) {
|
return mesStockApi.getAvailableStockListByItemIds(Collections.singletonList(itemId));
|
}
|
|
private void occupyPortBatch(TradeForeignOrderDO order) {
|
if (order != null
|
&& TradeForeignDeliveryModeEnum.PORT_PREPARE.getMode().equals(order.getDeliveryMode())
|
&& StrUtil.isNotBlank(order.getPortBatchCode())) {
|
portBatchService.occupy(order.getPortBatchCode(), order.getTotalCount());
|
}
|
}
|
|
private void releasePortBatch(TradeForeignOrderDO order) {
|
if (order != null
|
&& TradeForeignDeliveryModeEnum.PORT_PREPARE.getMode().equals(order.getDeliveryMode())
|
&& StrUtil.isNotBlank(order.getPortBatchCode())) {
|
portBatchService.release(order.getPortBatchCode(), order.getTotalCount());
|
}
|
}
|
|
// ==================== 私有方法 ====================
|
|
private TradeForeignOrderDO validateOrderExists(Long id) {
|
TradeForeignOrderDO order = orderMapper.selectById(id);
|
if (order == null) {
|
throw exception(FOREIGN_ORDER_NOT_EXISTS);
|
}
|
return order;
|
}
|
|
private List<TradeForeignOrderItemDO> validateAndBuildItems(TradeForeignOrderSaveReqVO reqVO) {
|
Set<Long> itemIds = convertSet(reqVO.getItems(), TradeForeignOrderSaveReqVO.Item::getItemId);
|
Map<Long, MdmItemRespDTO> itemMap = mdmItemApi.getItemMap(itemIds);
|
return convertList(reqVO.getItems(), o -> BeanUtils.toBean(o, TradeForeignOrderItemDO.class, item -> {
|
MdmItemRespDTO mdmItem = itemMap.get(item.getItemId());
|
if (mdmItem == null) {
|
throw exception(FOREIGN_ORDER_ITEM_NOT_EXISTS);
|
}
|
item.setItemUnitId(mdmItem.getUnitMeasureId());
|
item.setOutCount(BigDecimal.ZERO);
|
BigDecimal rate = item.getExchangeRate() != null ? item.getExchangeRate() : reqVO.getExchangeRate();
|
item.setExchangeRate(rate);
|
if (item.getForeignPrice() != null && item.getCount() != null) {
|
item.setTotalForeignPrice(MoneyUtils.priceMultiply(item.getForeignPrice(), item.getCount()));
|
}
|
if (item.getForeignPrice() != null && rate != null) {
|
item.setItemPrice(MoneyUtils.priceMultiply(item.getForeignPrice(), rate));
|
}
|
if (item.getItemPrice() != null && item.getCount() != null) {
|
item.setTotalPrice(MoneyUtils.priceMultiply(item.getItemPrice(), item.getCount()));
|
}
|
}));
|
}
|
|
private void updateOrderItemList(Long orderId, List<TradeForeignOrderItemDO> newList) {
|
List<TradeForeignOrderItemDO> oldList = orderItemMapper.selectListByOrderId(orderId);
|
List<List<TradeForeignOrderItemDO>> diffList = diffList(oldList, newList,
|
(oldVal, newVal) -> oldVal.getId() != null && oldVal.getId().equals(newVal.getId()));
|
if (CollUtil.isNotEmpty(diffList.get(0))) {
|
diffList.get(0).forEach(o -> o.setOrderId(orderId));
|
orderItemMapper.insertBatch(diffList.get(0));
|
}
|
if (CollUtil.isNotEmpty(diffList.get(1))) {
|
orderItemMapper.updateBatch(diffList.get(1));
|
}
|
if (CollUtil.isNotEmpty(diffList.get(2))) {
|
orderItemMapper.deleteByIds(convertList(diffList.get(2), TradeForeignOrderItemDO::getId));
|
}
|
}
|
|
private void calculateTotal(TradeForeignOrderDO order, List<TradeForeignOrderItemDO> items) {
|
order.setTotalCount(getSumValue(items, TradeForeignOrderItemDO::getCount, BigDecimal::add, BigDecimal.ZERO));
|
order.setTotalForeignPrice(getSumValue(items, TradeForeignOrderItemDO::getTotalForeignPrice, BigDecimal::add, BigDecimal.ZERO));
|
order.setTotalPrice(getSumValue(items, TradeForeignOrderItemDO::getTotalPrice, BigDecimal::add, BigDecimal.ZERO));
|
}
|
|
private Integer convertBpmResultToStatus(Integer bpmResult) {
|
if (BpmTaskStatusEnum.APPROVE.getStatus().equals(bpmResult)) {
|
return TradeForeignOrderStatusEnum.APPROVED.getStatus();
|
} else if (BpmTaskStatusEnum.REJECT.getStatus().equals(bpmResult)) {
|
return TradeForeignOrderStatusEnum.REJECTED.getStatus();
|
} else if (BpmTaskStatusEnum.CANCEL.getStatus().equals(bpmResult)) {
|
return TradeForeignOrderStatusEnum.CANCELLED.getStatus();
|
}
|
throw exception(FOREIGN_ORDER_UPDATE_AUDIT_STATUS_FAIL_NOT_PROCESS, "");
|
}
|
|
private void validateApproveCategoryAndProcessDefinition() {
|
List<String> codes = Collections.singletonList(FOREIGN_ORDER_APPROVE_CATEGORY_CODE);
|
Map<String, ?> categoryMap = bpmCategoryService.getCategoryMap(codes);
|
if (!categoryMap.containsKey(FOREIGN_ORDER_APPROVE_CATEGORY_CODE)) {
|
throw exception(FOREIGN_ORDER_BPM_PROCESS_DEFINITION_NOT_EXISTS);
|
}
|
List<BpmProcessDefinitionInfoDO> definitionInfoList = bpmProcessDefinitionService
|
.getProcessDefinitionInfoListByCategory(FOREIGN_ORDER_APPROVE_CATEGORY_CODE);
|
if (CollUtil.isEmpty(definitionInfoList)) {
|
throw exception(FOREIGN_ORDER_BPM_PROCESS_DEFINITION_NOT_EXISTS);
|
}
|
Set<String> processDefinitionIds = convertSet(definitionInfoList, BpmProcessDefinitionInfoDO::getProcessDefinitionId);
|
List<ProcessDefinition> processDefinitions = bpmProcessDefinitionService.getProcessDefinitionList(processDefinitionIds);
|
if (processDefinitions.stream().noneMatch(pd -> !pd.isSuspended())) {
|
throw exception(FOREIGN_ORDER_BPM_PROCESS_DEFINITION_NOT_EXISTS);
|
}
|
}
|
|
}
|