package cn.iocoder.yudao.module.trade.controller.admin.foreign;
|
|
import cn.hutool.core.collection.CollUtil;
|
import cn.iocoder.yudao.framework.apilog.core.annotation.ApiAccessLog;
|
import cn.iocoder.yudao.framework.common.pojo.CommonResult;
|
import cn.iocoder.yudao.framework.common.pojo.PageParam;
|
import cn.iocoder.yudao.framework.common.pojo.PageResult;
|
import cn.iocoder.yudao.framework.common.util.collection.MapUtils;
|
import cn.iocoder.yudao.framework.common.util.object.BeanUtils;
|
import cn.iocoder.yudao.framework.excel.core.util.ExcelUtils;
|
import cn.iocoder.yudao.module.crm.api.customer.CrmCustomerApi;
|
import cn.iocoder.yudao.module.crm.api.customer.dto.CrmCustomerRespDTO;
|
import cn.iocoder.yudao.module.mdm.api.item.MdmItemApi;
|
import cn.iocoder.yudao.module.mdm.api.item.dto.MdmItemRespDTO;
|
import cn.iocoder.yudao.module.mdm.api.unit.MdmUnitMeasureApi;
|
import cn.iocoder.yudao.module.mdm.api.unit.dto.MdmUnitMeasureRespDTO;
|
import cn.iocoder.yudao.module.system.api.storage.StorageAttachmentApi;
|
import cn.iocoder.yudao.module.system.api.storage.dto.StorageBlobRespDTO;
|
import cn.iocoder.yudao.module.system.api.user.AdminUserApi;
|
import cn.iocoder.yudao.module.system.api.user.dto.AdminUserRespDTO;
|
import cn.iocoder.yudao.module.mes.api.wms.dto.MesWmMaterialStockRecordDTO;
|
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.TradeForeignOrderRespVO;
|
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.enums.foreign.TradeForeignDeliveryModeEnum;
|
import cn.iocoder.yudao.module.trade.enums.foreign.TradeForeignOrderStatusEnum;
|
import cn.iocoder.yudao.module.trade.service.foreign.TradeForeignDocumentService;
|
import cn.iocoder.yudao.module.trade.service.foreign.TradeForeignOrderService;
|
import io.swagger.v3.oas.annotations.Operation;
|
import io.swagger.v3.oas.annotations.Parameter;
|
import io.swagger.v3.oas.annotations.tags.Tag;
|
import jakarta.annotation.Resource;
|
import jakarta.servlet.http.HttpServletResponse;
|
import jakarta.validation.Valid;
|
import org.springframework.security.access.prepost.PreAuthorize;
|
import org.springframework.validation.annotation.Validated;
|
import org.springframework.web.bind.annotation.*;
|
|
import java.io.IOException;
|
import java.math.BigDecimal;
|
import java.util.*;
|
|
import static cn.iocoder.yudao.framework.apilog.core.enums.OperateTypeEnum.EXPORT;
|
import static cn.iocoder.yudao.framework.common.pojo.CommonResult.success;
|
import static cn.iocoder.yudao.framework.common.util.collection.CollectionUtils.*;
|
import static cn.iocoder.yudao.framework.security.core.util.SecurityFrameworkUtils.getLoginUserId;
|
|
@Tag(name = "管理后台 - 外贸订单")
|
@RestController
|
@RequestMapping("/trade/foreign-order")
|
@Validated
|
public class TradeForeignOrderController {
|
|
@Resource
|
private TradeForeignOrderService orderService;
|
@Resource
|
private CrmCustomerApi customerApi;
|
@Resource
|
private MdmItemApi mdmItemApi;
|
@Resource
|
private MdmUnitMeasureApi mdmUnitMeasureApi;
|
@Resource
|
private AdminUserApi adminUserApi;
|
@Resource
|
private StorageAttachmentApi storageAttachmentApi;
|
@Resource
|
private TradeForeignDocumentService documentService;
|
|
@PostMapping("/create")
|
@Operation(summary = "创建外贸订单")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:create')")
|
public CommonResult<Long> createOrder(@Valid @RequestBody TradeForeignOrderSaveReqVO reqVO) {
|
return success(orderService.createOrder(reqVO, getLoginUserId()));
|
}
|
|
@PutMapping("/update")
|
@Operation(summary = "更新外贸订单")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:update')")
|
public CommonResult<Boolean> updateOrder(@Valid @RequestBody TradeForeignOrderSaveReqVO reqVO) {
|
orderService.updateOrder(reqVO);
|
return success(true);
|
}
|
|
@DeleteMapping("/delete")
|
@Operation(summary = "删除外贸订单")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:delete')")
|
public CommonResult<Boolean> deleteOrder(@RequestParam("id") Long id) {
|
orderService.deleteOrder(id);
|
return success(true);
|
}
|
|
@GetMapping("/get")
|
@Operation(summary = "获得外贸订单")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:query')")
|
public CommonResult<TradeForeignOrderRespVO> getOrder(@RequestParam("id") Long id) {
|
TradeForeignOrderDO order = orderService.getOrder(id);
|
if (order == null) {
|
return success(null);
|
}
|
return success(buildDetail(order, orderService.getOrderItemListByOrderId(id)));
|
}
|
|
@GetMapping("/page")
|
@Operation(summary = "获得外贸订单分页")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:query')")
|
public CommonResult<PageResult<TradeForeignOrderRespVO>> getOrderPage(@Valid TradeForeignOrderPageReqVO pageReqVO) {
|
return success(buildPage(orderService.getOrderPage(pageReqVO)));
|
}
|
|
@PutMapping("/submit")
|
@Operation(summary = "提交外贸订单审批")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:submit')")
|
public CommonResult<Boolean> submitOrder(@RequestParam("id") Long id,
|
@RequestParam("processDefinitionKey") String processDefinitionKey) {
|
orderService.submitOrder(id, processDefinitionKey, getLoginUserId());
|
return success(true);
|
}
|
|
@GetMapping("/approve-process-list")
|
@Operation(summary = "获得外贸订单可发起的审批流程列表")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:query')")
|
public CommonResult<List<Map<String, Object>>> getApproveProcessList() {
|
return success(orderService.getApproveProcessDefinitionList());
|
}
|
|
@PutMapping("/complete")
|
@Operation(summary = "完结外贸订单")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:complete')")
|
public CommonResult<Boolean> completeOrder(@RequestParam("id") Long id) {
|
orderService.completeOrder(id);
|
return success(true);
|
}
|
|
@PostMapping("/upload-document")
|
@Operation(summary = "上传外贸订单单据(附件)")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:update')")
|
public CommonResult<Boolean> uploadDocuments(@RequestParam("id") Long id,
|
@RequestBody List<Long> blobIds) {
|
orderService.uploadDocuments(id, blobIds);
|
return success(true);
|
}
|
|
@GetMapping("/attachments")
|
@Operation(summary = "获得外贸订单附件列表")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:query')")
|
public CommonResult<List<StorageBlobRespDTO>> getOrderAttachments(@RequestParam("id") Long id) {
|
return success(storageAttachmentApi.listAttachments("trade_foreign_order", id));
|
}
|
|
@PostMapping("/receive")
|
@Operation(summary = "外贸订单收汇登记")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:receive')")
|
public CommonResult<Long> createReceive(@Valid @RequestBody TradeForeignReceiveSaveReqVO reqVO) {
|
return success(orderService.createReceive(reqVO));
|
}
|
|
@GetMapping("/receive-list")
|
@Operation(summary = "获得外贸订单收汇列表")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:query')")
|
public CommonResult<List<TradeForeignReceiveDO>> getReceiveList(@RequestParam("id") Long id) {
|
return success(orderService.getReceiveListByOrderId(id));
|
}
|
|
@PostMapping("/archive")
|
@Operation(summary = "归档外贸订单(预留:统一电子档案库)")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:update')")
|
public CommonResult<Boolean> archiveOrder(@RequestParam("id") Long id) {
|
orderService.archiveOrder(id);
|
return success(true);
|
}
|
|
@PostMapping("/sync-k3")
|
@Operation(summary = "同步外贸订单到金蝶 K3(预留)")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:update')")
|
public CommonResult<Boolean> syncToK3(@RequestParam("id") Long id) {
|
orderService.syncToK3(id);
|
return success(true);
|
}
|
|
@PostMapping("/outbound")
|
@Operation(summary = "外贸订单出库(厂区直发绑定厂区出库单,MES 成品出库扣库存)")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:outbound')")
|
public CommonResult<Boolean> outbound(@Valid @RequestBody TradeForeignOrderOutboundReqVO reqVO) {
|
orderService.outbound(reqVO, getLoginUserId());
|
return success(true);
|
}
|
|
@GetMapping("/available-stock")
|
@Operation(summary = "按物料获得可用库存记录(供出库选择)")
|
@Parameter(name = "itemId", description = "物料编号", required = true)
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:query')")
|
public CommonResult<List<MesWmMaterialStockRecordDTO>> getAvailableStock(@RequestParam("itemId") Long itemId) {
|
return success(orderService.getAvailableStock(itemId));
|
}
|
|
@GetMapping("/export-excel")
|
@Operation(summary = "导出外贸订单 Excel")
|
@PreAuthorize("@ss.hasPermission('trade:foreign-order:export')")
|
@ApiAccessLog(operateType = EXPORT)
|
public void exportOrderExcel(@Valid TradeForeignOrderPageReqVO pageReqVO,
|
HttpServletResponse response) throws IOException {
|
pageReqVO.setPageSize(PageParam.PAGE_SIZE_NONE);
|
List<TradeForeignOrderRespVO> list = buildPage(orderService.getOrderPage(pageReqVO)).getList();
|
ExcelUtils.write(response, "外贸订单.xls", "数据", TradeForeignOrderRespVO.class, list);
|
}
|
|
// ==================== 构建响应 ====================
|
|
private TradeForeignOrderRespVO buildDetail(TradeForeignOrderDO order, List<TradeForeignOrderItemDO> items) {
|
TradeForeignOrderRespVO vo = BeanUtils.toBean(order, TradeForeignOrderRespVO.class);
|
vo.setStatusName(TradeForeignOrderStatusEnum.getNameByStatus(order.getStatus()));
|
vo.setDeliveryModeName(TradeForeignDeliveryModeEnum.getNameByMode(order.getDeliveryMode()));
|
if (order.getCustomerId() != null) {
|
CrmCustomerRespDTO customer = customerApi.getCustomer(order.getCustomerId());
|
if (customer != null) {
|
vo.setCustomerName(customer.getName());
|
}
|
}
|
if (order.getSaleUserId() != null) {
|
AdminUserRespDTO user = adminUserApi.getUser(order.getSaleUserId());
|
if (user != null) {
|
vo.setSaleUserName(user.getNickname());
|
}
|
}
|
if (order.getCreator() != null) {
|
try {
|
AdminUserRespDTO user = adminUserApi.getUser(Long.valueOf(order.getCreator()));
|
if (user != null) {
|
vo.setCreatorName(user.getNickname());
|
}
|
} catch (NumberFormatException ignored) {
|
}
|
}
|
vo.setItems(convertItems(items));
|
fillForeignReceive(vo, Collections.singletonList(order.getId()));
|
fillMissingDocs(vo);
|
return vo;
|
}
|
|
private PageResult<TradeForeignOrderRespVO> buildPage(PageResult<TradeForeignOrderDO> pageResult) {
|
if (CollUtil.isEmpty(pageResult.getList())) {
|
return PageResult.empty(pageResult.getTotal());
|
}
|
Set<Long> orderIds = convertSet(pageResult.getList(), TradeForeignOrderDO::getId);
|
List<TradeForeignOrderItemDO> items = orderService.getOrderItemListByOrderIds(orderIds);
|
Map<Long, List<TradeForeignOrderItemDO>> itemMap = convertMultiMap(items, TradeForeignOrderItemDO::getOrderId);
|
Map<Long, MdmItemRespDTO> mdmItemMap = mdmItemApi.getItemMap(convertSet(items, TradeForeignOrderItemDO::getItemId));
|
Map<Long, MdmUnitMeasureRespDTO> unitMap = buildUnitMap(items, mdmItemMap);
|
Map<Long, CrmCustomerRespDTO> customerMap = customerApi.getCustomerMap(
|
convertSet(pageResult.getList(), TradeForeignOrderDO::getCustomerId));
|
Set<Long> userIds = new HashSet<>(convertSet(pageResult.getList(), TradeForeignOrderDO::getSaleUserId));
|
Map<Long, AdminUserRespDTO> userMap = adminUserApi.getUserMap(userIds);
|
Map<Long, BigDecimal> receivedMap = buildReceivedMap(orderIds);
|
Map<Long, java.util.List<String>> missingMap = documentService.getMissingRequiredDocNamesByOrderIds(orderIds);
|
return BeanUtils.toBean(pageResult, TradeForeignOrderRespVO.class, vo -> {
|
vo.setStatusName(TradeForeignOrderStatusEnum.getNameByStatus(vo.getStatus()));
|
vo.setDeliveryModeName(TradeForeignDeliveryModeEnum.getNameByMode(vo.getDeliveryMode()));
|
MapUtils.findAndThen(customerMap, vo.getCustomerId(), c -> vo.setCustomerName(c.getName()));
|
MapUtils.findAndThen(userMap, vo.getSaleUserId(), u -> vo.setSaleUserName(u.getNickname()));
|
vo.setItems(convertItems(itemMap.get(vo.getId()), mdmItemMap, unitMap));
|
BigDecimal received = receivedMap.getOrDefault(vo.getId(), BigDecimal.ZERO);
|
vo.setReceivedForeignAmount(received);
|
vo.setUnreceivedForeignAmount(clampUnreceived(vo.getTotalForeignPrice(), received));
|
java.util.List<String> missingDocs = missingMap.getOrDefault(vo.getId(), Collections.emptyList());
|
vo.setMissingDocs(missingDocs);
|
vo.setMissingDocCount(missingDocs.size());
|
});
|
}
|
|
private void fillForeignReceive(TradeForeignOrderRespVO vo, Collection<Long> orderIds) {
|
BigDecimal received = buildReceivedMap(orderIds).getOrDefault(vo.getId(), BigDecimal.ZERO);
|
vo.setReceivedForeignAmount(received);
|
vo.setUnreceivedForeignAmount(clampUnreceived(vo.getTotalForeignPrice(), received));
|
}
|
|
/** 填充缺失的必填单据信息(按出货模式,全部必填口径) */
|
private void fillMissingDocs(TradeForeignOrderRespVO vo) {
|
List<String> missingDocs = documentService.getMissingRequiredDocNames(vo.getId(), false);
|
vo.setMissingDocs(missingDocs);
|
vo.setMissingDocCount(missingDocs.size());
|
}
|
|
private Map<Long, BigDecimal> buildReceivedMap(Collection<Long> orderIds) {
|
Map<Long, BigDecimal> result = new HashMap<>();
|
for (TradeForeignReceiveDO r : orderIds.isEmpty() ? Collections.<TradeForeignReceiveDO>emptyList() : nullSafeReceives(orderIds)) {
|
if (r.getOrderId() == null) {
|
continue;
|
}
|
result.merge(r.getOrderId(), r.getForeignAmount() == null ? BigDecimal.ZERO : r.getForeignAmount(), BigDecimal::add);
|
}
|
return result;
|
}
|
|
private List<TradeForeignReceiveDO> nullSafeReceives(Collection<Long> orderIds) {
|
List<TradeForeignReceiveDO> list = new ArrayList<>();
|
for (Long id : orderIds) {
|
list.addAll(orderService.getReceiveListByOrderId(id));
|
}
|
return list;
|
}
|
|
private BigDecimal clampUnreceived(BigDecimal total, BigDecimal received) {
|
BigDecimal t = total == null ? BigDecimal.ZERO : total;
|
BigDecimal u = t.subtract(received);
|
return u.compareTo(BigDecimal.ZERO) < 0 ? BigDecimal.ZERO : u;
|
}
|
|
private List<TradeForeignOrderRespVO.Item> convertItems(List<TradeForeignOrderItemDO> items) {
|
if (CollUtil.isEmpty(items)) {
|
return Collections.emptyList();
|
}
|
Map<Long, MdmItemRespDTO> mdmItemMap = mdmItemApi.getItemMap(convertSet(items, TradeForeignOrderItemDO::getItemId));
|
return convertItems(items, mdmItemMap, buildUnitMap(items, mdmItemMap));
|
}
|
|
private Map<Long, MdmUnitMeasureRespDTO> buildUnitMap(List<TradeForeignOrderItemDO> items, Map<Long, MdmItemRespDTO> mdmItemMap) {
|
Set<Long> unitIds = new HashSet<>(convertSet(items, TradeForeignOrderItemDO::getItemUnitId));
|
mdmItemMap.values().forEach(i -> {
|
if (i.getUnitMeasureId2() != null) {
|
unitIds.add(i.getUnitMeasureId2());
|
}
|
});
|
return convertMap(mdmUnitMeasureApi.getUnitMeasureList(unitIds).getCheckedData(), MdmUnitMeasureRespDTO::getId);
|
}
|
|
private List<TradeForeignOrderRespVO.Item> convertItems(List<TradeForeignOrderItemDO> items,
|
Map<Long, MdmItemRespDTO> mdmItemMap,
|
Map<Long, MdmUnitMeasureRespDTO> unitMap) {
|
if (CollUtil.isEmpty(items)) {
|
return Collections.emptyList();
|
}
|
return BeanUtils.toBean(items, TradeForeignOrderRespVO.Item.class, item -> {
|
MdmItemRespDTO mdmItem = mdmItemMap.get(item.getItemId());
|
if (mdmItem != null) {
|
item.setItemCode(mdmItem.getCode());
|
item.setItemName(mdmItem.getName());
|
item.setItemSpecification(mdmItem.getSpecification());
|
}
|
MapUtils.findAndThen(unitMap, item.getItemUnitId(), unit -> item.setItemUnitName(unit.getName()));
|
});
|
}
|
|
}
|