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

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

sckw-auth/src/main/java/com/sckw/auth/service/impl/AuthServiceImpl.java

@@ -359,7 +359,7 @@ public class AuthServiceImpl implements IAuthService {
             return HttpResult.error(HttpStatus.CODE_10301, "您的账号已冻结，如需帮助，请致电平台客服！");
         }
         //企业信息
-        REnterpriseVo enterprise = systemService.queryEntDetails(driver.getEntId());
+        EntCacheResDto enterprise = systemService.queryEntDetails(driver.getEntId());
 
         /**生成token**/
         String token = generateToken(loginBase, driver.getId());
@@ -409,7 +409,7 @@ public class AuthServiceImpl implements IAuthService {
             return HttpResult.error(HttpStatus.CODE_10301, "您的账号已冻结，如需帮助，请致电平台客服！");
         }
         //企业信息
-        REnterpriseVo enterprise = systemService.queryEntDetails(user.getEntId());
+        EntCacheResDto enterprise = systemService.queryEntDetails(user.getEntId());
         if (loginBase.getSystemType() == SystemTypeEnum.COMPANY.getCode() && enterprise == null) {
             return HttpResult.error(HttpStatus.QUERY_FAIL_CODE, "账号没有归属企业，请检查并重新输入！");
         }
@@ -482,11 +482,11 @@ public class AuthServiceImpl implements IAuthService {
 
         private final RDriverDetailVo driver;
 
-        private final REnterpriseVo enterprise;
+        private final EntCacheResDto enterprise;
 
         private final RemoteUserService remoteUserService;
 
-        public AsyncProcess1(LoginBase loginBase, KwsUserResDto user, RDriverDetailVo driver, REnterpriseVo enterprise ,
+        public AsyncProcess1(LoginBase loginBase, KwsUserResDto user, RDriverDetailVo driver, EntCacheResDto enterprise ,
                              RemoteUserService remoteUserService) {
             this.loginBase = loginBase;
             this.user = user;
@@ -513,14 +513,12 @@ public class AuthServiceImpl implements IAuthService {
          * @author: czh
          * @date: 2023/7/3
          */
-        private void SaveEntToCache(REnterpriseVo ent) {
+        private void SaveEntToCache(EntCacheResDto ent) {
             if (ent == null) {
                 return;
             }
-            LoginEntInfo loginEntInfo = new LoginEntInfo();
-            BeanUtils.copyProperties(ent, loginEntInfo);
-            String key = Global.getFullUserEntKey(loginEntInfo.getId());
-            RedissonUtils.putString(key, JSON.toJSONString(loginEntInfo), Global.APP_TOKEN_EXPIRE);
+            String key = Global.getFullUserEntKey(ent.getId());
+            RedissonUtils.putString(key, JSON.toJSONString(ent), Global.APP_TOKEN_EXPIRE);
         }
 
         /**

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,176 +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", "托运订单-承运方自建物流订单"),
     /*对账结算*/
     /**
      * 销售、采购对账
@@ -303,6 +321,11 @@ public enum MessageEnum {
      */
     private final String pushType;
 
+    /**
+     * 字段含义解释
+     */
+    private final String desc;
+
 
     public static String getCategoryByType(String type) {
         for (MessageEnum entityEnum : MessageEnum.values()) {
@@ -330,4 +353,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-api/sckw-system-api/src/main/java/com/sckw/system/api/RemoteSystemService.java

@@ -198,7 +198,7 @@ public interface RemoteSystemService {
      * @author zk
      * @date 2023/8/10
      **/
-    REnterpriseVo queryEntDetails(Long entId);
+    EntCacheResDto queryEntDetails(Long entId);
 
     /**
      * @param account 账号

sckw-modules-api/sckw-system-api/src/main/java/com/sckw/system/api/model/dto/res/EntCacheResDto.java

@@ -70,6 +70,11 @@ public class EntCacheResDto implements Serializable {
      */
     private String entTypes;
 
+    /**
+     * 企业属性 （1供应商，2采购商，34PL物流，43PL物流）
+     */
+    private String entTypeNames;
+
     /**
      * 机构信息
      */
@@ -91,13 +96,20 @@ public class EntCacheResDto implements Serializable {
     private String business;
 
     /**
-     * 企业地址-----区域表id---实际用途？
+     * 企业地址
      */
     private String cityName;
 
+    /**
+     * 企业地址
+     */
+    private Integer cityCode;
+
     /**
      * 联系人id
      */
     private Long contactsId;
 
+    private Integer status;
+
 }

sckw-modules/sckw-manage/src/main/java/com/sckw/manage/service/KwmCooperateApplyService.java

@@ -88,7 +88,7 @@ public class KwmCooperateApplyService {
 
 
     /**
-     * @param   list 数据
+     * @param list 数据
      * @return CooperateManageQueryResVo
      * @desc: 组装返参
      * @author: czh
@@ -515,10 +515,27 @@ public class KwmCooperateApplyService {
     @Transactional(rollbackFor = {})
     public void approve(CooperateApproveReqVo reqVo) {
         updateCooperateInfo(reqVo.getIds(), reqVo.getApprove(), reqVo.getRemark());
-
-        if (reqVo.getApprove().equals(CooperateStatusEnum.OK.getCode())) {
-            for (String id : reqVo.getIds().split(Global.COMMA)) {
+        for (String id : reqVo.getIds().split(Global.COMMA)) {
+            if (reqVo.getApprove().equals(CooperateStatusEnum.OK.getCode())) {
                 commonBusinessService.bingManager(reqVo.getManager(), Long.parseLong(id));
+
+                KwmCooperate kwmCooperate = kwmCooperateMapper.selectById(Long.parseLong(id));
+                EntCacheResDto entCacheResDto = remoteSystemService.queryEntCacheById(kwmCooperate.getEntId());
+                Map<String, Object> map = new HashMap<>(Global.NUMERICAL_TWO);
+                map.put("entName", entCacheResDto.getFirmName());
+                commonBusinessService.sendSystemMessage(Collections.singletonList(new UserInfo().setUserId(entCacheResDto.getContactsId()).setEntId(entCacheResDto.getId())),
+                        MessageEnum.COOPERATE_PASS,
+                        map,
+                        cooperateApplyUrl);
+            } else {
+                KwmCooperate kwmCooperate = kwmCooperateMapper.selectById(Long.parseLong(id));
+                EntCacheResDto entCacheResDto = remoteSystemService.queryEntCacheById(kwmCooperate.getEntId());
+                Map<String, Object> map = new HashMap<>(Global.NUMERICAL_TWO);
+                map.put("entName", entCacheResDto.getFirmName());
+                commonBusinessService.sendSystemMessage(Collections.singletonList(new UserInfo().setUserId(entCacheResDto.getContactsId()).setEntId(entCacheResDto.getId())),
+                        MessageEnum.COOPERATE_REFUSED,
+                        map,
+                        cooperateApplyUrl);
             }
         }
     }

sckw-modules/sckw-manage/src/main/java/com/sckw/manage/service/KwmCooperateManageService.java

@@ -3,7 +3,6 @@ package com.sckw.manage.service;
 import java.io.IOException;
 import java.util.Date;
 
-import com.alibaba.fastjson.JSONObject;
 import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
@@ -32,6 +31,8 @@ import com.sckw.manage.model.vo.req.FindCooperateByEntReqVo;
 import com.sckw.manage.model.vo.req.FindEntCooperateReqVo;
 import com.sckw.manage.model.vo.res.*;
 import com.sckw.payment.api.model.constant.OrderEnum;
+import com.sckw.stream.enums.MessageEnum;
+import com.sckw.stream.model.UserInfo;
 import com.sckw.system.api.RemoteSystemService;
 import com.sckw.order.api.dubbo.TradeOrderInfoService;
 import com.sckw.transport.api.dubbo.TransportDubboService;
@@ -40,10 +41,10 @@ import com.sckw.system.api.model.dto.res.EntCacheResDto;
 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.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
 
-import javax.json.JsonObject;
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -77,6 +78,8 @@ public class KwmCooperateManageService {
     @DubboReference(version = "1.0.0", group = "design", check = false)
     private PaymentDubboService paymentDubboService;
 
+    @Value(value = "${}")
+    private String cooperateManageUrl;
 
     /**
      * @param reqVo 分页入参
@@ -198,20 +201,80 @@ public class KwmCooperateManageService {
         }
         Long userId = LoginUserHolder.getUserId();
         Date date = new Date();
+        //校验解除限制
+        checkLimit(kwmCooperates);
+        kwmCooperates.forEach(item -> {
+            //运营端可以操作任意状态，企业端只能操作合作中的数据
+            if (SystemTypeEnum.MANAGE.getCode().equals(LoginUserHolder.getSystemType())) {
+                if (!item.getStatus().equals(CooperateStatusEnum.OK.getCode()) && type.equals(CooperateStatusEnum.PASS.getCode())) {
+                    throw new SystemException(HttpStatus.CRUD_FAIL_CODE, HttpStatus.MSG_012);
+                }
+
+                if (!item.getStatus().equals(CooperateStatusEnum.PASS.getCode()) && type.equals(CooperateStatusEnum.OK.getCode())) {
+                    throw new SystemException(HttpStatus.CRUD_FAIL_CODE, HttpStatus.MSG_012);
+                }
+            }
+            item.setStatus(type);
+            item.setUpdateBy(userId);
+            item.setUpdateTime(date);
+            if (kwmCooperateMapper.updateById(item) <= 0) {
+                throw new SystemException(HttpStatus.CRUD_FAIL_CODE, HttpStatus.UPDATE_FAIL);
+            }
+        });
+
+        Map<String, Object> map = new HashMap<>(Global.NUMERICAL_FOUR);
+        for (KwmCooperate kwmCooperate : kwmCooperates) {
+            Long targetEntId = kwmCooperate.getEntId().equals(LoginUserHolder.getEntId()) ? kwmCooperate.getInviteeEntId() : kwmCooperate.getInviterEntId();
+            Long entId = kwmCooperate.getEntId().equals(LoginUserHolder.getEntId()) ? kwmCooperate.getInviterEntId() : kwmCooperate.getInviteeEntId();
+            EntCacheResDto targetEntCacheResDto = remoteSystemService.queryEntCacheById(targetEntId);
+            EntCacheResDto targetEntTreeCacheResDto = remoteSystemService.queryEntTreeById(targetEntId);
+            EntCacheResDto ourEntCacheResDto = remoteSystemService.queryEntCacheById(entId);
+            EntCacheResDto ourEntTopCacheResDto = remoteSystemService.queryEntCacheById(kwmCooperate.getEntId());
+            if (type.equals(CooperateStatusEnum.PASS.getCode())) {
+                map.put("entName", targetEntCacheResDto.getFirmName());
+                map.put("createByName", LoginUserHolder.getUserName());
+                commonBusinessService.sendSystemMessage(Collections.singletonList(new UserInfo().setUserId(ourEntTopCacheResDto.getContactsId()).setEntId(ourEntTopCacheResDto.getId())),
+                        MessageEnum.COOPERATE_DISSOLVE,
+                        map,
+                        cooperateManageUrl);
+
+                map.put("entName", ourEntCacheResDto.getFirmName());
+                commonBusinessService.sendSystemMessage(Collections.singletonList(new UserInfo().setUserId(targetEntTreeCacheResDto.getContactsId()).setEntId(targetEntTreeCacheResDto.getId())),
+                        MessageEnum.COOPERATE_DISSOLVED,
+                        map,
+                        cooperateManageUrl);
+            } else {
+                map.put("entName", targetEntCacheResDto.getFirmName());
+                map.put("createByName", LoginUserHolder.getUserName());
+                commonBusinessService.sendSystemMessage(Collections.singletonList(new UserInfo().setUserId(ourEntTopCacheResDto.getContactsId()).setEntId(ourEntTopCacheResDto.getId())),
+                        MessageEnum.COOPERATE_RESTORE,
+                        map,
+                        cooperateManageUrl);
+
+
+            }
+
+        }
+
+    }
+
+
+    /**
+     * @param kwmCooperates 实体
+     * @desc: 解除的校验限制
+     * @author: czh
+     * @date: 2023/9/7
+     */
+    private void checkLimit(List<KwmCooperate> kwmCooperates) {
         //判断是否可以解除-销售订单
         KwmCooperate kwmCooperate = kwmCooperates.get(0);
-        Boolean order = tradeOrderInfoService.associateEnt(kwmCooperate.getInviteeEntId(), kwmCooperate.getInviterEntId());
-        if (order) {
+        if (tradeOrderInfoService.associateEnt(kwmCooperate.getInviteeEntId(), kwmCooperate.getInviterEntId())) {
             throw new SystemException(HttpStatus.CRUD_FAIL_CODE, HttpStatus.MSG_031);
         }
-
         //判断是否可以解除-托运和承运
         HttpResult response = transportDubboService.checkLogisticsOrderIsFinishByEntId(kwmCooperate.getInviteeEntId(), kwmCooperate.getInviterEntId());
-        log.info("getInviteeEntId-{}", kwmCooperate.getInviteeEntId());
-        log.info("getInviterEntId-{}", kwmCooperate.getInviterEntId());
-        log.info("aaaaa-{}", JSONObject.toJSONString(response));
-        Integer receivedResult = response.getCode();
-        if (!receivedResult.toString().equals(String.valueOf(HttpStatus.SUCCESS_CODE))) {
+        int receivedResult = response.getCode();
+        if (!Integer.toString(receivedResult).equals(String.valueOf(HttpStatus.SUCCESS_CODE))) {
             throw new SystemException(HttpStatus.CRUD_FAIL_CODE, HttpStatus.MSG_032);
         }
         Map<OrderEnum, List<String>> ledgerMap = paymentDubboService.checkLedger(kwmCooperate.getInviteeEntId(), kwmCooperate.getInviterEntId());
@@ -228,26 +291,6 @@ public class KwmCooperateManageService {
         if (!CollectionUtils.isEmpty(settlementMap.get(OrderEnum.TRADE))) {
             throw new SystemException(HttpStatus.CRUD_FAIL_CODE, HttpStatus.MSG_034);
         }
-        kwmCooperates.forEach(item -> {
-            //运营端可以操作任意状态，企业端只能操作合作中的数据
-            if (SystemTypeEnum.MANAGE.getCode().equals(LoginUserHolder.getSystemType())) {
-                if (!item.getStatus().equals(CooperateStatusEnum.OK.getCode()) && type.equals(CooperateStatusEnum.PASS.getCode())) {
-                    throw new SystemException(HttpStatus.CRUD_FAIL_CODE, HttpStatus.MSG_012);
-                }
-
-                if (!item.getStatus().equals(CooperateStatusEnum.PASS.getCode()) && type.equals(CooperateStatusEnum.OK.getCode())) {
-                    throw new SystemException(HttpStatus.CRUD_FAIL_CODE, HttpStatus.MSG_012);
-                }
-            }
-
-            item.setStatus(type);
-            item.setUpdateBy(userId);
-            item.setUpdateTime(date);
-            if (kwmCooperateMapper.updateById(item) <= 0) {
-                throw new SystemException(HttpStatus.CRUD_FAIL_CODE, HttpStatus.UPDATE_FAIL);
-            }
-        });
-
     }
 
     /**
@@ -258,7 +301,7 @@ public class KwmCooperateManageService {
      * @date: 2023/7/11
      */
     private boolean checkUserPermission(int status) {
-        return status != CooperateStatusEnum.OK.getCode() && !LoginUserHolder.getSystemType().equals(SystemTypeEnum.MANAGE.getCode());
+        return status != CooperateStatusEnum.OK.getCode() && !Objects.equals(LoginUserHolder.getSystemType(), SystemTypeEnum.MANAGE.getCode());
     }
 
     /**

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-system/src/main/java/com/sckw/system/controller/KwsMenuController.java

@@ -137,4 +137,16 @@ public class KwsMenuController {
         kwsMenuService.saveMapping(reqVo);
         return HttpResult.ok();
     }
+
+    /**
+     * @param  reqVo 入参
+     * @return HttpResult
+     * @desc: 根据菜单查映射关系
+     * @author: czh
+     * @date: 2023/6/13
+     */
+    @PostMapping("/queryMapping")
+    public HttpResult queryMapping(@Valid @RequestBody QueryChildMenuReqVo reqVo) {
+        return HttpResult.ok(kwsMenuService.queryMapping(reqVo.getId()));
+    }
 }

sckw-modules/sckw-system/src/main/java/com/sckw/system/dubbo/RemoteBaseService.java

@@ -184,7 +184,7 @@ public class RemoteBaseService {
      * @author zk
      * @date 2023/8/10
      **/
-    public REnterpriseVo queryEntDetails(Long entId) {
+    public EntCacheResDto queryEntDetails(Long entId) {
         return kwsEnterpriseService.queryEntDetails(entId);
     }
 

sckw-modules/sckw-system/src/main/java/com/sckw/system/dubbo/RemoteSystemServiceImpl.java

@@ -1,15 +1,16 @@
 package com.sckw.system.dubbo;
 
+
 import com.alibaba.fastjson.JSON;
 import com.alibaba.fastjson.JSONArray;
 import com.alibaba.fastjson.JSONObject;
 import com.sckw.core.model.constant.Global;
+import com.sckw.core.model.enums.EntTypeEnum;
 import com.sckw.core.utils.BeanUtils;
 import com.sckw.core.utils.CollectionUtils;
 import com.sckw.core.utils.StringUtils;
 import com.sckw.redis.utils.RedissonUtils;
 import com.sckw.system.api.RemoteSystemService;
-import com.sckw.system.api.model.dto.res.REnterpriseVo;
 import com.sckw.system.api.model.dto.res.*;
 import com.sckw.system.api.model.pojo.DeptInfoPojo;
 import com.sckw.system.dao.SysDictDao;
@@ -19,7 +20,9 @@ import com.sckw.system.model.vo.res.KwsUserResVo;
 import com.sckw.system.service.KwsUserService;
 import com.sckw.system.service.SysAreaService;
 import org.apache.dubbo.config.annotation.DubboService;
+import org.jetbrains.annotations.Nullable;
 import org.springframework.beans.factory.annotation.Autowired;
+
 import java.util.*;
 import java.util.stream.Collectors;
 
@@ -273,28 +276,47 @@ public class RemoteSystemServiceImpl implements RemoteSystemService {
         String dictCache = RedissonUtils.getString(key);
         //从redis查，查不到从数据库查，并写入redis
         if (StringUtils.isBlank(dictCache)) {
-            KwsEnterpriseResDto kwsEnterpriseResDto = remoteBaseService.queryEnterpriseById(entId);
-            if (Objects.isNull(kwsEnterpriseResDto)) {
+            EntCacheResDto entCacheResDto = getEntCacheResDto(entId);
+            if (Objects.isNull(entCacheResDto)) {
                 return null;
             }
-
-            EntCacheResDto entCacheResDto = new EntCacheResDto();
-            BeanUtils.copyProperties(kwsEnterpriseResDto, entCacheResDto);
-            entCacheResDto.setDeptInfo(remoteBaseService.queryDeftInfoByEntId(entId));
-            entCacheResDto.setCertificateInfo(remoteBaseService.queryCertificateByEntId(entId));
-            KwsUserResDto userByAccount = remoteBaseService.getUserByAccount(kwsEnterpriseResDto.getPhone());
-            if (Objects.nonNull(userByAccount)) {
-                entCacheResDto.setContactsId(userByAccount.getId());
-            }
-            List<EntTypeResDto> entTypeResDtos = remoteBaseService.queryEntTypeById(entId);
-            if (CollectionUtils.isNotEmpty(entTypeResDtos)) {
-                entCacheResDto.setEntTypes(String.join(Global.COMMA, entTypeResDtos.stream().map(EntTypeResDto::getType).map(String::valueOf).distinct().toList()));
-            }
             RedissonUtils.putString(key, JSON.toJSONString(entCacheResDto), Global.COMMON_EXPIRE);
             return entCacheResDto;
         }
+
+        EntCacheResDto entCacheResDto = JSONObject.parseObject(dictCache, EntCacheResDto.class);
+        if (Objects.isNull(entCacheResDto.getContactsId())) {
+            entCacheResDto = getEntCacheResDto(entId);
+            if (Objects.isNull(entCacheResDto)) {
+                return null;
+            }
+        }
+
         RedissonUtils.putString(key, dictCache, Global.COMMON_EXPIRE);
-        return JSONObject.parseObject(dictCache, EntCacheResDto.class);
+        return entCacheResDto;
+    }
+
+    @Nullable
+    private EntCacheResDto getEntCacheResDto(Long entId) {
+        KwsEnterpriseResDto kwsEnterpriseResDto = remoteBaseService.queryEnterpriseById(entId);
+        if (Objects.isNull(kwsEnterpriseResDto)) {
+            return null;
+        }
+
+        EntCacheResDto entCacheResDto = new EntCacheResDto();
+        BeanUtils.copyProperties(kwsEnterpriseResDto, entCacheResDto);
+        entCacheResDto.setDeptInfo(remoteBaseService.queryDeftInfoByEntId(entId));
+        entCacheResDto.setCertificateInfo(remoteBaseService.queryCertificateByEntId(entId));
+        KwsUserResDto userByAccount = remoteBaseService.getUserByAccount(kwsEnterpriseResDto.getPhone());
+        if (Objects.nonNull(userByAccount)) {
+            entCacheResDto.setContactsId(userByAccount.getId());
+        }
+        List<EntTypeResDto> entTypeResDtos = remoteBaseService.queryEntTypeById(entId);
+        if (CollectionUtils.isNotEmpty(entTypeResDtos)) {
+            entCacheResDto.setEntTypes(String.join(Global.COMMA, entTypeResDtos.stream().map(EntTypeResDto::getType).map(String::valueOf).distinct().toList()));
+            entCacheResDto.setEntTypeNames(EntTypeEnum.getNames(entCacheResDto.getEntTypes()));
+        }
+        return entCacheResDto;
     }
 
     /**
@@ -656,13 +678,13 @@ public class RemoteSystemServiceImpl implements RemoteSystemService {
 
     /**
      * @param entId 企业ID
-     * @desc 企业详情(企业登录/司机登录)
+     * @return
+     * @desc 企业详情(企业登录 / 司机登录)
      * @author zk
      * @date 2023/8/10
-     *
-     * @return*/
+     */
     @Override
-    public REnterpriseVo queryEntDetails(Long entId) {
+    public EntCacheResDto queryEntDetails(Long entId) {
         if (Objects.isNull(entId)) {
             return null;
         }
@@ -670,9 +692,9 @@ public class RemoteSystemServiceImpl implements RemoteSystemService {
     }
 
     /**
-     * @param account 账号
+     * @param account    账号
      * @param systemType 系统类型
-     * @desc 用户详情(企业端登录/运营端登录)
+     * @desc 用户详情(企业端登录 / 运营端登录)
      * @author zk
      * @date 2023/8/10
      **/
@@ -685,7 +707,7 @@ public class RemoteSystemServiceImpl implements RemoteSystemService {
         params.setAccount(account);
         params.setSystemType(systemType);
         List<KwsUserResVo> users = kwsUserService.findList(params);
-        if(CollectionUtils.isEmpty(users)) {
+        if (CollectionUtils.isEmpty(users)) {
             return null;
         }
         KwsUserResVo userResVo = users.get(Global.NUMERICAL_ZERO);

sckw-modules/sckw-system/src/main/java/com/sckw/system/service/KwsEnterpriseService.java

@@ -1,4 +1,6 @@
 package com.sckw.system.service;
+import com.google.common.collect.Lists;
+import java.util.Date;
 
 import cn.hutool.core.date.DateUtil;
 import com.github.pagehelper.PageHelper;
@@ -987,23 +989,29 @@ public class KwsEnterpriseService {
      * @author zk
      * @date 2023/8/10
      **/
-    public REnterpriseVo queryEntDetails(Long entId) {
+    public EntCacheResDto queryEntDetails(Long entId) {
         //企业信息
         KwsEnterprise enterprise = kwsEnterpriseDao.selectByKey(entId);
         if (enterprise == null) {
             return null;
         }
-        REnterpriseVo enterpriseVo = new REnterpriseVo();
-        enterpriseVo.setId(enterprise.getId());
-        enterpriseVo.setFirmName(enterprise.getFirmName());
-        enterpriseVo.setRegTime(enterprise.getRegTime());
-        enterpriseVo.setStatus(enterprise.getStatus());
-        enterpriseVo.setApproval(enterprise.getApproval());
-
+        EntCacheResDto entCacheResDto = new EntCacheResDto();
+        entCacheResDto.setId(enterprise.getId());
+        entCacheResDto.setFirmName(enterprise.getFirmName());
+        entCacheResDto.setApproval(enterprise.getApproval());
+        entCacheResDto.setRegTime(enterprise.getRegTime());
+        entCacheResDto.setContacts(enterprise.getContacts());
+        entCacheResDto.setPhone(enterprise.getPhone());
+        entCacheResDto.setBusiness(enterprise.getBusiness());
+        entCacheResDto.setCityName(enterprise.getCityName());
+        entCacheResDto.setCityCode(enterprise.getCityCode());
+        entCacheResDto.setStatus(enterprise.getStatus());
         //企业类型
         List<KwsEntType> entTypes = kwsEntTypeDao.findListByEntId(entId);
-        enterpriseVo.setEntTypes(entTypes != null ? String.join(Global.COMMA, entTypes.stream().map(KwsEntType::getType).map(String::valueOf).distinct().toList()) : null);
-        enterpriseVo.setEntTypeNames(enterpriseVo.getEntTypes() != null ? EntTypeEnum.getNames(enterpriseVo.getEntTypes()) : null);
+        if (CollectionUtils.isNotEmpty(entTypes)) {
+            entCacheResDto.setEntTypes(String.join(Global.COMMA, entTypes.stream().map(KwsEntType::getType).map(String::valueOf).distinct().toList()));
+            entCacheResDto.setEntTypeNames(EntTypeEnum.getNames(entCacheResDto.getEntTypes()));
+        }
 
         Map<String, Object> queryParams = new HashMap<>(Global.NUMERICAL_SIXTEEN) {{
             put("isMain", Global.YES);
@@ -1011,10 +1019,12 @@ public class KwsEnterpriseService {
             put("systemType", SystemTypeEnum.COMPANY.getCode());
         }};
         List<KwsUserResVo> users = kwsUserService.findPage(queryParams);
-        KwsUserResVo user = users != null && users.size() > 0 ? users.get(Global.NUMERICAL_ZERO) : null;
-        enterpriseVo.setMainId(user != null ? user.getId() : null);
-        enterpriseVo.setMainName(user != null ? user.getName() : null);
-        enterpriseVo.setMainPhone(user != null ? user.getPhone() : null);
+        if (CollectionUtils.isNotEmpty(users)) {
+            KwsUserResVo kwsUserResVo = users.get(0);
+            entCacheResDto.setContactsId(kwsUserResVo.getId());
+            entCacheResDto.setContacts(kwsUserResVo.getName());
+            entCacheResDto.setPhone(kwsUserResVo.getPhone());
+        }
 
         //企业资质有效性判断  1、当前资质没过期，且状态是已认证  2、只要有认证过一次就算有效  参数判断
         String checkType = String.valueOf(Global.NUMERICAL_TWO);
@@ -1022,16 +1032,16 @@ public class KwsEnterpriseService {
             List<CertificateResVo> certificates = queryCertificate(entId);
             for (CertificateResVo certificate : certificates) {
                 Date expireTime = certificate.getExpireTime();
-                enterpriseVo.setValid(DateUtil.compare(new Date(), expireTime) <= 0);
+                entCacheResDto.setValid(DateUtil.compare(new Date(), expireTime) <= 0);
             }
         } else {
             List<KwsEntCheckTrack> entCheckTrackResDtoList = entCheck(entId);
             if (CollectionUtils.isEmpty(entCheckTrackResDtoList)) {
-                enterpriseVo.setValid(false);
+                entCacheResDto.setValid(false);
             }
-            enterpriseVo.setValid(entCheckTrackResDtoList.stream().anyMatch(item -> item.getStatus() == Global.NO));
+            entCacheResDto.setValid(entCheckTrackResDtoList.stream().anyMatch(item -> item.getStatus() == Global.NO));
         }
-        return enterpriseVo;
+        return entCacheResDto;
     }
 
     /**

sckw-modules/sckw-system/src/main/java/com/sckw/system/service/KwsMenuService.java

@@ -487,4 +487,20 @@ public class KwsMenuService {
         kwsMenuMappingDao.saveBatch(list);
     }
 
+
+    /**
+     * @param  id 菜单id
+     * @return HttpResult
+     * @desc: 根据菜单查映射关系
+     * @author: czh
+     * @date: 2023/6/13
+     */
+    public List<KwsMenu> queryMapping(Long id) {
+        List<KwsMenuMapping> kwsMenuMappings = kwsMenuMappingDao.selectByMenuId(id);
+        if (CollectionUtils.isEmpty(kwsMenuMappings)) {
+            return Collections.emptyList();
+        }
+
+        return kwsMenuDao.selectByKeys(kwsMenuMappings.stream().map(KwsMenuMapping::getMappingId).toList());
+    }
 }

sckw-modules/sckw-system/src/main/resources/mapper/KwsUserDao.xml

@@ -238,7 +238,7 @@
       and b.del_flag = 0
       and d.del_flag = 0
     <if test="systemType != null and systemType != ''">
-      and su.system_type = #{system_type, jdbcType=VARCHAR}
+      and su.system_type = #{systemType, jdbcType=VARCHAR}
     </if>
     <if test="account != null and account != ''">
       and su.account = #{account, jdbcType=VARCHAR}

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/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)
@@ -2014,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);
@@ -2033,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);
@@ -2041,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);