订单拓展

sckw-modules/sckw-order/src/main/java/com/sckw/order/controller/KwoTradeOrderController.java

@@ -7,10 +7,13 @@ import com.sckw.core.utils.CollectionUtils;
 import com.sckw.core.web.constant.HttpStatus;
 import com.sckw.core.web.response.HttpResult;
 import com.sckw.excel.utils.ExcelUtil;
-import com.sckw.order.api.model.TradeOrderPara;
 import com.sckw.order.api.model.OrderPara;
+import com.sckw.order.api.model.TradeOrderPara;
+import com.sckw.order.model.vo.KwoTradeOrderArchiveVo;
+import com.sckw.order.model.vo.SaleTopVo;
 import com.sckw.order.model.vo.req.*;
 import com.sckw.order.serivce.KwoTradeOrderService;
+import com.sckw.payment.api.model.dto.common.R;
 import io.seata.spring.annotation.GlobalTransactional;
 import io.swagger.v3.oas.annotations.Operation;
 import io.swagger.v3.oas.annotations.tags.Tag;
@@ -21,6 +24,7 @@ import org.springframework.http.MediaType;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
+import java.math.BigDecimal;
 import java.util.List;
 
 /**
@@ -370,4 +374,30 @@ public class KwoTradeOrderController {
         return HttpResult.ok("订单撤销成功");
     }
 
+    /**
+     * 客户销售排行
+     */
+    @GetMapping("/saleTop")
+    @Operation(summary = "客户销售排行", description = "客户销售排行")
+    public R<List<SaleTopVo>> saleTop() {
+        return R.ok(kwoTradeOrderService.saleTop());
+    }
+
+    /**
+     * 累计交易金额
+     *
+     * @return
+     */
+    @GetMapping("/saleSum")
+    @Operation(summary = "累计交易金额", description = "累计交易金额")
+    public R<BigDecimal> saleSum() {
+        return R.ok(kwoTradeOrderService.saleSum());
+    }
+
+    @GetMapping("/saleSummary")
+    @Operation(summary = "商品销售排行", description = "商品销售排行")
+    public R<List<KwoTradeOrderArchiveVo>> saleSummary() {
+        return R.ok(kwoTradeOrderService.saleSummary());
+    }
+
 }

sckw-modules/sckw-order/src/main/java/com/sckw/order/dao/KwoTradeOrderArchiveMapper.java

@@ -0,0 +1,17 @@
+package com.sckw.order.dao;
+
+import com.baomidou.mybatisplus.core.mapper.BaseMapper;
+import com.sckw.order.model.KwoTradeOrderArchive;
+import com.sckw.order.model.vo.KwoTradeOrderArchiveVo;
+import org.apache.ibatis.annotations.Mapper;
+
+import java.util.List;
+
+/**
+ * @author xucaiqin
+ * @date 2026-04-27 10:13:13
+ */
+@Mapper
+public interface KwoTradeOrderArchiveMapper extends BaseMapper<KwoTradeOrderArchive> {
+    List<KwoTradeOrderArchiveVo> summary();
+}

sckw-modules/sckw-order/src/main/java/com/sckw/order/dao/KwoTradeOrderMapper.java

@@ -6,10 +6,12 @@ import com.sckw.order.api.model.*;
 import com.sckw.order.model.KwoTradeOrder;
 import com.sckw.order.model.SalesReportRawData;
 import com.sckw.order.model.dto.*;
+import com.sckw.order.model.vo.SaleTopVo;
 import com.sckw.order.model.vo.res.TradeOrderAppStatisticVO;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 
+import java.math.BigDecimal;
 import java.time.LocalDateTime;
 import java.util.Date;
 import java.util.List;
@@ -172,4 +174,11 @@ public interface KwoTradeOrderMapper extends BaseMapper<KwoTradeOrder> {
     List<SalesReportRawData> querySalesReportRawData(@Param("curEntId") Long curEntId,
                                                      @Param("customerId") Long customerId,
                                                      @Param("goodsId") Long goodsId);
+
+    List<SaleTopVo> saleTop();
+
+    BigDecimal saleSum();
+
+    List<TradeOrderDto> joinSelect();
+
 }

sckw-modules/sckw-order/src/main/java/com/sckw/order/model/KwoTradeOrder.java

@@ -148,6 +148,10 @@ public class KwoTradeOrder extends BaseModel implements Serializable {
      */
     @TableField("add_vehicles")
     private Integer addVehicles;
+    /**
+     * 归档标识 1-已归档
+     */
+    private Integer archiveFlag;
 
 
 }

sckw-modules/sckw-order/src/main/java/com/sckw/order/model/KwoTradeOrderArchive.java

@@ -0,0 +1,71 @@
+package com.sckw.order.model;
+
+import com.baomidou.mybatisplus.annotation.IdType;
+import com.baomidou.mybatisplus.annotation.TableField;
+import com.baomidou.mybatisplus.annotation.TableId;
+import com.baomidou.mybatisplus.annotation.TableName;
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+* @date 2026-04-27 10:13:13
+* @author xucaiqin
+*/
+/**
+    * 交易订单（采购订单/销售订单）
+    */
+@Schema(description="交易订单（采购订单/销售订单）")
+@Data
+@TableName(value = "kwo_trade_order_archive")
+public class KwoTradeOrderArchive {
+    /**
+     * 主键
+     */
+    @TableId(value = "id", type = IdType.AUTO)
+    @Schema(description="主键")
+    private Long id;
+
+    /**
+     * 贸易订单id
+     */
+    @TableField(value = "trade_order_id")
+    @Schema(description="贸易订单id")
+    private Long tradeOrderId;
+
+    /**
+     * 商品id
+     */
+    @TableField(value = "goods_id")
+    @Schema(description="商品id")
+    private Long goodsId;
+
+    /**
+     * 商品品名
+     */
+    @TableField(value = "product_name")
+    @Schema(description="商品品名")
+    private String productName;
+
+    /**
+     * 商品规格
+     */
+    @TableField(value = "product_spec")
+    @Schema(description="商品规格")
+    private String productSpec;
+
+    /**
+     * 商品成交单价
+     */
+    @TableField(value = "unit_price")
+    @Schema(description="商品成交单价")
+    private BigDecimal unitPrice;
+
+    /**
+     * 货物数量
+     */
+    @TableField(value = "amount")
+    @Schema(description="货物数量")
+    private BigDecimal amount;
+}

sckw-modules/sckw-order/src/main/java/com/sckw/order/model/vo/KwoTradeOrderArchiveVo.java

@@ -0,0 +1,48 @@
+package com.sckw.order.model.vo;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.math.BigDecimal;
+
+/**
+* @date 2026-04-27 10:13:13
+* @author xucaiqin
+*/
+
+
+@Schema(description="交易订单（采购订单/销售订单）")
+@Data
+public class KwoTradeOrderArchiveVo {
+
+
+    @Schema(description="最高价")
+    private BigDecimal maxPrice;
+    @Schema(description="最低价")
+    private BigDecimal minPrice;
+    @Schema(description="销售均价")
+    private BigDecimal avgPrice;
+    @Schema(description="销售额")
+    private BigDecimal salePrice;
+
+    /**
+     * 商品品名
+     */
+    @Schema(description="商品品名")
+    private String productName;
+    @Schema(description="占比")
+    private String percent;
+
+    /**
+     * 商品规格
+     */
+    @Schema(description="商品规格")
+    private String productSpec;
+
+
+    /**
+     * 货物数量
+     */
+    @Schema(description="完成总量")
+    private BigDecimal amount;
+}

sckw-modules/sckw-order/src/main/java/com/sckw/order/model/vo/SaleTopVo.java

@@ -0,0 +1,28 @@
+package com.sckw.order.model.vo;
+
+import io.swagger.v3.oas.annotations.media.Schema;
+import lombok.Data;
+
+import java.io.Serial;
+import java.io.Serializable;
+import java.math.BigDecimal;
+
+
+@Data
+@Schema(description = "数据统计-销售")
+public class SaleTopVo implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 7143305943655450894L;
+
+    @Schema(description = "名次")
+    private Integer sort;
+
+
+    @Schema(description = "企业名称")
+    private String entName;
+
+
+    @Schema(description = "总金额")
+    private BigDecimal amount;
+}

sckw-modules/sckw-order/src/main/java/com/sckw/order/serivce/KwoTradeOrderArchiveServiceImpl.java

@@ -0,0 +1,15 @@
+package com.sckw.order.serivce;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.sckw.order.dao.KwoTradeOrderArchiveMapper;
+import com.sckw.order.model.KwoTradeOrderArchive;
+import com.sckw.payment.service.KwoTradeOrderArchiveService;
+import org.springframework.stereotype.Service;
+/**
+* @date 2026-04-27 10:13:13
+* @author xucaiqin
+*/
+@Service
+public class KwoTradeOrderArchiveServiceImpl extends ServiceImpl<KwoTradeOrderArchiveMapper, KwoTradeOrderArchive> implements KwoTradeOrderArchiveService{
+
+}

sckw-modules/sckw-order/src/main/java/com/sckw/order/serivce/KwoTradeOrderService.java

@@ -42,11 +42,14 @@ import com.sckw.manage.api.RemoteManageService;
 import com.sckw.manage.api.model.dto.res.FindEntCooperateResVo;
 import com.sckw.mongo.model.SckwTradeOrder;
 import com.sckw.order.api.model.*;
+import com.sckw.order.dao.KwoTradeOrderArchiveMapper;
 import com.sckw.order.dao.KwoTradeOrderMapper;
 import com.sckw.order.enums.ContractStatusEnum;
 import com.sckw.order.enums.*;
 import com.sckw.order.model.*;
 import com.sckw.order.model.dto.*;
+import com.sckw.order.model.vo.KwoTradeOrderArchiveVo;
+import com.sckw.order.model.vo.SaleTopVo;
 import com.sckw.order.model.vo.req.ContractInfo;
 import com.sckw.order.model.vo.req.*;
 import com.sckw.order.model.vo.res.GoodsInfoDetailRes;
@@ -143,6 +146,7 @@ public class KwoTradeOrderService {
     private PaymentFeignService paymentFeignService;
 
     private final KwoTradeOrderMapper kwoTradeOrderMapper;
+    private final KwoTradeOrderArchiveMapper kwoTradeOrderArchiveMapper;
     private final StreamBridge streamBridge;
     private final KwoTradeOrderAddressService kwoTradeOrderAddressService;
     private final KwoTradeOrderUnitService kwoTradeOrderUnitService;
@@ -2249,7 +2253,7 @@ public class KwoTradeOrderService {
             walletFreeze.setOrderType(4);
             walletFreeze.setTradeType(4);
             walletFreeze.setRemark("贸易订单号：" + walletFreeze.getOrderNo() + ",下单冻结");
-            log.info("贸易订单号：{}，订单下单调用钱包服务冻结预付余额，参数：{}", walletFreeze.getOrderNo(),JSON.toJSONString(walletFreeze));
+            log.info("贸易订单号：{}，订单下单调用钱包服务冻结预付余额，参数：{}", walletFreeze.getOrderNo(), JSON.toJSONString(walletFreeze));
             freezeBaseResult = paymentFeignService.updatePrepaidBalance(walletFreeze);
         }
 
@@ -2295,16 +2299,16 @@ public class KwoTradeOrderService {
         freezeDto.setRemark("贸易订单号：" + freezeDto.getOrderNo() + ",撤销订单");
         BaseResult<Object> balanceResult;
         try {
-            log.info("贸易订单号：{}，订单撤销调用钱包服务解冻预付余额，参数：{}", freezeDto.getOrderNo(),JSON.toJSONString(freezeDto));
+            log.info("贸易订单号：{}，订单撤销调用钱包服务解冻预付余额，参数：{}", freezeDto.getOrderNo(), JSON.toJSONString(freezeDto));
             balanceResult = paymentFeignService.updatePrepaidBalance(freezeDto);
         } catch (Exception e) {
-            String errMsg = freezeDto.getRemark()+"异常";
+            String errMsg = freezeDto.getRemark() + "异常";
             log.error(errMsg, e);
             throw new BusinessException(errMsg);
         }
         if (balanceResult == null || balanceResult.getCode() != HttpStatus.SUCCESS_CODE || !Boolean.TRUE.equals(balanceResult.getData())) {
-            String errMsg = freezeDto.getRemark()+"失败";
-            log.error("{}:{}", errMsg, balanceResult != null ? balanceResult.getMessage(): "");
+            String errMsg = freezeDto.getRemark() + "失败";
+            log.error("{}:{}", errMsg, balanceResult != null ? balanceResult.getMessage() : "");
             throw new BusinessException(errMsg);
         }
 
@@ -2443,7 +2447,7 @@ public class KwoTradeOrderService {
 
             } else if (Objects.equals(kwoTradeOrder.getSettlement(), 2)) {
                 //预付制结算解冻
-                log.info("贸易订单号：{}，订单审核拒绝调用钱包服务解冻预付余额，参数：{}", walletFreeze.getOrderNo(),JSON.toJSONString(walletFreeze));
+                log.info("贸易订单号：{}，订单审核拒绝调用钱包服务解冻预付余额，参数：{}", walletFreeze.getOrderNo(), JSON.toJSONString(walletFreeze));
                 booleanBaseResult = paymentFeignService.updatePrepaidBalance(walletFreeze);
             }
             if (booleanBaseResult.getCode() != 60200) {
@@ -2842,7 +2846,7 @@ public class KwoTradeOrderService {
                 unFreezePrepaidDto.setOrderType(4);
                 unFreezePrepaidDto.setTradeType(5);
                 unFreezePrepaidDto.setRemark("贸易订单：" + unFreezePrepaidDto.getOrderNo() + ",");
-                log.info("贸易订单号：{}，订单完结调用钱包服务解冻预付余额，参数：{}", unFreezePrepaidDto.getOrderNo(),JSON.toJSONString(unFreezePrepaidDto));
+                log.info("贸易订单号：{}，订单完结调用钱包服务解冻预付余额，参数：{}", unFreezePrepaidDto.getOrderNo(), JSON.toJSONString(unFreezePrepaidDto));
                 BaseResult<Object> unFreezeResult = paymentFeignService.updatePrepaidBalance(unFreezePrepaidDto);
                 if (unFreezeResult.getCode() != HttpStatus.SUCCESS_CODE) {
                     log.error("贸易订单号：{}，订单完结解冻失败,异常信息为：{}", unFreezePrepaidDto.getOrderNo(), unFreezeResult.getMessage());
@@ -2857,7 +2861,7 @@ public class KwoTradeOrderService {
                 unFreezePrepaidDto.setTradeType(6);
                 consumePrepaidDto.setTradeAmount(kwoTradeOrder.getPrice());
                 consumePrepaidDto.setRemark("贸易订单号：" + consumePrepaidDto.getOrderNo() + "，订单完结消费");
-                log.info("贸易订单号：{}，订单完结调用钱包服务消费预付余额，参数：{}", consumePrepaidDto.getOrderNo(),JSON.toJSONString(consumePrepaidDto));
+                log.info("贸易订单号：{}，订单完结调用钱包服务消费预付余额，参数：{}", consumePrepaidDto.getOrderNo(), JSON.toJSONString(consumePrepaidDto));
                 BaseResult<Object> consumeResult = paymentFeignService.updatePrepaidBalance(consumePrepaidDto);
                 if (consumeResult.getCode() != HttpStatus.SUCCESS_CODE) {
                     log.error("贸易订单号：{}，订单完结消费失败,异常信息为：{}", consumePrepaidDto.getOrderNo(), consumeResult.getMessage());
@@ -3142,4 +3146,15 @@ public class KwoTradeOrderService {
 
     }
 
+    public List<SaleTopVo> saleTop() {
+        return kwoTradeOrderMapper.saleTop();
+    }
+
+    public BigDecimal saleSum() {
+        return kwoTradeOrderMapper.saleSum();
+    }
+
+    public List<KwoTradeOrderArchiveVo> saleSummary() {
+        return kwoTradeOrderArchiveMapper.summary();
+    }
 }

sckw-modules/sckw-order/src/main/java/com/sckw/order/task/TradeOrderTask.java

@@ -4,6 +4,7 @@ import cn.hutool.core.collection.CollUtil;
 import cn.hutool.core.util.NumberUtil;
 import com.alibaba.fastjson2.JSON;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
+import com.sckw.core.common.enums.enums.DictTypeEnum;
 import com.sckw.core.exception.BusinessException;
 import com.sckw.core.model.constant.Global;
 import com.sckw.core.model.enums.CooperateTypeEnum;
@@ -11,16 +12,23 @@ import com.sckw.core.model.enums.LogisticsOrderV1Enum;
 import com.sckw.core.utils.DateUtils;
 import com.sckw.core.web.constant.HttpStatus;
 import com.sckw.core.web.response.BaseResult;
+import com.sckw.order.api.model.TradeOrderDto;
 import com.sckw.order.dao.KwoTradeOrderGoodsMapper;
 import com.sckw.order.dao.KwoTradeOrderMapper;
 import com.sckw.order.dao.KwoTradeOrderUnitMapper;
 import com.sckw.order.enums.TradeOrderStatusEnum;
 import com.sckw.order.model.KwoTradeOrder;
+import com.sckw.order.model.KwoTradeOrderArchive;
 import com.sckw.order.model.KwoTradeOrderGoods;
 import com.sckw.order.model.KwoTradeOrderUnit;
 import com.sckw.payment.api.dubbo.PaymentDubboService;
 import com.sckw.payment.api.feign.PaymentFeignService;
 import com.sckw.payment.api.model.feign.WalletPrepaidDto;
+import com.sckw.payment.service.KwoTradeOrderArchiveService;
+import com.sckw.product.api.dubbo.GoodsInfoService;
+import com.sckw.product.api.model.KwpGoods;
+import com.sckw.system.api.RemoteSystemService;
+import com.sckw.system.api.model.dto.res.DictProduct;
 import com.sckw.transport.api.dubbo.TransportRemoteService;
 import com.sckw.transport.api.model.param.OrderFinishParam;
 import com.sckw.transport.api.model.vo.KwtLogisticsOrderVO;
@@ -49,6 +57,8 @@ public class TradeOrderTask {
     @Resource
     private KwoTradeOrderMapper kwoTradeOrderMapper;
     @Resource
+    private KwoTradeOrderArchiveService kwoTradeOrderArchiveService;
+    @Resource
     private KwoTradeOrderUnitMapper kwoTradeOrderUnitMapper;
     @Resource
     private KwoTradeOrderGoodsMapper kwoTradeOrderGoodsMapper;
@@ -56,6 +66,10 @@ public class TradeOrderTask {
     private TransportRemoteService transportRemoteService;
     @DubboReference(version = "1.0.0", group = "design", check = false, timeout = 8000)
     private PaymentDubboService paymentDubboService;
+    @DubboReference(version = "1.0.0", group = "design", check = false)
+    private GoodsInfoService goodsInfoService;
+    @DubboReference(version = "1.0.0", group = "design", check = false)
+    private RemoteSystemService remoteSystemService;
 
     @Autowired
     private PaymentFeignService paymentFeignService;
@@ -64,10 +78,7 @@ public class TradeOrderTask {
     @Scheduled(cron = "0 0/5 * * * ?")
     public void task() {
         log.info("定时任务");
-        List<KwoTradeOrder> kwoTradeOrders = kwoTradeOrderMapper.selectList(new LambdaQueryWrapper<KwoTradeOrder>()
-                .eq(KwoTradeOrder::getStatus, TradeOrderStatusEnum.DEAL.getCode())
-                .eq(KwoTradeOrder::getDelFlag, Global.UN_DELETED)
-        );
+        List<KwoTradeOrder> kwoTradeOrders = kwoTradeOrderMapper.selectList(new LambdaQueryWrapper<KwoTradeOrder>().eq(KwoTradeOrder::getStatus, TradeOrderStatusEnum.DEAL.getCode()).eq(KwoTradeOrder::getDelFlag, Global.UN_DELETED));
         if (CollUtil.isNotEmpty(kwoTradeOrders)) {
             for (KwoTradeOrder kwoTradeOrder : kwoTradeOrders) {
                 List<KwtLogisticsOrderVO> logisticOrderList = transportRemoteService.getLogisticOrderList(new OrderFinishParam(kwoTradeOrder.getId()));
@@ -76,9 +87,7 @@ public class TradeOrderTask {
                     threadPoolExecutor.execute(() -> {
                         log.info("没有物流订单结算");
                         try {
-                            List<KwoTradeOrderUnit> orderUnits = kwoTradeOrderUnitMapper.selectList(new LambdaQueryWrapper<KwoTradeOrderUnit>().eq(KwoTradeOrderUnit::getTOrderId, kwoTradeOrder.getId())
-                                    .eq(KwoTradeOrderUnit::getDelFlag, 0)
-                            );
+                            List<KwoTradeOrderUnit> orderUnits = kwoTradeOrderUnitMapper.selectList(new LambdaQueryWrapper<KwoTradeOrderUnit>().eq(KwoTradeOrderUnit::getTOrderId, kwoTradeOrder.getId()).eq(KwoTradeOrderUnit::getDelFlag, 0));
                             if (CollUtil.isEmpty(orderUnits) || orderUnits.size() < 2) {
                                 log.error("订单异常，未找到关联企业。订单id {}", kwoTradeOrder.getId());
                                 return;
@@ -86,11 +95,7 @@ public class TradeOrderTask {
                             Map<String, KwoTradeOrderUnit> unitMap = orderUnits.stream().collect(Collectors.toMap(KwoTradeOrderUnit::getUnitType, Function.identity(), (a, b) -> a));
                             BigDecimal sum = new BigDecimal("0");
 
-                            KwoTradeOrderGoods kwoTradeOrderGoods = kwoTradeOrderGoodsMapper.selectOne(new LambdaQueryWrapper<KwoTradeOrderGoods>()
-                                    .eq(KwoTradeOrderGoods::getDelFlag, 0)
-                                    .eq(KwoTradeOrderGoods::getTOrderId, kwoTradeOrder.getId())
-                                    .last("limit 1")
-                            );
+                            KwoTradeOrderGoods kwoTradeOrderGoods = kwoTradeOrderGoodsMapper.selectOne(new LambdaQueryWrapper<KwoTradeOrderGoods>().eq(KwoTradeOrderGoods::getDelFlag, 0).eq(KwoTradeOrderGoods::getTOrderId, kwoTradeOrder.getId()).last("limit 1"));
 
                             //更新贸易订单状态
 //                            WalletFreeze walletFreeze = new WalletFreeze();
@@ -108,10 +113,10 @@ public class TradeOrderTask {
                             try {
                                 Boolean aBoolean = transportRemoteService.logisticOrderFinish(new OrderFinishParam(kwoTradeOrder.getId()));
                             } catch (Exception e) {
-                                log.error("物流订单结算失败 {}",e.getMessage());
+                                log.error("物流订单结算失败 {}", e.getMessage());
                             }
                             kwoTradeOrder.setPrice(NumberUtil.mul(sum, kwoTradeOrderGoods.getUnitPrice()));
-                            calculatePrepaidBalance(kwoTradeOrder,unitMap);
+                            calculatePrepaidBalance(kwoTradeOrder, unitMap);
                         } catch (Exception ex) {
                             log.error("更新订单异常{}", ex.getMessage());
                         }
@@ -120,9 +125,7 @@ public class TradeOrderTask {
                     if (logisticOrderList.stream().allMatch(d -> Arrays.asList(LogisticsOrderV1Enum.COMPLETED.getCode(), LogisticsOrderV1Enum.REJECT_ORDER.getCode()).contains(d.getStatus()))) {
                         threadPoolExecutor.execute(() -> {
                             try {
-                                List<KwoTradeOrderUnit> orderUnits = kwoTradeOrderUnitMapper.selectList(new LambdaQueryWrapper<KwoTradeOrderUnit>().eq(KwoTradeOrderUnit::getTOrderId, kwoTradeOrder.getId())
-                                        .eq(KwoTradeOrderUnit::getDelFlag, 0)
-                                );
+                                List<KwoTradeOrderUnit> orderUnits = kwoTradeOrderUnitMapper.selectList(new LambdaQueryWrapper<KwoTradeOrderUnit>().eq(KwoTradeOrderUnit::getTOrderId, kwoTradeOrder.getId()).eq(KwoTradeOrderUnit::getDelFlag, 0));
                                 if (CollUtil.isEmpty(orderUnits) || orderUnits.size() < 2) {
                                     log.error("订单异常，未找到关联企业。订单id {}", kwoTradeOrder.getId());
                                     return;
@@ -135,11 +138,7 @@ public class TradeOrderTask {
                                 } else {
                                     sum = logisticOrderList.stream().map(KwtLogisticsOrderVO::getUnloadAmount).filter(Objects::nonNull).reduce(BigDecimal.ZERO, BigDecimal::add);
                                 }
-                                KwoTradeOrderGoods kwoTradeOrderGoods = kwoTradeOrderGoodsMapper.selectOne(new LambdaQueryWrapper<KwoTradeOrderGoods>()
-                                        .eq(KwoTradeOrderGoods::getDelFlag, 0)
-                                        .eq(KwoTradeOrderGoods::getTOrderId, kwoTradeOrder.getId())
-                                        .last("limit 1")
-                                );
+                                KwoTradeOrderGoods kwoTradeOrderGoods = kwoTradeOrderGoodsMapper.selectOne(new LambdaQueryWrapper<KwoTradeOrderGoods>().eq(KwoTradeOrderGoods::getDelFlag, 0).eq(KwoTradeOrderGoods::getTOrderId, kwoTradeOrder.getId()).last("limit 1"));
 
                                 //更新贸易订单状态
 //                                WalletFreeze walletFreeze = new WalletFreeze();
@@ -157,10 +156,10 @@ public class TradeOrderTask {
                                 try {
                                     Boolean aBoolean = transportRemoteService.logisticOrderFinish(new OrderFinishParam(kwoTradeOrder.getId()));
                                 } catch (Exception e) {
-                                    log.error("物流订单结算失败 {}",e.getMessage());
+                                    log.error("物流订单结算失败 {}", e.getMessage());
                                 }
                                 kwoTradeOrder.setPrice(NumberUtil.mul(sum, kwoTradeOrderGoods.getUnitPrice()));
-                                calculatePrepaidBalance(kwoTradeOrder,unitMap);
+                                calculatePrepaidBalance(kwoTradeOrder, unitMap);
                             } catch (Exception ex) {
                                 log.error("更新订单异常{}", ex.getMessage());
                             }
@@ -172,11 +171,7 @@ public class TradeOrderTask {
             }
 
         }
-        List<KwoTradeOrder> kwoTradeOrders2 = kwoTradeOrderMapper.selectList(new LambdaQueryWrapper<KwoTradeOrder>()
-                .in(KwoTradeOrder::getStatus, List.of(TradeOrderStatusEnum.AUDIT.getCode(), TradeOrderStatusEnum.ING.getCode()))
-                .lt(KwoTradeOrder::getEndTime, DateUtils.getEndOfDay(new Date()))
-                .eq(KwoTradeOrder::getDelFlag, Global.UN_DELETED)
-        );
+        List<KwoTradeOrder> kwoTradeOrders2 = kwoTradeOrderMapper.selectList(new LambdaQueryWrapper<KwoTradeOrder>().in(KwoTradeOrder::getStatus, List.of(TradeOrderStatusEnum.AUDIT.getCode(), TradeOrderStatusEnum.ING.getCode())).lt(KwoTradeOrder::getEndTime, DateUtils.getEndOfDay(new Date())).eq(KwoTradeOrder::getDelFlag, Global.UN_DELETED));
         if (CollUtil.isNotEmpty(kwoTradeOrders2)) {
             threadPoolExecutor.execute(() -> {
                 Map<Integer, List<KwoTradeOrder>> collect = kwoTradeOrders2.stream().collect(Collectors.groupingBy(KwoTradeOrder::getStatus));
@@ -194,16 +189,14 @@ public class TradeOrderTask {
 //                            log.info("解冻结果：{}", JSONObject.toJSONString(booleanBaseResult));
                             kwoTradeOrder.setStatus(TradeOrderStatusEnum.SUCCESS.getCode());
                             kwoTradeOrderMapper.updateById(kwoTradeOrder);
-                            List<KwoTradeOrderUnit> orderUnits = kwoTradeOrderUnitMapper.selectList(new LambdaQueryWrapper<KwoTradeOrderUnit>().eq(KwoTradeOrderUnit::getTOrderId, kwoTradeOrder.getId())
-                                    .eq(KwoTradeOrderUnit::getDelFlag, 0)
-                            );
+                            List<KwoTradeOrderUnit> orderUnits = kwoTradeOrderUnitMapper.selectList(new LambdaQueryWrapper<KwoTradeOrderUnit>().eq(KwoTradeOrderUnit::getTOrderId, kwoTradeOrder.getId()).eq(KwoTradeOrderUnit::getDelFlag, 0));
                             if (CollUtil.isEmpty(orderUnits) || orderUnits.size() < 2) {
                                 log.error("订单异常，未找到关联企业。订单id {}", kwoTradeOrder.getId());
                                 return;
                             }
                             Map<String, KwoTradeOrderUnit> unitMap = orderUnits.stream().collect(Collectors.toMap(KwoTradeOrderUnit::getUnitType, Function.identity(), (a, b) -> a));
 //                            unFreezePrepaid(kwoTradeOrder,unitMap);
-                            calculatePrepaidBalance(kwoTradeOrder,unitMap);
+                            calculatePrepaidBalance(kwoTradeOrder, unitMap);
                         }
                     }
                     if (Objects.equals(one.getKey(), TradeOrderStatusEnum.ING.getCode())) {
@@ -213,7 +206,7 @@ public class TradeOrderTask {
                             try {
                                 Boolean aBoolean = transportRemoteService.logisticOrderFinish(new OrderFinishParam(kwoTradeOrder.getId()));
                             } catch (Exception e) {
-                                log.error("物流订单结算失败 {}",e.getMessage());
+                                log.error("物流订单结算失败 {}", e.getMessage());
                             }
                         }
                     }
@@ -222,13 +215,49 @@ public class TradeOrderTask {
         }
     }
 
-    private void calculatePrepaidBalance(KwoTradeOrder kwoTradeOrder,Map<String, KwoTradeOrderUnit> unitMap){
-        if(Objects.equals(kwoTradeOrder.getStatus(),TradeOrderStatusEnum.SUCCESS.getCode())){
+    @Scheduled(cron = "0 0/1 * * * ?")
+    public void task2() {
+        List<TradeOrderDto> tradeOrderDtos = kwoTradeOrderMapper.joinSelect();
+        if (CollUtil.isNotEmpty(tradeOrderDtos)) {
+            Map<String, Map<String, String>> dict = remoteSystemService.queryDictByType(List.of(DictTypeEnum.GOODS_SPEC.getType()));
+            Map<String, String> goodsSpecMap = dict.get(DictTypeEnum.GOODS_SPEC.getType());
+
+            Map<Long, KwpGoods> goodsByIds = goodsInfoService.getGoodsByIds(tradeOrderDtos.stream().map(TradeOrderDto::getGoodsId).toList());
+            List<KwoTradeOrderArchive> list = tradeOrderDtos.stream().map(d -> {
+                KwoTradeOrderArchive kwoTradeOrderArchive = new KwoTradeOrderArchive();
+                kwoTradeOrderArchive.setTradeOrderId(d.getId());
+                kwoTradeOrderArchive.setGoodsId(d.getGoodsId());
+                KwpGoods kwpGoods = goodsByIds.get(d.getGoodsId());
+                if (Objects.nonNull(kwpGoods)) {
+                    DictProduct dictProduct = remoteSystemService.queryProductName(kwpGoods.getGoodsType());
+                    if (Objects.nonNull(dictProduct)) {
+                        kwoTradeOrderArchive.setProductName(dictProduct.getLabel());
+                    }
+                    kwoTradeOrderArchive.setProductSpec(goodsSpecMap.get(kwpGoods.getSpec()));
+                }
+
+                kwoTradeOrderArchive.setUnitPrice(d.getUnitPrice());
+                kwoTradeOrderArchive.setAmount(d.getAmount());
+                return kwoTradeOrderArchive;
+
+            }).toList();
+            kwoTradeOrderArchiveService.saveBatch(list);
+            for (TradeOrderDto tradeOrderDto : tradeOrderDtos) {
+                KwoTradeOrder kwoTradeOrder = new KwoTradeOrder();
+                kwoTradeOrder.setId(tradeOrderDto.getId());
+                kwoTradeOrder.setArchiveFlag(1);
+                kwoTradeOrderMapper.updateById(kwoTradeOrder);
+            }
+        }
+    }
+
+    private void calculatePrepaidBalance(KwoTradeOrder kwoTradeOrder, Map<String, KwoTradeOrderUnit> unitMap) {
+        if (Objects.equals(kwoTradeOrder.getStatus(), TradeOrderStatusEnum.SUCCESS.getCode())) {
             //贸易订单已完结，计算预付余额
-            if(Objects.equals(kwoTradeOrder.getSettlement(),1)){
+            if (Objects.equals(kwoTradeOrder.getSettlement(), 1)) {
                 //todo 普通结算
 
-            }else if(Objects.equals(kwoTradeOrder.getSettlement(),2)){
+            } else if (Objects.equals(kwoTradeOrder.getSettlement(), 2)) {
                 //预付制模式
                 //1解冻运费
                 if (unitMap.keySet().size() < 2) {
@@ -241,12 +270,12 @@ public class TradeOrderTask {
                 unFreezePrepaidDto.setSupEntId(unitMap.get(String.valueOf(CooperateTypeEnum.SUPPLIER.getCode())).getEntId());
                 unFreezePrepaidDto.setOrderType(4);
                 unFreezePrepaidDto.setTradeType(5);
-                unFreezePrepaidDto.setRemark("贸易订单："+unFreezePrepaidDto.getOrderNo()+",");
-                log.info("贸易订单号：{}，订单完结调用钱包服务解冻预付余额，参数：{}", unFreezePrepaidDto.getOrderNo(),JSON.toJSONString(unFreezePrepaidDto));
+                unFreezePrepaidDto.setRemark("贸易订单：" + unFreezePrepaidDto.getOrderNo() + ",");
+                log.info("贸易订单号：{}，订单完结调用钱包服务解冻预付余额，参数：{}", unFreezePrepaidDto.getOrderNo(), JSON.toJSONString(unFreezePrepaidDto));
                 BaseResult<Object> unFreezeResult = paymentFeignService.updatePrepaidBalance(unFreezePrepaidDto);
-                if(unFreezeResult.getCode()!= HttpStatus.SUCCESS_CODE){
-                    log.error("贸易订单号：{}，订单完结解冻失败,异常信息为：{}",unFreezePrepaidDto.getOrderNo(),unFreezeResult.getMessage());
-                    throw new BusinessException("贸易订单号："+unFreezePrepaidDto.getOrderNo()+"，订单完结解冻失败");
+                if (unFreezeResult.getCode() != HttpStatus.SUCCESS_CODE) {
+                    log.error("贸易订单号：{}，订单完结解冻失败,异常信息为：{}", unFreezePrepaidDto.getOrderNo(), unFreezeResult.getMessage());
+                    throw new BusinessException("贸易订单号：" + unFreezePrepaidDto.getOrderNo() + "，订单完结解冻失败");
                 }
                 //2计算订单金额
                 WalletPrepaidDto consumePrepaidDto = new WalletPrepaidDto();
@@ -256,19 +285,19 @@ public class TradeOrderTask {
                 unFreezePrepaidDto.setOrderType(4);
                 unFreezePrepaidDto.setTradeType(6);
                 consumePrepaidDto.setTradeAmount(kwoTradeOrder.getPrice());
-                consumePrepaidDto.setRemark("贸易订单号："+consumePrepaidDto.getOrderNo()+"，订单完结消费");
-                log.info("贸易订单号：{}，订单完结调用钱包服务消费预付余额，参数：{}", consumePrepaidDto.getOrderNo(),JSON.toJSONString(consumePrepaidDto));
+                consumePrepaidDto.setRemark("贸易订单号：" + consumePrepaidDto.getOrderNo() + "，订单完结消费");
+                log.info("贸易订单号：{}，订单完结调用钱包服务消费预付余额，参数：{}", consumePrepaidDto.getOrderNo(), JSON.toJSONString(consumePrepaidDto));
                 BaseResult<Object> consumeResult = paymentFeignService.updatePrepaidBalance(consumePrepaidDto);
-                if(consumeResult.getCode()!= HttpStatus.SUCCESS_CODE){
-                    log.error("贸易订单号：{}，订单完结消费失败,异常信息为：{}",consumePrepaidDto.getOrderNo(),consumeResult.getMessage());
-                    throw new BusinessException("贸易订单号："+consumePrepaidDto.getOrderNo()+"，订单完结消费失败");
+                if (consumeResult.getCode() != HttpStatus.SUCCESS_CODE) {
+                    log.error("贸易订单号：{}，订单完结消费失败,异常信息为：{}", consumePrepaidDto.getOrderNo(), consumeResult.getMessage());
+                    throw new BusinessException("贸易订单号：" + consumePrepaidDto.getOrderNo() + "，订单完结消费失败");
                 }
             }
         }
 
     }
 
-    private void unFreezePrepaid(KwoTradeOrder kwoTradeOrder,Map<String, KwoTradeOrderUnit> unitMap){
+    private void unFreezePrepaid(KwoTradeOrder kwoTradeOrder, Map<String, KwoTradeOrderUnit> unitMap) {
         //预付制模式
         //1解冻运费
         if (unitMap.keySet().size() < 2) {
@@ -281,12 +310,12 @@ public class TradeOrderTask {
         unFreezePrepaidDto.setSupEntId(unitMap.get(String.valueOf(CooperateTypeEnum.SUPPLIER.getCode())).getEntId());
         unFreezePrepaidDto.setOrderType(4);
         unFreezePrepaidDto.setTradeType(5);
-        unFreezePrepaidDto.setRemark("贸易订单："+unFreezePrepaidDto.getOrderNo()+",");
-        log.info("贸易订单号：{}，订单完结调用钱包服务解冻预付余额，参数：{}", unFreezePrepaidDto.getOrderNo(),JSON.toJSONString(unFreezePrepaidDto));
+        unFreezePrepaidDto.setRemark("贸易订单：" + unFreezePrepaidDto.getOrderNo() + ",");
+        log.info("贸易订单号：{}，订单完结调用钱包服务解冻预付余额，参数：{}", unFreezePrepaidDto.getOrderNo(), JSON.toJSONString(unFreezePrepaidDto));
         BaseResult<Object> unFreezeResult = paymentFeignService.updatePrepaidBalance(unFreezePrepaidDto);
-        if(unFreezeResult.getCode()!= HttpStatus.SUCCESS_CODE){
-            log.error("贸易订单号：{}，订单完结解冻失败,异常信息为：{}",unFreezePrepaidDto.getOrderNo(),unFreezeResult.getMessage());
-            throw new BusinessException("贸易订单号："+unFreezePrepaidDto.getOrderNo()+"，订单完结解冻失败");
+        if (unFreezeResult.getCode() != HttpStatus.SUCCESS_CODE) {
+            log.error("贸易订单号：{}，订单完结解冻失败,异常信息为：{}", unFreezePrepaidDto.getOrderNo(), unFreezeResult.getMessage());
+            throw new BusinessException("贸易订单号：" + unFreezePrepaidDto.getOrderNo() + "，订单完结解冻失败");
         }
     }
 }

sckw-modules/sckw-order/src/main/java/com/sckw/payment/service/KwoTradeOrderArchiveService.java

@@ -0,0 +1,12 @@
+package com.sckw.payment.service;
+
+import com.sckw.order.model.KwoTradeOrderArchive;
+import com.baomidou.mybatisplus.extension.service.IService;
+    /**
+* @date 2026-04-27 10:13:13
+* @author xucaiqin
+*/
+public interface KwoTradeOrderArchiveService extends IService<KwoTradeOrderArchive>{
+
+
+}

sckw-modules/sckw-order/src/main/resources/mapper/KwoTradeOrderArchiveMapper.xml

@@ -0,0 +1,39 @@
+<?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="com.sckw.order.dao.KwoTradeOrderArchiveMapper">
+  <resultMap id="BaseResultMap" type="com.sckw.order.model.KwoTradeOrderArchive">
+    <!--@mbg.generated-->
+    <!--@Table kwo_trade_order_archive-->
+    <id column="id" jdbcType="BIGINT" property="id" />
+    <result column="trade_order_id" jdbcType="BIGINT" property="tradeOrderId" />
+    <result column="goods_id" jdbcType="BIGINT" property="goodsId" />
+    <result column="product_name" jdbcType="VARCHAR" property="productName" />
+    <result column="product_spec" jdbcType="VARCHAR" property="productSpec" />
+    <result column="unit_price" jdbcType="DECIMAL" property="unitPrice" />
+    <result column="amount" jdbcType="DECIMAL" property="amount" />
+  </resultMap>
+  <sql id="Base_Column_List">
+    <!--@mbg.generated-->
+    id, trade_order_id, goods_id, product_name, product_spec, unit_price, amount
+  </sql>
+
+  <select id="summary" resultType="com.sckw.order.model.vo.KwoTradeOrderArchiveVo">
+    SELECT
+      product_name,
+      product_spec,
+      MAX(unit_price) AS maxPrice,
+      MIN(unit_price) AS minPrice,
+      SUM(amount),
+      ROUND(SUM(unit_price * amount) / SUM(amount), 2) AS avgPrice,
+      ROUND(SUM(unit_price * amount) / 10000, 2) AS salePrice,
+      ROUND(100 * SUM(unit_price * amount) / total_sales, 2) AS percent
+    FROM
+      kwo_trade_order_archive
+        CROSS JOIN
+      (SELECT SUM(unit_price * amount) AS total_sales FROM kwo_trade_order_archive) AS t
+    GROUP BY
+      product_name, product_spec
+    ORDER BY
+      amount DESC;
+    </select>
+</mapper>

sckw-modules/sckw-order/src/main/resources/mapper/KwoTradeOrderMapper.xml

@@ -1004,4 +1004,44 @@
             limit 5
         </where>
     </select>
+
+    <select id="saleTop" resultType="com.sckw.order.model.vo.SaleTopVo">
+        select ROW_NUMBER() OVER (ORDER BY amount DESC) AS sort,
+               sum(kto.price)                           as amount,
+               d.firm_name                                 entName
+        from kwo_trade_order kto
+                 inner JOIN kwo_trade_order_unit d ON kto.id = d.t_order_id AND d.unit_type = '1' AND d.del_flag = 0
+        <where>
+            kto.del_flag = 0
+              and kto.status = 4
+            group by kto.id,
+                     d.firm_name
+        </where>
+    </select>
+
+    <select id="saleSum" resultType="java.math.BigDecimal">
+        select
+        sum(kto.price)                           as amount
+        from kwo_trade_order kto
+        <where>
+            kto.del_flag = 0
+            and kto.status = 4
+            group by kto.id
+        </where>
+    </select>
+
+    <select id="joinSelect" resultType="com.sckw.order.api.model.TradeOrderDto">
+        select kto.id,
+               ktog.goods_id,
+               kto.amount,
+               ktog.unit_price
+        from kwo_trade_order kto
+                 inner join kwo_trade_order_goods ktog on kto.id = ktog.t_order_id and ktog.del_flag = 0
+        <where>
+            kto.del_flag = 0
+              and kto.archive_flag != 1
+              and kto.status = 4
+            limit 20
+        </where>
+    </select>
 </mapper>