消息推送接口开发

sckw-common/sckw-common-stream/src/main/java/com/sckw/stream/enums/MessageEnum.java

@@ -108,7 +108,7 @@ public enum MessageEnum {
     /**
      * 合作申请待审核
      */
-    COOPERATE_WAIT_APPROVAL("BUSINESS", "COOPERATE_WAIT_APPROVAL", "合作申请待审核", "【${entName}】对贵司发起了企业合作申请，请前往确认","terminal,ios,android"),
+    COOPERATE_WAIT_APPROVAL("BUSINESS", "COOPERATE_WAIT_APPROVAL", "合作申请待审核", "【${entName}】对贵司发起了企业合作申请，请前往确认", "terminal,ios,android"),
 
     /**
      * 合作申请审核通过
@@ -143,50 +143,139 @@ public enum MessageEnum {
     /**
      * 托运订单-发起物流托运
      * 触发点-贸易订单物流托运确认/承运订单分包托运确认
-     *
      */
     INITIATING_LOGISTICS_CONSIGNMENT("BUSINESS", "BUSINESS_INITIATING_LOGISTICS_CONSIGNMENT", "发起物流托运",
-            "贵司发起了对【${companyName}】的物流分配计划，请留意后续消息；订单号：${orderNo}","terminal,ios,android"),
+            "贵司发起了对【${companyName}】的物流分配计划，请留意后续消息；订单号：${orderNo}", "terminal,ios,android"),
 
     /**
      * 托运订单-自建物流订单
      */
     NEW_LOGISTICS_ORDER("BUSINESS", "BUSINESS_NEW_LOGISTICS_ORDER", "自建物流订单",
-            "贵司通过自建物流订单，发起了对【${companyName}】的物流分配计划，请留意后续消息；订单号：${orderNo}","terminal,ios,android"),
+            "贵司通过自建物流订单，发起了对【${companyName}】的物流分配计划，请留意后续消息；订单号：${orderNo}", "terminal,ios,android"),
 
     /**
      * 托运订单-撤回物流分配计划
      */
     CANCELLATION_LOGISTICS("BUSINESS", "BUSINESS_CANCELLATION_LOGISTICS", "撤回物流分配计划",
-            "贵司撤回了分配给【${companyName}】的物流分配计划，请及时确认；订单号：${orderNo}","terminal,ios,android"),
+            "贵司撤回了分配给【${companyName}】的物流分配计划，请及时确认；订单号：${orderNo}", "terminal,ios,android"),
 
     /**
      * 托运订单-承运方拒绝订单
      */
     REJECT_ORDER("BUSINESS", "BUSINESS_REJECT_ORDER", "承运方拒绝订单",
-            "你的物流托运任务被【【${companyName}】拒绝接单，请及时查看；订单号：${orderNo}","terminal,ios,android"),
+            "你的物流托运任务被【【${companyName}】拒绝接单，请及时查看；订单号：${orderNo}", "terminal,ios,android"),
     /**
      * 承运订单-有新分配的承运任务
      */
     NEW_CARRIAGE_ORDER("BUSINESS", "BUSINESS_NEW_CARRIAGE_ORDER", "有新分配的承运任务",
-            "【${companyName}】给您分配了物流承运计划，请及时查看；订单号：${orderNo}","terminal,ios,android"),
+            "【${companyName}】给您分配了物流承运计划，请及时查看；订单号：${orderNo}", "terminal,ios,android"),
     /**
      * 承运订单-自建物流订单
      */
     CARRIAGE_NEW_LOGISTICS_ORDER("BUSINESS", "BUSINESS_CARRIAGE_NEW_LOGISTICS_ORDER", "自建物流订单",
-            "贵司通过自建物流订单，发起了对【${companyName}】的物流承运计划，请及时通知往来单位；订单号：${orderNo}","terminal,ios,android"),
+            "贵司通过自建物流订单，发起了对【${companyName}】的物流承运计划，请及时通知往来单位；订单号：${orderNo}", "terminal,ios,android"),
     /**
      * 承运订单-拒绝分配计划
      */
     CARRIAGE_DISALLOTMENT("BUSINESS", "BUSINESS_CARRIAGE_DISALLOTMENT", "拒绝分配计划",
-            "贵司拒绝了【${companyName}】的物流分配计划，请及时通知往来单位；订单号：${orderNo}","terminal,ios,android"),
+            "贵司拒绝了【${companyName}】的物流分配计划，请及时通知往来单位；订单号：${orderNo}", "terminal,ios,android"),
     /**
      * 承运订单-托运方撤回承运任务
      */
     CARRIAGE_CANCELLATION_LOGISTICS("BUSINESS", "BUSINESS_CARRIAGE_CANCELLATION_LOGISTICS", "托运方撤回承运任务",
-            "【${companyName}】撤销了分配给您的物流承运计划，请及时查看；订单号：${orderNo}","terminal,ios,android"),
-
-
+            "【${companyName}】撤销了分配给您的物流承运计划，请及时查看；订单号：${orderNo}", "terminal,ios,android"),
+
+    /*对账结算*/
+    /**
+     * 销售、采购对账
+     */
+    LEDGER_SELL("BUSINESS", "BUSINESS_LEDGER_SELL", "发起销售对账",
+            "贵司发起了对【${company}】的贸易对账，请留意后续消息；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+    LEDGER_PURCHASE("BUSINESS", "BUSINESS_LEDGER_PURCHASE", "发起销售对账",
+            "【${company}】对贵司发起了贸易对账确认操作，请及时查看；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+    LEDGER_REVOCATION_SELL("BUSINESS", "BUSINESS_LEDGER_REVOCATION_SELL", "撤回对账",
+            "贵司撤回了与【${company}】的贸易对账，请及时确认并联系往来单位；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+    LEDGER_REVOCATION_PURCHASE("BUSINESS", "BUSINESS_LEDGER_REVOCATION_PURCHASE", "撤回对账",
+            "贵司撤回了与【${company}】的贸易对账，请及时确认并联系往来单位；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+
+    LEDGER_CONFIRM_SELL("BUSINESS", "BUSINESS_LEDGER_CONFIRM_SELL", "对账申请审核通过",
+            "贵司对【${company}】发起的贸易对账申请已审核通过，请及时确认；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+    LEDGER_CONFIRM_PURCHASE("BUSINESS", "BUSINESS_LEDGER_CONFIRM_PURCHASE", "对账申请审核通过",
+            "【${company}】发起的对账申请，贵司已审核通过，请确认；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+
+    LEDGER_SUCCESS_SELL("BUSINESS", "BUSINESS_LEDGER_SUCCESS_SELL", "销售对账完成",
+            "贵司完成了与【${company}】的对账，系统生成了结算单，请及时确认；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+    LEDGER_SUCCESS_PURCHASE("BUSINESS", "BUSINESS_LEDGER_SUCCESS_PURCHASE", "销售对账完成",
+            "【${company}】已完成对账流程，系统生成了结算单，请及时确认；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+
+    LEDGER_BACK_SELL("BUSINESS", "BUSINESS_LEDGER_BACK_SELL", "付款方驳回对账申请",
+            "贵司的贸易对账申请被【${company}】驳回，请及时查看；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+    LEDGER_BACK_PURCHASE("BUSINESS", "BUSINESS_LEDGER_BACK_PURCHASE", "付款方驳回对账申请",
+            "贵司驳回了与【${company}】的贸易对账，请及时确认；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+    /**
+     * 承运、托运对账
+     */
+    LEDGER_CARRIER("BUSINESS", "BUSINESS_LEDGER_CARRIER", "发起销售对账",
+            "贵司发起了对【${company}】的物流对账，请留意后续消息；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+    LEDGER_SHIPPER("BUSINESS", "BUSINESS_LEDGER_SHIPPER", "发起销售对账",
+            "【${company}】对贵司发起了物流对账确认操作，请及时查看；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+    LEDGER_REVOCATION_CARRIER("BUSINESS", "BUSINESS_LEDGER_REVOCATION_CARRIER", "撤回对账",
+            "贵司撤回了与【${company}】的物流对账，请及时确认并联系往来单位；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+    LEDGER_REVOCATION_SHIPPER("BUSINESS", "BUSINESS_LEDGER_REVOCATION_SHIPPER", "撤回对账",
+            "【${company}】撤回了对贵司发起的物流对账申请，请及时确认；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+
+    LEDGER_CONFIRM_CARRIER("BUSINESS", "BUSINESS_LEDGER_CONFIRM_CARRIER", "对账申请审核通过",
+            "贵司对【${company}】发起的物流对账申请已审核通过，请及时确认；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+    LEDGER_CONFIRM_SHIPPER("BUSINESS", "BUSINESS_LEDGER_CONFIRM_SHIPPER", "对账申请审核通过",
+            "【${company}】发起的对账申请，贵司已审核通过，请确认；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+
+    LEDGER_SUCCESS_CARRIER("BUSINESS", "BUSINESS_LEDGER_SUCCESS_CARRIER", "销售对账完成",
+            "贵司完成了与【${company}】的对账，系统生成了结算单，请及时确认；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+    LEDGER_SUCCESS_SHIPPER("BUSINESS", "BUSINESS_LEDGER_SUCCESS_SHIPPER", "销售对账完成",
+            "【${company}】已完成对账流程，系统生成了结算单，请及时确认；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+
+    LEDGER_BACK_CARRIER("BUSINESS", "BUSINESS_LEDGER_BACK_CARRIER", "付款方驳回对账申请",
+            "贵司的物流对账申请被【${company}】驳回，请及时查看；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+    LEDGER_BACK_SHIPPER("BUSINESS", "BUSINESS_LEDGER_BACK_SHIPPER", "付款方驳回对账申请",
+            "贵司驳回了与【${company}】的物流对账，请及时确认；对账单号：${number}，对账单名称：${name}", "terminal,ios,android"),
+
+    /**
+     * 销售、采购结算
+     */
+    //确认对账
+    SETTLEMENT_SELL("BUSINESS", "SETTLEMENT_SELL", "新增销售结算任务",
+            "贵司有一条新增的结算业务，请及时查看；【${company}】；结算单号：${number}", "terminal,ios,android"),
+    SETTLEMENT_PURCHASE("BUSINESS", "SETTLEMENT_PURCHASE", "新增采购结算任务",
+            "贵司有一条新增的结算业务，请及时查看；【${company}】；结算单号：${number}", "terminal,ios,android"),
+    //确认收款
+    SETTLEMENT_CONFIRM_SELL("BUSINESS", "SETTLEMENT_CONFIRM_SELL", "销售结算确认收款",
+            "贵司对一条结算单进行了确认收款操作，请及时确认；结算单号：${number}", "terminal,ios,android"),
+    SETTLEMENT_CONFIRM_PURCHASE("BUSINESS", "SETTLEMENT_CONFIRM_PURCHASE", "采购结算确认收款",
+            "【${company}】与贵司的一条结算业务已确认收款，请及时确认；结算单号：${number}", "terminal,ios,android"),
+    //发起付款
+    SETTLEMENT_START_SELL("BUSINESS", "SETTLEMENT_START_SELL", "销售付款被发起",
+            "【${company}】发起了对贵司的付款操作，请及时联系付款方进行确认；结算单号：${number}", "terminal,ios,android"),
+    SETTLEMENT_START_PURCHASE("BUSINESS", "SETTLEMENT_START_PURCHASE", "发起采购付款",
+            "贵司已发起了对【${company}】的付款操作，请及时确认并联系收款单位；结算单号：${number}", "terminal,ios,android"),
+
+    /**
+     * 承运、托运结算
+     */
+    //确认对账
+    SETTLEMENT_CARRIER("BUSINESS", "SETTLEMENT_CARRIER", "新增承运结算任务",
+            "贵司有一条新增的结算业务，请及时查看；【${company}】；结算单号：${number}", "terminal,ios,android"),
+    SETTLEMENT_SHIPPER("BUSINESS", "SETTLEMENT_SHIPPER", "新增托运结算任务",
+            "贵司有一条新增的结算业务，请及时查看；【${company}】；结算单号：${number}", "terminal,ios,android"),
+    //确认收款
+    SETTLEMENT_CONFIRM_CARRIER("BUSINESS", "SETTLEMENT_CONFIRM_CARRIER", "承运结算确认收款",
+            "贵司对一条结算单进行了确认收款操作，请及时确认；结算单号：${number}", "terminal,ios,android"),
+    SETTLEMENT_CONFIRM_SHIPPER("BUSINESS", "SETTLEMENT_CONFIRM_SHIPPER", "托运结算确认收款",
+            "【${company}】与贵司的一条结算业务已确认收款，请及时确认；结算单号：${number}", "terminal,ios,android"),
+    //发起付款
+    SETTLEMENT_START_CARRIER("BUSINESS", "SETTLEMENT_START_CARRIER", "承运付款被发起",
+            "【${company}】发起了对贵司的付款操作，请及时联系付款方进行确认；结算单号：${number}", "terminal,ios,android"),
+    SETTLEMENT_START_SHIPPER("BUSINESS", "SETTLEMENT_START_SHIPPER", "发起托运付款",
+            "贵司已发起了对【${company}】的付款操作，请及时确认并联系收款单位；结算单号：${number}", "terminal,ios,android"),
     ;
 
     /**

sckw-common/sckw-common-stream/src/main/java/com/sckw/stream/model/SckwMessage.java

@@ -1,5 +1,6 @@
 package com.sckw.stream.model;
 
+import com.sckw.core.utils.UUIDUtils;
 import com.sckw.stream.enums.MessageEnum;
 import lombok.AllArgsConstructor;
 import lombok.Data;
@@ -20,6 +21,10 @@ import java.util.Map;
 @AllArgsConstructor
 @Accessors(chain = true)
 public class SckwMessage {
+    public SckwMessage(MessageEnum messageEnum) {
+        this.messageEnum = messageEnum;
+        this.requestId = UUIDUtils.get32UUID();
+    }
 
     /**
      * 请求id

sckw-modules/sckw-payment/src/main/java/com/sckw/payment/controller/WalletController.java

@@ -1,21 +1,18 @@
 package com.sckw.payment.controller;
 
-import com.alibaba.fastjson2.JSON;
-import com.sckw.core.utils.UUIDUtils;
 import com.sckw.core.web.context.LoginUserHolder;
 import com.sckw.core.web.response.HttpResult;
 import com.sckw.payment.model.vo.req.*;
+import com.sckw.payment.service.MessageSender;
 import com.sckw.payment.service.WalletService;
 import com.sckw.stream.enums.MessageEnum;
-import com.sckw.stream.model.SckwMessage;
+import com.sckw.stream.model.UserInfo;
 import jakarta.annotation.Resource;
 import jakarta.validation.Valid;
 import lombok.extern.slf4j.Slf4j;
-import org.springframework.cloud.stream.function.StreamBridge;
 import org.springframework.validation.annotation.Validated;
 import org.springframework.web.bind.annotation.*;
 
-import java.util.ArrayList;
 import java.util.HashMap;
 
 /**
@@ -31,22 +28,6 @@ import java.util.HashMap;
 public class WalletController {
     @Resource
     private WalletService walletService;
-    @Resource
-    private StreamBridge streamBridge;
-    @GetMapping("test")
-    public HttpResult test() {
-        SckwMessage msg = new SckwMessage();
-        msg.setRequestId(UUIDUtils.get32UUID())
-                .setMessageEnum(MessageEnum.ORDER_INITIATE_SALE)
-                .setParams(new HashMap<>())
-                .setMsgUrl("")
-                .setUserInfos(new ArrayList<>())
-                .setCreateBy(LoginUserHolder.getUserId());
-        log.info("有新的提醒消息：{}", JSON.toJSONString(msg));
-        streamBridge.send("sckw-message", JSON.toJSONString(msg));
-
-        return HttpResult.ok();
-    }
     /**
      * 钱包总览信息
      *

sckw-modules/sckw-payment/src/main/java/com/sckw/payment/service/KwpLedgerLogisticsService.java

@@ -11,22 +11,23 @@ import com.sckw.core.model.enums.OrderRuleEnum;
 import com.sckw.core.model.enums.RedisOrderGenerateEnum;
 import com.sckw.core.model.page.PageRes;
 import com.sckw.core.model.vo.TableTop;
-import com.sckw.core.utils.*;
+import com.sckw.core.utils.CollectionUtils;
+import com.sckw.core.utils.IdWorker;
+import com.sckw.core.utils.OrderGenerateSeqNoUtils;
+import com.sckw.core.utils.StringTimeUtil;
 import com.sckw.core.web.context.LoginUserHolder;
 import com.sckw.core.web.response.HttpResult;
 import com.sckw.payment.dao.KwpLedgerLogisticsMapper;
 import com.sckw.payment.model.*;
 import com.sckw.payment.model.constant.LedgerEnum;
-import com.sckw.payment.model.constant.LedgerTrackEnum;
 import com.sckw.payment.model.constant.LogisticsUnitType;
 import com.sckw.payment.model.constant.SettlementEnum;
-import com.sckw.payment.model.dto.ILedger;
-import com.sckw.payment.model.dto.LedgerCarrierDto;
-import com.sckw.payment.model.dto.LedgerLogisticsDto;
-import com.sckw.payment.model.dto.LedgerShipperDto;
+import com.sckw.payment.model.dto.*;
 import com.sckw.payment.model.vo.req.*;
 import com.sckw.payment.model.vo.res.LedgerCountSumVo;
 import com.sckw.payment.model.vo.res.LedgerLogisticsDetailVo;
+import com.sckw.stream.enums.MessageEnum;
+import com.sckw.stream.model.UserInfo;
 import com.sckw.system.api.RemoteSystemService;
 import com.sckw.system.api.model.dto.res.EntCacheResDto;
 import com.sckw.system.api.model.dto.res.SysDictResDto;
@@ -63,6 +64,9 @@ public class KwpLedgerLogisticsService extends AbsLedger {
     private KwpLedgerLogisticsUnitService logisticsUnitService;
     @Resource
     private KwpLedgerLogisticsOrderService logisticsOrderService;
+    @Resource
+    private MessageSender messageSender;
+
     @Resource
     private KwpLedgerLogisticsMapper logisticsMapper;
     @DubboReference(version = "1.0.0", group = "design", check = false)
@@ -172,21 +176,31 @@ public class KwpLedgerLogisticsService extends AbsLedger {
     @GlobalTransactional(name = "default_tx_group", rollbackFor = Exception.class)
     public String sendLedger(LogisticsSendReq logisticsReq) {
         log.info("保存物流对账单：{}", JSONObject.toJSONString(logisticsReq));
-        String id = logisticsReq.getId();
-        if (StringUtils.isBlank(id)) {
-            //新增
-            logisticsReq.setGenerateTime(LocalDateTime.now());
-            logisticsReq.setStatus(LedgerEnum.TO_LEDGER.getStatus());
-            Long aLong = saveDraft(logisticsReq);
-            logisticsTrackService.saveTrack(aLong, Global.EMPTY_STRING, LedgerEnum.TO_LEDGER);
-        } else {
-            removeDraft(Long.parseLong(id));
-            logisticsReq.setGenerateTime(LocalDateTime.now());
-            logisticsReq.setStatus(LedgerEnum.TO_LEDGER.getStatus());
-            Long aLong = saveDraft(logisticsReq);
-            logisticsTrackService.saveTrack(aLong, Global.EMPTY_STRING, LedgerEnum.TO_LEDGER);
-
+        if (Objects.nonNull(logisticsReq.getIdLong())) {
+            removeDraft(logisticsReq.getIdLong());
         }
+        logisticsReq.setGenerateTime(LocalDateTime.now());
+        logisticsReq.setStatus(LedgerEnum.TO_LEDGER.getStatus());
+        IdNo idNo = saveDraft(logisticsReq);
+        logisticsTrackService.saveTrack(idNo.id(), Global.EMPTY_STRING, LedgerEnum.TO_LEDGER);
+
+        //托运方
+        KwpLedgerLogisticsUnit logisticsUnit = logisticsUnitService.queryCustomerEnt(idNo.id(), LogisticsUnitType.SHIPPER);
+        //承运方
+        KwpLedgerLogisticsUnit logisticsUnit2 = logisticsUnitService.queryCustomerEnt(idNo.id(), LogisticsUnitType.CARRIER);
+        //推送创建人
+        messageSender.sendCreate(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit.getFirmName());
+            put("number", idNo.no());
+            put("name", logisticsReq.getName());
+        }}, new UserInfo().setUserId(LoginUserHolder.getUserId()).setEntId(LoginUserHolder.getEntId()), MessageEnum.LEDGER_CARRIER);
+        //推送系统管理员
+        messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit2.getFirmName());
+            put("number", idNo.no());
+            put("name", logisticsReq.getName());
+        }}, logisticsUnit.getEntId(), MessageEnum.LEDGER_SHIPPER);
+
         return "保存对账单成功";
     }
 
@@ -210,7 +224,7 @@ public class KwpLedgerLogisticsService extends AbsLedger {
      * @param logisticsSendReq 物流对账单新增参数
      * @return
      */
-    public Long saveDraft(LogisticsSendReq logisticsSendReq) {
+    public IdNo saveDraft(LogisticsSendReq logisticsSendReq) {
         KwpLedgerLogistics kwpLedgerLogistics = new KwpLedgerLogistics();
         kwpLedgerLogistics.setId(Objects.isNull(logisticsSendReq.getIdLong()) ? new IdWorker(1).nextId() : logisticsSendReq.getIdLong());
         kwpLedgerLogistics.setEntId(LoginUserHolder.getEntId());
@@ -348,7 +362,7 @@ public class KwpLedgerLogisticsService extends AbsLedger {
 
         logisticsUnits.add(carrierUnit);
         logisticsUnitService.saveList(logisticsUnits);
-        return kwpLedgerLogistics.getId();
+        return new IdNo(kwpLedgerLogistics.getId(), kwpLedgerLogistics.getLLedgerNo());
     }
 
     /**
@@ -362,8 +376,8 @@ public class KwpLedgerLogisticsService extends AbsLedger {
         log.info("物流对账单草稿：{}", JSONObject.toJSONString(logisticsReq));
         logisticsReq.setGenerateTime(null);
         logisticsReq.setStatus(LedgerEnum.SAVE.getStatus());
-        Long aLong = saveDraft(logisticsReq);
-        logisticsTrackService.saveTrack(aLong, Global.EMPTY_STRING, LedgerEnum.SAVE);
+        IdNo aLong = saveDraft(logisticsReq);
+        logisticsTrackService.saveTrack(aLong.id(), Global.EMPTY_STRING, LedgerEnum.SAVE);
         return "草稿保存成功";
     }
 
@@ -416,6 +430,23 @@ public class KwpLedgerLogisticsService extends AbsLedger {
         kwpLedgerLogistics.setUpdateTime(LocalDateTime.now());
         logisticsMapper.updateById(kwpLedgerLogistics);
         logisticsTrackService.saveTrack(id, Global.EMPTY_STRING, LedgerEnum.REVOCATION);
+
+        //托运方
+        KwpLedgerLogisticsUnit logisticsUnit = logisticsUnitService.queryCustomerEnt(id, LogisticsUnitType.SHIPPER);
+        //承运方
+        KwpLedgerLogisticsUnit logisticsUnit2 = logisticsUnitService.queryCustomerEnt(id, LogisticsUnitType.CARRIER);
+        //推送创建人
+        messageSender.sendCreate(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit.getFirmName());
+            put("number", kwpLedgerLogistics.getLLedgerNo());
+            put("name", kwpLedgerLogistics.getName());
+        }}, new UserInfo().setUserId(LoginUserHolder.getUserId()).setEntId(LoginUserHolder.getEntId()), MessageEnum.LEDGER_REVOCATION_CARRIER);
+        //推送系统管理员
+        messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit2.getFirmName());
+            put("number", kwpLedgerLogistics.getLLedgerNo());
+            put("name", kwpLedgerLogistics.getName());
+        }}, logisticsUnit.getEntId(), MessageEnum.LEDGER_REVOCATION_SHIPPER);
         return "撤回成功";
     }
 
@@ -429,7 +460,7 @@ public class KwpLedgerLogisticsService extends AbsLedger {
         KwpLedgerLogistics kwpLedgerLogistics = logisticsMapper.selectById(id);
         orderCheck(kwpLedgerLogistics);
         backQueryCheck(kwpLedgerLogistics.getStatus());
-        return logisticsTrackService.selectOne(id, LedgerTrackEnum.REJECT);
+        return logisticsTrackService.selectOne(id, LedgerEnum.BACK);
     }
 
     /**
@@ -450,6 +481,24 @@ public class KwpLedgerLogisticsService extends AbsLedger {
         kwpLedgerLogistics.setUpdateTime(LocalDateTime.now());
         logisticsMapper.updateById(kwpLedgerLogistics);
         logisticsTrackService.saveTrack(ledgerReq.getIdLong(), ledgerReq.getRemark(), LedgerEnum.BACK);
+
+
+        //托运方
+        KwpLedgerLogisticsUnit logisticsUnit = logisticsUnitService.queryCustomerEnt(ledgerReq.getIdLong(), LogisticsUnitType.SHIPPER);
+        //承运方
+        KwpLedgerLogisticsUnit logisticsUnit2 = logisticsUnitService.queryCustomerEnt(ledgerReq.getIdLong(), LogisticsUnitType.CARRIER);
+        //推送创建人
+        messageSender.sendCreate(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit.getFirmName());
+            put("number", kwpLedgerLogistics.getLLedgerNo());
+            put("name", kwpLedgerLogistics.getName());
+        }}, new UserInfo().setUserId(LoginUserHolder.getUserId()).setEntId(LoginUserHolder.getEntId()), MessageEnum.LEDGER_BACK_CARRIER);
+        //推送系统管理员和变更人
+        messageSender.sendPurchaseBoth(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit2.getFirmName());
+            put("number", kwpLedgerLogistics.getLLedgerNo());
+            put("name", kwpLedgerLogistics.getName());
+        }}, ledgerReq.getIdLong(), logisticsUnit.getEntId(), MessageEnum.LEDGER_BACK_SHIPPER);
         return "驳回成功";
     }
 
@@ -473,6 +522,24 @@ public class KwpLedgerLogisticsService extends AbsLedger {
         kwpLedgerLogistics.setUpdateBy(LoginUserHolder.getUserId());
         logisticsMapper.updateById(kwpLedgerLogistics);
         logisticsTrackService.saveTrack(confirmReq.getIdLong(), Global.EMPTY_STRING, LedgerEnum.LEDGERED);
+
+
+        //托运方
+        KwpLedgerLogisticsUnit logisticsUnit = logisticsUnitService.queryCustomerEnt(confirmReq.getIdLong(), LogisticsUnitType.SHIPPER);
+        //承运方
+        KwpLedgerLogisticsUnit logisticsUnit2 = logisticsUnitService.queryCustomerEnt(confirmReq.getIdLong(), LogisticsUnitType.CARRIER);
+        //推送创建人
+        messageSender.sendCreate(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit.getFirmName());
+            put("number", kwpLedgerLogistics.getLLedgerNo());
+            put("name", kwpLedgerLogistics.getName());
+        }}, new UserInfo().setUserId(LoginUserHolder.getUserId()).setEntId(LoginUserHolder.getEntId()), MessageEnum.LEDGER_CONFIRM_SHIPPER);
+        //推送系统管理员和变更人
+        messageSender.sendPurchaseBoth(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit2.getFirmName());
+            put("number", kwpLedgerLogistics.getLLedgerNo());
+            put("name", kwpLedgerLogistics.getName());
+        }}, confirmReq.getIdLong(), logisticsUnit.getEntId(), MessageEnum.LEDGER_CONFIRM_SHIPPER);
         return "对账确认成功";
     }
 
@@ -529,6 +596,35 @@ public class KwpLedgerLogisticsService extends AbsLedger {
         settlementLogisticsService.save(kwpSettlementLogistics);
 
         logisticsTrackService.saveTrack(ledgerReq.getIdLong(), Global.EMPTY_STRING, LedgerEnum.SUCCESS);
+
+
+        //托运方
+        KwpLedgerLogisticsUnit logisticsUnit = logisticsUnitService.queryCustomerEnt(ledgerReq.getIdLong(), LogisticsUnitType.SHIPPER);
+        //承运方
+        KwpLedgerLogisticsUnit logisticsUnit2 = logisticsUnitService.queryCustomerEnt(ledgerReq.getIdLong(), LogisticsUnitType.CARRIER);
+        //推送创建人
+        messageSender.sendCreate(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit.getFirmName());
+            put("number", kwpLedgerLogistics.getLLedgerNo());
+            put("name", kwpLedgerLogistics.getName());
+        }}, new UserInfo().setUserId(LoginUserHolder.getUserId()).setEntId(LoginUserHolder.getEntId()), MessageEnum.LEDGER_SUCCESS_CARRIER);
+        //推送系统管理员和变更人
+        messageSender.sendPurchaseBoth(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit2.getFirmName());
+            put("number", kwpLedgerLogistics.getLLedgerNo());
+            put("name", kwpLedgerLogistics.getName());
+        }}, ledgerReq.getIdLong(), logisticsUnit.getEntId(), MessageEnum.LEDGER_SUCCESS_SHIPPER);
+
+
+        //推送双方系统管理员
+        messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit.getFirmName());
+            put("number", kwpSettlementLogistics.getSlOrderNo());
+        }}, logisticsUnit2.getEntId(), MessageEnum.SETTLEMENT_CARRIER);
+        messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit2.getFirmName());
+            put("number", kwpSettlementLogistics.getSlOrderNo());
+        }}, logisticsUnit.getEntId(), MessageEnum.SETTLEMENT_SHIPPER);
         return "对账完成";
     }
 

sckw-modules/sckw-payment/src/main/java/com/sckw/payment/service/KwpLedgerLogisticsTrackService.java

@@ -7,7 +7,6 @@ import com.sckw.core.utils.IdWorker;
 import com.sckw.payment.dao.KwpLedgerLogisticsTrackMapper;
 import com.sckw.payment.model.KwpLedgerLogisticsTrack;
 import com.sckw.payment.model.constant.LedgerEnum;
-import com.sckw.payment.model.constant.LedgerTrackEnum;
 import jakarta.validation.constraints.NotNull;
 import lombok.AllArgsConstructor;
 import org.springframework.stereotype.Service;
@@ -47,7 +46,7 @@ public class KwpLedgerLogisticsTrackService {
      * @param status 流程状态
      * @return
      */
-    public KwpLedgerLogisticsTrack selectOne(@NotNull Long id, LedgerTrackEnum status) {
+    public KwpLedgerLogisticsTrack selectOne(@NotNull Long id, LedgerEnum status) {
         LambdaQueryWrapper<KwpLedgerLogisticsTrack> wrapper = new LambdaQueryWrapper<>();
         wrapper.eq(KwpLedgerLogisticsTrack::getLLedgerId, id);
         wrapper.eq(Objects.nonNull(status), KwpLedgerLogisticsTrack::getStatus, status.getStatus());
@@ -70,4 +69,13 @@ public class KwpLedgerLogisticsTrackService {
         logisticsTrack.setDelFlag(Global.DELETED);
         logisticsTrackMapper.update(logisticsTrack, wrapper);
     }
+
+    public KwpLedgerLogisticsTrack queryLedgered(Long ledgerId) {
+        LambdaQueryWrapper<KwpLedgerLogisticsTrack> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(KwpLedgerLogisticsTrack::getLLedgerId, ledgerId);
+        wrapper.eq(KwpLedgerLogisticsTrack::getStatus, LedgerEnum.LEDGERED);
+        wrapper.eq(KwpLedgerLogisticsTrack::getDelFlag, NumberConstant.ZERO);
+        wrapper.last("limit 1");
+        return logisticsTrackMapper.selectOne(wrapper);
+    }
 }

sckw-modules/sckw-payment/src/main/java/com/sckw/payment/service/KwpLedgerLogisticsUnitService.java

@@ -1,5 +1,6 @@
 package com.sckw.payment.service;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.sckw.core.model.constant.Global;
 import com.sckw.payment.dao.KwpLedgerLogisticsUnitMapper;
@@ -10,6 +11,7 @@ import org.springframework.util.CollectionUtils;
 
 import java.time.LocalDateTime;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * @author xucaiqin
@@ -48,4 +50,15 @@ public class KwpLedgerLogisticsUnitService {
         logisticsUnitMapper.update(logisticsUnit, wrapper);
     }
 
+    public KwpLedgerLogisticsUnit queryCustomerEnt(Long id, Integer unitType) {
+        LambdaQueryWrapper<KwpLedgerLogisticsUnit> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(KwpLedgerLogisticsUnit::getLLedgerId, id)
+                .eq(KwpLedgerLogisticsUnit::getDelFlag, Global.UN_DELETED)
+                .eq(KwpLedgerLogisticsUnit::getUnitType, unitType).last("limit 1");
+        KwpLedgerLogisticsUnit kwpLedgerTradeUnit = logisticsUnitMapper.selectOne(wrapper);
+        if (Objects.isNull(kwpLedgerTradeUnit)) {
+            return new KwpLedgerLogisticsUnit();
+        }
+        return kwpLedgerTradeUnit;
+    }
 }

sckw-modules/sckw-payment/src/main/java/com/sckw/payment/service/KwpLedgerTradeService.java

@@ -19,13 +19,14 @@ import com.sckw.order.api.model.*;
 import com.sckw.payment.dao.KwpLedgerTradeMapper;
 import com.sckw.payment.model.*;
 import com.sckw.payment.model.constant.LedgerEnum;
-import com.sckw.payment.model.constant.LedgerTrackEnum;
 import com.sckw.payment.model.constant.SettlementEnum;
 import com.sckw.payment.model.constant.TradeUnitType;
 import com.sckw.payment.model.dto.*;
 import com.sckw.payment.model.vo.req.*;
 import com.sckw.payment.model.vo.res.LedgerCountSumVo;
 import com.sckw.payment.model.vo.res.LedgerTradeDetailVo;
+import com.sckw.stream.enums.MessageEnum;
+import com.sckw.stream.model.UserInfo;
 import com.sckw.system.api.RemoteSystemService;
 import com.sckw.system.api.model.dto.res.EntCacheResDto;
 import com.sckw.system.api.model.dto.res.SysDictResDto;
@@ -58,6 +59,7 @@ public class KwpLedgerTradeService extends AbsLedger {
     private final KwpLedgerTradeTrackService tradeTrackService;
     private final KwpLedgerTradeOrderService tradeOrderService;
     private final KwpLedgerTradeUnitService tradeUnitService;
+    private final MessageSender messageSender;
     @Resource
     private KwpSettlementTradeService settlementTradeService;
     @DubboReference(version = "1.0.0", group = "design", check = false)
@@ -184,7 +186,13 @@ public class KwpLedgerTradeService extends AbsLedger {
         tradeUnitService.remove(id);
     }
 
-    private Long saveDraft(TradeSendReq tradeSendReq) {
+    /**
+     * 保存草稿
+     *
+     * @param tradeSendReq
+     * @return 对账单id
+     */
+    private IdNo saveDraft(TradeSendReq tradeSendReq) {
         KwpLedgerTrade kwpLedgerTrade = new KwpLedgerTrade();
         kwpLedgerTrade.setId(Objects.isNull(tradeSendReq.getId()) ? new IdWorker(1).nextId() : tradeSendReq.getIdLong());
         kwpLedgerTrade.setEntId(LoginUserHolder.getEntId());
@@ -322,7 +330,7 @@ public class KwpLedgerTradeService extends AbsLedger {
         list.add(sellLedgerTradeUnit);
 
         tradeUnitService.saveList(list);
-        return kwpLedgerTrade.getId();
+        return new IdNo(kwpLedgerTrade.getId(), kwpLedgerTrade.getTLedgerNo());
     }
 
     /**
@@ -334,22 +342,31 @@ public class KwpLedgerTradeService extends AbsLedger {
     @Transactional(rollbackFor = Exception.class)
     public String sendLedger(TradeSendReq tradeSendReq) {
         log.info("保存对账单入参：{}", JSONObject.toJSONString(tradeSendReq));
-        if (Objects.isNull(tradeSendReq.getIdLong())) {
-            //新增
-            tradeSendReq.setGenerateTime(LocalDateTime.now());
-            tradeSendReq.setStatus(LedgerEnum.TO_LEDGER.getStatus());
-            Long aLong = saveDraft(tradeSendReq);
-            tradeTrackService.saveTrack(aLong, Global.EMPTY_STRING, LedgerEnum.TO_LEDGER);
-        } else {
+        if (Objects.nonNull(tradeSendReq.getIdLong())) {
             //先删除
             removeDraft(tradeSendReq.getIdLong());
-            //在新增
-            tradeSendReq.setGenerateTime(LocalDateTime.now());
-            tradeSendReq.setStatus(LedgerEnum.TO_LEDGER.getStatus());
-            Long aLong = saveDraft(tradeSendReq);
-            tradeTrackService.saveTrack(aLong, Global.EMPTY_STRING, LedgerEnum.TO_LEDGER);
-
         }
+        tradeSendReq.setGenerateTime(LocalDateTime.now());
+        tradeSendReq.setStatus(LedgerEnum.TO_LEDGER.getStatus());
+        IdNo idNo = saveDraft(tradeSendReq);
+        tradeTrackService.saveTrack(idNo.id(), Global.EMPTY_STRING, LedgerEnum.TO_LEDGER);
+
+        //推送消息
+        KwpLedgerTradeUnit kwpLedgerTradeUnit = tradeUnitService.queryCustomerEnt(idNo.id(), TradeUnitType.PURCHASE);
+        //推送创建人
+        messageSender.sendCreate(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", kwpLedgerTradeUnit.getFirmName());
+            put("number", idNo.no());
+            put("name", tradeSendReq.getName());
+        }}, new UserInfo().setUserId(LoginUserHolder.getUserId()).setEntId(LoginUserHolder.getEntId()), MessageEnum.LEDGER_SELL);
+
+        //推送系统管理员
+        KwpLedgerTradeUnit kwpLedgerTradeUnit2 = tradeUnitService.queryCustomerEnt(idNo.id(), TradeUnitType.SELL);
+        messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", kwpLedgerTradeUnit2.getFirmName());
+            put("number", idNo.no());
+            put("name", tradeSendReq.getName());
+        }}, kwpLedgerTradeUnit.getEntId(), MessageEnum.LEDGER_PURCHASE);
         return "保存对账单成功";
     }
 
@@ -364,8 +381,8 @@ public class KwpLedgerTradeService extends AbsLedger {
         log.info("贸易对账单保存草稿：{}", JSONObject.toJSONString(tradeSendReq));
         tradeSendReq.setGenerateTime(null);
         tradeSendReq.setStatus(LedgerEnum.SAVE.getStatus());
-        Long aLong = saveDraft(tradeSendReq);
-        tradeTrackService.saveTrack(aLong, Global.EMPTY_STRING, LedgerEnum.SAVE);
+        IdNo idNo = saveDraft(tradeSendReq);
+        tradeTrackService.saveTrack(idNo.id(), Global.EMPTY_STRING, LedgerEnum.SAVE);
         return "草稿保存成功";
     }
 
@@ -421,6 +438,22 @@ public class KwpLedgerTradeService extends AbsLedger {
         tradeMapper.updateById(kwpLedgerTrade);
 
         tradeTrackService.saveTrack(id, Global.EMPTY_STRING, LedgerEnum.REVOCATION);
+        //推送消息
+        KwpLedgerTradeUnit kwpLedgerTradeUnit = tradeUnitService.queryCustomerEnt(id, TradeUnitType.PURCHASE);
+        //推送创建人
+        messageSender.sendCreate(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", kwpLedgerTradeUnit.getFirmName());
+            put("number", kwpLedgerTrade.getTLedgerNo());
+            put("name", kwpLedgerTrade.getName());
+        }}, new UserInfo().setUserId(kwpLedgerTrade.getCreateBy()).setEntId(kwpLedgerTrade.getEntId()), MessageEnum.LEDGER_REVOCATION_SELL);
+
+        //推送系统管理员
+        KwpLedgerTradeUnit kwpLedgerTradeUnit2 = tradeUnitService.queryCustomerEnt(id, TradeUnitType.SELL);
+        messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", kwpLedgerTradeUnit2.getFirmName());
+            put("number", kwpLedgerTrade.getTLedgerNo());
+            put("name", kwpLedgerTrade.getName());
+        }}, kwpLedgerTradeUnit.getEntId(), MessageEnum.LEDGER_REVOCATION_PURCHASE);
         return "撤回成功";
     }
 
@@ -434,7 +467,7 @@ public class KwpLedgerTradeService extends AbsLedger {
         KwpLedgerTrade kwpLedgerTrade = tradeMapper.selectById(id);
         orderCheck(kwpLedgerTrade);
         backQueryCheck(kwpLedgerTrade.getStatus());
-        return tradeTrackService.selectOne(id, LedgerTrackEnum.REJECT);
+        return tradeTrackService.selectOne(id, LedgerEnum.BACK);
     }
 
     /**
@@ -454,6 +487,23 @@ public class KwpLedgerTradeService extends AbsLedger {
         kwpLedgerTrade.setUpdateTime(LocalDateTime.now());
         tradeMapper.updateById(kwpLedgerTrade);
         tradeTrackService.saveTrack(ledgerReq.getIdLong(), ledgerReq.getRemark(), LedgerEnum.BACK);
+
+        //推送消息
+        KwpLedgerTradeUnit kwpLedgerTradeUnit = tradeUnitService.queryCustomerEnt(ledgerReq.getIdLong(), TradeUnitType.PURCHASE);
+        //推送创建人
+        messageSender.sendCreate(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", kwpLedgerTradeUnit.getFirmName());
+            put("number", kwpLedgerTrade.getTLedgerNo());
+            put("name", kwpLedgerTrade.getName());
+        }}, new UserInfo().setUserId(kwpLedgerTrade.getCreateBy()).setEntId(kwpLedgerTrade.getEntId()), MessageEnum.LEDGER_BACK_SELL);
+
+        //推送系统管理员和变更人
+        KwpLedgerTradeUnit kwpLedgerTradeUnit2 = tradeUnitService.queryCustomerEnt(ledgerReq.getIdLong(), TradeUnitType.SELL);
+        messageSender.sendSellBoth(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", kwpLedgerTradeUnit2.getFirmName());
+            put("number", kwpLedgerTrade.getTLedgerNo());
+            put("name", kwpLedgerTrade.getName());
+        }}, ledgerReq.getIdLong(), kwpLedgerTradeUnit.getEntId(), MessageEnum.LEDGER_BACK_PURCHASE);
         return "驳回成功";
     }
 
@@ -477,6 +527,23 @@ public class KwpLedgerTradeService extends AbsLedger {
         kwpLedgerTrade.setUpdateTime(LocalDateTime.now());
         tradeMapper.updateById(kwpLedgerTrade);
         tradeTrackService.saveTrack(confirmReq.getIdLong(), Global.EMPTY_STRING, LedgerEnum.LEDGERED);
+
+        //推送消息
+        KwpLedgerTradeUnit kwpLedgerTradeUnit = tradeUnitService.queryCustomerEnt(confirmReq.getIdLong(), TradeUnitType.PURCHASE);
+        //推送创建人
+        messageSender.sendCreate(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", kwpLedgerTradeUnit.getFirmName());
+            put("number", kwpLedgerTrade.getTLedgerNo());
+            put("name", kwpLedgerTrade.getName());
+        }}, new UserInfo().setUserId(kwpLedgerTrade.getCreateBy()).setEntId(kwpLedgerTrade.getEntId()), MessageEnum.LEDGER_CONFIRM_SELL);
+
+        //推送系统管理员和变更人
+        KwpLedgerTradeUnit kwpLedgerTradeUnit2 = tradeUnitService.queryCustomerEnt(confirmReq.getIdLong(), TradeUnitType.SELL);
+        messageSender.sendSellBoth(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", kwpLedgerTradeUnit2.getFirmName());
+            put("number", kwpLedgerTrade.getTLedgerNo());
+            put("name", kwpLedgerTrade.getName());
+        }}, confirmReq.getIdLong(), kwpLedgerTradeUnit.getEntId(), MessageEnum.LEDGER_CONFIRM_PURCHASE);
         return "对账确认成功";
     }
 
@@ -546,6 +613,35 @@ public class KwpLedgerTradeService extends AbsLedger {
         }
         //保存操作记录
         tradeTrackService.saveTrack(id, Global.EMPTY_STRING, LedgerEnum.SUCCESS);
+
+
+        //推送消息
+        KwpLedgerTradeUnit kwpLedgerTradeUnit = tradeUnitService.queryCustomerEnt(ledgerReq.getIdLong(), TradeUnitType.PURCHASE);
+        //推送创建人
+        messageSender.sendCreate(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", kwpLedgerTradeUnit.getFirmName());
+            put("number", kwpLedgerTrade.getTLedgerNo());
+            put("name", kwpLedgerTrade.getName());
+        }}, new UserInfo().setUserId(kwpLedgerTrade.getCreateBy()).setEntId(kwpLedgerTrade.getEntId()), MessageEnum.LEDGER_SUCCESS_SELL);
+
+        //推送系统管理员和变更人
+        KwpLedgerTradeUnit kwpLedgerTradeUnit2 = tradeUnitService.queryCustomerEnt(ledgerReq.getIdLong(), TradeUnitType.SELL);
+        messageSender.sendSellBoth(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", kwpLedgerTradeUnit2.getFirmName());
+            put("number", kwpLedgerTrade.getTLedgerNo());
+            put("name", kwpLedgerTrade.getName());
+        }}, ledgerReq.getIdLong(), kwpLedgerTradeUnit.getEntId(), MessageEnum.LEDGER_SUCCESS_PURCHASE);
+
+        //推送双方系统管理员
+        messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", kwpLedgerTradeUnit.getFirmName());
+            put("number", kwpSettlementTrade.getStOrderNo());
+        }}, kwpLedgerTradeUnit2.getEntId(), MessageEnum.SETTLEMENT_SELL);
+        messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", kwpLedgerTradeUnit2.getFirmName());
+            put("number", kwpSettlementTrade.getStOrderNo());
+        }}, kwpLedgerTradeUnit.getEntId(), MessageEnum.SETTLEMENT_PURCHASE);
+
         return "对账完成";
     }
 
@@ -760,8 +856,7 @@ public class KwpLedgerTradeService extends AbsLedger {
         }
         //过滤筛选条件
         if (StringUtils.isNotBlank(ledgerListReq.getKeywords())) {
-            return detailRes.stream().filter(o -> StringUtils.contains(o.getTOrderNo(), ledgerListReq.getKeywords()) ||
-                    StringUtils.contains(o.getGoodsName(), ledgerListReq.getKeywords())).toList();
+            return detailRes.stream().filter(o -> StringUtils.contains(o.getTOrderNo(), ledgerListReq.getKeywords()) || StringUtils.contains(o.getGoodsName(), ledgerListReq.getKeywords())).toList();
         }
         return detailRes;
     }

sckw-modules/sckw-payment/src/main/java/com/sckw/payment/service/KwpLedgerTradeTrackService.java

@@ -7,7 +7,6 @@ import com.sckw.core.utils.IdWorker;
 import com.sckw.payment.dao.KwpLedgerTradeTrackMapper;
 import com.sckw.payment.model.KwpLedgerTradeTrack;
 import com.sckw.payment.model.constant.LedgerEnum;
-import com.sckw.payment.model.constant.LedgerTrackEnum;
 import jakarta.validation.constraints.NotNull;
 import lombok.AllArgsConstructor;
 import org.springframework.stereotype.Service;
@@ -48,7 +47,7 @@ public class KwpLedgerTradeTrackService {
      * @param status 流程状态
      * @return
      */
-    public KwpLedgerTradeTrack selectOne(@NotNull Long id, LedgerTrackEnum status) {
+    public KwpLedgerTradeTrack selectOne(@NotNull Long id, LedgerEnum status) {
         LambdaQueryWrapper<KwpLedgerTradeTrack> wrapper = new LambdaQueryWrapper<>();
         wrapper.eq(KwpLedgerTradeTrack::getTLedgerId, id);
         wrapper.eq(Objects.nonNull(status), KwpLedgerTradeTrack::getStatus, status.getStatus());
@@ -72,4 +71,19 @@ public class KwpLedgerTradeTrackService {
         tradeTrack.setDelFlag(Global.DELETED);
         tradeTrackMapper.update(tradeTrack, wrapper);
     }
+
+    /**
+     * 查询已对账的操作记录
+     *
+     * @param id
+     * @return
+     */
+    public KwpLedgerTradeTrack queryLedgered(Long id) {
+        LambdaQueryWrapper<KwpLedgerTradeTrack> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(KwpLedgerTradeTrack::getTLedgerId, id);
+        wrapper.eq(KwpLedgerTradeTrack::getStatus, LedgerEnum.LEDGERED);
+        wrapper.eq(KwpLedgerTradeTrack::getDelFlag, NumberConstant.ZERO);
+        wrapper.last("limit 1");
+        return tradeTrackMapper.selectOne(wrapper);
+    }
 }

sckw-modules/sckw-payment/src/main/java/com/sckw/payment/service/KwpLedgerTradeUnitService.java

@@ -1,5 +1,6 @@
 package com.sckw.payment.service;
 
+import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.sckw.core.model.constant.Global;
 import com.sckw.payment.dao.KwpLedgerTradeUnitMapper;
@@ -10,6 +11,7 @@ import org.springframework.stereotype.Service;
 
 import java.time.LocalDateTime;
 import java.util.List;
+import java.util.Objects;
 
 /**
  * @author xucaiqin
@@ -48,4 +50,20 @@ public class KwpLedgerTradeUnitService {
         tradeUnitMapper.update(kwpLedgerTradeUnit, wrapper);
     }
 
+    /**
+     * 根据对账单id查询对方企业信息
+     *
+     * @param id       对账单id
+     * @param unitType 对方企业类型
+     * @return 不为空
+     */
+    public KwpLedgerTradeUnit queryCustomerEnt(Long id, Integer unitType) {
+        LambdaQueryWrapper<KwpLedgerTradeUnit> wrapper = new LambdaQueryWrapper<>();
+        wrapper.eq(KwpLedgerTradeUnit::getTLedgerId, id).eq(KwpLedgerTradeUnit::getDelFlag, Global.UN_DELETED).eq(KwpLedgerTradeUnit::getUnitType, unitType).last("limit 1");
+        KwpLedgerTradeUnit kwpLedgerTradeUnit = tradeUnitMapper.selectOne(wrapper);
+        if (Objects.isNull(kwpLedgerTradeUnit)) {
+            return new KwpLedgerTradeUnit();
+        }
+        return kwpLedgerTradeUnit;
+    }
 }

sckw-modules/sckw-payment/src/main/java/com/sckw/payment/service/KwpSettlementOfflineService.java

@@ -27,6 +27,7 @@ import com.sckw.payment.model.vo.req.SettlementOfflineReq;
 import com.sckw.payment.model.vo.res.SettlementOfflineVo;
 import com.sckw.redis.config.RedisLockUtil;
 import com.sckw.redis.constant.RedisConstant;
+import com.sckw.stream.enums.MessageEnum;
 import com.sckw.system.api.RemoteSystemService;
 import com.sckw.system.api.model.dto.res.UserCacheResDto;
 import io.seata.spring.annotation.GlobalTransactional;
@@ -61,7 +62,8 @@ public class KwpSettlementOfflineService {
     private final KwpLedgerTradeOrderService tradeOrderService;
     private final KwpSettlementTradeTrackService settlementTradeTrackService;
     private final KwpLedgerTradeService ledgerTradeService;
-
+    private final MessageSender messageSender;
+    private final KwpLedgerTradeUnitService tradeUnitService;
     @DubboReference(version = "1.0.0", group = "design", check = false)
     private RemoteSystemService remoteSystemService;
     @DubboReference(version = "1.0.0", group = "design", check = false)
@@ -70,6 +72,7 @@ public class KwpSettlementOfflineService {
     private final KwpSettlementLogisticsService kwpSettlementLogisticsService;
     private final KwpSettlementLogisticsMapper kwpSettlementLogisticsMapper;
     private final KwpSettlementLogisticsTrackMapper kwpSettlementLogisticsTrackMapper;
+    private final KwpLedgerLogisticsUnitService logisticsUnitService;
 
     /**
      * 物流-线下付款(运费收款)记录-列表
@@ -237,6 +240,20 @@ public class KwpSettlementOfflineService {
             kwpSettlementOffline.setDelFlag(0);
             return settlementOfflineMapper.insert(kwpSettlementOffline);
         }
+        //托运方
+        KwpLedgerLogisticsUnit logisticsUnit = logisticsUnitService.queryCustomerEnt(settlementLogisticsDto.getLLedgerId(), LogisticsUnitType.SHIPPER);
+        //承运方
+        KwpLedgerLogisticsUnit logisticsUnit2 = logisticsUnitService.queryCustomerEnt(settlementLogisticsDto.getLLedgerId(), LogisticsUnitType.CARRIER);
+
+        //推送双方系统管理员
+        messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit.getFirmName());
+            put("number", settlementLogisticsDto.getSlOrderNo());
+        }}, logisticsUnit2.getEntId(), MessageEnum.SETTLEMENT_CONFIRM_CARRIER);
+        messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit2.getFirmName());
+            put("number", settlementLogisticsDto.getSlOrderNo());
+        }}, logisticsUnit.getEntId(), MessageEnum.SETTLEMENT_CONFIRM_SHIPPER);
         return null;
     }
 
@@ -376,6 +393,18 @@ public class KwpSettlementOfflineService {
                 //记录表记录数据
                 settlementTradeTrackService.save(KwpSettlementTradeTrack.build(byId.getId(), SettlementTrackEnum.OFFLINE_PAY.getStatus()));
 
+                KwpLedgerTradeUnit kwpLedgerTradeUnit = tradeUnitService.queryCustomerEnt(byId.getLedgerId(), TradeUnitType.PURCHASE);
+                KwpLedgerTradeUnit kwpLedgerTradeUnit2 = tradeUnitService.queryCustomerEnt(byId.getLedgerId(), TradeUnitType.SELL);
+                //推送双方系统管理员
+                messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+                    put("company", kwpLedgerTradeUnit.getFirmName());
+                    put("number", kwpSettlementTrade.getStOrderNo());
+                }}, kwpLedgerTradeUnit2.getEntId(), MessageEnum.SETTLEMENT_CONFIRM_SELL);
+                messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+                    put("company", kwpLedgerTradeUnit2.getFirmName());
+                    put("number", kwpSettlementTrade.getStOrderNo());
+                }}, kwpLedgerTradeUnit.getEntId(), MessageEnum.SETTLEMENT_CONFIRM_PURCHASE);
+
                 //中台接口 todo-xcq
                 return "确认回款成功";
             } finally {

sckw-modules/sckw-payment/src/main/java/com/sckw/payment/service/KwpSettlementWalletService.java

@@ -32,6 +32,7 @@ import com.sckw.payment.model.vo.req.WalletPayReq;
 import com.sckw.payment.model.vo.res.SettlementWalletVo;
 import com.sckw.redis.config.RedisLockUtil;
 import com.sckw.redis.constant.RedisConstant;
+import com.sckw.stream.enums.MessageEnum;
 import com.sckw.system.api.RemoteSystemService;
 import com.sckw.system.api.model.dto.res.UserCacheResDto;
 import com.sckw.transport.api.dubbo.TransportDubboService;
@@ -72,6 +73,10 @@ public class KwpSettlementWalletService {
     private final KwpWalletRelationService walletRelationService;
     private final RedisLockUtil redisLockUtil;
     private final KwpSettlementTradeTrackService settlementTradeTrackService;
+    private final MessageSender messageSender;
+    private final KwpLedgerTradeUnitService tradeUnitService;
+    private final KwpLedgerLogisticsUnitService logisticsUnitService;
+
     @DubboReference(version = "1.0.0", group = "design", check = false)
     private RemoteSystemService remoteSystemService;
     @DubboReference(version = "1.0.0", group = "design", check = false)
@@ -254,6 +259,21 @@ public class KwpSettlementWalletService {
 
             return insertKwpSettlementWallet;
         }
+
+        //托运方
+        KwpLedgerLogisticsUnit logisticsUnit = logisticsUnitService.queryCustomerEnt(settlementLogisticsDto.getLLedgerId(), LogisticsUnitType.SHIPPER);
+        //承运方
+        KwpLedgerLogisticsUnit logisticsUnit2 = logisticsUnitService.queryCustomerEnt(settlementLogisticsDto.getLLedgerId(), LogisticsUnitType.CARRIER);
+
+        //推送双方系统管理员
+        messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit.getFirmName());
+            put("number", settlementLogisticsDto.getSlOrderNo());
+        }}, logisticsUnit2.getEntId(), MessageEnum.SETTLEMENT_START_CARRIER);
+        messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+            put("company", logisticsUnit2.getFirmName());
+            put("number", settlementLogisticsDto.getSlOrderNo());
+        }}, logisticsUnit.getEntId(), MessageEnum.SETTLEMENT_START_SHIPPER);
         return null;
     }
 
@@ -396,6 +416,19 @@ public class KwpSettlementWalletService {
                         tradeOrderInfoService.updateOrderStatus(updateOrderStatusParam);
                     }
                 }
+
+                KwpLedgerTradeUnit kwpLedgerTradeUnit = tradeUnitService.queryCustomerEnt(byId.getLedgerId(), TradeUnitType.PURCHASE);
+                KwpLedgerTradeUnit kwpLedgerTradeUnit2 = tradeUnitService.queryCustomerEnt(byId.getLedgerId(), TradeUnitType.SELL);
+                //推送双方系统管理员
+                messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+                    put("company", kwpLedgerTradeUnit.getFirmName());
+                    put("number", kwpSettlementTrade.getStOrderNo());
+                }}, kwpLedgerTradeUnit2.getEntId(), MessageEnum.SETTLEMENT_START_SELL);
+                messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+                    put("company", kwpLedgerTradeUnit2.getFirmName());
+                    put("number", kwpSettlementTrade.getStOrderNo());
+                }}, kwpLedgerTradeUnit.getEntId(), MessageEnum.SETTLEMENT_START_PURCHASE);
+
                 //todo-xcq 调用中台接口
 
                 return "付款确认成功";
@@ -558,7 +591,21 @@ public class KwpSettlementWalletService {
                     updateOrderStatusParam.setUpdateByName(LoginUserHolder.getUserName());
                     tradeOrderInfoService.updateOrderStatus(updateOrderStatusParam);
                 }
+
+                KwpLedgerTradeUnit kwpLedgerTradeUnit = tradeUnitService.queryCustomerEnt(byId.getLedgerId(), TradeUnitType.PURCHASE);
+                KwpLedgerTradeUnit kwpLedgerTradeUnit2 = tradeUnitService.queryCustomerEnt(byId.getLedgerId(), TradeUnitType.SELL);
+                //推送双方系统管理员
+                messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+                    put("company", kwpLedgerTradeUnit.getFirmName());
+                    put("number", kwpSettlementTrade.getStOrderNo());
+                }}, kwpLedgerTradeUnit2.getEntId(), MessageEnum.SETTLEMENT_CONFIRM_SELL);
+                messageSender.sendManager(LoginUserHolder.getUserId(), new HashMap<>() {{
+                    put("company", kwpLedgerTradeUnit2.getFirmName());
+                    put("number", kwpSettlementTrade.getStOrderNo());
+                }}, kwpLedgerTradeUnit.getEntId(), MessageEnum.SETTLEMENT_CONFIRM_PURCHASE);
+
                 //todo-xcq 调用中台接口
+
                 return "确认回款成功";
             } finally {
                 redisLockUtil.unlock(key);