完结订单根据产品要求-修改返回贸易订单数据-只返回当前订单装货以及卸货量

采购订单-销售订单-撤销托运新增工作台消息数据发送

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

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

sckw-modules/sckw-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/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);