Merge remote-tracking branch 'origin/dev' into dev

sckw-common/sckw-common-core/src/main/java/com/sckw/core/model/vo/TableStatisticRes.java

@@ -5,6 +5,8 @@ import lombok.Setter;
 import lombok.ToString;
 import lombok.experimental.Accessors;
 
+import java.io.Serial;
+import java.io.Serializable;
 import java.util.List;
 
 /**
@@ -16,7 +18,10 @@ import java.util.List;
 @Setter
 @ToString
 @Accessors(chain = true)
-public class TableStatisticRes {
+public class TableStatisticRes implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 1699225803039367149L;
 
     /**
      * 表格顶部对象

sckw-common/sckw-common-core/src/main/java/com/sckw/core/model/vo/TableTop.java

@@ -5,6 +5,9 @@ import lombok.Setter;
 import lombok.ToString;
 import lombok.experimental.Accessors;
 
+import java.io.Serial;
+import java.io.Serializable;
+
 /**
  * @desc: 表格顶部对象
  * @author: yzc
@@ -14,7 +17,10 @@ import lombok.experimental.Accessors;
 @Setter
 @ToString
 @Accessors(chain = true)
-public class TableTop {
+public class TableTop implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = -2419518869931408146L;
 
     /**
      * tab名称

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

@@ -15,177 +15,194 @@ public enum MessageEnum {
      * 上架商品
      */
     PRODUCT_ON_SHELVES("SYSTEM", "SYSTEM_PRODUCT_ON_SHELVES", "商品已上架",
-            "贵司的商品：${productName}，已上架至商城中，请确认相关信息", "terminal,ios,android"),
+            "贵司的商品：${productName}，已上架至商城中，请确认相关信息", "terminal,ios,android", ""),
     /**
      * 下架商品
      */
     PRODUCT_REMOVED_SHELVES("SYSTEM", "SYSTEM_PRODUCT_REMOVED_SHELVES", "商品已下架",
-            "贵司的商品：${productName}，已从商城中下架了，请确认相关信息", "terminal,ios,android"),
+            "贵司的商品：${productName}，已从商城中下架了，请确认相关信息", "terminal,ios,android", ""),
     /**
      * 采发起采购下单
      */
     ORDER_INITIATE_PURCHASE("BUSINESS", "BUSINESS_ORDER_INITIATE_PURCHASE", "发起采购下单",
-            "贵司发起了对【${firmName}】的商品采购申请，请留意后续消息；订单号:${orderNo}", "terminal,ios,android"),
+            "贵司发起了对【${firmName}】的商品采购申请，请留意后续消息；订单号:${orderNo}", "terminal,ios,android", ""),
     /**
      * 有新的待受理订单
      */
     ORDER_NEW_PENDING("BUSINESS", "BUSINESS_ORDER_NEW_PENDING", "有新的待受理订单",
-            "【${firmName}】发起采购申请，请及时进行受理；订单号：${orderNo}", "terminal,ios,android"),
+            "【${firmName}】发起采购申请，请及时进行受理；订单号：${orderNo}", "terminal,ios,android", ""),
     /**
      * 发起代客下单
      */
     ORDER_INITIATE_SALE("BUSINESS", "BUSINESS_ORDER_INITIATE_SALE", "发起代客下单",
-            "贵司已代【${firmName}】发起了商品采购，请及时联系往来单位；订单号：${orderNo}", "terminal,ios,android"),
+            "贵司已代【${firmName}】发起了商品采购，请及时联系往来单位；订单号：${orderNo}", "terminal,ios,android", ""),
     /**
      * 有新的代客下单信息
      */
     ORDER_NEW_VALET_MSG("BUSINESS", "BUSINESS_ORDER_NEW_VALET_MSG", "有新的代客下单信息",
-            "【${firmName}】代您发起了商品采购，请确认；订单号：${orderNo}", "terminal,ios,android"),
+            "【${firmName}】代您发起了商品采购，请确认；订单号：${orderNo}", "terminal,ios,android", ""),
     /**
      * 驳回采购订单
      */
     ORDER_REJECT_VALET("BUSINESS", "BUSINESS_ORDER_REJECT_VALET", "驳回采购订单",
-            "贵司驳回了【${firmName}】的采购申请，请及时通知采购单位；订单号：${orderNo}", "terminal,ios,android"),
+            "贵司驳回了【${firmName}】的采购申请，请及时通知采购单位；订单号：${orderNo}", "terminal,ios,android", ""),
     /**
      * 采购订单被驳回
      */
     ORDER_REJECT_PURCHASE("BUSINESS", "BUSINESS_ORDER_REJECT_PURCHASE", "采购订单被驳回",
-            "您的采购申请被【${firmName}】驳回，请及时查看；订单号：${orderNo}", "terminal,ios,android"),
+            "您的采购申请被【${firmName}】驳回，请及时查看；订单号：${orderNo}", "terminal,ios,android", ""),
     /**
      * 司机拒绝接单
      */
     WAYBILL_REFUSE_SENDCAR_TRIP("BUSINESS", "BUSINESS_WAYBILL_REFUSE_SENDCAR_TRIP", "司机拒绝接单",
-            "贵司指派的运单被拒绝接单了，请及时确认；运单号：${orderNo},司机：${driverName}", "terminal,ios,android"),
+            "贵司指派的运单被拒绝接单了，请及时确认；运单号：${orderNo},司机：${driverName}", "terminal,ios,android", ""),
     /**
      * 司机拒绝接单
      */
     WAYBILL_REFUSE_SENDCAR_CIRCULATE("BUSINESS", "BUSINESS_WAYBILL_REFUSE_SENDCAR_CIRCULATE", "司机拒绝接单",
-            "贵司指派的运单被拒绝接单了，请及时确认；承运单号：${orderNo},司机：${driverName}", "terminal,ios,android"),
+            "贵司指派的运单被拒绝接单了，请及时确认；承运单号：${orderNo},司机：${driverName}", "terminal,ios,android", ""),
 
     /**
      * 司机拒绝出车
      */
     WAYBIL_CONFIRM_DEPARTURE("BUSINESS", "BUSINESS_WAYBIL_CONFIRM_DEPARTURE", "司机拒绝出车",
-            "贵司的运单被拒绝出车了，请及时确认；运单号：${orderNo},司机：${driverName}", "terminal,ios,android"),
+            "贵司的运单被拒绝出车了，请及时确认；运单号：${orderNo},司机：${driverName}", "terminal,ios,android", ""),
 
 
     /**
      * 发起企业资质审核
      */
-    ENT_CERTIFICATE("BUSINESS", "ENT_CERTIFICATE", "发起企业资质审核", "贵司发起了针对【${entName}】的资质认证，已提交至审核部门，请留意后续消息；发起人：${createByName}", "terminal,ios,android"),
+    ENT_CERTIFICATE("BUSINESS", "ENT_CERTIFICATE", "发起企业资质审核", "贵司发起了针对【${entName}】的资质认证，已提交至审核部门，请留意后续消息；发起人：${createByName}", "terminal,ios,android", ""),
 
     /**
      * 资质审核通过
      */
-    ENT_CERTIFICATE_PASS("BUSINESS", "ENT_CERTIFICATE_PASS", "企业资质审核通过", "贵司提交的【${entName}】资质认证，已审核通过；审核人员：${createByName}", "terminal,ios,android"),
+    ENT_CERTIFICATE_PASS("BUSINESS", "ENT_CERTIFICATE_PASS", "企业资质审核通过", "贵司提交的【${entName}】资质认证，已审核通过；审核人员：${createByName}", "terminal,ios,android", ""),
 
     /**
      * 资质审核驳回
      */
-    ENT_CERTIFICATE_REFUSED("BUSINESS", "ENT_CERTIFICATE_REFUSED", "企业资质审核驳回", "贵司提交的【${entName}】资质认证，已被审核驳回，请查看驳回原因并及时修改；审核人员：${createByName}", "terminal,ios,android"),
+    ENT_CERTIFICATE_REFUSED("BUSINESS", "ENT_CERTIFICATE_REFUSED", "企业资质审核驳回", "贵司提交的【${entName}】资质认证，已被审核驳回，请查看驳回原因并及时修改；审核人员：${createByName}", "terminal,ios,android", ""),
 
     /**
      * 发起主体单位资质审核
      */
-    ENT_DEPT_CERTIFICATE("BUSINESS", "ENT_DEPT_CERTIFICATE", "发起主体单位资质审核", "贵司发起了针对【${entName}】的资质认证，已提交至审核部门，请留意后续消息；发起人：${createByName}", "terminal,ios,android"),
+    ENT_DEPT_CERTIFICATE("BUSINESS", "ENT_DEPT_CERTIFICATE", "发起主体单位资质审核", "贵司发起了针对【${entName}】的资质认证，已提交至审核部门，请留意后续消息；发起人：${createByName}", "terminal,ios,android", ""),
 
     /**
      * 主体单位资质审核通过
      */
-    ENT_DEPT_CERTIFICATE_PASS("BUSINESS", "ENT_DEPT_CERTIFICATE_PASS", "主体单位资质审核通过", "贵司提交的【${entName}】资质认证，已审核通过；审核人员：${createByName}", "terminal,ios,android"),
+    ENT_DEPT_CERTIFICATE_PASS("BUSINESS", "ENT_DEPT_CERTIFICATE_PASS", "主体单位资质审核通过", "贵司提交的【${entName}】资质认证，已审核通过；审核人员：${createByName}", "terminal,ios,android", ""),
 
     /**
      * 主体单位资质审核驳回
      */
-    ENT_DEPT_CERTIFICATE_REFUSED("BUSINESS", "ENT_DEPT_CERTIFICATE_REFUSED", "主体单位资质审核驳回", "贵司提交的【${entName}】资质认证，已被审核驳回，请查看驳回原因并及时修改；审核人员：${createByName}", "terminal,ios,android"),
+    ENT_DEPT_CERTIFICATE_REFUSED("BUSINESS", "ENT_DEPT_CERTIFICATE_REFUSED", "主体单位资质审核驳回", "贵司提交的【${entName}】资质认证，已被审核驳回，请查看驳回原因并及时修改；审核人员：${createByName}", "terminal,ios,android", ""),
 
 
     /**
      * 发起合作申请
      */
-    SUBMIT_COOPERATE("BUSINESS", "SUBMIT_COOPERATE", "发起合作申请", "贵司发起了与【${entName}】的合作申请，请留意后续消息；发起人：${createByName}", "terminal,ios,android"),
+    SUBMIT_COOPERATE("BUSINESS", "SUBMIT_COOPERATE", "发起合作申请", "贵司发起了与【${entName}】的合作申请，请留意后续消息；发起人：${createByName}", "terminal,ios,android", ""),
 
     /**
      * 合作申请待审核
      */
-    COOPERATE_WAIT_APPROVAL("BUSINESS", "COOPERATE_WAIT_APPROVAL", "合作申请待审核", "【${entName}】对贵司发起了企业合作申请，请前往确认","terminal,ios,android"),
+    COOPERATE_WAIT_APPROVAL("BUSINESS", "COOPERATE_WAIT_APPROVAL", "合作申请待审核", "【${entName}】对贵司发起了企业合作申请，请前往确认","terminal,ios,android",""),
 
     /**
      * 合作申请审核通过
      */
-    COOPERATE_PASS("BUSINESS", "COOPERATE_PASS", "合作申请审核通过", "贵司发起的与【${entName}有限公司】的合作申请，已通过", "terminal,ios,android"),
+    COOPERATE_PASS("BUSINESS", "COOPERATE_PASS", "合作申请审核通过", "贵司发起的与【${entName}有限公司】的合作申请，已通过", "terminal,ios,android",""),
+
 
     /**
      * 合作申请审核驳回
      */
-    COOPERATE_REFUSED("BUSINESS", "COOPERATE_REFUSED", "合作申请审核驳回", "贵司发起的与【${entName}有限公司】的合作申请，已驳回，请及时确认", "terminal,ios,android"),
+    COOPERATE_REFUSED("BUSINESS", "COOPERATE_REFUSED", "合作申请审核驳回", "贵司发起的与【${entName}有限公司】的合作申请，已驳回，请及时确认", "terminal,ios,android",""),
 
     /**
      * 解除合作关系
      */
-    COOPERATE_DISSOLVE("BUSINESS", "COOPERATE_DISSOLVE", "解除合作关系", "贵司解除了与【${entName}】的合作关系，请及时通知合作单位；操作人：${createByName}", "terminal,ios,android"),
+    COOPERATE_DISSOLVE("BUSINESS", "COOPERATE_DISSOLVE", "解除合作关系", "贵司解除了与【${entName}】的合作关系，请及时通知合作单位；操作人：${createByName}", "terminal,ios,android",""),
 
     /**
      * 合作关系被解除
      */
-    COOPERATE_DISSOLVED("BUSINESS", "COOPERATE_DISSOLVED", "合作关系被解除", "【${entName}】解除了与贵司的合作关系，请及时联系合作范围并确认", "terminal,ios,android"),
+    COOPERATE_DISSOLVED("BUSINESS", "COOPERATE_DISSOLVED", "合作关系被解除", "【${entName}】解除了与贵司的合作关系，请及时联系合作范围并确认", "terminal,ios,android",""),
 
     /**
      * 恢复合作关系
      */
-    COOPERATE_RESTORE("BUSINESS", "COOPERATE_RESTORE", "恢复合作关系", "贵司恢复了与【${entName}有限公司】的合作关系，请及时通知合作单位；操作人：${createByName}", "terminal,ios,android"),
+    COOPERATE_RESTORE("BUSINESS", "COOPERATE_RESTORE", "恢复合作关系", "贵司恢复了与【${entName}有限公司】的合作关系，请及时通知合作单位；操作人：${createByName}", "terminal,ios,android",""),
 
     /**
      * 合作关系被恢复
      */
-    COOPERATE_RESTORED("BUSINESS", "COOPERATE_RESTORED", "合作关系被恢复", "【${entName}有限公司】恢复了与贵司的合作关系，请及时联系合作范围并确认", "terminal,ios,android"),
+    COOPERATE_RESTORED("BUSINESS", "COOPERATE_RESTORED", "合作关系被恢复", "【${entName}有限公司】恢复了与贵司的合作关系，请及时联系合作范围并确认", "terminal,ios,android",""),
 
     /**
      * 托运订单-发起物流托运
      * 触发点-贸易订单物流托运确认/承运订单分包托运确认
-     *
      */
     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", "承运订单-托运方撤回承运任务"),
 
+    /**
+     * 托运订单-承运方接单
+     */
+    CONSIGN_ACCEPT_LOGISTICS("BUSINESS", "BUSINESS_CONSIGN_ACCEPT_LOGISTICS", "承运方接单",
+            "【${companyName}】接受了贵司的物流分配计划，请及时查看；订单号：${orderNo}", "terminal,ios,android", "托运订单-承运方接单"),
+
+    /**
+     * 承运订单-我方接受物流任务
+     */
+    CARRIAGE_ACCEPT_LOGISTICS("BUSINESS", "BUSINESS_CARRIAGE_ACCEPT_LOGISTICS", "我方接受物流任务",
+            "贵司接受了【${companyName}】分配的物流分配任务，请及时查看；订单号：${orderNo}", "terminal,ios,android", "承运订单-我方接受物流任务"),
+
+    /**
+     * 托运订单-承运方自建物流订单-触发点自建承运物流订单确认
+     */
+    CARRIAGE_NEW_LOGISTICS("BUSINESS", "BUSINESS_CARRIAGE_NEW_LOGISTICS", "承运方自建物流订单",
+            "【${companyName}】自建了一条与贵司合作的物流订单，请及时确认；订单号：${orderNo}", "terminal,ios,android", "托运订单-承运方自建物流订单"),
 
     ;
 
@@ -214,6 +231,11 @@ public enum MessageEnum {
      */
     private final String pushType;
 
+    /**
+     * 字段含义解释
+     */
+    private final String desc;
+
 
     public static String getCategoryByType(String type) {
         for (MessageEnum entityEnum : MessageEnum.values()) {
@@ -241,4 +263,13 @@ public enum MessageEnum {
         }
         return null;
     }
+
+    public static String getDesc(MessageEnum messageEnum) {
+        for (MessageEnum entityEnum : MessageEnum.values()) {
+            if (entityEnum.equals(messageEnum)) {
+                return entityEnum.getDesc();
+            }
+        }
+        return null;
+    }
 }

sckw-modules/sckw-message/src/main/java/com/sckw/message/controller/MessageController.java

@@ -96,4 +96,14 @@ public class MessageController {
         return HttpResult.ok("删除消息成功");
     }
 
+    /**
+     * @desc: 用户消息中心
+     * @author: yzc
+     * @date: 2023-09-07 14:57
+     * @return: com.sckw.core.web.response.HttpResult
+     */
+    @GetMapping("/userMsgCenter")
+    public HttpResult userMsgCenter() {
+        return HttpResult.ok("获取用户消息中心成功", messageService.userMsgCenter());
+    }
 }

sckw-modules/sckw-message/src/main/java/com/sckw/message/dao/KwmMessageUserMapper.java

@@ -2,6 +2,9 @@ package com.sckw.message.dao;
 
 import com.baomidou.mybatisplus.core.mapper.BaseMapper;
 import com.sckw.message.model.KwmMessageUser;
+import com.sckw.message.model.dto.UserMsgCenterLatestMsgDTO;
+import com.sckw.message.model.dto.UserMsgCenterReqDTO;
+import com.sckw.message.model.vo.res.UserMsgCenterResVO;
 import org.apache.ibatis.annotations.Mapper;
 import org.apache.ibatis.annotations.Param;
 
@@ -24,4 +27,21 @@ public interface KwmMessageUserMapper extends BaseMapper<KwmMessageUser> {
      */
     void insertBatch(@Param(value = "list") List<KwmMessageUser> list);
 
+    /**
+     * @desc: 根据用户或企业，状态升序，type分组统计消息数量，查找前五条
+     * @author: yzc
+     * @date: 2023-09-07 15:38
+     * @Param item:
+     * @return: java.util.List<com.sckw.message.model.vo.res.UserMsgCenterResVO>
+     */
+    List<UserMsgCenterResVO> userMsgCenter(@Param(value = "item") UserMsgCenterReqDTO item);
+
+    /**
+     * @desc: 获取用户最新消息
+     * @author: yzc
+     * @date: 2023-09-07 17:43
+     * @Param item:
+     * @return: com.sckw.message.model.dto.UserMsgCenterLatestMsgDTO
+     */
+    UserMsgCenterLatestMsgDTO getLatestMsg(@Param(value = "item") UserMsgCenterReqDTO item);
 }

sckw-modules/sckw-message/src/main/java/com/sckw/message/model/dto/SelectMessagesDTO.java

@@ -6,6 +6,8 @@ import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
 
+import java.io.Serial;
+import java.io.Serializable;
 import java.util.Date;
 
 /**
@@ -17,7 +19,10 @@ import java.util.Date;
 @Setter
 @ToString
 @Builder
-public class SelectMessagesDTO {
+public class SelectMessagesDTO implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = -6087719092255350917L;
 
     /**
      * 一级企业id

sckw-modules/sckw-message/src/main/java/com/sckw/message/model/dto/UserMsgCenterLatestMsgDTO.java

@@ -0,0 +1,58 @@
+package com.sckw.message.model.dto;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+
+import java.io.Serial;
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * @desc: 用户消息中心最新消息dto
+ * @author: yzc
+ * @date: 2023-09-07 16:22
+ */
+@Getter
+@Setter
+@ToString
+public class UserMsgCenterLatestMsgDTO implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = -1102829961881130675L;
+
+    private Long id;
+
+    /**
+     * 状态:0未读/1已读
+     */
+    private Integer status;
+
+    /**
+     * 消息分类
+     */
+    private String type;
+
+    /**
+     * 消息标题
+     */
+    private String title;
+
+    /**
+     * 消息内容
+     */
+    private String content;
+
+    /**
+     * 消息跳转url
+     */
+    private String url;
+
+    /**
+     * 创建时间
+     */
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createTime;
+
+}

sckw-modules/sckw-message/src/main/java/com/sckw/message/model/dto/UserMsgCenterReqDTO.java

@@ -0,0 +1,32 @@
+package com.sckw.message.model.dto;
+
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+
+/**
+ * @desc: 消息中心请求dto
+ * @author: yzc
+ * @date: 2023-09-07 15:01
+ */
+@Getter
+@Setter
+@ToString
+@Accessors(chain = true)
+public class UserMsgCenterReqDTO {
+
+    /**
+     * 一级企业id
+     */
+    private Long entId;
+
+    /**
+     * 用户id
+     */
+    private Long userId;
+
+    private Integer status;
+
+    private String type;
+}

sckw-modules/sckw-message/src/main/java/com/sckw/message/model/vo/res/KwmMessageListResVO.java

@@ -5,6 +5,8 @@ import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
 
+import java.io.Serial;
+import java.io.Serializable;
 import java.util.Date;
 
 /**
@@ -15,7 +17,10 @@ import java.util.Date;
 @Getter
 @Setter
 @ToString
-public class KwmMessageListResVO {
+public class KwmMessageListResVO implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = -5549538304400226372L;
 
     private Long id;
 

sckw-modules/sckw-message/src/main/java/com/sckw/message/model/vo/res/MessagesStatisticsResVO.java

@@ -6,6 +6,8 @@ import lombok.Getter;
 import lombok.Setter;
 import lombok.ToString;
 
+import java.io.Serial;
+import java.io.Serializable;
 import java.util.Date;
 
 /**
@@ -17,7 +19,10 @@ import java.util.Date;
 @Setter
 @ToString
 @Builder
-public class MessagesStatisticsResVO {
+public class MessagesStatisticsResVO  implements Serializable {
+
+    @Serial
+    private static final long serialVersionUID = 4758956841872315397L;
 
     /**
      * 消息分类

sckw-modules/sckw-message/src/main/java/com/sckw/message/model/vo/res/UserMsgCenterResVO.java

@@ -0,0 +1,67 @@
+package com.sckw.message.model.vo.res;
+
+import com.fasterxml.jackson.annotation.JsonFormat;
+import lombok.Getter;
+import lombok.Setter;
+import lombok.ToString;
+import lombok.experimental.Accessors;
+
+import java.io.Serial;
+import java.io.Serializable;
+import java.util.Date;
+
+/**
+ * @desc: 用户消息中心响应vo
+ * @author: yzc
+ * @date: 2023-09-07 14:53
+ */
+@Getter
+@Setter
+@ToString
+@Accessors(chain = true)
+public class UserMsgCenterResVO implements Serializable {
+
+
+    @Serial
+    private static final long serialVersionUID = -3285612805457269859L;
+
+
+    private Long id;
+
+    /**
+     * 状态:0未读/1已读
+     */
+    private Integer status;
+
+    /**
+     * 消息分类
+     */
+    private String type;
+
+    /**
+     * 消息标题
+     */
+    private String title;
+
+    /**
+     * 未读数量
+     */
+    private Integer num;
+
+    /**
+     * 消息内容
+     */
+    private String content;
+
+    /**
+     * 消息跳转url
+     */
+    private String url;
+
+    /**
+     * 创建时间
+     */
+    @JsonFormat(pattern="yyyy-MM-dd HH:mm:ss", timezone = "GMT+8")
+    private Date createTime;
+
+}

sckw-modules/sckw-message/src/main/java/com/sckw/message/service/KwmMessageUserService.java

@@ -7,6 +7,9 @@ import com.sckw.core.utils.CollectionUtils;
 import com.sckw.core.web.context.LoginUserHolder;
 import com.sckw.message.dao.KwmMessageUserMapper;
 import com.sckw.message.model.KwmMessageUser;
+import com.sckw.message.model.dto.UserMsgCenterLatestMsgDTO;
+import com.sckw.message.model.dto.UserMsgCenterReqDTO;
+import com.sckw.message.model.vo.res.UserMsgCenterResVO;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.springframework.stereotype.Service;
@@ -150,4 +153,26 @@ public class KwmMessageUserService {
         }
         kwmMessageUserMapper.update(null, wrapper);
     }
+
+    /**
+     * @desc: 根据用户或企业，状态升序，type分组统计消息数量，查找前五条
+     * @author: yzc
+     * @date: 2023-09-07 15:40
+     * @Param dto:
+     * @return: java.util.List<com.sckw.message.model.vo.res.UserMsgCenterResVO>
+     */
+    public List<UserMsgCenterResVO> userMsgCenter(UserMsgCenterReqDTO dto) {
+        return kwmMessageUserMapper.userMsgCenter(dto);
+    }
+
+    /**
+     * @desc: 获取最新消息
+     * @author: yzc
+     * @date: 2023-09-07 17:42
+     * @Param dto:
+     * @return: com.sckw.message.model.dto.UserMsgCenterLatestMsgDTO
+     */
+    public UserMsgCenterLatestMsgDTO getLatestMsg(UserMsgCenterReqDTO dto) {
+        return  kwmMessageUserMapper.getLatestMsg(dto);
+    }
 }

sckw-modules/sckw-message/src/main/java/com/sckw/message/service/MessageService.java

@@ -16,9 +16,15 @@ import com.sckw.message.model.KwmMessage;
 import com.sckw.message.model.KwmMessageUser;
 import com.sckw.message.model.dto.MessageListDTO;
 import com.sckw.message.model.dto.SelectMessagesDTO;
-import com.sckw.message.model.vo.req.*;
+import com.sckw.message.model.dto.UserMsgCenterLatestMsgDTO;
+import com.sckw.message.model.dto.UserMsgCenterReqDTO;
+import com.sckw.message.model.vo.req.DeleteMessagesReqVO;
+import com.sckw.message.model.vo.req.ReadMessagesReqVO;
+import com.sckw.message.model.vo.req.SelectMessagesReqVO;
+import com.sckw.message.model.vo.req.StatisticsMessagesReqVO;
 import com.sckw.message.model.vo.res.KwmMessageListResVO;
 import com.sckw.message.model.vo.res.MessagesStatisticsResVO;
+import com.sckw.message.model.vo.res.UserMsgCenterResVO;
 import com.sckw.system.api.RemoteSystemService;
 import com.sckw.system.api.model.dto.res.EntCacheResDto;
 import com.sckw.system.api.model.dto.res.UserCacheResDto;
@@ -244,4 +250,30 @@ public class MessageService {
         res.setTableTops(tableTops).setTableBottom(tableBottom);
         return res;
     }
+
+    /**
+     * @desc: 用户消息中心获取
+     * @author: yzc
+     * @date: 2023-09-07 17:41
+     * @return: java.util.List<com.sckw.message.model.vo.res.UserMsgCenterResVO>
+     */
+    public List<UserMsgCenterResVO> userMsgCenter() {
+        UserMsgCenterReqDTO dto = new UserMsgCenterReqDTO();
+        if (Objects.equals(LoginUserHolder.getIsMain(), 1)) {
+            dto.setEntId(LoginUserHolder.getEntId());
+        } else {
+            dto.setUserId(LoginUserHolder.getUserId());
+        }
+        List<UserMsgCenterResVO> result = kwmMessageUserService.userMsgCenter(dto);
+        if (CollectionUtils.isEmpty(result)) {
+            return Collections.emptyList();
+        }
+        result.forEach(e -> {
+            dto.setStatus(e.getStatus()).setType(e.getType());
+            UserMsgCenterLatestMsgDTO msg = kwmMessageUserService.getLatestMsg(dto);
+            e.setId(msg.getId()).setTitle(msg.getTitle()).setContent(msg.getContent())
+                    .setUrl(msg.getUrl()).setCreateTime(msg.getCreateTime());
+        });
+        return result;
+    }
 }

sckw-modules/sckw-message/src/main/resources/mapper/KwmMessageUserMapper.xml

@@ -34,4 +34,50 @@
             </trim>
         </foreach>
     </insert>
+    <select id="userMsgCenter" resultType="com.sckw.message.model.vo.res.UserMsgCenterResVO">
+        SELECT
+        mu.status as status,
+        m.type as type,
+        count(*) as num
+        FROM
+        kwm_message_user mu
+        LEFT JOIN kwm_message m ON mu.msg_id = m.id
+        <where>
+            m.del_flag = 0 and mu.del_flag = 0
+            <if test="item.entId != null">
+                and mu.ent_id = #{item.entId}
+            </if>
+            <if test="item.userId != null">
+                and mu.user_id = #{item.userId}
+            </if>
+        </where>
+        GROUP BY m.type, mu.status
+        ORDER BY mu.status ASC
+        LIMIT 5;
+    </select>
+    <select id="getLatestMsg" resultType="com.sckw.message.model.dto.UserMsgCenterLatestMsgDTO">
+        SELECT
+        mu.id, mu.status, mu.create_time as createTime,
+        m.type, m.title, m.content, m.url
+        FROM
+        kwm_message_user mu
+        LEFT JOIN kwm_message m ON mu.msg_id = m.id
+        <where>
+            m.del_flag = 0 and mu.del_flag = 0
+            <if test="item.status != null">
+                and mu.status = #{item.status}
+            </if>
+            <if test="item.type != null and item.type != ''">
+                and m.type = #{item.type}
+            </if>
+            <if test="item.entId != null">
+                and mu.ent_id = #{item.entId}
+            </if>
+            <if test="item.userId != null">
+                and mu.user_id = #{item.userId}
+            </if>
+        </where>
+        order by mu.create_time desc limit 1;
+
+    </select>
 </mapper>

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/controller/AcceptCarriageOrderController.java

@@ -47,7 +47,7 @@ public class AcceptCarriageOrderController {
     AcceptCarriageOrderService acceptCarriageOrderService;
 
     @Autowired
-    private TransportCommonService transportCommonService;
+    TransportCommonService transportCommonService;
 
 
 
@@ -377,6 +377,7 @@ public class AcceptCarriageOrderController {
      */
     @RequestMapping(value = "/addOrder", method = RequestMethod.POST)
     public HttpResult addOrder(@Valid @RequestBody AddOrderDTO addOrderDTO) {
+        log.info("承运订单-页面新建订单 add {}",JSONObject.toJSONString(addOrderDTO));
         try {
             return acceptCarriageOrderService.addOrder(addOrderDTO);
         } catch (Exception e) {

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/controller/WaybillManagementController.java

@@ -4,7 +4,6 @@ import com.sckw.core.web.constant.HttpStatus;
 import com.sckw.core.web.response.HttpResult;
 import com.sckw.transport.model.dto.AddressDropListDTO;
 import com.sckw.transport.model.dto.WaybillOrderDTO;
-import com.sckw.transport.model.dto.WaybillOrderTicketApprovalDto;
 import com.sckw.transport.service.WaybillManagementService;
 import jakarta.validation.Valid;
 import lombok.RequiredArgsConstructor;

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/dao/KwtLogisticsOrderCirculateMapper.java

@@ -42,13 +42,13 @@ public interface KwtLogisticsOrderCirculateMapper extends BaseMapper<KwtLogistic
      * @param lOrderId 物流订单id
      * @param truckId 车辆ID
      * @param driverId 司机主键id
-     * @param status 循环派车状态（0正常、1失效）
+     * //@param status 循环派车状态（0正常、1失效）
      * @desc 查询物流运单装卸货地址信息
      * @author zk
      * @date 2023/7/20
      **/
     KwtLogisticsOrderCirculate findCirculate(@Param("lOrderId") Long lOrderId, @Param("truckId") Long truckId,
-                                             @Param("driverId") Long driverId, @Param("status") Integer status);
+                                             @Param("driverId") Long driverId);
 
     /**
      * @param lOrderId 物流订单id

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/model/KwtLogisticsOrderUnit.java

@@ -70,6 +70,11 @@ public class KwtLogisticsOrderUnit implements Serializable {
 
     private Long createBy;
 
+    /**
+     * 业务联系人id
+     */
+    private Long contactsId;
+
     private Date createTime;
 
     private Long updateBy;

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/model/dto/AddOrderDTO.java

@@ -39,6 +39,12 @@ public class AddOrderDTO {
     @NotBlank(message = "托运联系人不能为空")
     private String consignContacts;
 
+    /**
+     * 托运联系人id
+     */
+    @NotBlank(message = "托运联系人id不能为空")
+    private String consignContactsId;
+
     /**
      * 承运单位
      */
@@ -56,12 +62,20 @@ public class AddOrderDTO {
      */
     @NotBlank(message = "承运联系电话不能为空")
     private String acceptContactPhone;
+
+
     /**
      * 承运联系人
      */
-    @NotBlank(message = "承运联系人不能为空")
+    @NotBlank(message = "承运联系人id不能为空")
     private String acceptContacts;
 
+    /**
+     * 承运联系人id
+     */
+    @NotBlank(message = "承运联系人id不能为空")
+    private String acceptContactsId;
+
     /**
      * 货物名称
      */

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/model/dto/SubcontractConsignmentDTO.java

@@ -59,6 +59,17 @@ public class SubcontractConsignmentDTO /**implements IdsList*/ {
     @NotNull(message = "托运联系人不能为空")
     private String checkContacts;
 
+    /**
+     * 托运联系人id
+     */
+    @NotNull(message = "托运联系人id不能为空")
+    private String checkContactsId;
+    /**
+     * 承运联系人id
+     */
+    @NotNull(message = "承运联系人id不能为空")
+    private String consignContactsId;
+
     /**
      * 合理损耗
      */

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/model/param/LogisticsConsignmentParam.java

@@ -61,6 +61,11 @@ public class LogisticsConsignmentParam {
      */
     @NotNull(message = "托运联系人不能为空")
     private String checkContacts;
+    /**
+     * 托运联系人id
+     */
+    @NotNull(message = "托运联系人不能为空")
+    private String checkContactsId;
 
     /**
      * 合理损耗
@@ -107,6 +112,12 @@ public class LogisticsConsignmentParam {
     @NotNull(message = "承运联系人不能为空")
     private String consignContacts;
 
+    /**
+     * 承运联系人id
+     */
+    @NotNull(message = "承运联系人id不能为空")
+    private String consignContactsId;
+
     /**
      * 结算周期(周结、月结、季结)
      */

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/service/AcceptCarriageOrderService.java

@@ -37,6 +37,7 @@ import com.sckw.order.api.model.OrderDetailRes;
 import com.sckw.order.api.model.UnitInfoDetailRes;
 import com.sckw.product.api.dubbo.GoodsInfoService;
 import com.sckw.product.api.model.KwpGoods;
+import com.sckw.stream.enums.MessageEnum;
 import com.sckw.stream.model.SckwBusSum;
 import com.sckw.system.api.RemoteSystemService;
 import com.sckw.system.api.model.dto.res.EntCacheResDto;
@@ -248,6 +249,7 @@ public class AcceptCarriageOrderService {
                     bo.getContractId(), JSONObject.toJSONString(infoResDto));
             throw new RuntimeException("生成物流托运合同异常");
         }
+        //主体信息保存
         insertSubcontractLogisticsGoods(bo, lOrderNo, orderId);
         insertSubcontractLogisticsOrder(bo, lOrderNo, order, orderId, pids, orderStatus, logisticsOrder);
         insertSubcontractLogisticsOrderContract(bo, orderId, infoResDto);
@@ -258,6 +260,31 @@ public class AcceptCarriageOrderService {
         logisticsOrder.setSubcontractAmount(logisticsOrder.getSubcontractAmount().add(bo.getCarryingCapacity()));
 //        logisticsOrder.setIgnoreAmount(logisticsOrder.getIgnoreAmount().subtract(bo.getCarryingCapacity()));
         logisticsOrderMapper.updateById(logisticsOrder);
+
+        /**数据发送至消息列表*/
+        EntCacheResDto consignentMap = remoteSystemService.queryEntTreeById(Long.parseLong(bo.getConsignCompanyId()));
+        EntCacheResDto checkentMap = remoteSystemService.queryEntTreeById(Long.parseLong(bo.getCheckCompanyId()));
+
+        //托运单位
+        KwtLogisticsOrderUnit checkUnit = new KwtLogisticsOrderUnit();
+
+        checkUnit.setUnitType(1);
+        checkUnit.setFirmName(bo.getCheckCompany());
+        checkUnit.setEntId(Long.parseLong(bo.getCheckCompanyId()));
+        checkUnit.setTopEntId(checkentMap == null ? null : checkentMap.getId());
+        checkUnit.setContactsId(Long.parseLong(bo.getCheckContactsId()));
+
+        //承运单位
+        KwtLogisticsOrderUnit carriageUnit = new KwtLogisticsOrderUnit();
+        carriageUnit.setUnitType(2);
+        carriageUnit.setFirmName(bo.getConsignCompany());
+        carriageUnit.setEntId(Long.parseLong(bo.getConsignCompanyId()));
+        carriageUnit.setContactsId(Long.parseLong(bo.getConsignContactsId()));
+        carriageUnit.setFirmName(bo.getConsignCompany());
+        carriageUnit.setTopEntId(consignentMap == null ? null : consignentMap.getId());
+
+        commonService.initIatingLogisticsConsignment(checkUnit, carriageUnit, logisticsOrder.getLOrderNo(), logisticsOrder.getCreateBy(), logisticsOrder.getEntId());
+
         //修改父级mongodb数据
         //更新mongodb
         SckwLogisticsOrder lOrder = new SckwLogisticsOrder();
@@ -487,19 +514,25 @@ public class AcceptCarriageOrderService {
      * @param orderId
      */
     private void insertSubcontractLogisticsOrderUnit(SubcontractConsignmentDTO bo, Long orderId) {
+        EntCacheResDto consignentMap = remoteSystemService.queryEntTreeById(Long.parseLong(bo.getConsignCompanyId()));
+//        .setContactsId(consignentMap.get(Long.parseLong(bo.getConsignCompanyId())).getContactsId())
+        EntCacheResDto checkentMap = remoteSystemService.queryEntTreeById(Long.parseLong(bo.getCheckCompanyId()));
+////.setContactsId(checkentMap.get(Long.parseLong(bo.getCheckCompanyId())).getContactsId())
         KwtLogisticsOrderUnit checkUnit = new KwtLogisticsOrderUnit()
                 .setLOrderId(orderId)
                 .setId(new IdWorker(NumberConstant.ONE).nextId())
                 .setUnitType(NumberConstant.ONE)
                 .setFirmName(bo.getCheckCompany())
                 .setRemark(bo.getRemark())
+                .setTopEntId(checkentMap == null ? null : checkentMap.getId())
                 .setEntId(Long.parseLong(bo.getCheckCompanyId()))
                 .setContacts(bo.getCheckContacts())
                 .setPhone(bo.getCheckContactPhone())
                 .setCreateBy(LoginUserHolder.getUserId())
                 .setCreateTime(new Date())
                 .setUpdateBy(LoginUserHolder.getUserId())
-                .setUpdateTime(new Date());
+                .setUpdateTime(new Date())
+                .setContactsId(Long.parseLong(bo.getCheckContactsId()));
         logisticsOrderUnitMapper.insert(checkUnit);
 
         KwtLogisticsOrderUnit consignUnit = new KwtLogisticsOrderUnit()
@@ -508,13 +541,15 @@ public class AcceptCarriageOrderService {
                 .setUnitType(NumberConstant.TWO)
                 .setFirmName(bo.getConsignCompany())
                 .setRemark(bo.getRemark())
+                .setTopEntId(consignentMap == null ? null : consignentMap.getId())
                 .setEntId(Long.parseLong(bo.getConsignCompanyId()))
                 .setContacts(bo.getConsignContacts())
                 .setPhone(bo.getConsignContactPhone())
                 .setCreateBy(LoginUserHolder.getUserId())
                 .setCreateTime(new Date())
                 .setUpdateBy(LoginUserHolder.getUserId())
-                .setUpdateTime(new Date());
+                .setUpdateTime(new Date())
+                .setContactsId(Long.parseLong(bo.getConsignContactsId()));
         logisticsOrderUnitMapper.insert(consignUnit);
     }
 
@@ -710,6 +745,17 @@ public class AcceptCarriageOrderService {
                     .set(KwtLogisticsOrder::getStatus, orderStatus)
                     .set(KwtLogisticsOrder::getUpdateTime, new Date())
                     .set(KwtLogisticsOrder::getUpdateBy, LoginUserHolder.getUserId()));
+            /**消息列表推送*/
+            Long id = logisticsOrder.getId();
+            KwtLogisticsOrderUnit consignOrderUnit = logisticsOrderUnitMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrderUnit>()
+                    .eq(KwtLogisticsOrderUnit::getLOrderId, id)
+                    .eq(KwtLogisticsOrderUnit::getUnitType, NumberConstant.ONE));
+            KwtLogisticsOrderUnit carriageOrderUnit = logisticsOrderUnitMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrderUnit>()
+                    .eq(KwtLogisticsOrderUnit::getLOrderId, id)
+                    .eq(KwtLogisticsOrderUnit::getUnitType, NumberConstant.TWO));
+            commonService.publicLogisticsConsignmentPushMessage(consignOrderUnit, carriageOrderUnit, logisticsOrder.getLOrderNo(),
+                    logisticsOrder.getCreateBy(), logisticsOrder.getEntId(),
+                    MessageEnum.CONSIGN_ACCEPT_LOGISTICS, MessageEnum.CARRIAGE_ACCEPT_LOGISTICS);
         } else {
             orderStatus = LogisticsOrderEnum.REJECT_ORDER.getCode();
             //todo 改为拒绝接单  数据统计在页面已退回状态中
@@ -762,6 +808,18 @@ public class AcceptCarriageOrderService {
                 }
             }
 
+            /**消息列表推送*/
+            Long id = logisticsOrder.getId();
+            KwtLogisticsOrderUnit consignOrderUnit = logisticsOrderUnitMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrderUnit>()
+                    .eq(KwtLogisticsOrderUnit::getLOrderId, id)
+                    .eq(KwtLogisticsOrderUnit::getUnitType, NumberConstant.ONE));
+            KwtLogisticsOrderUnit carriageOrderUnit = logisticsOrderUnitMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrderUnit>()
+                    .eq(KwtLogisticsOrderUnit::getLOrderId, id)
+                    .eq(KwtLogisticsOrderUnit::getUnitType, NumberConstant.TWO));
+            commonService.publicLogisticsConsignmentPushMessage(consignOrderUnit, carriageOrderUnit, logisticsOrder.getLOrderNo(),
+                    logisticsOrder.getCreateBy(), logisticsOrder.getEntId(),
+                    MessageEnum.REJECT_ORDER, MessageEnum.CARRIAGE_DISALLOTMENT);
+
         }
         //状态表新增状态数据
         KwtLogisticsOrderTrack track = logisticsOrderTrackMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrderTrack>()
@@ -1366,8 +1424,9 @@ public class AcceptCarriageOrderService {
         if (logisticsOrder.getPid() != null) {
             //数据推送至贸易订单
             CompleteLogisticsOrderParam tradeOrder = new CompleteLogisticsOrderParam();
+            //todo 2023-09-07 修改为传递页面传输值  不传递总量
             //获取实际装货量-实际卸货量
-            Map<String, BigDecimal> map = logisticsOrderMapper.countAmountByTradeOrderId(logisticsOrder.getTOrderId());
+//            Map<String, BigDecimal> map = logisticsOrderMapper.countAmountByTradeOrderId(logisticsOrder.getTOrderId());
             //获取是否订单已经全部处理完成
             List<Integer> orderStatusList = new ArrayList<>();
             orderStatusList.add(LogisticsOrderEnum.TO_BE_PLANNED.getCode());
@@ -1381,8 +1440,10 @@ public class AcceptCarriageOrderService {
                 tradeOrder.setIsAllComplete(true);
             }
             tradeOrder.setTOrderId(logisticsOrder.getTOrderId());
-            tradeOrder.setActualLoadAmount(map.get("totalLoadAmount"));
-            tradeOrder.setActualUnloadAmount(map.get("totalUnloadAmount"));
+//            tradeOrder.setActualLoadAmount(map.get("totalLoadAmount"));
+//            tradeOrder.setActualUnloadAmount(map.get("totalUnloadAmount"));
+            tradeOrder.setActualLoadAmount(orderFinishDTO.getLoadAmount());
+            tradeOrder.setActualUnloadAmount(orderFinishDTO.getUnloadAmount());
             tradeOrder.setUpdateBy(LoginUserHolder.getUserId());
             tradeOrder.setUpdateByName(LoginUserHolder.getUserName());
             log.info("承运订单-分包托运-手动完结订单请求参数:{}", JSONObject.toJSONString(tradeOrder));
@@ -1828,6 +1889,28 @@ public class AcceptCarriageOrderService {
         saveLogisticsOrderTrack(lOrderId, orderStatus);
         saveLogisticsOrderUnit(orderDTO, lOrderId);
         saveMongoDb(orderDTO, orderStatus, lOrderId, lOrderNo, infoResDto);
+        /**发送信息至消息列表*/
+        //托运单位
+        EntCacheResDto entCacheResDto = remoteSystemService.queryEntCacheById(Long.parseLong(orderDTO.getConsignCompanyId()));
+        KwtLogisticsOrderUnit consignUnit = new KwtLogisticsOrderUnit();
+        consignUnit.setUnitType(NumberConstant.ONE);
+        consignUnit.setEntId(Long.parseLong(orderDTO.getConsignCompanyId()));
+        consignUnit.setTopEntId(entCacheResDto == null ? null : entCacheResDto.getId());
+        consignUnit.setFirmName(orderDTO.getConsignCompany());
+        consignUnit.setContactsId(Long.parseLong(orderDTO.getConsignContactsId()));
+
+        //承运单位
+        EntCacheResDto entCacheResDto1 = remoteSystemService.queryEntCacheById(Long.parseLong(orderDTO.getAcceptCompanyId()));
+        KwtLogisticsOrderUnit carriageUnit = new KwtLogisticsOrderUnit();
+        carriageUnit.setUnitType(NumberConstant.TWO);
+        carriageUnit.setEntId(Long.parseLong(orderDTO.getAcceptCompanyId()));
+        carriageUnit.setTopEntId(entCacheResDto1 == null ? null : entCacheResDto1.getId());
+        carriageUnit.setFirmName(orderDTO.getAcceptCompany());
+        carriageUnit.setContactsId(Long.parseLong(orderDTO.getAcceptContactsId()));
+        System.out.println("承运订单新建订单-消息列表推送 start");
+        commonService.publicLogisticsConsignmentPushMessage(consignUnit, carriageUnit, lOrderNo, LoginUserHolder.getUserId(), LoginUserHolder.getEntId()
+                , MessageEnum.CARRIAGE_NEW_LOGISTICS, MessageEnum.CARRIAGE_NEW_LOGISTICS_ORDER);
+        System.out.println("承运订单新建订单-消息列表推送 end ");
         return HttpResult.ok();
     }
 
@@ -2004,11 +2087,12 @@ public class AcceptCarriageOrderService {
         if (Objects.isNull(ent)) {
             throw new BusinessException("企业:" + orderDTO.getConsignCompany() + "的一级企业信息不存在！");
         }
+        consignUnit.setContactsId(Long.parseLong(orderDTO.getConsignContactsId()));
         consignUnit.setTopEntId(ent.getId());
         consignUnit.setFirmName(orderDTO.getConsignCompany());
         consignUnit.setContacts(orderDTO.getConsignContacts());
         consignUnit.setPhone(orderDTO.getConsignContactPhone());
-        consignUnit.setRemark(orderDTO.getRemark());
+//        consignUnit.setRemark(orderDTO.getRemark());
         consignUnit.setStatus(NumberConstant.ZERO);
         consignUnit.setCreateBy(LoginUserHolder.getUserId());
         consignUnit.setCreateTime(new Date());
@@ -2024,11 +2108,12 @@ public class AcceptCarriageOrderService {
         if (Objects.isNull(ent1)) {
             throw new BusinessException("企业:" + orderDTO.getConsignCompany() + "的一级企业信息不存在！");
         }
+        unit.setContactsId(Long.parseLong(orderDTO.getAcceptContactsId()));
         unit.setTopEntId(ent1.getId());
         unit.setFirmName(orderDTO.getAcceptCompany());
         unit.setContacts(orderDTO.getAcceptContacts());
         unit.setPhone(orderDTO.getAcceptContactPhone());
-        unit.setRemark(orderDTO.getRemark());
+//        unit.setRemark(orderDTO.getRemark());
         unit.setStatus(NumberConstant.ZERO);
         unit.setCreateBy(LoginUserHolder.getUserId());
         unit.setCreateTime(new Date());
@@ -2225,7 +2310,7 @@ public class AcceptCarriageOrderService {
         longs.add(LoginUserHolder.getUserId());
         List<Long> longList = longs.stream().distinct().collect(Collectors.toList());
 //        LoginUserHolder.getIsMain()
-        List<AcceptCarriageOrderVO> list = logisticsOrderMapper.selectLogisticsOrderList(query, orderList, type, entId,longList,longList);
+        List<AcceptCarriageOrderVO> list = logisticsOrderMapper.selectLogisticsOrderList(query, orderList, type, entId, longList, longList);
         PageInfo<AcceptCarriageOrderVO> pageInfo = new PageInfo<>(list);
         if (CollectionUtils.isEmpty(list)) {
             return PageRes.build(pageInfo, list);
@@ -2333,7 +2418,7 @@ public class AcceptCarriageOrderService {
         List<Long> longs = LoginUserHolder.getAuthUserIdList();
         longs.add(LoginUserHolder.getUserId());
         List<Long> longList = longs.stream().distinct().collect(Collectors.toList());
-        List<TableTops> list = logisticsOrderMapper.countLogisticsOrderListByStatus(query, orderList, type, entId,longList,longList);
+        List<TableTops> list = logisticsOrderMapper.countLogisticsOrderListByStatus(query, orderList, type, entId, longList, longList);
         List<TableTops> arrayList = new ArrayList<>();
         arrayList.addAll(list);
         /**补全数据状态不齐的情况*/
@@ -2453,7 +2538,7 @@ public class AcceptCarriageOrderService {
         List<Long> longs = LoginUserHolder.getAuthUserIdList();
         longs.add(LoginUserHolder.getUserId());
         List<Long> longList = longs.stream().distinct().collect(Collectors.toList());
-        List<AcceptCarriageOrderVO> list = logisticsOrderMapper.selectLogisticsOrderList(query, orderList, type, entId,longList,longList);
+        List<AcceptCarriageOrderVO> list = logisticsOrderMapper.selectLogisticsOrderList(query, orderList, type, entId, longList, longList);
         /**计费方式*/
         Map<String, String> chargingDictData = getDictData(DictTypeEnum.CHARGING_TYPE.getType());
         /**结算周期*/

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/service/CommonService.java

@@ -2,32 +2,41 @@ package com.sckw.transport.service;
 
 import cn.hutool.core.date.DateTime;
 import cn.hutool.core.util.ObjectUtil;
+import com.alibaba.fastjson2.JSON;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.sckw.contract.api.RemoteContractService;
 import com.sckw.core.common.enums.NumberConstant;
 import com.sckw.core.common.enums.enums.DictEnum;
 import com.sckw.core.exception.BusinessException;
-import com.sckw.core.model.constant.Global;
 import com.sckw.core.model.enums.LogisticsOrderEnum;
 import com.sckw.core.model.enums.OrderRuleEnum;
 import com.sckw.core.model.enums.RedisOrderGenerateEnum;
 import com.sckw.core.utils.*;
+import com.sckw.core.web.context.LoginUserHolder;
 import com.sckw.fleet.api.RemoteFleetService;
 import com.sckw.fleet.api.model.vo.RDriverVo;
 import com.sckw.mongo.model.TableTops;
 import com.sckw.redis.constant.RedisConstant;
 import com.sckw.redis.utils.RedissonUtils;
+import com.sckw.stream.enums.MessageEnum;
+import com.sckw.stream.model.SckwMessage;
+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;
 import com.sckw.system.api.model.dto.res.UserCacheResDto;
 import com.sckw.transport.dao.KwtLogisticsOrderContractMapper;
 import com.sckw.transport.dao.KwtLogisticsOrderMapper;
 import com.sckw.transport.model.KwtLogisticsOrder;
 import com.sckw.transport.model.KwtLogisticsOrderContract;
+import com.sckw.transport.model.KwtLogisticsOrderUnit;
+import com.sckw.transport.model.dto.AddOrderDTO;
 import com.sckw.transport.model.vo.UserInfoVo;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.dubbo.config.annotation.DubboReference;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.cloud.stream.function.StreamBridge;
 import org.springframework.stereotype.Service;
 
 import java.math.BigDecimal;
@@ -43,6 +52,15 @@ import java.util.stream.Collectors;
 @Service
 public class CommonService {
 
+    @Autowired
+    private StreamBridge streamBridge;
+
+    @Value("${message.logistics.order.consignLogisticsOrderUrl}")
+    private String consignLogisticsOrderUrl;
+
+    @Value("${message.logistics.order.carriageLogisticsOrderUrl}")
+    private String carriageLogisticsOrderUrl;
+
     @DubboReference(version = "1.0.0", group = "design", check = false, timeout = 8000)
     RemoteSystemService remoteSystemService;
 
@@ -215,4 +233,287 @@ public class CommonService {
         return userList;
     }
 
+
+    /**
+     * 发起物流托运-[贸易订单物流托运确认/承运订单分包托运确认]
+     *
+     * @param checkUnit    托运单位
+     * @param carriageUnit 承运单位
+     * @param orderNo      单据号
+     * @param createBy     创建人
+     * @param entId        创建数据的企业id
+     */
+    public void initIatingLogisticsConsignment(KwtLogisticsOrderUnit checkUnit, KwtLogisticsOrderUnit carriageUnit, String orderNo, Long createBy, Long entId) {
+        boolean flag = false;
+        if (createBy.equals(checkUnit.getContactsId()) || createBy.equals(carriageUnit.getContactsId())) {
+            flag = true;
+        }
+        Map<String, Object> map = new HashMap<>(NumberConstant.SIXTEEN);
+        map.put("orderNo", orderNo);
+        if (flag && createBy.equals(checkUnit.getContactsId())) {
+            sendMessageLogistics(checkUnit, carriageUnit, map);
+        } else if (flag && createBy.equals(carriageUnit.getContactsId())) {
+            sendMessageLogistics(checkUnit, carriageUnit, map);
+        } else {
+            UserCacheResDto userCacheResDto = remoteSystemService.queryUserCacheById(createBy);
+            //给订单创建人发消息
+            List<UserInfo> userInfos = new ArrayList<>();
+            UserInfo createUser = new UserInfo();
+            createUser.setUserId(createBy).setEntId(entId);
+            userInfos.add(createUser);
+            map.put("companyName", userCacheResDto == null ? null : userCacheResDto.getEntInfo().getFirmName());
+            SckwMessage msg = new SckwMessage();
+            msg.setRequestId(UUIDUtils.get32UUID())
+                    .setMessageEnum(MessageEnum.INITIATING_LOGISTICS_CONSIGNMENT)
+                    .setParams(map)
+                    .setMsgUrl(consignLogisticsOrderUrl)
+                    .setUserInfos(userInfos)
+                    .setCreateBy(LoginUserHolder.getUserId());
+            log.info("发起物流托运-[贸易订单物流托运确认/承运订单分包托运确认]-创建人：{}", JSON.toJSONString(msg));
+
+            sendMessageLogistics(checkUnit, carriageUnit, map);
+        }
+
+    }
+
+    /**
+     * 给承运和托运双方发送消息
+     *
+     * @param checkUnit
+     * @param carriageUnit
+     * @param map
+     */
+    private void sendMessageLogistics(KwtLogisticsOrderUnit checkUnit, KwtLogisticsOrderUnit carriageUnit, Map map) {
+        //给业务联系人发消息[承运方]
+        List<UserInfo> userInfoList = new ArrayList<>();
+        UserInfo userInfo = new UserInfo();
+        userInfo.setUserId(carriageUnit.getContactsId()).setEntId(carriageUnit.getTopEntId());
+        userInfoList.add(userInfo);
+        map.put("companyName", carriageUnit.getFirmName());
+        SckwMessage sckwMessage = new SckwMessage();
+        sckwMessage.setRequestId(UUIDUtils.get32UUID())
+                .setMessageEnum(MessageEnum.INITIATING_LOGISTICS_CONSIGNMENT)
+                .setParams(map)
+                .setMsgUrl(carriageLogisticsOrderUrl)
+                .setUserInfos(userInfoList)
+                .setCreateBy(LoginUserHolder.getUserId());
+        log.info("发起物流托运-[贸易订单物流托运确认/承运订单分包托运确认]-[承运方]-业务联系人：{}", JSON.toJSONString(sckwMessage));
+
+        //给业务联系人发消息[托运方]
+        List<UserInfo> list = new ArrayList<>();
+        UserInfo userInfo1 = new UserInfo();
+        userInfo1.setUserId(checkUnit.getContactsId()).setEntId(checkUnit.getTopEntId());
+        list.add(userInfo);
+        map.put("companyName", checkUnit.getFirmName());
+        SckwMessage message = new SckwMessage();
+        message.setRequestId(UUIDUtils.get32UUID())
+                .setMessageEnum(MessageEnum.NEW_CARRIAGE_ORDER)
+                .setParams(map)
+                .setMsgUrl(carriageLogisticsOrderUrl)
+                .setUserInfos(list)
+                .setCreateBy(LoginUserHolder.getUserId());
+        log.info("发起物流托运-[贸易订单物流托运确认/承运订单分包托运确认]-[托运方]-业务联系人：{}", JSON.toJSONString(message));
+        streamBridge.send("sckw-message", JSON.toJSONString(message));
+    }
+
+    public void newLogisticsOrder(AddOrderDTO addOrderDTO, String lOrderNo, Long createBy, Long entId) {
+
+        EntCacheResDto consignentMap = remoteSystemService.queryEntTreeById(Long.parseLong(addOrderDTO.getConsignCompanyId()));
+        EntCacheResDto acceptMap = remoteSystemService.queryEntTreeById(Long.parseLong(addOrderDTO.getAcceptCompanyId()));
+
+        //托运单位
+        KwtLogisticsOrderUnit checkUnit = new KwtLogisticsOrderUnit();
+        checkUnit.setUnitType(1);
+        checkUnit.setFirmName(addOrderDTO.getConsignCompany());
+        checkUnit.setEntId(Long.parseLong(addOrderDTO.getConsignCompanyId()));
+        checkUnit.setTopEntId(consignentMap == null ? null : consignentMap.getId());
+        checkUnit.setContactsId(Long.parseLong(addOrderDTO.getConsignContactsId()));
+
+        //承运单位
+        KwtLogisticsOrderUnit carriageUnit = new KwtLogisticsOrderUnit();
+        carriageUnit.setUnitType(2);
+        carriageUnit.setFirmName(addOrderDTO.getAcceptCompany());
+        carriageUnit.setEntId(Long.parseLong(addOrderDTO.getAcceptCompanyId()));
+        carriageUnit.setContactsId(Long.parseLong(addOrderDTO.getAcceptContactsId()));
+        carriageUnit.setFirmName(addOrderDTO.getConsignCompany());
+        carriageUnit.setTopEntId(acceptMap == null ? null : acceptMap.getId());
+        boolean flag = false;
+        if (createBy.equals(checkUnit.getContactsId()) || createBy.equals(carriageUnit.getContactsId())) {
+            flag = true;
+        }
+        Map<String, Object> map = new HashMap<>(NumberConstant.SIXTEEN);
+        map.put("orderNo", lOrderNo);
+        if (flag && createBy.equals(checkUnit.getContactsId())) {
+            sendMessageNewLogisticsOrder(checkUnit, map,MessageEnum.NEW_LOGISTICS_ORDER,consignLogisticsOrderUrl);
+        } else if (flag && createBy.equals(carriageUnit.getContactsId())) {
+            sendMessageNewLogisticsOrder(carriageUnit, map,MessageEnum.NEW_CARRIAGE_ORDER,carriageLogisticsOrderUrl);
+        } else {
+            UserCacheResDto userCacheResDto = remoteSystemService.queryUserCacheById(createBy);
+            //给订单创建人发消息
+            List<UserInfo> userInfos = new ArrayList<>();
+            UserInfo createUser = new UserInfo();
+            createUser.setUserId(createBy).setEntId(entId);
+            userInfos.add(createUser);
+            map.put("companyName", userCacheResDto == null ? null : userCacheResDto.getEntInfo().getFirmName());
+            SckwMessage msg = new SckwMessage();
+            msg.setRequestId(UUIDUtils.get32UUID())
+                    .setMessageEnum(MessageEnum.NEW_LOGISTICS_ORDER)
+                    .setParams(map)
+                    .setMsgUrl(consignLogisticsOrderUrl)
+                    .setUserInfos(userInfos)
+                    .setCreateBy(LoginUserHolder.getUserId());
+            log.info("托运订单/承运订单自建物流订单-创建人：{}", JSON.toJSONString(msg));
+
+            sendMessageNewLogisticsOrder(checkUnit, map,MessageEnum.NEW_LOGISTICS_ORDER,consignLogisticsOrderUrl);
+            sendMessageNewLogisticsOrder(carriageUnit, map,MessageEnum.NEW_CARRIAGE_ORDER,carriageLogisticsOrderUrl);
+        }
+
+    }
+
+    /**
+     * 托运订单-新建订单
+     * 承运订单-新建订单
+     * @param checkUnit 托运单位
+     * @param map   请求参数
+     * @param messageEnum   消息枚举
+     * @param consignLogisticsOrderUrl 页面地址url
+     */
+    private void sendMessageNewLogisticsOrder(KwtLogisticsOrderUnit checkUnit, Map<String, Object> map, MessageEnum messageEnum, String consignLogisticsOrderUrl) {
+        //给业务联系人发消息[承运方]
+        List<UserInfo> userInfoList = new ArrayList<>();
+        UserInfo userInfo = new UserInfo();
+        userInfo.setUserId(checkUnit.getContactsId()).setEntId(checkUnit.getTopEntId());
+        userInfoList.add(userInfo);
+        map.put("companyName", checkUnit.getFirmName());
+        SckwMessage sckwMessage = new SckwMessage();
+        sckwMessage.setRequestId(UUIDUtils.get32UUID())
+                .setMessageEnum(messageEnum)
+                .setParams(map)
+                .setMsgUrl(consignLogisticsOrderUrl)
+                .setUserInfos(userInfoList)
+                .setCreateBy(LoginUserHolder.getUserId());
+        log.info("托运订单/承运订单自建物流订单-业务联系人：{}", JSON.toJSONString(sckwMessage));
+
+    }
+
+    /**
+     * 撤销托运
+     * @param consignUnit 托运订单
+     * @param carriageUnit 承运订单
+     * @param orderNo  物流订单
+     * @param createBy  创建人
+     * @param entId 当前单据企业id
+     * @param consignMessageEnum 托运单位使用的消息枚举
+     * @param carriageMessageEnum 承运单位使用的消息枚举
+     */
+    public void cancelLogisticsConsignment(KwtLogisticsOrderUnit consignUnit,KwtLogisticsOrderUnit carriageUnit ,String orderNo, Long createBy, Long entId,
+                                           MessageEnum consignMessageEnum,MessageEnum carriageMessageEnum) {
+        boolean flag = false;
+        if (createBy.equals(consignUnit.getContactsId()) || createBy.equals(carriageUnit.getContactsId())) {
+            flag = true;
+        }
+        Map<String, Object> map = new HashMap<>(NumberConstant.SIXTEEN);
+        map.put("orderNo", orderNo);
+        if (flag && createBy.equals(consignUnit.getContactsId())) {
+            sendMessagePublicLogistics(consignUnit, carriageUnit, map,consignMessageEnum);
+        } else if (flag && createBy.equals(carriageUnit.getContactsId())) {
+            sendMessagePublicLogistics(consignUnit, carriageUnit, map,carriageMessageEnum);
+        } else {
+            UserCacheResDto userCacheResDto = remoteSystemService.queryUserCacheById(createBy);
+            //给订单创建人发消息
+            List<UserInfo> userInfos = new ArrayList<>();
+            UserInfo createUser = new UserInfo();
+            createUser.setUserId(createBy).setEntId(entId);
+            userInfos.add(createUser);
+            map.put("companyName", userCacheResDto == null ? null : userCacheResDto.getEntInfo().getFirmName());
+            SckwMessage msg = new SckwMessage();
+            msg.setRequestId(UUIDUtils.get32UUID())
+                    .setMessageEnum(consignMessageEnum)
+                    .setParams(map)
+                    .setMsgUrl(consignLogisticsOrderUrl)
+                    .setUserInfos(userInfos)
+                    .setCreateBy(LoginUserHolder.getUserId());
+            log.info(MessageEnum.getDesc(consignMessageEnum)+"-创建人：{}", JSON.toJSONString(msg));
+
+            sendMessagePublicLogistics(consignUnit, carriageUnit, map,consignMessageEnum);
+        }
+    }
+
+
+    /**
+     * 公共推送消息处理
+     * @param consignUnit 托运订单
+     * @param carriageUnit 承运订单
+     * @param orderNo  物流订单
+     * @param createBy  创建人
+     * @param entId 当前单据企业id
+     * @param consignMessageEnum 托运单位使用的消息枚举
+     * @param carriageMessageEnum 承运单位使用的消息枚举
+     */
+    public void publicLogisticsConsignmentPushMessage(KwtLogisticsOrderUnit consignUnit,KwtLogisticsOrderUnit carriageUnit ,String orderNo, Long createBy, Long entId,
+                                           MessageEnum consignMessageEnum,MessageEnum carriageMessageEnum) {
+        boolean flag = false;
+        if (createBy.equals(consignUnit.getContactsId()) || createBy.equals(carriageUnit.getContactsId())) {
+            flag = true;
+        }
+        Map<String, Object> map = new HashMap<>(NumberConstant.SIXTEEN);
+        map.put("orderNo", orderNo);
+        if (flag && createBy.equals(consignUnit.getContactsId())) {
+            sendMessagePublicLogistics(consignUnit, carriageUnit, map,consignMessageEnum);
+        } else if (flag && createBy.equals(carriageUnit.getContactsId())) {
+            sendMessagePublicLogistics(consignUnit, carriageUnit, map,carriageMessageEnum);
+        } else {
+            UserCacheResDto userCacheResDto = remoteSystemService.queryUserCacheById(createBy);
+            //给订单创建人发消息
+            List<UserInfo> userInfos = new ArrayList<>();
+            UserInfo createUser = new UserInfo();
+            createUser.setUserId(createBy).setEntId(entId);
+            userInfos.add(createUser);
+            map.put("companyName", userCacheResDto == null ? null : userCacheResDto.getEntInfo().getFirmName());
+            SckwMessage msg = new SckwMessage();
+            msg.setRequestId(UUIDUtils.get32UUID())
+                    .setMessageEnum(consignMessageEnum)
+                    .setParams(map)
+                    .setMsgUrl(consignLogisticsOrderUrl)
+                    .setUserInfos(userInfos)
+                    .setCreateBy(LoginUserHolder.getUserId());
+            log.info(MessageEnum.getDesc(consignMessageEnum)+"-创建人：{}", JSON.toJSONString(msg));
+
+            sendMessagePublicLogistics(consignUnit, carriageUnit, map,consignMessageEnum);
+        }
+    }
+
+
+    private void sendMessagePublicLogistics(KwtLogisticsOrderUnit consignUnit, KwtLogisticsOrderUnit carriageUnit, Map<String, Object> map,MessageEnum consignMessageEnum) {
+        //给业务联系人发消息[承运方]
+        List<UserInfo> userInfoList = new ArrayList<>();
+        UserInfo userInfo = new UserInfo();
+        userInfo.setUserId(carriageUnit.getContactsId()).setEntId(carriageUnit.getTopEntId());
+        userInfoList.add(userInfo);
+        map.put("companyName", carriageUnit.getFirmName());
+        SckwMessage sckwMessage = new SckwMessage();
+        sckwMessage.setRequestId(UUIDUtils.get32UUID())
+                .setMessageEnum(consignMessageEnum)
+                .setParams(map)
+                .setMsgUrl(carriageLogisticsOrderUrl)
+                .setUserInfos(userInfoList)
+                .setCreateBy(LoginUserHolder.getUserId());
+        log.info(MessageEnum.getDesc(consignMessageEnum)+"-[承运方]-业务联系人：{}", JSON.toJSONString(sckwMessage));
+
+        //给业务联系人发消息[托运方]
+        List<UserInfo> list = new ArrayList<>();
+        UserInfo userInfo1 = new UserInfo();
+        userInfo1.setUserId(consignUnit.getContactsId()).setEntId(consignUnit.getTopEntId());
+        list.add(userInfo);
+        map.put("companyName", consignUnit.getFirmName());
+        SckwMessage message = new SckwMessage();
+        message.setRequestId(UUIDUtils.get32UUID())
+                .setMessageEnum(MessageEnum.NEW_CARRIAGE_ORDER)
+                .setParams(map)
+                .setMsgUrl(carriageLogisticsOrderUrl)
+                .setUserInfos(list)
+                .setCreateBy(LoginUserHolder.getUserId());
+        log.info(MessageEnum.getDesc(consignMessageEnum)+"-[托运方]-业务联系人：{}", JSON.toJSONString(message));
+        streamBridge.send("sckw-message", JSON.toJSONString(message));
+    }
 }

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/service/ConsignOrderService.java

@@ -814,8 +814,9 @@ public class ConsignOrderService {
         if (logisticsOrder.getPid() != null) {
             //数据推送至贸易订单
             CompleteLogisticsOrderParam tradeOrder = new CompleteLogisticsOrderParam();
+            //todo 2023-09-07 修改为不传递总量，只传递当前单据页面传递值
             //获取实际装货量-实际卸货量
-            Map<String, BigDecimal> map = kwtLogisticsOrderMapper.countAmountByTradeOrderId(logisticsOrder.getTOrderId());
+//            Map<String, BigDecimal> map = kwtLogisticsOrderMapper.countAmountByTradeOrderId(logisticsOrder.getTOrderId());
             //获取是否订单已经全部处理完成
             List<Integer> statusList = new ArrayList<>();
             statusList.add(LogisticsOrderEnum.TO_BE_PLANNED.getCode());
@@ -829,8 +830,10 @@ public class ConsignOrderService {
                 tradeOrder.setIsAllComplete(true);
             }
             tradeOrder.setTOrderId(logisticsOrder.getTOrderId());
-            tradeOrder.setActualLoadAmount(map.get("totalLoadAmount"));
-            tradeOrder.setActualUnloadAmount(map.get("totalUnloadAmount"));
+//            tradeOrder.setActualLoadAmount(map.get("totalLoadAmount"));
+//            tradeOrder.setActualUnloadAmount(map.get("totalUnloadAmount"));
+            tradeOrder.setActualLoadAmount(orderFinishDTO.getLoadAmount());
+            tradeOrder.setActualUnloadAmount(orderFinishDTO.getUnloadAmount());
             tradeOrder.setUpdateBy(LoginUserHolder.getUserId());
             tradeOrder.setUpdateByName(LoginUserHolder.getUserName());
             log.info("托运订单手动完结请求参数:{}", JSONObject.toJSONString(tradeOrder));
@@ -1206,13 +1209,17 @@ public class ConsignOrderService {
             log.info("托运订单创建订单异常");
             throw new BusinessException("自建订单异常");
         }
+        /**数据保存*/
         saveConsignLogisticsOrder(addOrderDTO, lOrderId, orderStatus, lOrderNo);
         saveConsignLogisticsOrderAddress(addOrderDTO, lOrderId);
         saveConsignLogisticsOrderGoods(addOrderDTO, lOrderId, lOrderNo);
         saveConsignLogisticsOrderContract(addOrderDTO, lOrderId, infoResDto);
         saveConsignLogisticsOrderTrack(lOrderId, orderStatus);
         saveConsignLogisticsOrderUnit(addOrderDTO, lOrderId);
+        /**保存mongodb*/
         saveMongoDb(addOrderDTO, orderStatus, lOrderId, lOrderNo, infoResDto);
+        /**消息主体*/
+        commonService.newLogisticsOrder(addOrderDTO,lOrderNo,LoginUserHolder.getUserId(),LoginUserHolder.getEntId());
         return HttpResult.ok();
     }
 
@@ -1426,7 +1433,8 @@ public class ConsignOrderService {
         consignUnit.setFirmName(addOrderDTO.getConsignCompany());
         consignUnit.setContacts(addOrderDTO.getConsignContacts());
         consignUnit.setPhone(addOrderDTO.getConsignContactPhone());
-        consignUnit.setRemark(addOrderDTO.getRemark());
+        consignUnit.setContactsId(Long.parseLong(addOrderDTO.getConsignContactsId()));
+//        consignUnit.setRemark(addOrderDTO.getRemark());
         consignUnit.setStatus(NumberConstant.ZERO);
         consignUnit.setCreateBy(LoginUserHolder.getUserId());
         consignUnit.setCreateTime(new Date());
@@ -1446,8 +1454,9 @@ public class ConsignOrderService {
         unit.setFirmName(addOrderDTO.getAcceptCompany());
         unit.setContacts(addOrderDTO.getAcceptContacts());
         unit.setPhone(addOrderDTO.getAcceptContactPhone());
-        unit.setRemark(addOrderDTO.getRemark());
+//        unit.setRemark(addOrderDTO.getRemark());
         unit.setStatus(NumberConstant.ZERO);
+        unit.setContactsId(Long.parseLong(addOrderDTO.getAcceptContactsId()));
         unit.setCreateBy(LoginUserHolder.getUserId());
         unit.setCreateTime(new Date());
         unit.setUpdateBy(LoginUserHolder.getUserId());

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/service/KwtWaybillOrderService.java

@@ -34,6 +34,7 @@ import com.sckw.system.api.model.dto.res.UserCacheResDto;
 import com.sckw.transport.dao.*;
 import com.sckw.transport.model.*;
 import com.sckw.transport.model.dto.*;
+import com.sckw.transport.model.vo.UserInfoVo;
 import com.sckw.transport.model.vo.WaybillCountVo;
 import com.sckw.transport.model.vo.WaybillOrderDriverVo;
 import jakarta.annotation.Resource;
@@ -82,6 +83,8 @@ public class KwtWaybillOrderService {
     KwtLogisticsOrderGoodsMapper logisticsOrderGoodsDao;
     @Autowired
     KwtLogisticsOrderCirculateMapper logisticsOrderCirculateDao;
+    @Autowired
+    CommonService commonService;
     @Resource
     private StreamBridge streamBridge;
     @DubboReference(version = "1.0.0", group = "design", check = false)
@@ -236,7 +239,7 @@ public class KwtWaybillOrderService {
                 changeWaybillOrderCirculate(circulate.getId(), params, null);
                 wOrder.set_id(circulate.getId());
             } else {
-                circulate = logisticsOrderCirculateDao.findCirculate(waybillOrder.getLOrderId(), waybillOrder.getTruckId(), waybillOrder.getDriverId(), Global.NO);
+                circulate = logisticsOrderCirculateDao.findCirculate(waybillOrder.getLOrderId(), waybillOrder.getTruckId(), waybillOrder.getDriverId());
                 changeWaybillOrderCirculate(circulate.getId(), params, null);
             }
         }
@@ -283,7 +286,7 @@ public class KwtWaybillOrderService {
                 changeWaybillOrderCirculate(circulate.getId(), null, params);
                 wOrder.set_id(circulate.getId());
             } else {
-                circulate = logisticsOrderCirculateDao.findCirculate(waybillOrder.getLOrderId(), waybillOrder.getTruckId(), waybillOrder.getDriverId(), Global.NO);
+                circulate = logisticsOrderCirculateDao.findCirculate(waybillOrder.getLOrderId(), waybillOrder.getTruckId(), waybillOrder.getDriverId());
                 changeWaybillOrderCirculate(circulate.getId(), null, params);
             }
         }
@@ -491,12 +494,14 @@ public class KwtWaybillOrderService {
         List<SckwWaybillOrder> sckwWaybillOrders = new ArrayList();
         for (SendCarDto1 sendCarDto : params) {
             /**KwtWaybillOrder数据组装**/
-            String wOrderNo = getRedisGenerateWaybillOrderNo(RedisOrderGenerateEnum.WAYBILL_ORDER, OrderRuleEnum.WAYBILL_ORDER, logisticsOrder.getLOrderNo());
-            KwtWaybillOrder waybillOrder = this.setKwtWaybillOrder(sendCarDto, wOrderNo);
+            KwtWaybillOrder waybillOrder = this.setKwtWaybillOrder(sendCarDto);
             /**数据存储**/
             if (sendCarDto.getType() == Global.NUMERICAL_ONE) {
                 for (int i = 0; i < sendCarDto.getCount(); i++) {
                     //车辆运单存储
+                    String wOrderNo = getRedisGenerateWaybillOrderNo(RedisOrderGenerateEnum.WAYBILL_ORDER, OrderRuleEnum.WAYBILL_ORDER, logisticsOrder.getLOrderNo());
+                    waybillOrder.setId(null);
+                    waybillOrder.setWOrderNo(wOrderNo);
                     ranksSave(waybillOrder, loadAddress, unloadAddress);
 
                     /**SckwWaybillOrder数据组装**/
@@ -534,7 +539,6 @@ public class KwtWaybillOrderService {
         return HttpResult.ok(sckwWaybillOrders);
     }
 
-
     /**
      * 获取生成车辆运单单据号最大值处理
      */
@@ -569,7 +573,6 @@ public class KwtWaybillOrderService {
      **/
     public void ranksSave(KwtWaybillOrder waybillOrder, KwtWaybillOrderAddress loadAddress, KwtWaybillOrderAddress unloadAddress) {
         /**车辆运单信息**/
-        waybillOrder.setId(null);
         waybillOrderDao.insert(waybillOrder);
 
         /**车辆运单地址信息**/
@@ -597,7 +600,7 @@ public class KwtWaybillOrderService {
     public KwtLogisticsOrderCirculate circulateSave(KwtWaybillOrder waybillOrder) {
         //循环派车信息
         KwtLogisticsOrderCirculate circulate = logisticsOrderCirculateDao.findCirculate(waybillOrder.getLOrderId(),
-                waybillOrder.getTruckId(), waybillOrder.getDriverId(), 0);
+                waybillOrder.getTruckId(), waybillOrder.getDriverId());
         if (circulate == null) {
             circulate = new KwtLogisticsOrderCirculate();
             BeanUtils.copyProperties(waybillOrder, circulate);
@@ -605,8 +608,13 @@ public class KwtWaybillOrderService {
             circulate.setStatus(0);
             int count = logisticsOrderCirculateDao.insert(circulate);
             return count > 0 ? circulate : null;
+        } else {
+            BeanUtils.copyProperties(waybillOrder, circulate);
+            circulate.setWOrderId(null);
+            circulate.setStatus(0);
+            int count = logisticsOrderCirculateDao.updateById(circulate);
+            return count > 0 ? circulate : null;
         }
-        return circulate;
     }
 
     /**
@@ -662,11 +670,10 @@ public class KwtWaybillOrderService {
      * @author zk
      * @date 2023/7/20
      **/
-    public KwtWaybillOrder setKwtWaybillOrder(SendCarDto1 sendCarDto, String wOrderNo) {
+    public KwtWaybillOrder setKwtWaybillOrder(SendCarDto1 sendCarDto) {
         KwtWaybillOrder waybillOrder = new KwtWaybillOrder();
         waybillOrder.setEntId(LoginUserHolder.getEntId());
         waybillOrder.setLOrderId(sendCarDto.getLOrderId());
-        waybillOrder.setWOrderNo(wOrderNo);
         waybillOrder.setType(sendCarDto.getType());
         waybillOrder.setStartTime(sendCarDto.getLoadDateTime());
         waybillOrder.setEndTime(sendCarDto.getUnloadDateTime());
@@ -1201,6 +1208,7 @@ public class KwtWaybillOrderService {
             /**5Mongodb数据更新**/
             //1车辆订单
             SckwWaybillOrder wOrder = new SckwWaybillOrder();
+            wOrder.setWOrderNo(waybillOrder.getWOrderNo());
             editSckwWaybillOrder(wOrder, waybillOrder, 2);
 
             //2承运订单
@@ -1403,7 +1411,7 @@ public class KwtWaybillOrderService {
         if (waybillOrder.getType() == Global.NUMERICAL_TWO) {
             //循环派车信息
             KwtLogisticsOrderCirculate circulate = logisticsOrderCirculateDao.findCirculate(waybillOrder.getLOrderId(),
-                    waybillOrder.getTruckId(), waybillOrder.getDriverId(), 0);
+                    waybillOrder.getTruckId(), waybillOrder.getDriverId());
             circulate.setStatus(Global.NUMERICAL_ONE);
             logisticsOrderCirculateDao.updateById(circulate);
         }
@@ -1625,7 +1633,7 @@ public class KwtWaybillOrderService {
         if (waybillOrder.getType() == Global.NUMERICAL_TWO) {
             //循环派车信息
             KwtLogisticsOrderCirculate circulate = logisticsOrderCirculateDao.findCirculate(waybillOrder.getLOrderId(),
-                    waybillOrder.getTruckId(), waybillOrder.getDriverId(), 0);
+                    waybillOrder.getTruckId(), waybillOrder.getDriverId());
             /*circulate.setWOrderId(null);
             logisticsOrderCirculateDao.updateById(circulate);*/
             Long newId = new IdWorker(Global.NUMERICAL_ONE).nextId();
@@ -2009,10 +2017,9 @@ public class KwtWaybillOrderService {
             add(track != null ? track.getCreateBy() : null);
         }};
         createBys = createBys.stream().distinct().collect(Collectors.toList());
-        Map<Long, UserCacheResDto> users = remoteSystemService.queryUserCacheMapByIds(createBys);
-        UserCacheResDto loadUser = users == null ? null : users.get(loadTicket != null ? loadTicket.getUpdateBy() : null);
-        UserCacheResDto unloadUser = users == null ? null : users.get(unloadTicket != null ? unloadTicket.getUpdateBy() : null);
-        UserCacheResDto approver = users == null ? null : users.get(track != null ? track.getCreateBy() : null);
+        List<UserInfoVo> users = commonService.findUserList(createBys);
+        Map<Long, String> usersMap = new HashMap<>(Global.NUMERICAL_SIXTEEN);
+        users.forEach(e -> usersMap.put(e.getId(), e.getName()));
 
         Map result = new HashMap();
         result.put("wOrderId", wOrderId);
@@ -2028,7 +2035,7 @@ public class KwtWaybillOrderService {
         result.put("loadUrls", loadTicket != null ? loadTicket.getUrls() : null);
         result.put("loadOperateTime", loadTicket != null ? loadTicket.getOperateTime() : null);
         result.put("loadCreateTime", loadTicket != null ? loadTicket.getCreateTime() : null);
-        result.put("loadCreateByName", loadUser != null ? loadUser.getName() : null);
+        result.put("loadCreateByName", usersMap.get(loadTicket.getUpdateBy()));
         result.put("loadCityName", loadAddress != null ? loadAddress.getCityName() : null);
         result.put("loadDetailAddress", loadAddress != null ? loadAddress.getDetailAddress() : null);
         result.put("unloadStatus", loadTicket != null ? 0 : 1);
@@ -2036,13 +2043,12 @@ public class KwtWaybillOrderService {
         result.put("unloadUrls", unloadTicket != null ? unloadTicket.getUrls() : null);
         result.put("unloadOperateTime", unloadTicket != null ? unloadTicket.getOperateTime() : null);
         result.put("unloadCreateTime", unloadTicket != null ? unloadTicket.getCreateTime() : null);
-        result.put("unloadCreateByName", unloadUser != null ? unloadUser.getName() : null);
+        result.put("unloadCreateByName", usersMap.get(unloadTicket.getUpdateBy()));
         result.put("unloadCityName", unloadAddress != null ? unloadAddress.getCityName() : null);
         result.put("unloadDetailAddress", unloadAddress != null ? unloadAddress.getDetailAddress() : null);
         result.put("approvalTime", track != null ? track.getCreateTime() : null);
         result.put("approvalOpinions", track != null ? track.getRemark() : null);
-        result.put("approver", approver != null ? approver.getName() : null);
-
+        result.put("approver", usersMap.get(track.getUpdateBy()));
         return HttpResult.ok(result);
     }
 

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/service/LogisticsConsignmentService.java

@@ -29,6 +29,7 @@ import com.sckw.order.api.model.*;
 import com.sckw.product.api.dubbo.GoodsInfoService;
 import com.sckw.product.api.model.KwpGoods;
 import com.sckw.redis.config.RedisLockUtil;
+import com.sckw.stream.enums.MessageEnum;
 import com.sckw.stream.model.SckwBusSum;
 import com.sckw.system.api.RemoteSystemService;
 import com.sckw.system.api.model.dto.res.EntCacheResDto;
@@ -210,8 +211,29 @@ public class LogisticsConsignmentService {
         HttpResult httpResult = tradeOrderInfoService.createOrCancelLogisticsOrder(param);
         if (httpResult.getCode() != HttpStatus.SUCCESS_CODE) {
             log.info("{}生成物流托运失败!,返回信息:{}", tradeOrder.getTOrderNo(), JSONObject.toJSONString(httpResult));
-            throw new BusinessException("{" + tradeOrder.getTOrderNo() + "}生成物流托运失败!");
+            throw new BusinessException("{" + tradeOrder.getTOrderNo() + "}生成物流托运失败!"+httpResult.getMsg());
         }
+        /**消息列表*/
+        EntCacheResDto consignentMap = remoteSystemService.queryEntTreeById(Long.parseLong(bo.getConsignCompanyId()));
+        EntCacheResDto checkentMap = remoteSystemService.queryEntTreeById(Long.parseLong(bo.getCheckCompanyId()));
+        //托运单位
+        KwtLogisticsOrderUnit checkUnit = new KwtLogisticsOrderUnit();
+
+        checkUnit.setUnitType(1);
+        checkUnit.setFirmName(bo.getCheckCompany());
+        checkUnit.setEntId(Long.parseLong(bo.getCheckCompanyId()));
+        checkUnit.setTopEntId(checkentMap == null ? null : checkentMap.getId());
+        checkUnit.setContactsId(Long.parseLong(bo.getCheckContactsId()));
+
+        //承运单位
+        KwtLogisticsOrderUnit carriageUnit = new KwtLogisticsOrderUnit();
+        carriageUnit.setUnitType(2);
+        carriageUnit.setFirmName(bo.getConsignCompany());
+        carriageUnit.setEntId(Long.parseLong(bo.getConsignCompanyId()));
+        carriageUnit.setTopEntId(consignentMap == null ? null : consignentMap.getId());
+        carriageUnit.setContactsId(Long.parseLong(bo.getConsignContactsId()));
+
+        commonService.initIatingLogisticsConsignment(checkUnit, carriageUnit, lOrderNo, LoginUserHolder.getUserId(), LoginUserHolder.getEntId());
     }
 
     /**
@@ -349,9 +371,11 @@ public class LogisticsConsignmentService {
      * @param orderId
      */
     private void insertLogisticsOrderUnit(LogisticsConsignmentParam bo, Long orderId) {
-        Map<Long, EntCacheResDto> consignentMap = remoteSystemService.queryEntTreeByIds(Collections.singletonList(Long.parseLong(bo.getConsignCompanyId())));
-        Map<Long, EntCacheResDto> checkentMap = remoteSystemService.queryEntTreeByIds(Collections.singletonList(Long.parseLong(bo.getCheckCompanyId())));
-        if (consignentMap.isEmpty() || checkentMap.isEmpty()) {
+        EntCacheResDto consignentMap = remoteSystemService.queryEntTreeById(Long.parseLong(bo.getConsignCompanyId()));
+//                        .setContactsId(consignentMap.get(Long.parseLong(bo.getConsignCompanyId())).getContactsId())
+        EntCacheResDto checkentMap = remoteSystemService.queryEntTreeById(Long.parseLong(bo.getCheckCompanyId()));
+//                        .setContactsId(checkentMap.get(Long.parseLong(bo.getCheckCompanyId())).getContactsId())
+        if (consignentMap == null || checkentMap== null) {
             throw new BusinessException("企业对应一级企业不存在");
         }
         KwtLogisticsOrderUnit checkUnit = new KwtLogisticsOrderUnit()
@@ -361,13 +385,14 @@ public class LogisticsConsignmentService {
                 .setFirmName(bo.getCheckCompany())
                 .setRemark(bo.getRemark())
                 .setEntId(Long.parseLong(bo.getCheckCompanyId()))
-                .setTopEntId(checkentMap.get(Long.parseLong(bo.getCheckCompanyId())).getId())
+                .setTopEntId(checkentMap.getId())
                 .setContacts(bo.getCheckContacts())
                 .setPhone(bo.getCheckContactPhone())
                 .setCreateBy(LoginUserHolder.getUserId())
                 .setCreateTime(new Date())
                 .setUpdateBy(LoginUserHolder.getUserId())
-                .setUpdateTime(new Date());
+                .setUpdateTime(new Date())
+                .setContactsId(Long.parseLong(bo.getCheckContactsId()));
         kwtLogisticsOrderUnitMapper.insert(checkUnit);
 
         KwtLogisticsOrderUnit consignUnit = new KwtLogisticsOrderUnit()
@@ -377,13 +402,14 @@ public class LogisticsConsignmentService {
                 .setFirmName(bo.getConsignCompany())
                 .setRemark(bo.getRemark())
                 .setEntId(Long.parseLong(bo.getConsignCompanyId()))
-                .setTopEntId(consignentMap.get(Long.parseLong(bo.getConsignCompanyId())).getId())
+                .setTopEntId(consignentMap.getId())
                 .setContacts(bo.getConsignContacts())
                 .setPhone(bo.getConsignContactPhone())
                 .setCreateBy(LoginUserHolder.getUserId())
                 .setCreateTime(new Date())
                 .setUpdateBy(LoginUserHolder.getUserId())
-                .setUpdateTime(new Date());
+                .setUpdateTime(new Date())
+                .setContactsId(Long.parseLong(bo.getConsignContactsId()));
         kwtLogisticsOrderUnitMapper.insert(consignUnit);
     }
 
@@ -1043,6 +1069,20 @@ public class LogisticsConsignmentService {
                 streamBridge.send("sckw-busSum", JSON.toJSONString(sckwBusSum));
                 result.setMsg("操作成功");
                 result.setCode(HttpStatus.SUCCESS_CODE);
+
+                /**消息列表发送*/
+                //托运
+                KwtLogisticsOrderUnit consignUnit = kwtLogisticsOrderUnitMapper.selectOne(
+                        new LambdaQueryWrapper<KwtLogisticsOrderUnit>()
+                                .eq(KwtLogisticsOrderUnit::getLOrderId,s)
+                                .eq(KwtLogisticsOrderUnit::getUnitType, NumberConstant.ONE));
+                //承运
+                KwtLogisticsOrderUnit carriageUnit = kwtLogisticsOrderUnitMapper.selectOne(
+                        new LambdaQueryWrapper<KwtLogisticsOrderUnit>()
+                                .eq(KwtLogisticsOrderUnit::getLOrderId,s)
+                                .eq(KwtLogisticsOrderUnit::getUnitType, NumberConstant.TWO));
+                commonService.cancelLogisticsConsignment(consignUnit,carriageUnit,logisticsOrder.getLOrderNo(),logisticsOrder.getCreateBy(),
+                        logisticsOrder.getEntId(), MessageEnum.CANCELLATION_LOGISTICS,MessageEnum.CARRIAGE_CANCELLATION_LOGISTICS);
             } else {
                 result.setMsg("操作失败:" + httpResult.getMsg());
                 result.setCode(HttpStatus.GLOBAL_EXCEPTION_CODE);
@@ -1123,6 +1163,20 @@ public class LogisticsConsignmentService {
                 sckwBusSum.setObject(logisticsOrder);
                 streamBridge.send("sckw-busSum", JSON.toJSONString(sckwBusSum));
                 result.setCode(HttpStatus.SUCCESS_CODE);
+
+                /**消息列表发送*/
+                //托运
+                KwtLogisticsOrderUnit consignUnit = kwtLogisticsOrderUnitMapper.selectOne(
+                        new LambdaQueryWrapper<KwtLogisticsOrderUnit>()
+                                .eq(KwtLogisticsOrderUnit::getLOrderId,id)
+                                .eq(KwtLogisticsOrderUnit::getUnitType, NumberConstant.ONE));
+                //承运
+                KwtLogisticsOrderUnit carriageUnit = kwtLogisticsOrderUnitMapper.selectOne(
+                        new LambdaQueryWrapper<KwtLogisticsOrderUnit>()
+                                .eq(KwtLogisticsOrderUnit::getLOrderId,id)
+                                .eq(KwtLogisticsOrderUnit::getUnitType, NumberConstant.TWO));
+                commonService.cancelLogisticsConsignment(consignUnit,carriageUnit,logisticsOrder.getLOrderNo(),logisticsOrder.getCreateBy(),
+                        logisticsOrder.getEntId(), MessageEnum.CANCELLATION_LOGISTICS,MessageEnum.CARRIAGE_CANCELLATION_LOGISTICS);
             } else {
                 result.setCode(HttpStatus.GLOBAL_EXCEPTION_CODE);
                 result.setMsg("操作失败:" + httpResult.getMsg());
@@ -1237,8 +1291,9 @@ public class LogisticsConsignmentService {
 
         /**数据推送至贸易订单*/
         CompleteLogisticsOrderParam tradeOrder = new CompleteLogisticsOrderParam();
+        //TODO 2023-09-07 修改使用直接传递页面数据 不统计计算
         //获取实际装货量-实际卸货量
-        Map<String, BigDecimal> map = kwtLogisticsOrderMapper.countAmountByTradeOrderId(logisticsOrder.getTOrderId());
+//        Map<String, BigDecimal> map = kwtLogisticsOrderMapper.countAmountByTradeOrderId(logisticsOrder.getTOrderId());
         //获取是否订单已经全部处理完成
         List<Integer> statusList = new ArrayList<>();
         statusList.add(LogisticsOrderEnum.TO_BE_PLANNED.getCode());
@@ -1252,8 +1307,10 @@ public class LogisticsConsignmentService {
             tradeOrder.setIsAllComplete(true);
         }
         tradeOrder.setTOrderId(logisticsOrder.getTOrderId());
-        tradeOrder.setActualLoadAmount(map.get("totalLoadAmount"));
-        tradeOrder.setActualUnloadAmount(map.get("totalUnloadAmount"));
+//        tradeOrder.setActualLoadAmount(map.get("totalLoadAmount"));
+//        tradeOrder.setActualUnloadAmount(map.get("totalUnloadAmount"));
+        tradeOrder.setActualLoadAmount(orderFinishDTO.getLoadAmount());
+        tradeOrder.setActualUnloadAmount(orderFinishDTO.getUnloadAmount());
         tradeOrder.setUpdateBy(LoginUserHolder.getUserId());
         tradeOrder.setUpdateByName(LoginUserHolder.getUserName());
         log.info("采购订单手动完结订单请求参数:{}", JSONObject.toJSONString(tradeOrder));

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/service/TransportCommonService.java

@@ -23,6 +23,7 @@ import com.sckw.order.api.dubbo.TradeOrderInfoService;
 import com.sckw.order.api.model.CreateOrCancelLogisticsOrderParam;
 import com.sckw.order.api.model.OrderDetailRes;
 import com.sckw.order.api.model.UnitInfoDetailRes;
+import com.sckw.stream.enums.MessageEnum;
 import com.sckw.stream.model.SckwBusSum;
 import com.sckw.system.api.RemoteSystemService;
 import com.sckw.system.api.model.dto.res.EntCacheResDto;
@@ -68,6 +69,9 @@ public class TransportCommonService {
     @DubboReference(version = "1.0.0", group = "design", check = false, timeout = 6000)
     RemoteContractService remoteContractService;
 
+    @Autowired
+    public CommonService commonService;
+
     @Autowired
     public KwtLogisticsOrderGoodsMapper logisticsOrderGoodsMapper;
 
@@ -432,6 +436,26 @@ public class TransportCommonService {
             busSum1.setObject(logisticsOrder1);
             streamBridge.send("sckw-busSum", JSON.toJSONString(busSum1));
         }
+//        String type = orderDto.getType();
+//        if ("1".equals(type)) {
+//            commonService.cancelLogisticsConsignment(logisticsOrder.getLOrderNo(), logisticsOrder.getCreateBy(), logisticsOrder.getEntId(), MessageEnum.CANCELLATION_LOGISTICS,newLogisticsOrderUrl);
+//        } else if ("2".equals(type)) {
+//            commonService.cancelLogisticsConsignment(logisticsOrder.getLOrderNo(), logisticsOrder.getCreateBy(), logisticsOrder.getEntId(), MessageEnum.CARRIAGE_CANCELLATION_LOGISTICS,newLogisticsOrderUrl);
+//        }
+
+        Long id = logisticsOrder.getId();
+        //托运
+        KwtLogisticsOrderUnit consignUnit = logisticsOrderUnitMapper.selectOne(
+                new LambdaQueryWrapper<KwtLogisticsOrderUnit>()
+                        .eq(KwtLogisticsOrderUnit::getLOrderId,id)
+                        .eq(KwtLogisticsOrderUnit::getUnitType, NumberConstant.ONE));
+        //承运
+        KwtLogisticsOrderUnit carriageUnit = logisticsOrderUnitMapper.selectOne(
+                new LambdaQueryWrapper<KwtLogisticsOrderUnit>()
+                        .eq(KwtLogisticsOrderUnit::getLOrderId,id)
+                        .eq(KwtLogisticsOrderUnit::getUnitType, NumberConstant.TWO));
+        commonService.cancelLogisticsConsignment(consignUnit,carriageUnit,logisticsOrder.getLOrderNo(),logisticsOrder.getCreateBy(),
+                logisticsOrder.getEntId(),MessageEnum.CANCELLATION_LOGISTICS,MessageEnum.CARRIAGE_CANCELLATION_LOGISTICS);
         return result;
     }
 

sckw-modules/sckw-transport/src/main/java/com/sckw/transport/service/WaybillManagementService.java

@@ -89,6 +89,9 @@ public class WaybillManagementService {
      * @return
      */
     public HttpResult waybillData(Long id) {
+        if (Objects.isNull(id)){
+            return HttpResult.error("id不能为空");
+        }
         WaybillDataVO waybillDataVO = new WaybillDataVO();
         Criteria criteria = new Criteria();
         criteria.and("wOrderId").is(id);

sckw-modules/sckw-transport/src/main/resources/mapper/KwtLogisticsOrderCirculateMapper.xml

@@ -68,7 +68,6 @@
         and l_order_id = #{lOrderId, jdbcType=BIGINT}
         and truck_id = #{truckId, jdbcType=BIGINT}
         and driver_id = #{driverId, jdbcType=BIGINT}
-        and status = #{status, jdbcType=INTEGER}
     </select>
 
     <select id="findCirculateList" resultType="com.sckw.transport.model.KwtLogisticsOrderCirculate" >