shuolol/asinkj
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

7月新需求修改

Browse Source
This commit is contained in:
dev 2025-08-04 17:18:52 +08:00
parent d9ef46cfa5
commit 4bff366471
53 changed files with 3179 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/controller/BizOrderOutItemController.java Normal file
View File

@ -0,0 +1,106 @@
package org.asinkj.amz.controller;
import java.util.List;
import lombok.RequiredArgsConstructor;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import org.asinkj.common.idempotent.annotation.RepeatSubmit;
import org.asinkj.common.log.annotation.Log;
import org.asinkj.common.web.core.BaseController;
import org.asinkj.common.mybatis.core.page.PageQuery;
import org.asinkj.common.core.domain.R;
import org.asinkj.common.core.validate.AddGroup;
import org.asinkj.common.core.validate.EditGroup;
import org.asinkj.common.log.enums.BusinessType;
import org.asinkj.common.excel.utils.ExcelUtil;
import org.asinkj.amz.domain.vo.BizOrderOutItemVo;
import org.asinkj.amz.domain.bo.BizOrderOutItemBo;
import org.asinkj.amz.service.IBizOrderOutItemService;
import org.asinkj.common.mybatis.core.page.TableDataInfo;
/**
* 采购订单明细
* 前端访问路由地址为:/amz/orderOutItem
*
* @author shuo hu
* @date 2025-07-22
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/orderOutItem")
public class BizOrderOutItemController extends BaseController {
private final IBizOrderOutItemService bizOrderOutItemService;
/**
* 查询采购订单明细列表
*/
@SaCheckPermission("amz:orderOutItem:list")
@GetMapping("/list")
public TableDataInfo<BizOrderOutItemVo> list(BizOrderOutItemBo bo, PageQuery pageQuery) {
return bizOrderOutItemService.queryPageList(bo, pageQuery);
}
/**
* 导出采购订单明细列表
*/
@SaCheckPermission("amz:orderOutItem:export")
@Log(title = "采购订单明细", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(BizOrderOutItemBo bo, HttpServletResponse response) {
List<BizOrderOutItemVo> list = bizOrderOutItemService.queryList(bo);
ExcelUtil.exportExcel(list, "采购订单明细", BizOrderOutItemVo.class, response);
}
/**
* 获取采购订单明细详细信息
*
* @param tenantId 主键
*/
@SaCheckPermission("amz:orderOutItem:query")
@GetMapping("/{tenantId}")
public R<BizOrderOutItemVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable String tenantId) {
return R.ok(bizOrderOutItemService.queryById(tenantId));
}
/**
* 新增采购订单明细
*/
@SaCheckPermission("amz:orderOutItem:add")
@Log(title = "采购订单明细", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody BizOrderOutItemBo bo) {
return toAjax(bizOrderOutItemService.insertByBo(bo));
}
/**
* 修改采购订单明细
*/
@SaCheckPermission("amz:orderOutItem:edit")
@Log(title = "采购订单明细", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody BizOrderOutItemBo bo) {
return toAjax(bizOrderOutItemService.updateByBo(bo));
}
/**
* 删除采购订单明细
*
* @param tenantIds 主键串
*/
@SaCheckPermission("amz:orderOutItem:remove")
@Log(title = "采购订单明细", businessType = BusinessType.DELETE)
@DeleteMapping("/{tenantIds}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable String[] tenantIds) {
return toAjax(bizOrderOutItemService.deleteWithValidByIds(List.of(tenantIds), true));
}
}

106
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/controller/BizPackingSpecsController.java Normal file
View File

@ -0,0 +1,106 @@
package org.asinkj.amz.controller;
import java.util.List;
import lombok.RequiredArgsConstructor;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import org.asinkj.common.idempotent.annotation.RepeatSubmit;
import org.asinkj.common.log.annotation.Log;
import org.asinkj.common.web.core.BaseController;
import org.asinkj.common.mybatis.core.page.PageQuery;
import org.asinkj.common.core.domain.R;
import org.asinkj.common.core.validate.AddGroup;
import org.asinkj.common.core.validate.EditGroup;
import org.asinkj.common.log.enums.BusinessType;
import org.asinkj.common.excel.utils.ExcelUtil;
import org.asinkj.amz.domain.vo.BizPackingSpecsVo;
import org.asinkj.amz.domain.bo.BizPackingSpecsBo;
import org.asinkj.amz.service.IBizPackingSpecsService;
import org.asinkj.common.mybatis.core.page.TableDataInfo;
/**
* 产品装箱规格
* 前端访问路由地址为:/amz/packingSpecs
*
* @author shuo hu
* @date 2025-07-17
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/packingSpecs")
public class BizPackingSpecsController extends BaseController {
private final IBizPackingSpecsService bizPackingSpecsService;
/**
* 查询产品装箱规格列表
*/
@SaCheckPermission("amz:packingSpecs:list")
@GetMapping("/list")
public TableDataInfo<BizPackingSpecsVo> list(BizPackingSpecsBo bo, PageQuery pageQuery) {
return bizPackingSpecsService.queryPageList(bo, pageQuery);
}
/**
* 导出产品装箱规格列表
*/
@SaCheckPermission("amz:packingSpecs:export")
@Log(title = "产品装箱规格", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(BizPackingSpecsBo bo, HttpServletResponse response) {
List<BizPackingSpecsVo> list = bizPackingSpecsService.queryList(bo);
ExcelUtil.exportExcel(list, "产品装箱规格", BizPackingSpecsVo.class, response);
}
/**
* 获取产品装箱规格详细信息
*
* @param id 主键
*/
@SaCheckPermission("amz:packingSpecs:query")
@GetMapping("/{id}")
public R<BizPackingSpecsVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(bizPackingSpecsService.queryById(id));
}
/**
* 新增产品装箱规格
*/
@SaCheckPermission("amz:packingSpecs:add")
@Log(title = "产品装箱规格", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody BizPackingSpecsBo bo) {
return toAjax(bizPackingSpecsService.insertByBo(bo));
}
/**
* 修改产品装箱规格
*/
@SaCheckPermission("amz:packingSpecs:edit")
@Log(title = "产品装箱规格", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody BizPackingSpecsBo bo) {
return toAjax(bizPackingSpecsService.updateByBo(bo));
}
/**
* 删除产品装箱规格
*
* @param ids 主键串
*/
@SaCheckPermission("amz:packingSpecs:remove")
@Log(title = "产品装箱规格", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(bizPackingSpecsService.deleteWithValidByIds(List.of(ids), true));
}
}

122
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/controller/BizPurchaseOutOrderController.java Normal file
View File

@ -0,0 +1,122 @@
package org.asinkj.amz.controller;
import java.util.List;
import lombok.RequiredArgsConstructor;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import org.asinkj.common.idempotent.annotation.RepeatSubmit;
import org.asinkj.common.log.annotation.Log;
import org.asinkj.common.web.core.BaseController;
import org.asinkj.common.mybatis.core.page.PageQuery;
import org.asinkj.common.core.domain.R;
import org.asinkj.common.core.validate.AddGroup;
import org.asinkj.common.core.validate.EditGroup;
import org.asinkj.common.log.enums.BusinessType;
import org.asinkj.common.excel.utils.ExcelUtil;
import org.asinkj.amz.domain.vo.BizPurchaseOutOrderVo;
import org.asinkj.amz.domain.bo.BizPurchaseOutOrderBo;
import org.asinkj.amz.service.IBizPurchaseOutOrderService;
import org.asinkj.common.mybatis.core.page.TableDataInfo;
/**
* 组合订单
* 前端访问路由地址为:/amz/purchaseOutOrder
*
* @author shuo hu
* @date 2025-07-22
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/purchaseOutOrder")
public class BizPurchaseOutOrderController extends BaseController {
private final IBizPurchaseOutOrderService bizPurchaseOutOrderService;
/**
* 查询组合订单列表
*/
@SaCheckPermission("amz:purchaseOutOrder:list")
@GetMapping("/list")
public TableDataInfo<BizPurchaseOutOrderVo> list(BizPurchaseOutOrderBo bo, PageQuery pageQuery) {
return bizPurchaseOutOrderService.queryPageList(bo, pageQuery);
}
/**
* 导出组合订单列表
*/
@SaCheckPermission("amz:purchaseOutOrder:export")
@Log(title = "组合订单", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(BizPurchaseOutOrderBo bo, HttpServletResponse response) {
List<BizPurchaseOutOrderVo> list = bizPurchaseOutOrderService.queryList(bo);
ExcelUtil.exportExcel(list, "组合订单", BizPurchaseOutOrderVo.class, response);
}
/**
* 获取组合订单详细信息
*
* @param tenantId 主键
*/
@SaCheckPermission("amz:purchaseOutOrder:query")
@GetMapping("/{tenantId}")
public R<BizPurchaseOutOrderVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable String tenantId) {
return R.ok(bizPurchaseOutOrderService.queryByPurchaseId(tenantId));
}
/**
* 新增组合订单
*/
@SaCheckPermission("amz:purchaseOutOrder:add")
@Log(title = "组合订单", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody BizPurchaseOutOrderBo bo) {
return toAjax(bizPurchaseOutOrderService.insertByBo(bo));
}
/**
* 修改组合订单
*/
@SaCheckPermission("amz:purchaseOutOrder:edit")
@Log(title = "组合订单", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody BizPurchaseOutOrderBo bo) {
return toAjax(bizPurchaseOutOrderService.updateByBo(bo));
}
/**
* 删除组合订单
*
* @param tenantIds 主键串
*/
@SaCheckPermission("amz:purchaseOutOrder:remove")
@Log(title = "组合订单", businessType = BusinessType.DELETE)
@DeleteMapping("/{tenantIds}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable String[] tenantIds) {
return toAjax(bizPurchaseOutOrderService.deleteWithValidByIds(List.of(tenantIds), true));
}
@SaCheckPermission("amz:purchaseOutOrder:edit")
@Log(title = "创建发货订单", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PostMapping("submit")
public R<Void> submit(@Validated(EditGroup.class) @RequestBody BizPurchaseOutOrderBo bo) {
bizPurchaseOutOrderService.createSendOrderByBo(bo);
return R.ok();
}
}

11
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/controller/BizSendOrderController.java
View File

@ -74,7 +74,7 @@ public class BizSendOrderController extends BaseController {
/**
* 新增供应商创建的发货单
*/
@SaCheckRole(value = {"gongying", "superadmin"}, mode = SaMode.OR)
@SaCheckRole(value = {"gongying", "superadmin", "gengdan"}, mode = SaMode.OR)
@Log(title = "供应商创建的发货单", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
@ -94,6 +94,15 @@ public class BizSendOrderController extends BaseController {
}
@SaCheckRole(value = {"gongying", "gengdan", "superadmin", "yunying"}, mode = SaMode.OR)
@Log(title = "供应商创建的发货单", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PostMapping("/data")
public R<Void> setData(@Validated(EditGroup.class) @RequestBody BizSendOrderBo bo) {
return toAjax(bizSendOrderService.updateDataByBo(bo));
}
@SaCheckRole(value = {"gongying", "gengdan", "superadmin"}, mode = SaMode.OR)
@Log(title = "供应商创建的发货单", businessType = BusinessType.UPDATE)
@RepeatSubmit()

106
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/controller/BizSendOrderItemController.java Normal file
View File

@ -0,0 +1,106 @@
package org.asinkj.amz.controller;
import java.util.List;
import lombok.RequiredArgsConstructor;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.validation.constraints.*;
import cn.dev33.satoken.annotation.SaCheckPermission;
import org.springframework.web.bind.annotation.*;
import org.springframework.validation.annotation.Validated;
import org.asinkj.common.idempotent.annotation.RepeatSubmit;
import org.asinkj.common.log.annotation.Log;
import org.asinkj.common.web.core.BaseController;
import org.asinkj.common.mybatis.core.page.PageQuery;
import org.asinkj.common.core.domain.R;
import org.asinkj.common.core.validate.AddGroup;
import org.asinkj.common.core.validate.EditGroup;
import org.asinkj.common.log.enums.BusinessType;
import org.asinkj.common.excel.utils.ExcelUtil;
import org.asinkj.amz.domain.vo.BizSendOrderItemVo;
import org.asinkj.amz.domain.bo.BizSendOrderItemBo;
import org.asinkj.amz.service.IBizSendOrderItemService;
import org.asinkj.common.mybatis.core.page.TableDataInfo;
/**
* 供应商创建的发货单明细
* 前端访问路由地址为:/amz/sendOrderItem
*
* @author shuo hu
* @date 2025-07-24
*/
@Validated
@RequiredArgsConstructor
@RestController
@RequestMapping("/sendOrderItem")
public class BizSendOrderItemController extends BaseController {
private final IBizSendOrderItemService bizSendOrderItemService;
/**
* 查询供应商创建的发货单明细列表
*/
@SaCheckPermission("amz:sendOrderItem:list")
@GetMapping("/list")
public TableDataInfo<BizSendOrderItemVo> list(BizSendOrderItemBo bo, PageQuery pageQuery) {
return bizSendOrderItemService.queryPageList(bo, pageQuery);
}
/**
* 导出供应商创建的发货单明细列表
*/
@SaCheckPermission("amz:sendOrderItem:export")
@Log(title = "供应商创建的发货单明细", businessType = BusinessType.EXPORT)
@PostMapping("/export")
public void export(BizSendOrderItemBo bo, HttpServletResponse response) {
List<BizSendOrderItemVo> list = bizSendOrderItemService.queryList(bo);
ExcelUtil.exportExcel(list, "供应商创建的发货单明细", BizSendOrderItemVo.class, response);
}
/**
* 获取供应商创建的发货单明细详细信息
*
* @param id 主键
*/
@SaCheckPermission("amz:sendOrderItem:query")
@GetMapping("/{id}")
public R<BizSendOrderItemVo> getInfo(@NotNull(message = "主键不能为空")
@PathVariable Long id) {
return R.ok(bizSendOrderItemService.queryById(id));
}
/**
* 新增供应商创建的发货单明细
*/
@SaCheckPermission("amz:sendOrderItem:add")
@Log(title = "供应商创建的发货单明细", businessType = BusinessType.INSERT)
@RepeatSubmit()
@PostMapping()
public R<Void> add(@Validated(AddGroup.class) @RequestBody BizSendOrderItemBo bo) {
return toAjax(bizSendOrderItemService.insertByBo(bo));
}
/**
* 修改供应商创建的发货单明细
*/
@SaCheckPermission("amz:sendOrderItem:edit")
@Log(title = "供应商创建的发货单明细", businessType = BusinessType.UPDATE)
@RepeatSubmit()
@PutMapping()
public R<Void> edit(@Validated(EditGroup.class) @RequestBody BizSendOrderItemBo bo) {
return toAjax(bizSendOrderItemService.updateByBo(bo));
}
/**
* 删除供应商创建的发货单明细
*
* @param ids 主键串
*/
@SaCheckPermission("amz:sendOrderItem:remove")
@Log(title = "供应商创建的发货单明细", businessType = BusinessType.DELETE)
@DeleteMapping("/{ids}")
public R<Void> remove(@NotEmpty(message = "主键不能为空")
@PathVariable Long[] ids) {
return toAjax(bizSendOrderItemService.deleteWithValidByIds(List.of(ids), true));
}
}

22
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/controller/SysAmazonStoreController.java
View File

@ -186,6 +186,28 @@ public class SysAmazonStoreController extends BaseController {
return R.ok();
}
/**
* 获取委外组合订单
* @param startDate
* @param endDate
* @return
*/
@GetMapping("/purchaseOrderOut/{startDate}/{endDate}")
public R<Void> updatePurchaseOrderOutSeller(@PathVariable String startDate, @PathVariable String endDate) {
try {
sysAmazonStoreService.pullPurchaseOutOrderData(startDate, endDate, new LingxinCallback() {
@Override
public void onFinished(String result, int status) {
}
});
} catch (Exception e) {
throw new RuntimeException(e);
}
return R.ok();
}
@SaCheckPermission("amz:amazonStore:remove")
@Log(title = "亚马逊FBAtest", businessType = BusinessType.OTHER)
@GetMapping("/test")

100
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/BizOrderOutItem.java Normal file
View File

@ -0,0 +1,100 @@
package org.asinkj.amz.domain;
import io.github.linpeilie.annotations.AutoMapper;
import io.github.linpeilie.annotations.AutoMapping;
import org.asinkj.common.tenant.core.TenantEntity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serial;
/**
* 采购订单明细对象 biz_order_out_item
*
* @author shuo hu
* @date 2025-07-22
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("biz_order_out_item")
public class BizOrderOutItem extends TenantEntity {
@Serial
private static final long serialVersionUID = 1L;
private String purchaseOrderSn;
/**
* 删除标志（0正常 2删除）
*/
@TableLogic
private String delFlag;
/**
* 明细项自增主键
*/
@TableId(value = "item_id", type = IdType.ASSIGN_ID)
private Long itemId;
/**
* 关联采购订单号 (外键)
*/
private String outOrderSn;
/**
* 产品名称
*/
private String productName;
/**
* SKU编码
*/
private String sku;
/**
* 采购需求数量
*/
private Long quantityRequire;
/**
* 业务创建时间 (Jackson格式: yyyy-MM-dd HH:mm:ss)
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@AutoMapping(dateFormat = "yyyy-MM-dd HH:mm:ss")
private Date bizCreateTime;
/**
* 创建人姓名
*/
private String createRealname;
/**
* 预计到达时间
*/
private String expectArriveTime;
/**
* 仓库名称
*/
private String warehouseName;
/**
* 供应商名称
*/
private String supplierName;
/**
* 实际到货数量
*/
private Long quantityReal;
/**
* 已入库数量
*/
private Long quantityEntry;
}

76
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/BizPackingSpecs.java Normal file
View File

@ -0,0 +1,76 @@
package org.asinkj.amz.domain;
import org.asinkj.common.tenant.core.TenantEntity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.io.Serial;
/**
* 产品装箱规格对象 biz_packing_specs
*
* @author shuo hu
* @date 2025-07-17
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("biz_packing_specs")
public class BizPackingSpecs extends TenantEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 规格ID（主键）
*/
private Long id;
/**
* 关联采购单明细项ID
*/
private Long sendOrderId;
/**
* 规格名称（如规格A）
*/
private String specName;
/**
* 箱数（单位：箱）
*/
private Long cartonCount;
/**
* 每箱件数（单位：件）
*/
private Long piecesPerCarton;
/**
* 箱子长度（单位：厘米）
*/
private Long length;
/**
* 箱子宽度（单位：厘米）
*/
private Long width;
/**
* 箱子高度（单位：厘米）
*/
private Long height;
/**
* 单箱重量（单位：千克）
*/
private Long weight;
/**
* 删除标志（0正常 2删除）
*/
@TableLogic
private String delFlag;
}

4
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/BizPurchaseOrder.java
View File

@ -297,8 +297,6 @@ public class BizPurchaseOrder extends TenantEntity {
private String storeName;
private String type;
}

10
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/BizPurchaseOrderItem.java
View File

@ -128,6 +128,9 @@ public class BizPurchaseOrderItem extends TenantEntity {
*/
private Long quantityQc;
/**
* 待质检量
*/
@ -190,14 +193,7 @@ public class BizPurchaseOrderItem extends TenantEntity {
private Long sfgAvlQty;
private String orderStatus;
@TableField(exist = false)
private List<SysStatusHistory> sysStatusHistories;
@TableField(exist = false)
private String hasForward = "N";
@TableField(exist = false)
private String hasSendOrder = "N";
}

121
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/BizPurchaseOutOrder.java Normal file
View File

@ -0,0 +1,121 @@
package org.asinkj.amz.domain;
import io.github.linpeilie.annotations.AutoMapping;
import org.asinkj.common.tenant.core.TenantEntity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serial;
/**
* 组合订单对象 biz_purchase_out_order
*
* @author shuo hu
* @date 2025-07-22
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("biz_purchase_out_order")
public class BizPurchaseOutOrder extends TenantEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 删除标志（0正常 2删除）
*/
@TableLogic
private String delFlag;
/**
* 订单唯一编号
*/
private String orderSn;
/**
* 仓库名称
*/
private String warehouseName;
/**
* 外包仓库名称
*/
private String outsourceWarehouseName;
/**
* 供应商名称
*/
private String supplierName;
/**
* 业务创建时间 (Jackson格式: yyyy-MM-dd HH:mm:ss)
*/
@JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@AutoMapping(dateFormat = "yyyy-MM-dd HH:mm:ss")
private Date bizCreateTime;
/**
* 状态文本描述
*/
private String statusText;
/**
* 创建人姓名
*/
private String createRealname;
/**
* PTP流水号
*/
private String ptpSn;
/**
* 产品名称
*/
private String productName;
/**
* 标准SKU编码
*/
private String sku;
/**
* FNSKU编码
*/
private String fnsku;
/**
* 外包数量
*/
private Long outsourceQuantity;
/**
* 实收数量
*/
private Long receiveQuantity;
/**
* 预计到达时间
*/
private String expectArriveTime;
/**
* MSKU编码列表 (数组存储)
*/
private String msku;
/**
* 关联计划单号列表 (数组存储)
*/
private String planSn;
/**
* 销售商名称
*/
private String sellerName;
}

3
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/BizSendOrder.java
View File

@ -112,5 +112,8 @@ public class BizSendOrder extends TenantEntity {
@TableField(exist = false)
private String shipmentIdKey;
private String type;
private String createName;
}

66
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/BizSendOrderItem.java Normal file
View File

@ -0,0 +1,66 @@
package org.asinkj.amz.domain;
import org.asinkj.common.tenant.core.TenantEntity;
import com.baomidou.mybatisplus.annotation.*;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import java.io.Serial;
/**
* 供应商创建的发货单明细对象 biz_send_order_item
*
* @author shuo hu
* @date 2025-07-24
*/
@Data
@EqualsAndHashCode(callSuper = true)
@TableName("biz_send_order_item")
public class BizSendOrderItem extends TenantEntity {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
private Long id;
/**
* 删除标志（0正常 2删除）
*/
@TableLogic
private String delFlag;
/**
* 采购单号
*/
private String orderSn;
/**
* 发货日期
*/
private Date sendDate;
/**
* 发货日期
*/
private String storeName;
/**
* 发货日期
*/
private String productName;
private String sku;
/**
* 发货日期
*/
private Long quantitySend;
private Long mainOrderSn;
}

3
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/BizShipmentPlan.java
View File

@ -191,5 +191,8 @@ public class BizShipmentPlan extends TenantEntity {
private String address;
private Long itemCount;
}

101
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/bo/BizOrderOutItemBo.java Normal file
View File

@ -0,0 +1,101 @@
package org.asinkj.amz.domain.bo;
import org.asinkj.amz.domain.BizOrderOutItem;
import org.asinkj.common.mybatis.core.domain.BaseEntity;
import org.asinkj.common.core.validate.AddGroup;
import org.asinkj.common.core.validate.EditGroup;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
* 采购订单明细业务对象 biz_order_out_item
*
* @author shuo hu
* @date 2025-07-22
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = BizOrderOutItem.class, reverseConvertGenerate = false)
public class BizOrderOutItemBo extends BaseEntity {
private String purchaseOrderSn;
/**
* 明细项自增主键
*/
@NotNull(message = "明细项自增主键不能为空", groups = { AddGroup.class, EditGroup.class })
private Long itemId;
/**
* 关联采购订单号 (外键)
*/
@NotBlank(message = "关联采购订单号 (外键)不能为空", groups = { AddGroup.class, EditGroup.class })
private String outOrderSn;
/**
* 产品名称
*/
@NotBlank(message = "产品名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String productName;
/**
* SKU编码
*/
@NotBlank(message = "SKU编码不能为空", groups = { AddGroup.class, EditGroup.class })
private String sku;
/**
* 采购需求数量
*/
@NotNull(message = "采购需求数量不能为空", groups = { AddGroup.class, EditGroup.class })
private Long quantityRequire;
/**
* 业务创建时间 (Jackson格式: yyyy-MM-dd HH:mm:ss)
*/
@NotNull(message = "业务创建时间 (Jackson格式: yyyy-MM-dd HH:mm:ss)不能为空", groups = { AddGroup.class, EditGroup.class })
private Date bizCreateTime;
/**
* 创建人姓名
*/
@NotBlank(message = "创建人姓名不能为空", groups = { AddGroup.class, EditGroup.class })
private String createRealname;
/**
* 预计到达时间
*/
@NotBlank(message = "预计到达时间不能为空", groups = { AddGroup.class, EditGroup.class })
private String expectArriveTime;
/**
* 仓库名称
*/
@NotBlank(message = "仓库名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String warehouseName;
/**
* 供应商名称
*/
@NotBlank(message = "供应商名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String supplierName;
/**
* 实际到货数量
*/
@NotNull(message = "实际到货数量不能为空", groups = { AddGroup.class, EditGroup.class })
private Long quantityReal;
/**
* 已入库数量
*/
@NotNull(message = "已入库数量不能为空", groups = { AddGroup.class, EditGroup.class })
private Long quantityEntry;
}

78
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/bo/BizPackingSpecsBo.java Normal file
View File

@ -0,0 +1,78 @@
package org.asinkj.amz.domain.bo;
import org.asinkj.amz.domain.BizPackingSpecs;
import org.asinkj.common.mybatis.core.domain.BaseEntity;
import org.asinkj.common.core.validate.AddGroup;
import org.asinkj.common.core.validate.EditGroup;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
/**
* 产品装箱规格业务对象 biz_packing_specs
*
* @author shuo hu
* @date 2025-07-17
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = BizPackingSpecs.class, reverseConvertGenerate = false)
public class BizPackingSpecsBo extends BaseEntity {
/**
* 规格ID（主键）
*/
@NotNull(message = "规格ID（主键）不能为空", groups = { AddGroup.class, EditGroup.class })
private Long id;
/**
* 关联采购单明细项ID
*/
@NotNull(message = "关联采购单明细项ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long sendOrderId;
/**
* 规格名称（如规格A）
*/
@NotBlank(message = "规格名称（如规格A）不能为空", groups = { AddGroup.class, EditGroup.class })
private String specName;
/**
* 箱数（单位：箱）
*/
@NotNull(message = "箱数（单位：箱）不能为空", groups = { AddGroup.class, EditGroup.class })
private Long cartonCount;
/**
* 每箱件数（单位：件）
*/
@NotNull(message = "每箱件数（单位：件）不能为空", groups = { AddGroup.class, EditGroup.class })
private Long piecesPerCarton;
/**
* 箱子长度（单位：厘米）
*/
@NotNull(message = "箱子长度（单位：厘米）不能为空", groups = { AddGroup.class, EditGroup.class })
private Long length;
/**
* 箱子宽度（单位：厘米）
*/
@NotNull(message = "箱子宽度（单位：厘米）不能为空", groups = { AddGroup.class, EditGroup.class })
private Long width;
/**
* 箱子高度（单位：厘米）
*/
@NotNull(message = "箱子高度（单位：厘米）不能为空", groups = { AddGroup.class, EditGroup.class })
private Long height;
/**
* 单箱重量（单位：千克）
*/
@NotNull(message = "单箱重量（单位：千克）不能为空", groups = { AddGroup.class, EditGroup.class })
private Long weight;
}

134
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/bo/BizPurchaseOutOrderBo.java Normal file
View File

@ -0,0 +1,134 @@
package org.asinkj.amz.domain.bo;
import org.asinkj.amz.domain.BizPurchaseOutOrder;
import org.asinkj.amz.domain.vo.BizOrderOutItemVo;
import org.asinkj.common.mybatis.core.domain.BaseEntity;
import org.asinkj.common.core.validate.AddGroup;
import org.asinkj.common.core.validate.EditGroup;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
import java.util.Date;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
* 组合订单业务对象 biz_purchase_out_order
*
* @author shuo hu
* @date 2025-07-22
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = BizPurchaseOutOrder.class, reverseConvertGenerate = false)
public class BizPurchaseOutOrderBo extends BaseEntity {
/**
* 订单唯一编号
*/
@NotBlank(message = "订单唯一编号不能为空", groups = { AddGroup.class, EditGroup.class })
private String orderSn;
/**
* 仓库名称
*/
@NotBlank(message = "仓库名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String warehouseName;
/**
* 外包仓库名称
*/
@NotBlank(message = "外包仓库名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String outsourceWarehouseName;
/**
* 供应商名称
*/
@NotBlank(message = "供应商名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String supplierName;
/**
* 业务创建时间 (Jackson格式: yyyy-MM-dd HH:mm:ss)
*/
@NotNull(message = "业务创建时间 (Jackson格式: yyyy-MM-dd HH:mm:ss)不能为空", groups = { AddGroup.class, EditGroup.class })
private Date bizCreateTime;
/**
* 状态文本描述
*/
@NotBlank(message = "状态文本描述不能为空", groups = { AddGroup.class, EditGroup.class })
private String statusText;
/**
* 创建人姓名
*/
@NotBlank(message = "创建人姓名不能为空", groups = { AddGroup.class, EditGroup.class })
private String createRealname;
/**
* PTP流水号
*/
// @NotBlank(message = "PTP流水号不能为空", groups = { AddGroup.class, EditGroup.class })
private String ptpSn;
/**
* 产品名称
*/
@NotBlank(message = "产品名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String productName;
/**
* 标准SKU编码
*/
// @NotBlank(message = "标准SKU编码不能为空", groups = { AddGroup.class, EditGroup.class })
private String sku;
/**
* FNSKU编码
*/
// @NotBlank(message = "FNSKU编码不能为空", groups = { AddGroup.class, EditGroup.class })
private String fnsku;
/**
* 外包数量
*/
@NotNull(message = "外包数量不能为空", groups = { AddGroup.class, EditGroup.class })
private Long outsourceQuantity;
/**
* 实收数量
*/
@NotNull(message = "实收数量不能为空", groups = { AddGroup.class, EditGroup.class })
private Long receiveQuantity;
/**
* 预计到达时间
*/
// @NotBlank(message = "预计到达时间不能为空", groups = { AddGroup.class, EditGroup.class })
private String expectArriveTime;
/**
* MSKU编码列表 (数组存储)
*/
// @NotBlank(message = "MSKU编码列表 (数组存储)不能为空", groups = { AddGroup.class, EditGroup.class })
private String msku;
/**
* 关联计划单号列表 (数组存储)
*/
// @NotBlank(message = "关联计划单号列表 (数组存储)不能为空", groups = { AddGroup.class, EditGroup.class })
private String planSn;
/**
* 销售商名称
*/
@NotBlank(message = "销售商名称不能为空", groups = { AddGroup.class, EditGroup.class })
private String sellerName;
private List<BizOrderOutItemVo> items;
}

13
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/bo/BizSendOrderBo.java
View File

@ -10,6 +10,7 @@ import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
import java.util.Date;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonFormat;
@ -57,6 +58,9 @@ public class BizSendOrderBo extends BaseEntity {
@NotBlank(message = "产品名称不能为空", groups = {AddGroup.class, EditGroup.class})
private String productName;
// @NotBlank(message = "sku不能为空", groups = {AddGroup.class, EditGroup.class})
private String sku;
/**
* 发货数量
*/
@ -72,19 +76,19 @@ public class BizSendOrderBo extends BaseEntity {
/**
* 箱数
*/
@NotNull(message = "箱数不能为空", groups = {AddGroup.class, EditGroup.class})
// @NotNull(message = "箱数不能为空", groups = {AddGroup.class, EditGroup.class})
private Long boxCount;
/**
* 箱子尺寸
*/
@NotBlank(message = "箱子尺寸不能为空", groups = {AddGroup.class, EditGroup.class})
// @NotBlank(message = "箱子尺寸不能为空", groups = {AddGroup.class, EditGroup.class})
private String boxDimensions;
/**
* 单箱重量
*/
@NotNull(message = "单箱重量不能为空", groups = {AddGroup.class, EditGroup.class})
// @NotNull(message = "单箱重量不能为空", groups = {AddGroup.class, EditGroup.class})
private Long weightPerBox;
/**
@ -113,5 +117,8 @@ public class BizSendOrderBo extends BaseEntity {
private String shipmentId;
private List<BizPackingSpecsBo> packingSpecsList;
private String createName;
}

65
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/bo/BizSendOrderItemBo.java Normal file
View File

@ -0,0 +1,65 @@
package org.asinkj.amz.domain.bo;
import org.asinkj.amz.domain.BizSendOrderItem;
import org.asinkj.common.mybatis.core.domain.BaseEntity;
import org.asinkj.common.core.validate.AddGroup;
import org.asinkj.common.core.validate.EditGroup;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import lombok.EqualsAndHashCode;
import jakarta.validation.constraints.*;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
/**
* 供应商创建的发货单明细业务对象 biz_send_order_item
*
* @author shuo hu
* @date 2025-07-24
*/
@Data
@EqualsAndHashCode(callSuper = true)
@AutoMapper(target = BizSendOrderItem.class, reverseConvertGenerate = false)
public class BizSendOrderItemBo extends BaseEntity {
/**
* 主键ID
*/
@NotNull(message = "主键ID不能为空", groups = { AddGroup.class, EditGroup.class })
private Long id;
/**
* 采购单号
*/
@NotBlank(message = "采购单号不能为空", groups = { AddGroup.class, EditGroup.class })
private String orderSn;
/**
* 发货日期
*/
@NotNull(message = "发货日期不能为空", groups = { AddGroup.class, EditGroup.class })
private Date sendDate;
/**
* 发货日期
*/
@NotBlank(message = "发货日期不能为空", groups = { AddGroup.class, EditGroup.class })
private String storeName;
/**
* 发货日期
*/
@NotBlank(message = "发货日期不能为空", groups = { AddGroup.class, EditGroup.class })
private String productName;
/**
* 发货日期
*/
@NotNull(message = "发货日期不能为空", groups = { AddGroup.class, EditGroup.class })
private Long quantitySend;
private String sku;
}

3
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/bo/BizShipmentPlanBo.java
View File

@ -183,6 +183,9 @@ public class BizShipmentPlanBo extends BaseEntity {
// @NotNull(message = "套数（系统中的申报量）不能为空", groups = { AddGroup.class, EditGroup.class })
private Long setTotal;
private Long itemCount;
/**
* 渠道ID
*/

135
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/vo/BizOrderOutItemVo.java Normal file
View File

@ -0,0 +1,135 @@
package org.asinkj.amz.domain.vo;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.asinkj.amz.domain.BizOrderOutItem;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import org.asinkj.amz.domain.BizPurchaseOrder;
import org.asinkj.amz.domain.BizPurchaseOrderItem;
import org.asinkj.amz.domain.BizShipForward;
import org.asinkj.common.excel.annotation.ExcelDictFormat;
import org.asinkj.common.excel.convert.ExcelDictConvert;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
* 采购订单明细视图对象 biz_order_out_item
*
* @author shuo hu
* @date 2025-07-22
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = BizOrderOutItem.class)
public class BizOrderOutItemVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
@ExcelProperty(value = "采购订单号")
private String purchaseOrderSn;
/**
* 明细项自增主键
*/
@ExcelProperty(value = "明细项自增主键")
private Long itemId;
@ExcelProperty(value = "比例")
private BigDecimal ratio;
/**
* 关联采购订单号 (外键)
*/
@ExcelProperty(value = "关联采购订单号 (外键)")
private String outOrderSn;
/**
* 产品名称
*/
@ExcelProperty(value = "产品名称")
private String productName;
/**
* SKU编码
*/
@ExcelProperty(value = "SKU编码")
private String sku;
/**
* 采购需求数量
*/
@ExcelProperty(value = "采购需求数量")
private Long quantityRequire;
/**
* 业务创建时间 (Jackson格式: yyyy-MM-dd HH:mm:ss)
*/
@ExcelProperty(value = "业务创建时间 (Jackson格式: yyyy-MM-dd HH:mm:ss)")
private Date bizCreateTime;
/**
* 创建人姓名
*/
@ExcelProperty(value = "创建人姓名")
private String createRealname;
/**
* 预计到达时间
*/
@ExcelProperty(value = "预计到达时间")
private String expectArriveTime;
/**
* 仓库名称
*/
@ExcelProperty(value = "仓库名称")
private String warehouseName;
/**
* 供应商名称
*/
@ExcelProperty(value = "供应商名称")
private String supplierName;
/**
* 实际到货数量
*/
@ExcelProperty(value = "实际到货数量")
private Long quantityReal;
/**
* 已入库数量
*/
@ExcelProperty(value = "已入库数量")
private Long quantityEntry;
/**
* 已发货数量
*/
private Long quantityShipped;
/**
* 剩余数量
*/
private Long quantityLeft;
private BizPurchaseOrder order;
private BizPurchaseOrderItem item;
private List<BizShipForward> forwards;
}

94
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/vo/BizPackingSpecsVo.java Normal file
View File

@ -0,0 +1,94 @@
package org.asinkj.amz.domain.vo;
import org.asinkj.amz.domain.BizPackingSpecs;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import org.asinkj.common.excel.annotation.ExcelDictFormat;
import org.asinkj.common.excel.convert.ExcelDictConvert;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 产品装箱规格视图对象 biz_packing_specs
*
* @author shuo hu
* @date 2025-07-17
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = BizPackingSpecs.class)
public class BizPackingSpecsVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 规格ID（主键）
*/
@ExcelProperty(value = "规格ID", converter = ExcelDictConvert.class)
@ExcelDictFormat(readConverterExp = "主=键")
private Long id;
/**
* 关联采购单明细项ID
*/
@ExcelProperty(value = "关联采购单明细项ID")
private Long sendOrderId;
/**
* 规格名称（如规格A）
*/
@ExcelProperty(value = "规格名称", converter = ExcelDictConvert.class)
@ExcelDictFormat(readConverterExp = "如=规格A")
private String specName;
/**
* 箱数（单位：箱）
*/
@ExcelProperty(value = "箱数", converter = ExcelDictConvert.class)
@ExcelDictFormat(readConverterExp = "单=位：箱")
private Long cartonCount;
/**
* 每箱件数（单位：件）
*/
@ExcelProperty(value = "每箱件数", converter = ExcelDictConvert.class)
@ExcelDictFormat(readConverterExp = "单=位：件")
private Long piecesPerCarton;
/**
* 箱子长度（单位：厘米）
*/
@ExcelProperty(value = "箱子长度", converter = ExcelDictConvert.class)
@ExcelDictFormat(readConverterExp = "单=位：厘米")
private Long length;
/**
* 箱子宽度（单位：厘米）
*/
@ExcelProperty(value = "箱子宽度", converter = ExcelDictConvert.class)
@ExcelDictFormat(readConverterExp = "单=位：厘米")
private Long width;
/**
* 箱子高度（单位：厘米）
*/
@ExcelProperty(value = "箱子高度", converter = ExcelDictConvert.class)
@ExcelDictFormat(readConverterExp = "单=位：厘米")
private Long height;
/**
* 单箱重量（单位：千克）
*/
@ExcelProperty(value = "单箱重量", converter = ExcelDictConvert.class)
@ExcelDictFormat(readConverterExp = "单=位：千克")
private Long weight;
}

20
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/vo/BizPurchaseOrderItemVo.java
View File

@ -1,10 +1,13 @@
package org.asinkj.amz.domain.vo;
import java.util.Date;
import com.baomidou.mybatisplus.annotation.TableField;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.asinkj.amz.domain.BizPurchaseOrderItem;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import org.asinkj.amz.domain.SysStatusHistory;
import org.asinkj.common.excel.annotation.ExcelDictFormat;
import org.asinkj.common.excel.convert.ExcelDictConvert;
import io.github.linpeilie.annotations.AutoMapper;
@ -13,7 +16,7 @@ import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
@ -212,4 +215,19 @@ public class BizPurchaseOrderItemVo implements Serializable {
@ExcelDictFormat(dictType = "vendor_order_status")
private String orderStatus;
private Long quantityLeft;
private Long quantityShipped;
@TableField(exist = false)
private List<SysStatusHistory> sysStatusHistories;
@TableField(exist = false)
private String hasForward = "N";
@TableField(exist = false)
private String hasSendOrder = "N";
}

7
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/vo/BizPurchaseOrderVo.java
View File

@ -2,6 +2,7 @@ package org.asinkj.amz.domain.vo;
import java.math.BigDecimal;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.asinkj.amz.domain.BizPurchaseOrder;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
@ -349,14 +350,12 @@ public class BizPurchaseOrderVo implements Serializable {
private BigDecimal remainingQuantity;
private String type;
private List<BizPurchaseOrderItem> items;
private List<BizPurchaseOrderItemVo> items;
private List<BizShipForward> forwardList;
}

145
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/vo/BizPurchaseOutOrderVo.java Normal file
View File

@ -0,0 +1,145 @@
package org.asinkj.amz.domain.vo;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.asinkj.amz.domain.BizOrderOutItem;
import org.asinkj.amz.domain.BizPurchaseOutOrder;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import org.asinkj.common.excel.annotation.ExcelDictFormat;
import org.asinkj.common.excel.convert.ExcelDictConvert;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
import java.util.List;
/**
* 组合订单视图对象 biz_purchase_out_order
*
* @author shuo hu
* @date 2025-07-22
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = BizPurchaseOutOrder.class)
public class BizPurchaseOutOrderVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 订单唯一编号
*/
@ExcelProperty(value = "订单唯一编号")
private String orderSn;
/**
* 仓库名称
*/
@ExcelProperty(value = "仓库名称")
private String warehouseName;
/**
* 外包仓库名称
*/
@ExcelProperty(value = "外包仓库名称")
private String outsourceWarehouseName;
/**
* 供应商名称
*/
@ExcelProperty(value = "供应商名称")
private String supplierName;
/**
* 业务创建时间 (Jackson格式: yyyy-MM-dd HH:mm:ss)
*/
@ExcelProperty(value = "业务创建时间 (Jackson格式: yyyy-MM-dd HH:mm:ss)")
private Date bizCreateTime;
/**
* 状态文本描述
*/
@ExcelProperty(value = "状态文本描述")
private String statusText;
/**
* 创建人姓名
*/
@ExcelProperty(value = "创建人姓名")
private String createRealname;
/**
* PTP流水号
*/
@ExcelProperty(value = "PTP流水号")
private String ptpSn;
/**
* 产品名称
*/
@ExcelProperty(value = "产品名称")
private String productName;
/**
* 标准SKU编码
*/
@ExcelProperty(value = "标准SKU编码")
private String sku;
/**
* FNSKU编码
*/
@ExcelProperty(value = "FNSKU编码")
private String fnsku;
/**
* 外包数量
*/
@ExcelProperty(value = "外包数量")
private Long outsourceQuantity;
@ExcelProperty(value = "已下单数量")
private Long quantityShipped;
@ExcelProperty(value = "剩余数量")
private Long quantityLeft;
/**
* 实收数量
*/
@ExcelProperty(value = "实收数量")
private Long receiveQuantity;
/**
* 预计到达时间
*/
@ExcelProperty(value = "预计到达时间")
private String expectArriveTime;
/**
* MSKU编码列表 (数组存储)
*/
@ExcelProperty(value = "MSKU编码列表 (数组存储)")
private String msku;
/**
* 关联计划单号列表 (数组存储)
*/
@ExcelProperty(value = "关联计划单号列表 (数组存储)")
private String planSn;
/**
* 销售商名称
*/
@ExcelProperty(value = "销售商名称")
private String sellerName;
private List<BizOrderOutItemVo> items;
}

73
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/vo/BizSendOrderItemVo.java Normal file
View File

@ -0,0 +1,73 @@
package org.asinkj.amz.domain.vo;
import java.util.Date;
import com.fasterxml.jackson.annotation.JsonFormat;
import org.asinkj.amz.domain.BizSendOrderItem;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import org.asinkj.common.excel.annotation.ExcelDictFormat;
import org.asinkj.common.excel.convert.ExcelDictConvert;
import io.github.linpeilie.annotations.AutoMapper;
import lombok.Data;
import java.io.Serial;
import java.io.Serializable;
import java.util.Date;
/**
* 供应商创建的发货单明细视图对象 biz_send_order_item
*
* @author shuo hu
* @date 2025-07-24
*/
@Data
@ExcelIgnoreUnannotated
@AutoMapper(target = BizSendOrderItem.class)
public class BizSendOrderItemVo implements Serializable {
@Serial
private static final long serialVersionUID = 1L;
/**
* 主键ID
*/
@ExcelProperty(value = "主键ID")
private Long id;
/**
* 采购单号
*/
@ExcelProperty(value = "采购单号")
private String orderSn;
/**
* 发货日期
*/
@ExcelProperty(value = "发货日期")
private Date sendDate;
/**
* 发货日期
*/
@ExcelProperty(value = "发货日期")
private String storeName;
/**
* 发货日期
*/
@ExcelProperty(value = "发货日期")
private String productName;
/**
* 发货日期
*/
@ExcelProperty(value = "发货日期")
private Long quantitySend;
private String sku;
}

8
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/vo/BizSendOrderVo.java
View File

@ -6,6 +6,7 @@ import org.asinkj.amz.domain.BizLogisticsOrder;
import org.asinkj.amz.domain.BizSendOrder;
import com.alibaba.excel.annotation.ExcelIgnoreUnannotated;
import com.alibaba.excel.annotation.ExcelProperty;
import org.asinkj.amz.domain.BizSendOrderItem;
import org.asinkj.amz.domain.BizShipmentPlan;
import org.asinkj.common.excel.annotation.ExcelDictFormat;
import org.asinkj.common.excel.convert.ExcelDictConvert;
@ -130,4 +131,11 @@ public class BizSendOrderVo implements Serializable {
private List<BizShipmentPlan> bizShipmentPlans;
private List<BizSendOrderItem> items;
private String type;
private String createName;
}

3
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/domain/vo/BizShipmentPlanVo.java
View File

@ -201,6 +201,9 @@ public class BizShipmentPlanVo implements Serializable {
// @ExcelDictFormat(readConverterExp = "系=统中的申报量")
private Long setTotal;
private Long itemCount;
/**
* 渠道ID
*/

10
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/dubbo/RemoteFBADataServiceImpl.java
View File

@ -26,6 +26,8 @@ import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
import static java.lang.Thread.sleep;
@RequiredArgsConstructor
@Service
@DubboService
@ -77,6 +79,14 @@ public class RemoteFBADataServiceImpl implements RemoteFBADataService {
}
});
sleep(100000);
sysAmazonStoreService.pullPurchaseOutOrderData(startDate, endDate, new LingxinCallback() {
@Override
public void onFinished(String result, int status) {
}
});
}
@Override

16
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/mapper/BizOrderOutItemMapper.java Normal file
View File

@ -0,0 +1,16 @@
package org.asinkj.amz.mapper;
import org.asinkj.amz.domain.BizOrderOutItem;
import org.asinkj.amz.domain.vo.BizOrderOutItemVo;
import org.asinkj.common.mybatis.core.mapper.BaseMapperPlus;
import org.apache.ibatis.annotations.Mapper;
/**
* 采购订单明细Mapper接口
*
* @author shuo hu
* @date 2025-07-22
*/
@Mapper
public interface BizOrderOutItemMapper extends BaseMapperPlus<BizOrderOutItem, BizOrderOutItemVo> {
}

16
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/mapper/BizPackingSpecsMapper.java Normal file
View File

@ -0,0 +1,16 @@
package org.asinkj.amz.mapper;
import org.asinkj.amz.domain.BizPackingSpecs;
import org.asinkj.amz.domain.vo.BizPackingSpecsVo;
import org.asinkj.common.mybatis.core.mapper.BaseMapperPlus;
import org.apache.ibatis.annotations.Mapper;
/**
* 产品装箱规格Mapper接口
*
* @author shuo hu
* @date 2025-07-17
*/
@Mapper
public interface BizPackingSpecsMapper extends BaseMapperPlus<BizPackingSpecs, BizPackingSpecsVo> {
}

16
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/mapper/BizPurchaseOutOrderMapper.java Normal file
View File

@ -0,0 +1,16 @@
package org.asinkj.amz.mapper;
import org.asinkj.amz.domain.BizPurchaseOutOrder;
import org.asinkj.amz.domain.vo.BizPurchaseOutOrderVo;
import org.asinkj.common.mybatis.core.mapper.BaseMapperPlus;
import org.apache.ibatis.annotations.Mapper;
/**
* 组合订单Mapper接口
*
* @author shuo hu
* @date 2025-07-22
*/
@Mapper
public interface BizPurchaseOutOrderMapper extends BaseMapperPlus<BizPurchaseOutOrder, BizPurchaseOutOrderVo> {
}

16
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/mapper/BizSendOrderItemMapper.java Normal file
View File

@ -0,0 +1,16 @@
package org.asinkj.amz.mapper;
import org.asinkj.amz.domain.BizSendOrderItem;
import org.asinkj.amz.domain.vo.BizSendOrderItemVo;
import org.asinkj.common.mybatis.core.mapper.BaseMapperPlus;
import org.apache.ibatis.annotations.Mapper;
/**
* 供应商创建的发货单明细Mapper接口
*
* @author shuo hu
* @date 2025-07-24
*/
@Mapper
public interface BizSendOrderItemMapper extends BaseMapperPlus<BizSendOrderItem, BizSendOrderItemVo> {
}

69
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/IBizOrderOutItemService.java Normal file
View File

@ -0,0 +1,69 @@
package org.asinkj.amz.service;
import org.asinkj.amz.domain.BizOrderOutItem;
import org.asinkj.amz.domain.vo.BizOrderOutItemVo;
import org.asinkj.amz.domain.bo.BizOrderOutItemBo;
import org.asinkj.common.mybatis.core.page.TableDataInfo;
import org.asinkj.common.mybatis.core.page.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 采购订单明细Service接口
*
* @author shuo hu
* @date 2025-07-22
*/
public interface IBizOrderOutItemService {
/**
* 查询采购订单明细
*
* @param tenantId 主键
* @return 采购订单明细
*/
BizOrderOutItemVo queryById(String tenantId);
/**
* 分页查询采购订单明细列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 采购订单明细分页列表
*/
TableDataInfo<BizOrderOutItemVo> queryPageList(BizOrderOutItemBo bo, PageQuery pageQuery);
/**
* 查询符合条件的采购订单明细列表
*
* @param bo 查询条件
* @return 采购订单明细列表
*/
List<BizOrderOutItemVo> queryList(BizOrderOutItemBo bo);
/**
* 新增采购订单明细
*
* @param bo 采购订单明细
* @return 是否新增成功
*/
Boolean insertByBo(BizOrderOutItemBo bo);
/**
* 修改采购订单明细
*
* @param bo 采购订单明细
* @return 是否修改成功
*/
Boolean updateByBo(BizOrderOutItemBo bo);
/**
* 校验并批量删除采购订单明细信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
Boolean deleteWithValidByIds(Collection<String> ids, Boolean isValid);
}

69
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/IBizPackingSpecsService.java Normal file
View File

@ -0,0 +1,69 @@
package org.asinkj.amz.service;
import org.asinkj.amz.domain.BizPackingSpecs;
import org.asinkj.amz.domain.vo.BizPackingSpecsVo;
import org.asinkj.amz.domain.bo.BizPackingSpecsBo;
import org.asinkj.common.mybatis.core.page.TableDataInfo;
import org.asinkj.common.mybatis.core.page.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 产品装箱规格Service接口
*
* @author shuo hu
* @date 2025-07-17
*/
public interface IBizPackingSpecsService {
/**
* 查询产品装箱规格
*
* @param id 主键
* @return 产品装箱规格
*/
BizPackingSpecsVo queryById(Long id);
/**
* 分页查询产品装箱规格列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 产品装箱规格分页列表
*/
TableDataInfo<BizPackingSpecsVo> queryPageList(BizPackingSpecsBo bo, PageQuery pageQuery);
/**
* 查询符合条件的产品装箱规格列表
*
* @param bo 查询条件
* @return 产品装箱规格列表
*/
List<BizPackingSpecsVo> queryList(BizPackingSpecsBo bo);
/**
* 新增产品装箱规格
*
* @param bo 产品装箱规格
* @return 是否新增成功
*/
Boolean insertByBo(BizPackingSpecsBo bo);
/**
* 修改产品装箱规格
*
* @param bo 产品装箱规格
* @return 是否修改成功
*/
Boolean updateByBo(BizPackingSpecsBo bo);
/**
* 校验并批量删除产品装箱规格信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

71
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/IBizPurchaseOutOrderService.java Normal file
View File

@ -0,0 +1,71 @@
package org.asinkj.amz.service;
import org.asinkj.amz.domain.BizPurchaseOutOrder;
import org.asinkj.amz.domain.vo.BizPurchaseOutOrderVo;
import org.asinkj.amz.domain.bo.BizPurchaseOutOrderBo;
import org.asinkj.common.mybatis.core.page.TableDataInfo;
import org.asinkj.common.mybatis.core.page.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 组合订单Service接口
*
* @author shuo hu
* @date 2025-07-22
*/
public interface IBizPurchaseOutOrderService {
/**
* 查询组合订单
*
* @param tenantId 主键
* @return 组合订单
*/
BizPurchaseOutOrderVo queryByPurchaseId(String tenantId);
/**
* 分页查询组合订单列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 组合订单分页列表
*/
TableDataInfo<BizPurchaseOutOrderVo> queryPageList(BizPurchaseOutOrderBo bo, PageQuery pageQuery);
/**
* 查询符合条件的组合订单列表
*
* @param bo 查询条件
* @return 组合订单列表
*/
List<BizPurchaseOutOrderVo> queryList(BizPurchaseOutOrderBo bo);
/**
* 新增组合订单
*
* @param bo 组合订单
* @return 是否新增成功
*/
Boolean insertByBo(BizPurchaseOutOrderBo bo);
/**
* 修改组合订单
*
* @param bo 组合订单
* @return 是否修改成功
*/
Boolean updateByBo(BizPurchaseOutOrderBo bo);
/**
* 校验并批量删除组合订单信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
Boolean deleteWithValidByIds(Collection<String> ids, Boolean isValid);
int createSendOrderByBo(BizPurchaseOutOrderBo bo);
}

69
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/IBizSendOrderItemService.java Normal file
View File

@ -0,0 +1,69 @@
package org.asinkj.amz.service;
import org.asinkj.amz.domain.BizSendOrderItem;
import org.asinkj.amz.domain.vo.BizSendOrderItemVo;
import org.asinkj.amz.domain.bo.BizSendOrderItemBo;
import org.asinkj.common.mybatis.core.page.TableDataInfo;
import org.asinkj.common.mybatis.core.page.PageQuery;
import java.util.Collection;
import java.util.List;
/**
* 供应商创建的发货单明细Service接口
*
* @author shuo hu
* @date 2025-07-24
*/
public interface IBizSendOrderItemService {
/**
* 查询供应商创建的发货单明细
*
* @param id 主键
* @return 供应商创建的发货单明细
*/
BizSendOrderItemVo queryById(Long id);
/**
* 分页查询供应商创建的发货单明细列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 供应商创建的发货单明细分页列表
*/
TableDataInfo<BizSendOrderItemVo> queryPageList(BizSendOrderItemBo bo, PageQuery pageQuery);
/**
* 查询符合条件的供应商创建的发货单明细列表
*
* @param bo 查询条件
* @return 供应商创建的发货单明细列表
*/
List<BizSendOrderItemVo> queryList(BizSendOrderItemBo bo);
/**
* 新增供应商创建的发货单明细
*
* @param bo 供应商创建的发货单明细
* @return 是否新增成功
*/
Boolean insertByBo(BizSendOrderItemBo bo);
/**
* 修改供应商创建的发货单明细
*
* @param bo 供应商创建的发货单明细
* @return 是否修改成功
*/
Boolean updateByBo(BizSendOrderItemBo bo);
/**
* 校验并批量删除供应商创建的发货单明细信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid);
}

2
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/IBizSendOrderService.java
View File

@ -73,4 +73,6 @@ public interface IBizSendOrderService {
void linkByBo(BizSendOrderBo bo);
void updateStatus(Long sendOrderId, String completed,String shipmentId);
int updateDataByBo(BizSendOrderBo bo);
}

2
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/ISysAmazonStoreService.java
View File

@ -78,6 +78,8 @@ public interface ISysAmazonStoreService {
void updateAmzFBAData(LingxinCallback lingxinCallback) throws Exception;
void pullPurchaseOutOrderData(String startDate, String endDate, LingxinCallback lingxinCallback);
void pullPurchaseOrderData(String startDate, String endDate, LingxinCallback lingxinCallback);
void updatePurchaseOrderSeller(String startDate, String endDate, LingxinCallback lingxinCallback);

140
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/impl/BizOrderOutItemServiceImpl.java Normal file
View File

@ -0,0 +1,140 @@
package org.asinkj.amz.service.impl;
import org.asinkj.common.core.utils.MapstructUtils;
import org.asinkj.common.core.utils.StringUtils;
import org.asinkj.common.mybatis.core.page.TableDataInfo;
import org.asinkj.common.mybatis.core.page.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.asinkj.amz.domain.bo.BizOrderOutItemBo;
import org.asinkj.amz.domain.vo.BizOrderOutItemVo;
import org.asinkj.amz.domain.BizOrderOutItem;
import org.asinkj.amz.mapper.BizOrderOutItemMapper;
import org.asinkj.amz.service.IBizOrderOutItemService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 采购订单明细Service业务层处理
*
* @author shuo hu
* @date 2025-07-22
*/
@RequiredArgsConstructor
@Service
public class BizOrderOutItemServiceImpl implements IBizOrderOutItemService {
private final BizOrderOutItemMapper baseMapper;
/**
* 查询采购订单明细
*
* @param tenantId 主键
* @return 采购订单明细
*/
@Override
public BizOrderOutItemVo queryById(String tenantId){
return baseMapper.selectVoById(tenantId);
}
/**
* 分页查询采购订单明细列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 采购订单明细分页列表
*/
@Override
public TableDataInfo<BizOrderOutItemVo> queryPageList(BizOrderOutItemBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<BizOrderOutItem> lqw = buildQueryWrapper(bo);
Page<BizOrderOutItemVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询符合条件的采购订单明细列表
*
* @param bo 查询条件
* @return 采购订单明细列表
*/
@Override
public List<BizOrderOutItemVo> queryList(BizOrderOutItemBo bo) {
LambdaQueryWrapper<BizOrderOutItem> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<BizOrderOutItem> buildQueryWrapper(BizOrderOutItemBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<BizOrderOutItem> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getItemId() != null, BizOrderOutItem::getItemId, bo.getItemId());
lqw.eq(StringUtils.isNotBlank(bo.getOutOrderSn()), BizOrderOutItem::getOutOrderSn, bo.getOutOrderSn());
lqw.like(StringUtils.isNotBlank(bo.getProductName()), BizOrderOutItem::getProductName, bo.getProductName());
lqw.eq(StringUtils.isNotBlank(bo.getSku()), BizOrderOutItem::getSku, bo.getSku());
lqw.eq(bo.getQuantityRequire() != null, BizOrderOutItem::getQuantityRequire, bo.getQuantityRequire());
lqw.eq(bo.getBizCreateTime() != null, BizOrderOutItem::getBizCreateTime, bo.getBizCreateTime());
lqw.like(StringUtils.isNotBlank(bo.getCreateRealname()), BizOrderOutItem::getCreateRealname, bo.getCreateRealname());
lqw.eq(StringUtils.isNotBlank(bo.getExpectArriveTime()), BizOrderOutItem::getExpectArriveTime, bo.getExpectArriveTime());
lqw.like(StringUtils.isNotBlank(bo.getWarehouseName()), BizOrderOutItem::getWarehouseName, bo.getWarehouseName());
lqw.like(StringUtils.isNotBlank(bo.getSupplierName()), BizOrderOutItem::getSupplierName, bo.getSupplierName());
lqw.eq(bo.getQuantityReal() != null, BizOrderOutItem::getQuantityReal, bo.getQuantityReal());
lqw.eq(bo.getQuantityEntry() != null, BizOrderOutItem::getQuantityEntry, bo.getQuantityEntry());
return lqw;
}
/**
* 新增采购订单明细
*
* @param bo 采购订单明细
* @return 是否新增成功
*/
@Override
public Boolean insertByBo(BizOrderOutItemBo bo) {
BizOrderOutItem add = MapstructUtils.convert(bo, BizOrderOutItem.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
// if (flag) {
// bo.setTenantId(add.getTenantId());
// }
return flag;
}
/**
* 修改采购订单明细
*
* @param bo 采购订单明细
* @return 是否修改成功
*/
@Override
public Boolean updateByBo(BizOrderOutItemBo bo) {
BizOrderOutItem update = MapstructUtils.convert(bo, BizOrderOutItem.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(BizOrderOutItem entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 校验并批量删除采购订单明细信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
@Override
public Boolean deleteWithValidByIds(Collection<String> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteByIds(ids) > 0;
}
}

136
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/impl/BizPackingSpecsServiceImpl.java Normal file
View File

@ -0,0 +1,136 @@
package org.asinkj.amz.service.impl;
import org.asinkj.common.core.utils.MapstructUtils;
import org.asinkj.common.core.utils.StringUtils;
import org.asinkj.common.mybatis.core.page.TableDataInfo;
import org.asinkj.common.mybatis.core.page.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.asinkj.amz.domain.bo.BizPackingSpecsBo;
import org.asinkj.amz.domain.vo.BizPackingSpecsVo;
import org.asinkj.amz.domain.BizPackingSpecs;
import org.asinkj.amz.mapper.BizPackingSpecsMapper;
import org.asinkj.amz.service.IBizPackingSpecsService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 产品装箱规格Service业务层处理
*
* @author shuo hu
* @date 2025-07-17
*/
@RequiredArgsConstructor
@Service
public class BizPackingSpecsServiceImpl implements IBizPackingSpecsService {
private final BizPackingSpecsMapper baseMapper;
/**
* 查询产品装箱规格
*
* @param id 主键
* @return 产品装箱规格
*/
@Override
public BizPackingSpecsVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 分页查询产品装箱规格列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 产品装箱规格分页列表
*/
@Override
public TableDataInfo<BizPackingSpecsVo> queryPageList(BizPackingSpecsBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<BizPackingSpecs> lqw = buildQueryWrapper(bo);
Page<BizPackingSpecsVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询符合条件的产品装箱规格列表
*
* @param bo 查询条件
* @return 产品装箱规格列表
*/
@Override
public List<BizPackingSpecsVo> queryList(BizPackingSpecsBo bo) {
LambdaQueryWrapper<BizPackingSpecs> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<BizPackingSpecs> buildQueryWrapper(BizPackingSpecsBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<BizPackingSpecs> lqw = Wrappers.lambdaQuery();
lqw.eq(bo.getSendOrderId() != null, BizPackingSpecs::getSendOrderId, bo.getSendOrderId());
lqw.like(StringUtils.isNotBlank(bo.getSpecName()), BizPackingSpecs::getSpecName, bo.getSpecName());
lqw.eq(bo.getCartonCount() != null, BizPackingSpecs::getCartonCount, bo.getCartonCount());
lqw.eq(bo.getPiecesPerCarton() != null, BizPackingSpecs::getPiecesPerCarton, bo.getPiecesPerCarton());
lqw.eq(bo.getLength() != null, BizPackingSpecs::getLength, bo.getLength());
lqw.eq(bo.getWidth() != null, BizPackingSpecs::getWidth, bo.getWidth());
lqw.eq(bo.getHeight() != null, BizPackingSpecs::getHeight, bo.getHeight());
lqw.eq(bo.getWeight() != null, BizPackingSpecs::getWeight, bo.getWeight());
return lqw;
}
/**
* 新增产品装箱规格
*
* @param bo 产品装箱规格
* @return 是否新增成功
*/
@Override
public Boolean insertByBo(BizPackingSpecsBo bo) {
BizPackingSpecs add = MapstructUtils.convert(bo, BizPackingSpecs.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改产品装箱规格
*
* @param bo 产品装箱规格
* @return 是否修改成功
*/
@Override
public Boolean updateByBo(BizPackingSpecsBo bo) {
BizPackingSpecs update = MapstructUtils.convert(bo, BizPackingSpecs.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(BizPackingSpecs entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 校验并批量删除产品装箱规格信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteByIds(ids) > 0;
}
}

35
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/impl/BizPurchaseOrderServiceImpl.java
View File

@ -10,6 +10,7 @@ import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import lombok.extern.slf4j.Slf4j;
import org.asinkj.amz.api.RemoteFBADataService;
import org.asinkj.amz.domain.*;
import org.asinkj.amz.domain.vo.BizPurchaseOrderItemVo;
import org.asinkj.amz.mapper.*;
import org.asinkj.amz.service.IBizPurchaseOrderItemService;
import org.asinkj.common.core.utils.MapstructUtils;
@ -67,6 +68,10 @@ public class BizPurchaseOrderServiceImpl implements IBizPurchaseOrderService {
private RemoteFBADataService remoteFBADataService;
@Resource
private BizSendOrderItemMapper bizSendOrderItemMapper;
/**
* 查询采购单主
*
@ -90,8 +95,11 @@ public class BizPurchaseOrderServiceImpl implements IBizPurchaseOrderService {
LambdaQueryWrapper<BizPurchaseOrder> lqw = buildQueryWrapper(bo);
Page<BizPurchaseOrderVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
List<BizPurchaseOrderVo> records = result.getRecords();
if (result.getTotal() == 0) {
return TableDataInfo.build(result);
}
Set<String> orderSnSet = records.stream().map(BizPurchaseOrderVo::getOrderSn).collect(Collectors.toSet());
Set<Long> orderIds = records.stream().map(BizPurchaseOrderVo::getId).collect(Collectors.toSet());
LambdaQueryWrapper<BizPurchaseOrderItem> lambdaQueryWrapper = new LambdaQueryWrapper<>();
lambdaQueryWrapper.in(CollectionUtil.isNotEmpty(orderSnSet), BizPurchaseOrderItem::getOrderSn, orderSnSet);
@ -126,12 +134,27 @@ public class BizPurchaseOrderServiceImpl implements IBizPurchaseOrderService {
historyLambdaQueryWrapper.in(CollectionUtil.isNotEmpty(itemIds), SysStatusHistory::getRecordId, itemIds);
Map<Long, List<SysStatusHistory>> sysStatusHistoryMap = sysStatusHistoryMapper.selectList(historyLambdaQueryWrapper).stream().collect(Collectors.groupingBy(SysStatusHistory::getRecordId));
// bizOrderOutItemMapper.selectList();
LambdaQueryWrapper<BizSendOrderItem> sendOrderItemWrapper = new LambdaQueryWrapper<>();
sendOrderItemWrapper.in(BizSendOrderItem::getOrderSn, orderSnSet);
List<BizSendOrderItem> bizSendOrderItems = bizSendOrderItemMapper.selectList(sendOrderItemWrapper);
Map<String, Long> collect2 = bizSendOrderItems.stream()
.collect(Collectors.groupingBy(
// 使用分隔符"_"拼接orderId和sku作为分组键
item -> item.getOrderSn() + "_" + item.getSku(),
// 对每个分组计算quality的总和
Collectors.reducing(0L, BizSendOrderItem::getQuantitySend, Long::sum)
));
for (BizPurchaseOrderVo record : records) {
List<BizPurchaseOrderItem> bizPurchaseOrderItems = itemMaps.get(record.getOrderSn());
if (CollectionUtil.isNotEmpty(bizPurchaseOrderItems)) {
List<BizPurchaseOrderItemVo> convert = MapstructUtils.convert(bizPurchaseOrderItems, BizPurchaseOrderItemVo.class);
Map<Long, List<BizSendOrder>> finalBizSendOrderItemMap = BizSendOrderItemMap;
Map<Long, List<BizShipForward>> finalBizShipForwardItemMap = bizShipForwardItemMap;
bizPurchaseOrderItems.forEach(item -> {
convert.forEach(item -> {
item.setSysStatusHistories(sysStatusHistoryMap.get(item.getId()));
List<BizShipForward> bizShipForwards = finalBizShipForwardItemMap.get(item.getId());
List<BizSendOrder> bizSendOrders = finalBizSendOrderItemMap.get(item.getId());
@ -141,8 +164,11 @@ public class BizPurchaseOrderServiceImpl implements IBizPurchaseOrderService {
if (CollectionUtil.isNotEmpty(bizSendOrders)) {
item.setHasSendOrder("Y");
}
Long l = collect2.get(item.getOrderSn() + "_" + item.getSku());
item.setQuantityShipped(l);
item.setQuantityLeft(item.getQuantityReal() - Optional.ofNullable(item.getQuantityShipped()).orElse(0L));
});
record.setItems(bizPurchaseOrderItems);
record.setItems(convert);
}
List<BizShipForward> bizShipForwards = bizShipForwardMap.get(record.getOrderSn());
if (CollectionUtil.isNotEmpty(bizShipForwards)) {
@ -240,7 +266,7 @@ public class BizPurchaseOrderServiceImpl implements IBizPurchaseOrderService {
}
if (!LoginHelper.isSuperAdmin()) {
lqw.in(BizPurchaseOrder::getStatus, 2, 9);
lqw.in(BizPurchaseOrder::getStatus, 1, 2, 9);
}
if (StrUtil.isNotBlank(bo.getSku())) {
LambdaQueryWrapper<BizPurchaseOrderItem> lambdaQueryWrapper = new LambdaQueryWrapper<>();
@ -265,6 +291,7 @@ public class BizPurchaseOrderServiceImpl implements IBizPurchaseOrderService {
BizPurchaseOrder add = MapstructUtils.convert(bo, BizPurchaseOrder.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setOrderSn(add.getOrderSn());
}

311
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/impl/BizPurchaseOutOrderServiceImpl.java Normal file
View File

@ -0,0 +1,311 @@
package org.asinkj.amz.service.impl;
import cn.hutool.core.collection.CollectionUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.asinkj.amz.domain.*;
import org.asinkj.amz.domain.vo.BizOrderOutItemVo;
import org.asinkj.amz.mapper.*;
import org.asinkj.common.core.utils.MapstructUtils;
import org.asinkj.common.core.utils.StringUtils;
import org.asinkj.common.mybatis.core.page.TableDataInfo;
import org.asinkj.common.mybatis.core.page.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.asinkj.common.satoken.utils.LoginHelper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.asinkj.amz.domain.bo.BizPurchaseOutOrderBo;
import org.asinkj.amz.domain.vo.BizPurchaseOutOrderVo;
import org.asinkj.amz.service.IBizPurchaseOutOrderService;
import javax.annotation.Resource;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.*;
import java.util.function.Function;
import java.util.stream.Collectors;
/**
* 组合订单Service业务层处理
*
* @author shuo hu
* @date 2025-07-22
*/
@RequiredArgsConstructor
@Service
public class BizPurchaseOutOrderServiceImpl implements IBizPurchaseOutOrderService {
private static final Logger log = LoggerFactory.getLogger(BizPurchaseOutOrderServiceImpl.class);
private final BizPurchaseOutOrderMapper baseMapper;
@Resource
private BizOrderOutItemMapper bizOrderOutItemMapper;
@Resource
private BizPurchaseOrderMapper bizPurchaseOrderMapper;
@Resource
private BizPurchaseOrderItemMapper bizPurchaseOrderItemMapper;
@Resource
private BizSendOrderMapper bizSendOrderMapper;
@Resource
private BizSendOrderItemMapper bizSendOrderItemMapper;
@Autowired
private BizPurchaseOutOrderMapper bizPurchaseOutOrderMapper;
@Resource
private BizShipForwardMapper bizForwardMapper;
@Resource
private SysUserMapper sysUserMapper;
/**
* 查询组合订单
*
* @param tenantId 主键
* @return 组合订单
*/
@Override
public BizPurchaseOutOrderVo queryByPurchaseId(String tenantId) {
LambdaQueryWrapper<BizPurchaseOutOrder> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(BizPurchaseOutOrder::getOrderSn, tenantId);
return baseMapper.selectVoOne(queryWrapper);
}
/**
* 分页查询组合订单列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 组合订单分页列表
*/
@Override
public TableDataInfo<BizPurchaseOutOrderVo> queryPageList(BizPurchaseOutOrderBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<BizPurchaseOutOrder> lqw = buildQueryWrapper(bo);
Page<BizPurchaseOutOrderVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
List<BizPurchaseOutOrderVo> records = result.getRecords();
if (result.getTotal() == 0) {
return TableDataInfo.build(result);
}
List<String> collect = records.stream().map(BizPurchaseOutOrderVo::getOrderSn).collect(Collectors.toList());
LambdaQueryWrapper<BizOrderOutItem> objectLambdaQueryWrapper = new LambdaQueryWrapper<>();
objectLambdaQueryWrapper.in(CollectionUtil.isNotEmpty(collect), BizOrderOutItem::getOutOrderSn, collect);
List<BizOrderOutItem> bizOrderOutItems = bizOrderOutItemMapper.selectList(objectLambdaQueryWrapper);
Set<String> collect1 = bizOrderOutItems.stream().map(BizOrderOutItem::getPurchaseOrderSn).collect(Collectors.toSet());
LambdaQueryWrapper<BizPurchaseOrder> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.in(BizPurchaseOrder::getOrderSn, collect1);
List<BizPurchaseOrder> bizPurchaseOrders = bizPurchaseOrderMapper.selectList(queryWrapper);
LambdaQueryWrapper<BizPurchaseOrderItem> queryItemWrapper = new LambdaQueryWrapper<>();
queryItemWrapper.in(BizPurchaseOrderItem::getOrderSn, collect1);
List<BizPurchaseOrderItem> bizPurchaseOrderItems = bizPurchaseOrderItemMapper.selectList(queryItemWrapper);
Map<String, BizPurchaseOrderItem> itemsMap = bizPurchaseOrderItems.stream().collect(Collectors.toMap(c -> c.getOrderSn() + c.getSku(), Function.identity()));
Map<String, BizPurchaseOrder> purchaseOrderMap = bizPurchaseOrders.stream().collect(Collectors.toMap(BizPurchaseOrder::getOrderSn, Function.identity()));
Map<String, List<BizOrderOutItem>> itemMap = bizOrderOutItems.stream().collect(Collectors.groupingBy(BizOrderOutItem::getOutOrderSn));
// bizOrderOutItemMapper.selectList();
LambdaQueryWrapper<BizSendOrderItem> sendOrderItemWrapper = new LambdaQueryWrapper<>();
sendOrderItemWrapper.in(BizSendOrderItem::getOrderSn, collect1);
List<BizSendOrderItem> bizSendOrderItems = bizSendOrderItemMapper.selectList(sendOrderItemWrapper);
LambdaQueryWrapper<BizSendOrder> sendOrderWrapper = new LambdaQueryWrapper<>();
sendOrderWrapper.in(BizSendOrder::getOrderSn, collect);
List<BizSendOrder> bizSendOrders = bizSendOrderMapper.selectList(sendOrderWrapper);
Map<String, Long> collect3 = bizSendOrders.stream().collect(Collectors.groupingBy(BizSendOrder::getOrderSn, Collectors.reducing(0L, BizSendOrder::getQuantitySend, Long::sum)));
LambdaQueryWrapper<BizShipForward> bizShipForwardWrapper = new LambdaQueryWrapper<>();
bizShipForwardWrapper.in(CollectionUtil.isNotEmpty(collect1), BizShipForward::getOrderSn, collect1);
List<BizShipForward> bizShipForwards1 = bizForwardMapper.selectList(bizShipForwardWrapper);
Map<String, List<BizShipForward>> bizShipForwardMap = new HashMap<>();
if (CollectionUtil.isNotEmpty(bizShipForwards1)) {
bizShipForwardMap = bizShipForwards1.stream().collect(Collectors.groupingBy(BizShipForward::getOrderSn));
}
Map<String, Long> collect2 = bizSendOrderItems.stream()
.collect(Collectors.groupingBy(
// 使用分隔符"_"拼接orderId和sku作为分组键
item -> item.getOrderSn() + "_" + item.getSku(),
// 对每个分组计算quality的总和
Collectors.reducing(0L, BizSendOrderItem::getQuantitySend, Long::sum)
));
for (BizPurchaseOutOrderVo record : records) {
List<BizOrderOutItem> bizOrderOutItems1 = itemMap.get(record.getOrderSn());
List<BizOrderOutItemVo> convert = MapstructUtils.convert(bizOrderOutItems1, BizOrderOutItemVo.class);
record.setQuantityShipped(Optional.ofNullable(collect3.get(record.getOrderSn())).orElse(0L));
record.setQuantityLeft(record.getOutsourceQuantity() - Optional.ofNullable(collect3.get(record.getOrderSn())).orElse(0L));
for (BizOrderOutItemVo item : convert) {
BizPurchaseOrder bizPurchaseOrder = purchaseOrderMap.get(item.getPurchaseOrderSn());
item.setOrder(bizPurchaseOrder);
BizPurchaseOrderItem bizPurchaseOrderItem = itemsMap.get(item.getPurchaseOrderSn() + item.getSku());
item.setItem(bizPurchaseOrderItem);
List<BizShipForward> bizShipForwards = bizShipForwardMap.get(item.getPurchaseOrderSn());
if (CollectionUtil.isNotEmpty(bizShipForwards)) {
item.setForwards(bizShipForwards);
}
item.setQuantityShipped(Optional.ofNullable(collect2.get(item.getPurchaseOrderSn() + "_" + item.getSku())).orElse(0L));
item.setQuantityLeft(item.getQuantityReal() - Optional.ofNullable(item.getQuantityShipped()).orElse(0L));
BigDecimal ratio = new BigDecimal(item.getQuantityReal()).divide(new BigDecimal(record.getOutsourceQuantity()), 2, RoundingMode.HALF_UP);
item.setRatio(ratio);
}
record.setItems(convert);
}
return TableDataInfo.build(result);
}
/**
* 查询符合条件的组合订单列表
*
* @param bo 查询条件
* @return 组合订单列表
*/
@Override
public List<BizPurchaseOutOrderVo> queryList(BizPurchaseOutOrderBo bo) {
LambdaQueryWrapper<BizPurchaseOutOrder> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<BizPurchaseOutOrder> buildQueryWrapper(BizPurchaseOutOrderBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<BizPurchaseOutOrder> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getOrderSn()), BizPurchaseOutOrder::getOrderSn, bo.getOrderSn());
lqw.like(StringUtils.isNotBlank(bo.getWarehouseName()), BizPurchaseOutOrder::getWarehouseName, bo.getWarehouseName());
lqw.like(StringUtils.isNotBlank(bo.getOutsourceWarehouseName()), BizPurchaseOutOrder::getOutsourceWarehouseName, bo.getOutsourceWarehouseName());
lqw.like(StringUtils.isNotBlank(bo.getSupplierName()), BizPurchaseOutOrder::getSupplierName, bo.getSupplierName());
lqw.eq(bo.getBizCreateTime() != null, BizPurchaseOutOrder::getBizCreateTime, bo.getBizCreateTime());
lqw.eq(StringUtils.isNotBlank(bo.getStatusText()), BizPurchaseOutOrder::getStatusText, bo.getStatusText());
lqw.like(StringUtils.isNotBlank(bo.getCreateRealname()), BizPurchaseOutOrder::getCreateRealname, bo.getCreateRealname());
lqw.eq(StringUtils.isNotBlank(bo.getPtpSn()), BizPurchaseOutOrder::getPtpSn, bo.getPtpSn());
lqw.like(StringUtils.isNotBlank(bo.getProductName()), BizPurchaseOutOrder::getProductName, bo.getProductName());
lqw.eq(StringUtils.isNotBlank(bo.getSku()), BizPurchaseOutOrder::getSku, bo.getSku());
lqw.eq(StringUtils.isNotBlank(bo.getFnsku()), BizPurchaseOutOrder::getFnsku, bo.getFnsku());
lqw.eq(bo.getOutsourceQuantity() != null, BizPurchaseOutOrder::getOutsourceQuantity, bo.getOutsourceQuantity());
lqw.eq(bo.getReceiveQuantity() != null, BizPurchaseOutOrder::getReceiveQuantity, bo.getReceiveQuantity());
lqw.eq(StringUtils.isNotBlank(bo.getExpectArriveTime()), BizPurchaseOutOrder::getExpectArriveTime, bo.getExpectArriveTime());
lqw.eq(StringUtils.isNotBlank(bo.getMsku()), BizPurchaseOutOrder::getMsku, bo.getMsku());
lqw.eq(StringUtils.isNotBlank(bo.getPlanSn()), BizPurchaseOutOrder::getPlanSn, bo.getPlanSn());
lqw.like(StringUtils.isNotBlank(bo.getSellerName()), BizPurchaseOutOrder::getSellerName, bo.getSellerName());
return lqw;
}
/**
* 新增组合订单
*
* @param bo 组合订单
* @return 是否新增成功
*/
@Override
public Boolean insertByBo(BizPurchaseOutOrderBo bo) {
BizPurchaseOutOrder add = MapstructUtils.convert(bo, BizPurchaseOutOrder.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
return flag;
}
/**
* 修改组合订单
*
* @param bo 组合订单
* @return 是否修改成功
*/
@Override
public Boolean updateByBo(BizPurchaseOutOrderBo bo) {
BizPurchaseOutOrder update = MapstructUtils.convert(bo, BizPurchaseOutOrder.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(BizPurchaseOutOrder entity) {
//TODO 做一些数据校验,如唯一约束
}
/**
* 校验并批量删除组合订单信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
@Override
public Boolean deleteWithValidByIds(Collection<String> ids, Boolean isValid) {
if (isValid) {
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteByIds(ids) > 0;
}
@Override
public int createSendOrderByBo(BizPurchaseOutOrderBo bo) {
log.info("开始创建发货订单{}", bo);
LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysUser::getNickName, bo.getSupplierName());
List<SysUser> sysUsers = sysUserMapper.selectList(queryWrapper);
if (CollectionUtil.isEmpty(sysUsers)) {
throw new RuntimeException("供应商不存在");
}
SysUser sysUser = sysUsers.get(0);
BizSendOrder bizSendOrder = new BizSendOrder();
// BizSendOrderItem bizSendOrderItem = new BizSendOrderItem();
bizSendOrder.setOrderSn(bo.getOrderSn());
bizSendOrder.setStoreName(bo.getSellerName());
bizSendOrder.setProductName(bo.getProductName());
bizSendOrder.setCreateName(LoginHelper.getLoginUser().getNickname());
bizSendOrder.setQuantitySend(bo.getOutsourceQuantity());
bizSendOrder.setSendName(bo.getSupplierName());
bizSendOrder.setSendId(sysUser.getUserId());
bizSendOrder.setType("com");
// LambdaUpdateWrapper<BizPurchaseOutOrder> updateWrapper = Wrappers.lambdaUpdate(BizPurchaseOutOrder.class)
// .eq(BizPurchaseOutOrder::getOrderSn, bo.getOrderSn()) // 根据orderSn定位记录
// .setSql("outsource_quantity = outsource_quantity - " + bo.getOutsourceQuantity()); // SQL表达式更新：减去x值
//
// // 执行更新（返回受影响行数）
// int affectedRows = bizPurchaseOutOrderMapper.update(null, updateWrapper);
bizSendOrderMapper.insert(bizSendOrder);
List<BizSendOrderItem> bizSendOrderItems = new ArrayList<>();
for (BizOrderOutItemVo item : bo.getItems()) {
BizSendOrderItem bizSendOrderItem = new BizSendOrderItem();
bizSendOrderItem.setQuantitySend(item.getOrder().getQuantityReal());
bizSendOrderItem.setOrderSn(item.getPurchaseOrderSn());
bizSendOrderItem.setMainOrderSn(bizSendOrder.getId());
bizSendOrderItem.setProductName(item.getProductName());
bizSendOrderItem.setSku(item.getSku());
bizSendOrderItems.add(bizSendOrderItem);
// LambdaUpdateWrapper<BizPurchaseOrderItem> updateOrderWrapper = Wrappers.lambdaUpdate(BizPurchaseOrderItem.class)
// .eq(BizPurchaseOrderItem::getOrderSn, item.getPurchaseOrderSn()) // 根据orderSn定位记录
// .eq(BizPurchaseOrderItem::getSku, item.getSku())
// .setSql("quantity_real = quantity_real - " + item.getOrder().getQuantityReal()); // SQL表达式更新：减去x值
//
// // 执行更新（返回受影响行数）
// bizPurchaseOrderItemMapper.update(null, updateOrderWrapper);
log.info("更新采购订单{}", item.getPurchaseOrderSn());
}
bizSendOrderItemMapper.insertBatch(bizSendOrderItems);
return 0;
}
}

133
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/impl/BizSendOrderItemServiceImpl.java Normal file
View File

@ -0,0 +1,133 @@
package org.asinkj.amz.service.impl;
import org.asinkj.common.core.utils.MapstructUtils;
import org.asinkj.common.core.utils.StringUtils;
import org.asinkj.common.mybatis.core.page.TableDataInfo;
import org.asinkj.common.mybatis.core.page.PageQuery;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import lombok.RequiredArgsConstructor;
import org.springframework.stereotype.Service;
import org.asinkj.amz.domain.bo.BizSendOrderItemBo;
import org.asinkj.amz.domain.vo.BizSendOrderItemVo;
import org.asinkj.amz.domain.BizSendOrderItem;
import org.asinkj.amz.mapper.BizSendOrderItemMapper;
import org.asinkj.amz.service.IBizSendOrderItemService;
import java.util.List;
import java.util.Map;
import java.util.Collection;
/**
* 供应商创建的发货单明细Service业务层处理
*
* @author shuo hu
* @date 2025-07-24
*/
@RequiredArgsConstructor
@Service
public class BizSendOrderItemServiceImpl implements IBizSendOrderItemService {
private final BizSendOrderItemMapper baseMapper;
/**
* 查询供应商创建的发货单明细
*
* @param id 主键
* @return 供应商创建的发货单明细
*/
@Override
public BizSendOrderItemVo queryById(Long id){
return baseMapper.selectVoById(id);
}
/**
* 分页查询供应商创建的发货单明细列表
*
* @param bo 查询条件
* @param pageQuery 分页参数
* @return 供应商创建的发货单明细分页列表
*/
@Override
public TableDataInfo<BizSendOrderItemVo> queryPageList(BizSendOrderItemBo bo, PageQuery pageQuery) {
LambdaQueryWrapper<BizSendOrderItem> lqw = buildQueryWrapper(bo);
Page<BizSendOrderItemVo> result = baseMapper.selectVoPage(pageQuery.build(), lqw);
return TableDataInfo.build(result);
}
/**
* 查询符合条件的供应商创建的发货单明细列表
*
* @param bo 查询条件
* @return 供应商创建的发货单明细列表
*/
@Override
public List<BizSendOrderItemVo> queryList(BizSendOrderItemBo bo) {
LambdaQueryWrapper<BizSendOrderItem> lqw = buildQueryWrapper(bo);
return baseMapper.selectVoList(lqw);
}
private LambdaQueryWrapper<BizSendOrderItem> buildQueryWrapper(BizSendOrderItemBo bo) {
Map<String, Object> params = bo.getParams();
LambdaQueryWrapper<BizSendOrderItem> lqw = Wrappers.lambdaQuery();
lqw.eq(StringUtils.isNotBlank(bo.getOrderSn()), BizSendOrderItem::getOrderSn, bo.getOrderSn());
lqw.eq(bo.getSendDate() != null, BizSendOrderItem::getSendDate, bo.getSendDate());
lqw.like(StringUtils.isNotBlank(bo.getStoreName()), BizSendOrderItem::getStoreName, bo.getStoreName());
lqw.like(StringUtils.isNotBlank(bo.getProductName()), BizSendOrderItem::getProductName, bo.getProductName());
lqw.eq(bo.getQuantitySend() != null, BizSendOrderItem::getQuantitySend, bo.getQuantitySend());
return lqw;
}
/**
* 新增供应商创建的发货单明细
*
* @param bo 供应商创建的发货单明细
* @return 是否新增成功
*/
@Override
public Boolean insertByBo(BizSendOrderItemBo bo) {
BizSendOrderItem add = MapstructUtils.convert(bo, BizSendOrderItem.class);
validEntityBeforeSave(add);
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
return flag;
}
/**
* 修改供应商创建的发货单明细
*
* @param bo 供应商创建的发货单明细
* @return 是否修改成功
*/
@Override
public Boolean updateByBo(BizSendOrderItemBo bo) {
BizSendOrderItem update = MapstructUtils.convert(bo, BizSendOrderItem.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update) > 0;
}
/**
* 保存前的数据校验
*/
private void validEntityBeforeSave(BizSendOrderItem entity){
//TODO 做一些数据校验,如唯一约束
}
/**
* 校验并批量删除供应商创建的发货单明细信息
*
* @param ids 待删除的主键集合
* @param isValid 是否进行有效性校验
* @return 是否删除成功
*/
@Override
public Boolean deleteWithValidByIds(Collection<Long> ids, Boolean isValid) {
if(isValid){
//TODO 做一些业务上的校验,判断是否需要校验
}
return baseMapper.deleteByIds(ids) > 0;
}
}

69
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/impl/BizSendOrderServiceImpl.java
View File

@ -6,11 +6,10 @@ import cn.hutool.core.util.StrUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import org.apache.dubbo.config.annotation.DubboReference;
import org.asinkj.amz.domain.*;
import org.asinkj.amz.domain.bo.BizPackingSpecsBo;
import org.asinkj.amz.domain.bo.SysAmazonStoreBo;
import org.asinkj.amz.domain.vo.SysAmazonStoreVo;
import org.asinkj.amz.mapper.BizLogisticsOrderDetailMapper;
import org.asinkj.amz.mapper.BizLogisticsOrderMapper;
import org.asinkj.amz.mapper.BizShipmentPlanMapper;
import org.asinkj.amz.mapper.*;
import org.asinkj.amz.service.IBizShipmentPlanService;
import org.asinkj.amz.service.ISysAmazonStoreService;
import org.asinkj.common.core.utils.MapstructUtils;
@ -28,7 +27,6 @@ import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.asinkj.amz.domain.bo.BizSendOrderBo;
import org.asinkj.amz.domain.vo.BizSendOrderVo;
import org.asinkj.amz.mapper.BizSendOrderMapper;
import org.asinkj.amz.service.IBizSendOrderService;
import javax.annotation.Resource;
@ -65,6 +63,9 @@ public class BizSendOrderServiceImpl implements IBizSendOrderService {
@Resource
private BizShipmentPlanMapper bizShipmentPlanMapper;
@Resource
private BizSendOrderItemMapper bizSendOrderItemMapper;
/**
* 查询供应商创建的发货单
*
@ -110,6 +111,15 @@ public class BizSendOrderServiceImpl implements IBizSendOrderService {
Map<Long, List<BizShipmentPlan>> shipmentsByOrderIdsMap = getShipmentsByOrderIds(ids);
List<Long> logicIds = records.stream().map(BizSendOrderVo::getLogisticsProviderId).distinct().toList();
Map<Long, RemoteUserVo> remoteUserVoMap = remoteUserService.selectListByIds(logicIds).stream().collect(Collectors.toMap(RemoteUserVo::getUserId, Function.identity()));
Set<Long> recordIds = records.stream().map(BizSendOrderVo::getId).collect(Collectors.toSet());
Map<Long, List<BizSendOrderItem>> sendOrderItemMap = new HashMap<>();
if (CollectionUtil.isNotEmpty(recordIds)) {
LambdaQueryWrapper<BizSendOrderItem> sendOrderItemWrapper = new LambdaQueryWrapper<>();
sendOrderItemWrapper.in(BizSendOrderItem::getMainOrderSn, recordIds);
List<BizSendOrderItem> bizSendOrderItems = bizSendOrderItemMapper.selectList(sendOrderItemWrapper);
sendOrderItemMap = bizSendOrderItems.stream().collect(Collectors.groupingBy(BizSendOrderItem::getMainOrderSn));
}
for (BizSendOrderVo record : records) {
RemoteUserVo remoteUserVo = remoteUserVoMap.get(record.getLogisticsProviderId());
if (remoteUserVo != null) {
@ -122,7 +132,13 @@ public class BizSendOrderServiceImpl implements IBizSendOrderService {
List<BizShipmentPlan> bizShipmentPlans = shipmentsByOrderIdsMap.get(record.getId());
record.setBizShipmentPlans(bizShipmentPlans);
// if (record.getType().equals("com")) {
List<BizSendOrderItem> bizSendOrderItems1 = sendOrderItemMap.get(record.getId());
record.setItems(bizSendOrderItems1);
// }
}
return TableDataInfo.build(result);
}
@ -203,16 +219,50 @@ public class BizSendOrderServiceImpl implements IBizSendOrderService {
* @param bo 供应商创建的发货单
* @return 是否新增成功
*/
@Resource
private BizPackingSpecsMapper bizPackingSpecsMapper;
@Resource
private SysUserMapper sysUserMapper;
@Override
public Boolean insertByBo(BizSendOrderBo bo) {
BizSendOrder add = MapstructUtils.convert(bo, BizSendOrder.class);
validEntityBeforeSave(add);
add.setSendId(LoginHelper.getUserId());
add.setSendName(LoginHelper.getLoginUser().getNickname());
LambdaQueryWrapper<SysUser> queryWrapper = new LambdaQueryWrapper<>();
queryWrapper.eq(SysUser::getNickName, bo.getSendName());
List<SysUser> sysUsers = sysUserMapper.selectList(queryWrapper);
if (CollectionUtil.isEmpty(sysUsers)) {
throw new RuntimeException("供应商不存在");
}
SysUser sysUser = sysUsers.get(0);
add.setSendId(sysUser.getUserId());
add.setSendName(sysUser.getNickName());
add.setCreateName(LoginHelper.getLoginUser().getNickname());
boolean flag = baseMapper.insert(add) > 0;
if (flag) {
bo.setId(add.getId());
}
BizSendOrderItem bizSendOrderItem = new BizSendOrderItem();
bizSendOrderItem.setQuantitySend(bo.getQuantitySend());
bizSendOrderItem.setOrderSn(bo.getOrderSn());
bizSendOrderItem.setMainOrderSn(add.getId());
bizSendOrderItem.setProductName(bo.getProductName());
bizSendOrderItem.setSku(bo.getSku());
bizSendOrderItemMapper.insert(bizSendOrderItem);
// List<BizPackingSpecsBo> packingSpecsList = bo.getPackingSpecsList();
// for (BizPackingSpecsBo bizPackingSpecsBo : packingSpecsList) {
// bizPackingSpecsBo.setSendOrderId(add.getId());
// }
// List<BizPackingSpecs> bizPackingSpecsList = MapstructUtils.convert(packingSpecsList, BizPackingSpecs.class);
//
// bizPackingSpecsMapper.insertBatch(bizPackingSpecsList);
return flag;
}
@ -272,4 +322,11 @@ public class BizSendOrderServiceImpl implements IBizSendOrderService {
queryWrapper.eq(BizSendOrder::getId, sendOrderId).set(BizSendOrder::getSendStatus, completed).set(BizSendOrder::getShipmentId, shipmentId);
baseMapper.update(queryWrapper);
}
@Override
public int updateDataByBo(BizSendOrderBo bo) {
BizSendOrder update = MapstructUtils.convert(bo, BizSendOrder.class);
validEntityBeforeSave(update);
return baseMapper.updateById(update);
}
}

6
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/impl/BizShipmentPlanServiceImpl.java
View File

@ -236,6 +236,7 @@ public class BizShipmentPlanServiceImpl implements IBizShipmentPlanService {
lqw.eq(StringUtils.isNotBlank(bo.getShippingSolution()), BizShipmentPlan::getShippingSolution, bo.getShippingSolution());
lqw.eq(bo.getGmtModified() != null, BizShipmentPlan::getGmtModified, bo.getGmtModified());
// lqw.eq(bo.getGmtCreate() != null, BizShipmentPlan::getGmtCreate, bo.getGmtCreate());
if (bo.getGmtCreate() != null) {
lqw.ge(BizShipmentPlan::getGmtCreate, DateUtil.beginOfDay(bo.getGmtCreate()))
.lt(BizShipmentPlan::getGmtCreate, DateUtil.endOfDay(bo.getGmtCreate()));
@ -261,11 +262,16 @@ public class BizShipmentPlanServiceImpl implements IBizShipmentPlanService {
SysAmazonStoreBo sysAmazonStoreBo = new SysAmazonStoreBo();
sysAmazonStoreBo.setUserId(LoginHelper.getUserId());
if (!LoginHelper.isSuperAdmin()) {
List<SysAmazonStoreVo> sysAmazonStoreVos = iSysAmazonStoreService.queryList(sysAmazonStoreBo);
Set<Long> collect = sysAmazonStoreVos.stream().map(SysAmazonStoreVo::getSid).collect(Collectors.toSet());
if (CollectionUtil.isNotEmpty(collect)) {
lqw.in(BizShipmentPlan::getSid, collect);
}
}
return lqw;
}

134
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/amz/service/impl/SysAmazonStoreServiceImpl.java
View File

@ -10,7 +10,7 @@ import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONArray;
import com.alibaba.fastjson2.JSONObject;
import com.alibaba.fastjson2.TypeReference;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.extern.slf4j.Slf4j;
import okhttp3.Call;
@ -87,6 +87,12 @@ public class SysAmazonStoreServiceImpl implements ISysAmazonStoreService {
@Resource
private BizPurchaseOrderItemMapper bizPurchaseOrderItemMapper;
@Resource
private BizPurchaseOutOrderMapper bizPurchaseOutOrderMapper;
@Resource
private BizOrderOutItemMapper bizOrderOutItemMapper;
@Value("${lingxing.appId}")
private String appId;
@ -504,6 +510,113 @@ public class SysAmazonStoreServiceImpl implements ISysAmazonStoreService {
}
/**
* 查询采购订单
*
* @param startDate
* @param endDate
* @param lingxinCallback
*/
@Override
public void pullPurchaseOutOrderData(String startDate, String endDate, LingxinCallback lingxinCallback) {
Map<String, Object> queryParam = new HashMap<>();
queryParam.put("offset", 0);
queryParam.put("length", 500);
queryParam.put("search_field_time", "create_time");
queryParam.put("start_date", startDate);
queryParam.put("end_date", endDate);
RequestAttributes ra = RequestContextHolder.getRequestAttributes();
HttpUtil.postWithParams("/erp/sc/routing/purchase/purchaseOutsourceOrder/getOrders", queryParam, new Callback() {
@Override
public void onFailure(@NotNull Call call, @NotNull IOException e) {
}
@Override
public void onResponse(@NotNull Call call, @NotNull Response response) throws IOException {
RequestContextHolder.setRequestAttributes(ra);
try {
String string = response.body().string();
log.info("onResponse+{}", string);
JSONObject jsonObject = JSONObject.parse(string);
JSONObject data1 = jsonObject.getJSONObject("data");
if (ObjectUtil.isEmpty(data1)) {
log.info("未获取到采购订单");
return;
}
JSONArray data = data1.getJSONArray("list");
if (ObjectUtil.isEmpty(data)) {
log.info("未获取到采购订单");
return;
}
List<PurchaseOutOrder> list = data.toList(PurchaseOutOrder.class);
log.info("purchaseOutOrder:{}", list);
//
List<String> collect = list.stream().map(PurchaseOutOrder::getOrderSn).collect(Collectors.toList());
// 删除collect 里面已经存在表里的数据
List<BizPurchaseOutOrder> bizPurchaseOutOrders = bizPurchaseOutOrderMapper.selectList(new LambdaQueryWrapper<BizPurchaseOutOrder>().in(BizPurchaseOutOrder::getOrderSn, collect));
if (CollectionUtil.isNotEmpty(bizPurchaseOutOrders)) {
List<String> collect1 = bizPurchaseOutOrders.stream().map(BizPurchaseOutOrder::getOrderSn).collect(Collectors.toList());
list.removeIf(PurchaseOutOrder -> collect1.contains(PurchaseOutOrder.getOrderSn()));
}
if (CollectionUtil.isEmpty(list)) {
log.info("未获取到新的组合采购订单");
return;
}
List<BizPurchaseOutOrder> insertList = MapstructUtils.convert(list, BizPurchaseOutOrder.class);
List<BizOrderOutItem> bizOrderOutItems = new ArrayList<>();
for (PurchaseOutOrder purchaseOutOrder : list) {
List<BizOrderOutItem> items = MapstructUtils.convert(purchaseOutOrder.getItems(), BizOrderOutItem.class);
for (BizOrderOutItem bizOrderOutItem : items) {
bizOrderOutItem.setOutOrderSn(purchaseOutOrder.getOrderSn());
bizOrderOutItem.setCreateBy(1L);
bizOrderOutItem.setCreateTime(new Date());
bizOrderOutItem.setUpdateBy(1L);
bizOrderOutItem.setUpdateTime(new Date());
}
bizOrderOutItems.addAll(items);
}
if (CollectionUtil.isNotEmpty(insertList)) {
for (BizPurchaseOutOrder bizPurchaseOutOrder : insertList) {
bizPurchaseOutOrder.setCreateBy(1L);
bizPurchaseOutOrder.setCreateTime(new Date());
bizPurchaseOutOrder.setUpdateBy(1L);
bizPurchaseOutOrder.setUpdateTime(new Date());
}
bizPurchaseOutOrderMapper.insertBatch(insertList);
}
if (CollectionUtil.isNotEmpty(bizOrderOutItems)) {
bizOrderOutItemMapper.insertBatch(bizOrderOutItems);
Set<String> purchaseOrders = bizOrderOutItems.stream().map(BizOrderOutItem::getPurchaseOrderSn).collect(Collectors.toSet());
LambdaUpdateWrapper<BizPurchaseOrder> bizPurchaseOrderLambdaUpdateWrapper = new LambdaUpdateWrapper<>();
bizPurchaseOrderLambdaUpdateWrapper.in(BizPurchaseOrder::getOrderSn, purchaseOrders);
bizPurchaseOrderLambdaUpdateWrapper.set(BizPurchaseOrder::getType,"com");
bizPurchaseOrderMapper.update(null, bizPurchaseOrderLambdaUpdateWrapper);
}
// bizPurchaseOutOrderMapper.insertBatch( convert);
} catch (Exception ex) {
log.info("错误{}", ex);
}
}
});
}
/**
* 查询采购订单
*
@ -745,8 +858,22 @@ public class SysAmazonStoreServiceImpl implements ISysAmazonStoreService {
queryParam.put("dateBegin", startDate);
queryParam.put("dateEnd", endDate);
// queryParam.put("sids", JSON.toJSON(List.of(112)));
queryParam.put("shipmentIdList", JSON.toJSON(List.of("FBA18Y3QBXGJ")));
queryParam.put("dateType", 2);
// queryParam.put("shipmentIdList", JSON.toJSON(List.of("FBA18Z3J5FZH",
// "FBA18Z3J824M",
// "FBA18Z3JSFWM",
// "FBA18Z3JYPPQ",
// "FBA18Z3H6TCQ",
// "FBA18Z1TCH2X",
// "FBA18Z1V1725",
// "FBA18Z1SC376",
// "FBA18Z1T68LG",
// "FBA18Z1SJJ2F",
// "FBA18Z2N4LHF",
// "FBA18Z2MHHFL",
// "FBA18Z2M9HXM",
// "FBA18Z2MZ2S5",
// "FBA18Z2NTCK7")));
queryParam.put("dateType", 1);
HttpUtil.postWithParams("/amzStaServer/openapi/inbound-plan/page", queryParam, new Callback() {
@Override
@ -933,6 +1060,7 @@ public class SysAmazonStoreServiceImpl implements ISysAmazonStoreService {
bizShipmentPlan.setShipmentName(shipment.getShipmentName());
bizShipmentPlan.setShipmentStatus(shipment.getStatus());
bizShipmentPlan.setDestination(shipment.getWarehouseId());
bizShipmentPlan.setItemCount(Long.valueOf(shipment.getItemCount()));
bizShipmentPlan.setStaShipmentDate(shipment.getShipingTime());
bizShipmentPlan.setSetTotal(Long.valueOf(shipment.getItemCount()));
FbaShipmentApiResponse.Address shipFromAddress = new FbaShipmentApiResponse.Address();

51
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/asinking/entity/OutOrderItem.java Normal file
View File

@ -0,0 +1,51 @@
package org.asinkj.asinking.entity;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.github.linpeilie.annotations.AutoMapper;
import io.github.linpeilie.annotations.AutoMapping;
import lombok.Data;
import org.asinkj.amz.domain.BizOrderOutItem;
import org.asinkj.amz.domain.BizPurchaseOutOrder;
import org.asinkj.amz.mapStruct.DateConvert;
import java.util.Date;
@Data
@AutoMapper(target = BizOrderOutItem.class, uses = DateConvert.class)
public class OutOrderItem {
@JsonProperty("purchase_order_sn")
private String purchaseOrderSn;
@JsonProperty("product_name")
private String productName;
@JsonProperty("sku")
private String sku;
@JsonProperty("quantity_require")
private Integer quantityRequire;
@JsonProperty("create_time")
// @JsonFormat(pattern = "yyyy-MM-dd HH:mm:ss")
@AutoMapping(qualifiedByName = "stringToDate")
private String bizCreateTime;
@JsonProperty("create_realname")
private String createRealname;
@JsonProperty("expect_arrive_time")
private String expectArriveTime;
@JsonProperty("warehouse_name")
private String warehouseName;
@JsonProperty("supplier_name")
private String supplierName;
@JsonProperty("quantity_real")
private Integer quantityReal;
@JsonProperty("quantity_entry")
private Integer quantityEntry;
}

72
asinkj-biz/asinkj-amz/src/main/java/org/asinkj/asinking/entity/PurchaseOutOrder.java Normal file
View File

@ -0,0 +1,72 @@
package org.asinkj.asinking.entity;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.annotation.JsonProperty;
import io.github.linpeilie.annotations.AutoMapper;
import io.github.linpeilie.annotations.AutoMapping;
import lombok.Data;
import org.asinkj.amz.domain.BizPurchaseOrderItem;
import org.asinkj.amz.domain.BizPurchaseOutOrder;
import org.asinkj.amz.mapStruct.DateConvert;
import java.util.Date;
import java.util.List;
@Data
@AutoMapper(target = BizPurchaseOutOrder.class, uses = DateConvert.class)
public class PurchaseOutOrder {
@JsonProperty("order_sn")
private String orderSn;
@JsonProperty("warehouse_name")
private String warehouseName;
@JsonProperty("outsource_warehouse_name")
private String outsourceWarehouseName;
@JsonProperty("supplier_name")
private String supplierName;
@JsonProperty("create_time")
@AutoMapping(qualifiedByName = "stringToDate")
private String bizCreateTime;
@JsonProperty("status_text")
private String statusText;
@JsonProperty("create_realname")
private String createRealname;
@JsonProperty("ptp_sn")
private String ptpSn;
@JsonProperty("product_name")
private String productName;
@JsonProperty("sku")
private String sku;
@JsonProperty("fnsku")
private String fnsku;
@JsonProperty("outsource_quantity")
private Integer outsourceQuantity;
@JsonProperty("receive_quantity")
private Integer receiveQuantity;
@JsonProperty("expect_arrive_time")
private String expectArriveTime;
// @JsonProperty("msku")
// private List<String> msku;
//
// @JsonProperty("plan_sn")
// private List<String> planSn;
@JsonProperty("seller_name")
private String sellerName;
@JsonProperty("item")
private List<OutOrderItem> items;
}

7
asinkj-biz/asinkj-amz/src/main/resources/mapper/amz/BizOrderOutItemMapper.xml Normal file
View File

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.asinkj.amz.mapper.BizOrderOutItemMapper">
</mapper>

7
asinkj-biz/asinkj-amz/src/main/resources/mapper/amz/BizPackingSpecsMapper.xml Normal file
View File

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.asinkj.amz.mapper.BizPackingSpecsMapper">
</mapper>

7
asinkj-biz/asinkj-amz/src/main/resources/mapper/amz/BizPurchaseOutOrderMapper.xml Normal file
View File

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.asinkj.amz.mapper.BizPurchaseOutOrderMapper">
</mapper>

7
asinkj-biz/asinkj-amz/src/main/resources/mapper/amz/BizSendOrderItemMapper.xml Normal file
View File

@ -0,0 +1,7 @@
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="org.asinkj.amz.mapper.BizSendOrderItemMapper">
</mapper>