1.增加redis分布式锁

2.提交阿里规范
3.提交点击防重
4.物流托运新增单据状态逻辑

sckw-modules/sckw-example/src/main/java/com/sckw/example/controller/TransportController.java

@@ -2,6 +2,7 @@ package com.sckw.example.controller;
 
 import com.sckw.core.web.context.LoginUserHolder;
 import com.sckw.example.service.TransportService;
+import com.sckw.redis.config.RedisLockUtil;
 import com.sckw.system.api.RemoteSystemService;
 import com.sckw.system.api.model.dto.res.EntCacheResDto;
 import lombok.AllArgsConstructor;
@@ -29,6 +30,9 @@ public class TransportController {
     @DubboReference(version = "1.0.0", group = "design", check = false)
     private RemoteSystemService systemService;
 
+    @Autowired
+    private RedisLockUtil redisLockUtil;
+
     /**
      * 统计承运接单
      *
@@ -64,7 +68,7 @@ public class TransportController {
      * @return
      */
     @RequestMapping(value = "/statisticsPendingVerificationWaybill", method = RequestMethod.GET)
-    public Integer statisticsPendingVerificationWaybill(){
+    public Integer statisticsPendingVerificationWaybill() {
         EntCacheResDto entCacheResDto = systemService.queryEntTreeById(LoginUserHolder.getEntId());
         Long topEntId = entCacheResDto.getId();
         Integer integer = transportService.statisticsPendingVerificationWaybill(topEntId);
@@ -72,9 +76,19 @@ public class TransportController {
     }
 
     @RequestMapping(value = "/refreshScopeDemo", method = RequestMethod.GET)
-    public void refreshScopeDemo(){
+    public void refreshScopeDemo() {
         transportService.refreshScopeDemo();
     }
 
-
+    @RequestMapping(value = "/getRedissionDemo", method = RequestMethod.GET)
+    public void getRedissionDemo() {
+        boolean b = redisLockUtil.tryLock("20231019A", 1);
+        if (b) {
+            System.out.println("获取到锁");
+        }
+        boolean b1 = redisLockUtil.tryLock("20231019A", 6000000);
+        if (b1) {
+            System.out.println("没获取到锁");
+        }
+    }
 }

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

@@ -175,6 +175,7 @@ public class AcceptCarriageOrderController {
      * @param orderDTO  物流订单接单请求数据
      * @return  接单响应结果
      */
+    @RepeatSubmit(interval = 3000,message ="两次请求间隔未超过3秒")
     @RequestMapping(value = "/orderTaking", method = RequestMethod.POST)
     public HttpResult orderTaking(@Validated @RequestBody OrderTakingDTO orderDTO) {
         return acceptCarriageOrderService.orderTaking(orderDTO);
@@ -291,6 +292,7 @@ public class AcceptCarriageOrderController {
      * @return  响应结果
      */
     @RequestMapping(value = "/acceptStopDocumentCommit", method = RequestMethod.POST)
+    @RepeatSubmit(interval = 3000,message = "两次请求时间间隔不能小于3秒")
     public HttpResult stopDocumentCommit(@Validated @RequestBody StopOrderTakingDTO stopOrderTakingDTO) {
         log.info("承运订单/托运订单-设置停止接单-提交 请求参数:{}", JSONObject.toJSONString(stopOrderTakingDTO));
         try {
@@ -343,6 +345,7 @@ public class AcceptCarriageOrderController {
      * @return  响应结果
      */
     @RequestMapping(value = "/commitAcceptCarriageOrderFinish", method = RequestMethod.POST)
+    @RepeatSubmit(interval = 3000,message = "两次请求间隔时间不能小于三秒")
     public HttpResult commitAcceptCarriageOrderFinish(@Valid @RequestBody OrderFinishDTO orderFinishDTO) {
         try {
             return acceptCarriageOrderService.commitAcceptCarriageOrderFinish(orderFinishDTO);
@@ -375,7 +378,7 @@ public class AcceptCarriageOrderController {
      * @param addOrderDTO 页面传递参数
      * @return  响应结果
      */
-    @RepeatSubmit(interval = 3000,message ="两次请求间隔未超过3秒")
+    @RepeatSubmit(interval = 3000,message ="两次请求间隔时间不能小于3秒")
     @RequestMapping(value = "/addOrder", method = RequestMethod.POST)
     public HttpResult addOrder(@Valid @RequestBody AddOrderDTO addOrderDTO) {
         log.info("承运订单-页面新建订单 add {}", JSONObject.toJSONString(addOrderDTO));

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

@@ -1,6 +1,7 @@
 package com.sckw.transport.controller;
 
 import com.alibaba.fastjson.JSONObject;
+import com.sckw.core.annotation.RepeatSubmit;
 import com.sckw.core.exception.CustomPromptException;
 import com.sckw.core.model.enums.OrderRuleEnum;
 import com.sckw.core.model.enums.RedisOrderGenerateEnum;
@@ -155,6 +156,7 @@ public class ConsignOrderController {
      * @param stopOrderTakingDTO 请求参数
      * @return  响应结果
      */
+    @RepeatSubmit(interval = 3000,message = "两次请求间隔不能小于3秒")
     @RequestMapping(value = "/consignStopDocumentCommit", method = RequestMethod.POST)
     public HttpResult consignStopDocumentCommit(@Validated @RequestBody StopOrderTakingDTO stopOrderTakingDTO) {
         log.info("托运订单-设置停止接单-提交 commit {}", JSONObject.toJSONString(stopOrderTakingDTO));
@@ -289,6 +291,7 @@ public class ConsignOrderController {
      * @return  响应结果
      */
     @RequestMapping(value = "/addOrder", method = RequestMethod.POST)
+    @RepeatSubmit(interval = 3000,message = "提交间隔时间不能小于3秒")
     public HttpResult addOrder(@Valid @RequestBody AddOrderDTO addOrderDTO) {
         try {
             return consignOrderService.addOrder(addOrderDTO);

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

@@ -1,6 +1,7 @@
 package com.sckw.transport.controller;
 
 import com.alibaba.fastjson.JSONObject;
+import com.sckw.core.annotation.RepeatSubmit;
 import com.sckw.core.exception.CustomPromptException;
 import com.sckw.core.model.enums.OrderRuleEnum;
 import com.sckw.core.model.enums.RedisOrderGenerateEnum;
@@ -52,13 +53,14 @@ public class LogisticsConsignmentController {
      * @return  响应结果
      */
     @Validated
+    @RepeatSubmit(interval = 3000,message ="两次请求间隔未超过3秒")
     @RequestMapping(value = "/purchaseLogisticsConsignment", method = RequestMethod.POST)
     public HttpResult purchaseLogisticsConsignment(@Valid @RequestBody LogisticsConsignmentParam logisticsConsignmentParam) {
         log.info("采购订单传递参数信息:{}", JSONObject.toJSONString(logisticsConsignmentParam));
         try {
             return logisticsConsignmentService.purchaseLogisticsConsignment(logisticsConsignmentParam,"1");
         } catch (Exception e) {
-            OrderGenerateSeqNoUtils.getSeqNoMinusOne(RedisOrderGenerateEnum.LOGISTICS_ORDER, OrderRuleEnum.LOGISTICS_ORDER);
+//            OrderGenerateSeqNoUtils.getSeqNoMinusOne(RedisOrderGenerateEnum.LOGISTICS_ORDER, OrderRuleEnum.LOGISTICS_ORDER);
             log.error("采购订单-物流托运生成托运订单 error :{}", e.getMessage(), e);
             return HttpResult.error(HttpStatus.GLOBAL_EXCEPTION_CODE, e.getMessage());
         }
@@ -106,6 +108,7 @@ public class LogisticsConsignmentController {
      * @return  操作结果
      */
     @Validated
+    @RepeatSubmit(interval = 3000,message ="两次请求间隔未超过3秒")
     @RequestMapping(value = "/purchaseCancelConsign", method = RequestMethod.POST)
     @GlobalTransactional(name = "default_tx_group")
     public HttpResult purchaseCancelConsign(@Valid @RequestBody BaseList baseList) {
@@ -180,6 +183,7 @@ public class LogisticsConsignmentController {
      * @return  响应结果
      */
     @Validated
+    @RepeatSubmit(interval = 3000,message ="两次请求间隔未超过3秒")
     @RequestMapping(value = "/purchaseOrderFinish", method = RequestMethod.POST)
     public HttpResult purchaseOrderFinish(@RequestBody @Validated OrderFinishDTO orderFinishDTO) {
         log.info("采购订单-托运订单列表-完结订单 传递参数信息:{}", JSONObject.toJSONString(orderFinishDTO));
@@ -199,6 +203,7 @@ public class LogisticsConsignmentController {
      * @return  响应结果
      */
     @RequestMapping(value = "/sellLogisticsConsignment", method = RequestMethod.POST)
+    @RepeatSubmit(interval = 3000,message ="两次请求间隔未超过3秒")
     public HttpResult sellLogisticsConsignment(@Valid @RequestBody LogisticsConsignmentParam logisticsConsignmentParam) {
         log.info("销售订单-物流托运生成托运订单 传递参数信息:{}", JSONObject.toJSONString(logisticsConsignmentParam));
         try {
@@ -270,6 +275,7 @@ public class LogisticsConsignmentController {
      */
     @RequestMapping(value = "/sellCancelConsign", method = RequestMethod.POST)
     @GlobalTransactional(name = "default_tx_group")
+    @RepeatSubmit(interval = 3000,message ="两次请求间隔未超过3秒")
     public HttpResult sellCancelConsign(@Valid @RequestBody BaseList baseList) {
         log.info("销售订单-托运订单列表-撤销托运:{}", JSONObject.toJSONString(baseList));
         try {
@@ -307,6 +313,7 @@ public class LogisticsConsignmentController {
      */
     @Validated
     @RequestMapping(value = "/sellOrderFinish", method = RequestMethod.POST)
+    @RepeatSubmit(interval = 3000,message ="两次请求间隔未超过3秒")
     public HttpResult sellOrderFinish(@RequestBody @Validated OrderFinishDTO orderFinishDTO) {
         log.info("销售订单-托运订单列表-完结订单 传递参数信息:{}", JSONObject.toJSONString(orderFinishDTO));
         try {
@@ -351,23 +358,4 @@ public class LogisticsConsignmentController {
         ExcelUtil.downData(response, SellLogisticOrderExcelVo.class, list);
     }
 
-
-    /**
-     * 生成物流订单编号demo
-     * @return  响应结果
-     */
-    @RequestMapping(value = "/addLogisticsNumberDemo", method = RequestMethod.GET)
-    public HttpResult addLogisticsNumberDemo() {
-        return logisticsConsignmentService.addLogisticsNumberDemo();
-    }
-
-
-    /**
-     * 生成车辆订单编号demo
-     * @return  响应结果
-     */
-    @RequestMapping(value = "/addWaybillNumberDemo", method = RequestMethod.GET)
-    public HttpResult addWaybillNumberDemo() {
-        return logisticsConsignmentService.addWaybillNumberDemo();
-    }
 }

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

@@ -39,6 +39,8 @@ import com.sckw.order.api.model.OrderDetailRes;
 import com.sckw.order.api.model.UnitInfoDetailRes;
 import com.sckw.payment.api.dubbo.PaymentDubboService;
 import com.sckw.payment.api.model.dto.SettlementMoney;
+import com.sckw.redis.config.RedisLockUtil;
+import com.sckw.redis.constant.RedisConstant;
 import com.sckw.stream.model.SckwBusSum;
 import com.sckw.system.api.RemoteSystemService;
 import com.sckw.system.api.model.dto.res.AreaTreeFrontResDto;
@@ -106,6 +108,9 @@ public class ConsignOrderService {
     @DubboReference(version = "1.0.0", group = "design", check = false, timeout = 6000)
     PaymentDubboService paymentDubboService;
 
+    @Autowired
+    RedisLockUtil redisLockUtil;
+
     @Autowired
     public CommonService commonService;
 
@@ -855,16 +860,19 @@ public class ConsignOrderService {
         /**完结订单 不做页面填写数量与数据库数量进行计算验证-直接获取页面填写数据进行保存处理*/
         //物流订单id
         String id = orderFinishDTO.getId();
-        KwtLogisticsOrder logisticsOrder = kwtLogisticsOrderMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrder>()
-                .eq(KwtLogisticsOrder::getId, id));
-        if (logisticsOrder == null) {
-            throw new BusinessException("采购订单-完结订单-物流单据不存在!");
-        }
+        String key = String.format(RedisConstant.LOGISTICS_ORDER_FINISH_KEY, orderFinishDTO.getId());
+        if (redisLockUtil.tryLock(key)) {
+            try {
+                KwtLogisticsOrder logisticsOrder = kwtLogisticsOrderMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrder>()
+                        .eq(KwtLogisticsOrder::getId, id));
+                if (logisticsOrder == null) {
+                    throw new BusinessException("采购订单-完结订单-物流单据不存在!");
+                }
 //        BigDecimal totalLoadAmount = logisticsOrder.getTotalLoadAmount() == null ? new BigDecimal("0.00") : logisticsOrder.getTotalLoadAmount();
 //        if (totalLoadAmount.compareTo(orderFinishDTO.getLoadAmount()) < 0) {
 //            throw new BusinessException("完结订单,实装量不能大于分配量");
 //        }
-        //todo 2023-09-01 根据要求去除校验 物流订单手动完结，实装量可大于分配量，实卸量目前暂定不可大于实装量；根据计费方式，当对应实装或实卸大于分配量时自然完结
+                //todo 2023-09-01 根据要求去除校验 物流订单手动完结，实装量可大于分配量，实卸量目前暂定不可大于实装量；根据计费方式，当对应实装或实卸大于分配量时自然完结
 //        BigDecimal amount = logisticsOrder.getAmount() == null ? new BigDecimal("0.00") : logisticsOrder.getAmount();
 //        if (amount.compareTo(orderFinishDTO.getLoadAmount()) < 0) {
 //            throw new BusinessException("完结订单,装货量不能大于运输总量");
@@ -872,106 +880,112 @@ public class ConsignOrderService {
 //        if (orderFinishDTO.getUnloadAmount().compareTo(orderFinishDTO.getLoadAmount()) > 0) {
 //            throw new BusinessException("完结订单,填写卸货量不能大于装货量");
 //        }
-        /**订单状态验证*/
-        if (!LogisticsOrderEnum.WAIT_DELIVERY.getStatus().equals(String.valueOf(logisticsOrder.getStatus()))
-                && !LogisticsOrderEnum.IN_TRANSIT.getStatus().equals(String.valueOf(logisticsOrder.getStatus()))) {
-            throw new BusinessException("当前订单并不属于【待派车】,【运输中】状态");
-        }
-        //验证当前物流订单是否还存在进行的车辆运单
-        boolean flag = commonService.judgmentWaybillOrderIsFinish(id);
-        if (flag) {
-            throw new BusinessException("检测您现在有运单正在执行中，该订单目前不可完结，请先将运单执行完毕！");
-        }
-        //修改单据本身数据
-        BigDecimal ignoreAmount = logisticsOrder.getAmount().subtract(orderFinishDTO.getLoadAmount() == null ? new BigDecimal("0.00") : logisticsOrder.getLoadAmount());
-        logisticsOrder.setTotalLoadAmount(orderFinishDTO.getLoadAmount());
-        logisticsOrder.setTotalUnloadAmount(orderFinishDTO.getUnloadAmount());
-        logisticsOrder.setStatus(LogisticsOrderEnum.HAVE_FINISHED.getCode());
-        logisticsOrder.setUpdateTime(new Date());
-        logisticsOrder.setUpdateBy(LoginUserHolder.getUserId());
-        logisticsOrder.setIgnoreAmount(ignoreAmount);
-        kwtLogisticsOrderMapper.updateById(logisticsOrder);
-        updateLogisticOrderTrack(logisticsOrder.getId(), LogisticsOrderEnum.HAVE_FINISHED, orderFinishDTO.getRemark());
-        //获取物流订单下的子单
-        /**完结订单-对应物流订单下子订单都要进行完结*/
-        List<KwtLogisticsOrder> kwtLogisticsOrders = kwtLogisticsOrderMapper.selectList(new LambdaQueryWrapper<KwtLogisticsOrder>()
-                .eq(KwtLogisticsOrder::getDelFlag, NumberConstant.ZERO)
-                .apply(id != null, "FIND_IN_SET ('" + id + "', pids)").ne(KwtLogisticsOrder::getId, id));
-        /**找到该订单下所有的物流订单**/
-        //需要修改的mongodb数据
-        List<Map<String, Object>> list = new ArrayList<>();
-        if (!org.springframework.util.CollectionUtils.isEmpty(kwtLogisticsOrders)) {
-            //修改单据状态
+                /**订单状态验证*/
+                if (!LogisticsOrderEnum.WAIT_DELIVERY.getStatus().equals(String.valueOf(logisticsOrder.getStatus()))
+                        && !LogisticsOrderEnum.IN_TRANSIT.getStatus().equals(String.valueOf(logisticsOrder.getStatus()))) {
+                    throw new BusinessException("当前订单并不属于【待派车】,【运输中】状态");
+                }
+                //验证当前物流订单是否还存在进行的车辆运单
+                boolean flag = commonService.judgmentWaybillOrderIsFinish(id);
+                if (flag) {
+                    throw new BusinessException("检测您现在有运单正在执行中，该订单目前不可完结，请先将运单执行完毕！");
+                }
+                //修改单据本身数据
+                BigDecimal ignoreAmount = logisticsOrder.getAmount().subtract(orderFinishDTO.getLoadAmount() == null ? new BigDecimal("0.00") : logisticsOrder.getLoadAmount());
+                logisticsOrder.setTotalLoadAmount(orderFinishDTO.getLoadAmount());
+                logisticsOrder.setTotalUnloadAmount(orderFinishDTO.getUnloadAmount());
+                logisticsOrder.setStatus(LogisticsOrderEnum.HAVE_FINISHED.getCode());
+                logisticsOrder.setUpdateTime(new Date());
+                logisticsOrder.setUpdateBy(LoginUserHolder.getUserId());
+                logisticsOrder.setIgnoreAmount(ignoreAmount);
+                kwtLogisticsOrderMapper.updateById(logisticsOrder);
+                updateLogisticOrderTrack(logisticsOrder.getId(), LogisticsOrderEnum.HAVE_FINISHED, orderFinishDTO.getRemark());
+                //获取物流订单下的子单
+                /**完结订单-对应物流订单下子订单都要进行完结*/
+                List<KwtLogisticsOrder> kwtLogisticsOrders = kwtLogisticsOrderMapper.selectList(new LambdaQueryWrapper<KwtLogisticsOrder>()
+                        .eq(KwtLogisticsOrder::getDelFlag, NumberConstant.ZERO)
+                        .apply(id != null, "FIND_IN_SET ('" + id + "', pids)").ne(KwtLogisticsOrder::getId, id));
+                /**找到该订单下所有的物流订单**/
+                //需要修改的mongodb数据
+                List<Map<String, Object>> list = new ArrayList<>();
+                if (!org.springframework.util.CollectionUtils.isEmpty(kwtLogisticsOrders)) {
+                    //修改单据状态
 //            List<Long> ids = kwtLogisticsOrders.stream().map(KwtLogisticsOrder::getId).collect(Collectors.toList());
-            //修改单据剩余运输量
-            kwtLogisticsOrders.forEach(kwtLogisticsOrder -> {
-                BigDecimal subtract = kwtLogisticsOrder.getAmount().subtract(kwtLogisticsOrder.getTotalLoadAmount());
-                updateLogisticOrderAndTrack(kwtLogisticsOrder.getId(), orderFinishDTO, subtract);
-                //新增mongodb要修改的数据
-                Map<String, Object> map = new HashMap<>(Global.NUMERICAL_SIXTEEN);
-                map.put("id", kwtLogisticsOrder.getId());
-                map.put("ignoreAmount", subtract);
-                list.add(map);
+                    //修改单据剩余运输量
+                    kwtLogisticsOrders.forEach(kwtLogisticsOrder -> {
+                        BigDecimal subtract = kwtLogisticsOrder.getAmount().subtract(kwtLogisticsOrder.getTotalLoadAmount());
+                        updateLogisticOrderAndTrack(kwtLogisticsOrder.getId(), orderFinishDTO, subtract);
+                        //新增mongodb要修改的数据
+                        Map<String, Object> map = new HashMap<>(Global.NUMERICAL_SIXTEEN);
+                        map.put("id", kwtLogisticsOrder.getId());
+                        map.put("ignoreAmount", subtract);
+                        list.add(map);
 //                updateMongoDbByLogisticsOrder(kwtLogisticsOrder.getId(), orderFinishDTO, subtract);
-            });
-        }
-        /**是否是一级订单,是->推送至贸易,否,数据推送至物流订单上级*/
-        if (logisticsOrder.getPid() == null && "1".equals(logisticsOrder.getType())) {
-            //数据推送至贸易订单
-            CompleteLogisticsOrderParam tradeOrder = new CompleteLogisticsOrderParam();
-            //todo 2023-09-07 修改为不传递总量，只传递当前单据页面传递值
-            //获取实际装货量-实际卸货量
+                    });
+                }
+                /**是否是一级订单,是->推送至贸易,否,数据推送至物流订单上级*/
+                if (logisticsOrder.getPid() == null && "1".equals(logisticsOrder.getType())) {
+                    //数据推送至贸易订单
+                    CompleteLogisticsOrderParam tradeOrder = new CompleteLogisticsOrderParam();
+                    //todo 2023-09-07 修改为不传递总量，只传递当前单据页面传递值
+                    //获取实际装货量-实际卸货量
 //            Map<String, BigDecimal> map = kwtLogisticsOrderMapper.countAmountByTradeOrderId(logisticsOrder.getTOrderId());
-            //获取是否订单已经全部处理完成
-            List<Integer> statusList = new ArrayList<>();
-            statusList.add(LogisticsOrderEnum.TO_BE_PLANNED.getCode());
-            statusList.add(LogisticsOrderEnum.PENDING_ORDER.getCode());
-            statusList.add(LogisticsOrderEnum.WAIT_DELIVERY.getCode());
-            statusList.add(LogisticsOrderEnum.IN_TRANSIT.getCode());
-            List<KwtLogisticsOrder> logisticsOrders = kwtLogisticsOrderMapper.selectList(new LambdaQueryWrapper<KwtLogisticsOrder>()
-                    .eq(KwtLogisticsOrder::getTOrderId, logisticsOrder.getTOrderId())
-                    .in(KwtLogisticsOrder::getStatus, statusList));
-            if (org.springframework.util.CollectionUtils.isEmpty(logisticsOrders)) {
-                tradeOrder.setIsAllComplete(true);
-            }
-            tradeOrder.setTOrderId(logisticsOrder.getTOrderId());
+                    //获取是否订单已经全部处理完成
+                    List<Integer> statusList = new ArrayList<>();
+                    statusList.add(LogisticsOrderEnum.TO_BE_PLANNED.getCode());
+                    statusList.add(LogisticsOrderEnum.PENDING_ORDER.getCode());
+                    statusList.add(LogisticsOrderEnum.WAIT_DELIVERY.getCode());
+                    statusList.add(LogisticsOrderEnum.IN_TRANSIT.getCode());
+                    List<KwtLogisticsOrder> logisticsOrders = kwtLogisticsOrderMapper.selectList(new LambdaQueryWrapper<KwtLogisticsOrder>()
+                            .eq(KwtLogisticsOrder::getTOrderId, logisticsOrder.getTOrderId())
+                            .in(KwtLogisticsOrder::getStatus, statusList));
+                    if (org.springframework.util.CollectionUtils.isEmpty(logisticsOrders)) {
+                        tradeOrder.setIsAllComplete(true);
+                    }
+                    tradeOrder.setTOrderId(logisticsOrder.getTOrderId());
 //            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));
-            HttpResult httpResult = tradeOrderInfoService.completeLogisticsOrder(tradeOrder);
-            if (httpResult.getCode() != HttpStatus.SUCCESS_CODE) {
-                log.info("贸易订单手动完结订单异常,传递信息:{},返回信息:{}", JSONObject.toJSONString(tradeOrder), JSONObject.toJSONString(httpResult));
-                throw new BusinessException("单据完结出现错误！" + httpResult.getMsg());
-            }
-            CreateOrCancelLogisticsOrderParam param = new CreateOrCancelLogisticsOrderParam();
-            param.setTOrderId(Long.valueOf(logisticsOrder.getTOrderId()));
-            param.setEntrustAmount(orderFinishDTO.getLoadAmount().subtract(logisticsOrder.getAmount()));
-            param.setUpdateBy(LoginUserHolder.getUserId());
-            param.setUpdateByName(LoginUserHolder.getUserName());
-            HttpResult result1 = tradeOrderInfoService.createOrCancelLogisticsOrder(param);
-            if (result1.getCode() != HttpStatus.SUCCESS_CODE) {
-                log.info("托运订单手动完结订单-完结订单,返回信息:{}", "id:" + logisticsOrder.getTOrderId() + "orderNo" + logisticsOrder.getTOrderNo(), JSONObject.toJSONString(result1));
-                throw new BusinessException("{" + logisticsOrder.getTOrderNo() + "} 托运订单手动完结订单-完结订单!" + result1.getMsg());
-            }
-        }
+                    tradeOrder.setActualLoadAmount(orderFinishDTO.getLoadAmount());
+                    tradeOrder.setActualUnloadAmount(orderFinishDTO.getUnloadAmount());
+                    tradeOrder.setUpdateBy(LoginUserHolder.getUserId());
+                    tradeOrder.setUpdateByName(LoginUserHolder.getUserName());
+                    log.info("托运订单手动完结请求参数:{}", JSONObject.toJSONString(tradeOrder));
+                    HttpResult httpResult = tradeOrderInfoService.completeLogisticsOrder(tradeOrder);
+                    if (httpResult.getCode() != HttpStatus.SUCCESS_CODE) {
+                        log.info("贸易订单手动完结订单异常,传递信息:{},返回信息:{}", JSONObject.toJSONString(tradeOrder), JSONObject.toJSONString(httpResult));
+                        throw new BusinessException("单据完结出现错误！" + httpResult.getMsg());
+                    }
+                    CreateOrCancelLogisticsOrderParam param = new CreateOrCancelLogisticsOrderParam();
+                    param.setTOrderId(Long.valueOf(logisticsOrder.getTOrderId()));
+                    param.setEntrustAmount(orderFinishDTO.getLoadAmount().subtract(logisticsOrder.getAmount()));
+                    param.setUpdateBy(LoginUserHolder.getUserId());
+                    param.setUpdateByName(LoginUserHolder.getUserName());
+                    HttpResult result1 = tradeOrderInfoService.createOrCancelLogisticsOrder(param);
+                    if (result1.getCode() != HttpStatus.SUCCESS_CODE) {
+                        log.info("托运订单手动完结订单-完结订单,返回信息:{}", "id:" + logisticsOrder.getTOrderId() + "orderNo" + logisticsOrder.getTOrderNo(), JSONObject.toJSONString(result1));
+                        throw new BusinessException("{" + logisticsOrder.getTOrderNo() + "} 托运订单手动完结订单-完结订单!" + result1.getMsg());
+                    }
+                }
 
-        //修改合同履约量
-        commonService.updatePerformed(logisticsOrder, orderFinishDTO.getLoadAmount(), orderFinishDTO.getUnloadAmount());
+                //修改合同履约量
+                commonService.updatePerformed(logisticsOrder, orderFinishDTO.getLoadAmount(), orderFinishDTO.getUnloadAmount());
 
-        //修改mongodb的数据
-        updateMongoDbByLogisticsOrder(logisticsOrder.getId(), orderFinishDTO, ignoreAmount);
-        if (!CollectionUtils.isEmpty(list) && list.size() > 0) {
-            for (Map<String, Object> map : list) {
-                updateMongoDbByLogisticsOrder(Long.parseLong(map.get("id").toString()), orderFinishDTO, new BigDecimal(map.get("ignoreAmount").toString()));
+                //修改mongodb的数据
+                updateMongoDbByLogisticsOrder(logisticsOrder.getId(), orderFinishDTO, ignoreAmount);
+                if (!CollectionUtils.isEmpty(list) && list.size() > 0) {
+                    for (Map<String, Object> map : list) {
+                        updateMongoDbByLogisticsOrder(Long.parseLong(map.get("id").toString()), orderFinishDTO, new BigDecimal(map.get("ignoreAmount").toString()));
+                    }
+                }
+
+                transportCommonService.closeHandle(logisticsOrder.getId());
+                waybillOrderService.cancelSendCar(logisticsOrder.getId());
+            } finally {
+                redisLockUtil.unlock(key);
             }
+        } else {
+            HttpResult.error("当前数据正在处理，请稍后再试");
         }
-
-        transportCommonService.closeHandle(logisticsOrder.getId());
-        waybillOrderService.cancelSendCar(logisticsOrder.getId());
         return HttpResult.ok("托运订单-完结订单成功");
     }
 

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

@@ -8,6 +8,8 @@ import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
 import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
 import com.github.pagehelper.PageHelper;
 import com.github.pagehelper.PageInfo;
+import com.sckw.contract.api.RemoteContractService;
+import com.sckw.contract.api.model.dto.res.ContractCommonInfoResDto;
 import com.sckw.core.common.enums.NumberConstant;
 import com.sckw.core.common.enums.enums.DictTypeEnum;
 import com.sckw.core.exception.BusinessException;
@@ -33,6 +35,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.redis.constant.RedisConstant;
 import com.sckw.stream.enums.MessageEnum;
 import com.sckw.stream.model.SckwBusSum;
 import com.sckw.system.api.RemoteSystemService;
@@ -103,6 +106,9 @@ public class LogisticsConsignmentService {
     @DubboReference(version = "1.0.0", group = "design", check = false, timeout = 6000)
     RemoteFleetService remoteFleetService;
 
+    @DubboReference(version = "1.0.0", group = "design", check = false, timeout = 6000)
+    RemoteContractService contractService;
+
     @Autowired
     public KwtLogisticsOrderGoodsMapper kwtLogisticsOrderGoodsMapper;
 
@@ -127,8 +133,8 @@ public class LogisticsConsignmentService {
     /**
      * 采购订单-物流托运生成托运订单
      *
-     * @param bo
-     * @return
+     * @param bo    请求参数
+     * @return  响应数据
      */
     @Transactional(rollbackFor = Exception.class)
     public HttpResult purchaseLogisticsConsignment(LogisticsConsignmentParam bo, String orderType) {
@@ -140,7 +146,16 @@ public class LogisticsConsignmentService {
         if (checked.getCode() != HttpStatus.SUCCESS_CODE) {
             return HttpResult.error(checked.getMsg());
         }
-        logisticsConsignmentInsert(bo, orderType);
+        String key = String.format(RedisConstant.TRADE_TO_LOGISTICS_NO_GENERATE_KEY, bo.getTOrderId());
+        if (redisLockUtil.tryLock(key)) {
+            try {
+                logisticsConsignmentInsert(bo, orderType);
+            } finally {
+                redisLockUtil.unlock(key);
+            }
+        } else {
+            return HttpResult.error("请求不可重复操作,请稍后重试");
+        }
         return HttpResult.ok();
     }
 
@@ -161,8 +176,8 @@ public class LogisticsConsignmentService {
     /**
      * 销售订单-物流托运生成托运订单
      *
-     * @param bo
-     * @return
+     * @param bo    请求数据
+     * @return 响应数据
      */
     @Transactional(rollbackFor = Exception.class)
     public HttpResult sellLogisticsConsignment(LogisticsConsignmentParam bo, String orderType) {
@@ -174,7 +189,16 @@ public class LogisticsConsignmentService {
         if (checked.getCode() != HttpStatus.SUCCESS_CODE) {
             return HttpResult.error(checked.getMsg());
         }
-        logisticsConsignmentInsert(bo, orderType);
+        String key = String.format(RedisConstant.TRADE_TO_LOGISTICS_NO_GENERATE_KEY, bo.getTOrderId());
+        if (redisLockUtil.tryLock(key)) {
+            try {
+                logisticsConsignmentInsert(bo, orderType);
+            } finally {
+                redisLockUtil.unlock(key);
+            }
+        } else {
+            return HttpResult.error("当前数据不可重复操作，稍后重试");
+        }
         return HttpResult.ok();
     }
 
@@ -208,7 +232,31 @@ public class LogisticsConsignmentService {
             order.setSubcontractAmount(new BigDecimal("0.00"));
         }
         Long orderId = new IdWorker(NumberConstant.ONE).nextId();
+        long contractId = Long.parseLong(bo.getContractId());
+        List<Long> contractList = new ArrayList<>();
+        contractList.add(contractId);
+        Map<Long, ContractCommonInfoResDto> longContractCommonInfoResDtoMap = contractService.queryContractBaseInfo(contractList);
+        if (CollectionUtils.isEmpty(longContractCommonInfoResDtoMap)) {
+            throw new BusinessException("托运订单新建订单-并未有对应合同,应先签约合同");
+        }
+        if (longContractCommonInfoResDtoMap.get(contractId) == null) {
+            throw new BusinessException("托运订单新建订单-并未有对应合同,应先签约合同");
+        }
+        ContractCommonInfoResDto infoResDto = longContractCommonInfoResDtoMap.get(contractId);
+        /**状态判断
+         * 是否是已签约合同
+         * */
+        // 0 已签约 1待签约
+        Integer status = infoResDto.getStatus();
         Integer orderStatus = LogisticsOrderEnum.PENDING_ORDER.getCode();
+        if (NumberConstant.ONE == status) {
+            orderStatus = LogisticsOrderEnum.TO_BE_PLANNED.getCode();
+        } else if (NumberConstant.ZERO == status) {
+            orderStatus = LogisticsOrderEnum.PENDING_ORDER.getCode();
+        } else {
+            log.info("物流托运创建订单异常");
+            throw new BusinessException("物流托运创建订单异常");
+        }
         insertLogisticsGoods(bo, lOrderNo, orderId);
         insertLogisticsOrder(bo, lOrderNo, order, tradeOrder, orderId, orderStatus);
         insertLogisticsOrderContract(bo, orderId);
@@ -427,8 +475,8 @@ public class LogisticsConsignmentService {
     /**
      * 物流订单-企业信息
      *
-     * @param bo
-     * @param orderId
+     * @param bo 请求参数
+     * @param orderId   订单id
      */
     private void insertLogisticsOrderUnit(LogisticsConsignmentParam bo, Long orderId) {
         EntCacheResDto consignentMap = remoteSystemService.queryEntTreeById(Long.parseLong(bo.getConsignCompanyId()));
@@ -476,8 +524,8 @@ public class LogisticsConsignmentService {
     /**
      * 物流订单-状态
      *
-     * @param bo
-     * @param orderId
+     * @param bo 请求数据
+     * @param orderId   订单状态
      */
     private void insertLogisticsOrderTrack(LogisticsConsignmentParam bo, Long orderId, Integer orderStatus) {
         KwtLogisticsOrderTrack entity = new KwtLogisticsOrderTrack();
@@ -577,7 +625,7 @@ public class LogisticsConsignmentService {
     /**
      * 物流订单-合同
      *
-     * @param bo
+     * @param bo 请求数据
      */
     private void insertLogisticsOrderContract(LogisticsConsignmentParam bo, Long orderId) {
         KwtLogisticsOrderContract kwtLogisticsOrderContract = new KwtLogisticsOrderContract();
@@ -598,8 +646,8 @@ public class LogisticsConsignmentService {
     /**
      * 物流订单-装卸货地址
      *
-     * @param bo
-     * @param orderId
+     * @param bo    请求数据
+     * @param orderId 订单id
      */
     private void insertLogisticsOrderAddress(LogisticsConsignmentParam bo, Long orderId) {
         KwtLogisticsOrderAddress loadOrderAddress = new KwtLogisticsOrderAddress();
@@ -957,7 +1005,7 @@ public class LogisticsConsignmentService {
      * @param page     当前页
      * @param pageSize 每页条数
      * @param type     采购订单1/销售订单2
-     * @return
+     * @return  物流订单实体
      */
     private List<LogisticsOrderDTO> getLogisticsOrderData(String id, Integer page, Integer pageSize, String type) {
         List<LogisticsOrderDTO> list = kwtLogisticsOrderMapper.selectOrderList(id, page, pageSize, type);
@@ -984,10 +1032,10 @@ public class LogisticsConsignmentService {
     /**
      * 采购订单获取车辆信息
      *
-     * @param ids
-     * @param page
-     * @param pageSize
-     * @return
+     * @param ids 订单ids
+     * @param page 当前页
+     * @param pageSize  每页条数
+     * @return  车辆运单数据
      */
     public PageRes<OrderCarDTO> purchaseLogisticsCar(String ids, Integer page, Integer pageSize) {
         PageHelper.startPage(page, pageSize);
@@ -1134,13 +1182,22 @@ public class LogisticsConsignmentService {
             throw new BusinessException("单据id不能为空");
         }
         HttpResult result = new HttpResult();
-        //1采购 2销售
-        if (String.valueOf(NumberConstant.ONE).equals(type)) {
-            result = cancelConsignByOrder(ids, remark);
-        } else if (String.valueOf(NumberConstant.TWO).equals(type)) {
-            result = cancelConsignBySellOrder(ids, remark);
+        String key = String.format(RedisConstant.LOGISTICS_ORDER_CANCEL_KEY, ids.toString());
+        if (redisLockUtil.tryLock(key)) {
+            try {
+                //1采购 2销售
+                if (String.valueOf(NumberConstant.ONE).equals(type)) {
+                    result = cancelConsignByOrder(ids, remark);
+                } else if (String.valueOf(NumberConstant.TWO).equals(type)) {
+                    result = cancelConsignBySellOrder(ids, remark);
+                } else {
+                    throw new BusinessException("类型错误!");
+                }
+            } finally {
+                redisLockUtil.unlock(key);
+            }
         } else {
-            throw new BusinessException("类型错误!");
+            return HttpResult.error("当前数据不可重复操作,稍后请重试");
         }
         return result;
     }
@@ -1359,17 +1416,26 @@ public class LogisticsConsignmentService {
         if (!String.valueOf(httpResult.getCode()).equals(String.valueOf(HttpStatus.SUCCESS_CODE))) {
             return HttpResult.error(httpResult.getMsg());
         }
-        //1采购 2销售
-        if (String.valueOf(NumberConstant.ONE).equals(type)) {
-            log.info("采购订单-托运订单列表-完结订单 处理开始 seata xid:{}", RootContext.getXID());
-            purchaseOrderFinish(orderFinishDTO);
-            log.info("采购订单-托运订单列表-完结订单 处理结束 seata xid:{}", RootContext.getXID());
-        } else if (String.valueOf(NumberConstant.TWO).equals(type)) {
-            log.info("销售订单-托运订单列表-完结订单 处理开始 seata xid:{}", RootContext.getXID());
-            sellOrderFinish(orderFinishDTO);
-            log.info("销售订单-托运订单列表-完结订单 处理结束 seata xid:{}", RootContext.getXID());
+        String key = String.format(RedisConstant.LOGISTICS_ORDER_FINISH_KEY, orderFinishDTO.getId());
+        if (redisLockUtil.tryLock(key)) {
+            try {
+                //1采购 2销售
+                if (String.valueOf(NumberConstant.ONE).equals(type)) {
+                    log.info("采购订单-托运订单列表-完结订单 处理开始 seata xid:{}", RootContext.getXID());
+                    purchaseOrderFinish(orderFinishDTO);
+                    log.info("采购订单-托运订单列表-完结订单 处理结束 seata xid:{}", RootContext.getXID());
+                } else if (String.valueOf(NumberConstant.TWO).equals(type)) {
+                    log.info("销售订单-托运订单列表-完结订单 处理开始 seata xid:{}", RootContext.getXID());
+                    sellOrderFinish(orderFinishDTO);
+                    log.info("销售订单-托运订单列表-完结订单 处理结束 seata xid:{}", RootContext.getXID());
+                } else {
+                    throw new RuntimeException("完结订单-单据类型异常!");
+                }
+            } finally {
+                redisLockUtil.unlock(key);
+            }
         } else {
-            throw new RuntimeException("完结订单-单据类型异常!");
+            return HttpResult.error("当前数据不可重复操作");
         }
         return HttpResult.ok("完结订单-成功");
     }
@@ -2132,26 +2198,12 @@ public class LogisticsConsignmentService {
         return logisticOrderExcelVos;
     }
 
-    public HttpResult addLogisticsNumberDemo() {
-        String seqNo = OrderGenerateSeqNoUtils.getSeqNo(RedisOrderGenerateEnum.LOGISTICS_ORDER, OrderRuleEnum.LOGISTICS_ORDER, "0", "1", "3");
-        String seqNo1 = OrderGenerateSeqNoUtils.getOtherSeqNo(RedisOrderGenerateEnum.LOGISTICS_ORDER, OrderRuleEnum.LOGISTICS_ORDER);
-        System.out.println(seqNo);
-        System.out.println(seqNo1);
-        return HttpResult.ok(seqNo + ":" + seqNo1);
-    }
-
     public static void getLogisticsLOrderNo(String t, String number, String number1, String number2) {
         StringBuilder str = new StringBuilder();
         String date = DateUtils.formatDate(new Date());
         str.append(t).append(date).append(number).append(number1).append(number2);
     }
 
-    public HttpResult addWaybillNumberDemo() {
-//        String seqNo = OrderGenerateSeqNoUtils.getWaybillSeqNo(RedisOrderGenerateEnum.WAYBILL_ORDER, OrderRuleEnum.WAYBILL_ORDER,"T2308290001101");
-//        System.out.println(seqNo);
-        return HttpResult.ok();
-    }
-
     /**
      * 采购/销售订单-完成车次统计
      *

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

@@ -21,7 +21,12 @@ import com.sckw.core.web.response.HttpResult;
 import com.sckw.mongo.enums.BusinessTypeEnum;
 import com.sckw.mongo.model.SckwLogisticsOrder;
 import com.sckw.order.api.dubbo.TradeOrderInfoService;
-import com.sckw.order.api.model.*;
+import com.sckw.order.api.model.CreateOrCancelLogisticsOrderParam;
+import com.sckw.order.api.model.OrderDetailRes;
+import com.sckw.order.api.model.UnitInfoDetailRes;
+import com.sckw.order.api.model.UpdateActualAmountParam;
+import com.sckw.redis.config.RedisLockUtil;
+import com.sckw.redis.constant.RedisConstant;
 import com.sckw.stream.enums.MessageEnum;
 import com.sckw.stream.model.SckwBusSum;
 import com.sckw.system.api.RemoteSystemService;
@@ -68,6 +73,9 @@ public class TransportCommonService {
     @DubboReference(version = "1.0.0", group = "design", check = false, timeout = 6000)
     RemoteContractService remoteContractService;
 
+    @Autowired
+    RedisLockUtil redisLockUtil;
+
     @Autowired
     MessageUrlConfig messageUrlConfig;
 
@@ -336,118 +344,121 @@ public class TransportCommonService {
     public HttpResult cancelConsign(CancelOrderDTO orderDto) {
         log.info("订单-撤销托运请求参数:{}", JSONObject.toJSONString(orderDto));
         HttpResult result = new HttpResult();
-        KwtLogisticsOrder logisticsOrder = logisticsOrderMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrder>()
-                        .eq(KwtLogisticsOrder::getId, orderDto.getId())
-                /* .eq(KwtLogisticsOrder::getLOrderNo, orderDto.getOrderNo())*/
-                /**.eq(KwtLogisticsOrder::getEntId, LoginUserHolder.getEntId())*/);
-        if (logisticsOrder == null) {
-            result.setCode(HttpStatus.GLOBAL_EXCEPTION_CODE);
-            result.setMsg("单据不存在");
-            return result;
-        }
-        if (!LogisticsOrderEnum.PENDING_ORDER.getStatus().equals(String.valueOf(logisticsOrder.getStatus()))) {
-            result.setCode(HttpStatus.GLOBAL_EXCEPTION_CODE);
-            result.setMsg("待接单才允许撤销托运");
-            return result;
-        }
-        /**以此字段判别是否存在分包操作*/
-        if (ObjectUtils.isEmpty(logisticsOrder.getPid()) && "1".equals(logisticsOrder.getType())) {
-            /**并不存在分包，撤销数据回归到贸易订单，[待接单状态]下才能撤销托运*/
-            /**调用dubbo 修改数值*/
-            Long tOrderId = logisticsOrder.getTOrderId();
-            CreateOrCancelLogisticsOrderParam param = new CreateOrCancelLogisticsOrderParam();
-            param.setEntrustAmount(logisticsOrder.getAmount().negate());
-            param.setUpdateBy(LoginUserHolder.getUserId());
-            param.setUpdateByName(LoginUserHolder.getUserName());
-            param.setTOrderId(tOrderId);
-            HttpResult httpResult = tradeOrderInfoService.createOrCancelLogisticsOrder(param);
-            if (HttpStatus.SUCCESS_CODE != httpResult.getCode()) {
-                log.info("撤销托运错误:,请求参数:{},响应信息:{}", JSONObject.toJSONString(param), JSONObject.toJSONString(httpResult));
-            }
-            logisticsOrderMapper.update(null, new LambdaUpdateWrapper<KwtLogisticsOrder>()
-                    .eq(KwtLogisticsOrder::getId, logisticsOrder.getId())
-                    .set(KwtLogisticsOrder::getStatus, LogisticsOrderEnum.CANCEL_ORDER.getCode())
-                    .set(KwtLogisticsOrder::getUpdateBy, LoginUserHolder.getUserId())
-                    .set(KwtLogisticsOrder::getUpdateTime, new Date()));
-            updateOrderTrack(logisticsOrder.getId(), orderDto.getRemark(), LogisticsOrderEnum.CANCEL_ORDER);
-            //mongodb更新
-            SckwLogisticsOrder order = new SckwLogisticsOrder();
-            order.set_id(logisticsOrder.getId());
-            order.setLOrderId(logisticsOrder.getId());
-            order.setStatus(LogisticsOrderEnum.CANCEL_ORDER.getStatus());
-            order.setUpdateTime(new Date());
-            order.setUpdateByName(LoginUserHolder.getUserName());
-            order.setUpdateBy(LoginUserHolder.getUserId());
-            SckwBusSum busSum = new SckwBusSum();
-            //业务汇总类型
-            busSum.setBusSumType(BusinessTypeEnum.LOGISTICS_ORDER_TYPE.getName());
-            //操作对象（1新增/2修改）
-            busSum.setMethod(NumberConstant.TWO);
-            //业务汇总数据对象
-            busSum.setObject(order);
-            streamBridge.send("sckw-busSum", JSON.toJSONString(busSum));
-        } else {
-            /**即代表存在分包,当次是属于被分包.需要将数据回归到上游数据。*/
-            Long pid = logisticsOrder.getPid();
-            /**指的是上游单据进行回归*/
-            KwtLogisticsOrder order = logisticsOrderMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrder>()
-                    .eq(KwtLogisticsOrder::getId, pid));
-            //上游分配量
-            BigDecimal amount = logisticsOrder.getAmount();
-            //已经完成的量
-            BigDecimal loadAmount = logisticsOrder.getLoadAmount();
-            //未完成的量
-            BigDecimal subtract = amount.subtract(loadAmount);
-            //.setScale(2,BigDecimal.ROUND_HALF_DOWN)
-            BigDecimal add = order.getSubcontractAmount().subtract(amount);
-            logisticsOrderMapper.update(null, new LambdaUpdateWrapper<KwtLogisticsOrder>()
-                    .eq(KwtLogisticsOrder::getId, order.getId())
-                    .set(KwtLogisticsOrder::getDelFlag, NumberConstant.ZERO)
-                    .set(KwtLogisticsOrder::getSubcontractAmount, add)
-                    .set(KwtLogisticsOrder::getUpdateBy, LoginUserHolder.getUserId())
-                    .set(KwtLogisticsOrder::getUpdateTime, new Date()));
-//            updateOrderTrack(logisticsOrder.getId(),orderDto.getRemark(),LogisticsOrderEnum.CANCEL_ORDER);
-            /**下游订单进行状态改变*/
-            logisticsOrderMapper.update(null, new LambdaUpdateWrapper<KwtLogisticsOrder>()
-                    .eq(KwtLogisticsOrder::getId, logisticsOrder.getId())
-                    .set(KwtLogisticsOrder::getStatus, LogisticsOrderEnum.CANCEL_ORDER.getCode())
-                    .set(KwtLogisticsOrder::getUpdateBy, LoginUserHolder.getUserId())
-                    .set(KwtLogisticsOrder::getUpdateTime, new Date()));
-            updateOrderTrack(logisticsOrder.getId(), orderDto.getRemark(), LogisticsOrderEnum.CANCEL_ORDER);
-            /**mongodb更新*/
-            //父级
-            SckwLogisticsOrder sckwLogisticsOrder = new SckwLogisticsOrder();
-            sckwLogisticsOrder.set_id(order.getId());
-            sckwLogisticsOrder.setLOrderId(order.getId());
-            sckwLogisticsOrder.setSubcontractAmount(add);
-            sckwLogisticsOrder.setUpdateTime(new Date());
-            sckwLogisticsOrder.setUpdateByName(LoginUserHolder.getUserName());
-            sckwLogisticsOrder.setUpdateBy(LoginUserHolder.getUserId());
-            SckwBusSum busSum = new SckwBusSum();
-            //业务汇总类型
-            busSum.setBusSumType(BusinessTypeEnum.LOGISTICS_ORDER_TYPE.getName());
-            //操作对象（1新增/2修改）
-            busSum.setMethod(NumberConstant.TWO);
-            //业务汇总数据对象
-            busSum.setObject(sckwLogisticsOrder);
-            //当前级
-            streamBridge.send("sckw-busSum", JSON.toJSONString(busSum));
-            SckwLogisticsOrder logisticsOrder1 = new SckwLogisticsOrder();
-            logisticsOrder1.set_id(logisticsOrder.getId());
-            logisticsOrder1.setLOrderId(logisticsOrder.getId());
-            logisticsOrder1.setStatus(LogisticsOrderEnum.CANCEL_ORDER.getStatus());
-            logisticsOrder1.setUpdateTime(new Date());
-            logisticsOrder1.setUpdateByName(LoginUserHolder.getUserName());
-            logisticsOrder1.setUpdateBy(LoginUserHolder.getUserId());
-            SckwBusSum busSum1 = new SckwBusSum();
-            //业务汇总类型
-            busSum1.setBusSumType(BusinessTypeEnum.LOGISTICS_ORDER_TYPE.getName());
-            //操作对象（1新增/2修改）
-            busSum1.setMethod(NumberConstant.TWO);
-            //业务汇总数据对象
-            busSum1.setObject(logisticsOrder1);
-            streamBridge.send("sckw-busSum", JSON.toJSONString(busSum1));
-        }
+        String key = String.format(RedisConstant.LOGISTICS_ORDER_CANCEL_KEY, orderDto.getId());
+        if (redisLockUtil.tryLock(key)) {
+            try {
+                KwtLogisticsOrder logisticsOrder = logisticsOrderMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrder>()
+                                .eq(KwtLogisticsOrder::getId, orderDto.getId())
+                        /* .eq(KwtLogisticsOrder::getLOrderNo, orderDto.getOrderNo())*/
+                        /**.eq(KwtLogisticsOrder::getEntId, LoginUserHolder.getEntId())*/);
+                if (logisticsOrder == null) {
+                    result.setCode(HttpStatus.GLOBAL_EXCEPTION_CODE);
+                    result.setMsg("单据不存在");
+                    return result;
+                }
+                if (!LogisticsOrderEnum.PENDING_ORDER.getStatus().equals(String.valueOf(logisticsOrder.getStatus()))) {
+                    result.setCode(HttpStatus.GLOBAL_EXCEPTION_CODE);
+                    result.setMsg("待接单才允许撤销托运");
+                    return result;
+                }
+                /**以此字段判别是否存在分包操作*/
+                if (ObjectUtils.isEmpty(logisticsOrder.getPid()) && "1".equals(logisticsOrder.getType())) {
+                    /**并不存在分包，撤销数据回归到贸易订单，[待接单状态]下才能撤销托运*/
+                    /**调用dubbo 修改数值*/
+                    Long tOrderId = logisticsOrder.getTOrderId();
+                    CreateOrCancelLogisticsOrderParam param = new CreateOrCancelLogisticsOrderParam();
+                    param.setEntrustAmount(logisticsOrder.getAmount().negate());
+                    param.setUpdateBy(LoginUserHolder.getUserId());
+                    param.setUpdateByName(LoginUserHolder.getUserName());
+                    param.setTOrderId(tOrderId);
+                    HttpResult httpResult = tradeOrderInfoService.createOrCancelLogisticsOrder(param);
+                    if (HttpStatus.SUCCESS_CODE != httpResult.getCode()) {
+                        log.info("撤销托运错误:,请求参数:{},响应信息:{}", JSONObject.toJSONString(param), JSONObject.toJSONString(httpResult));
+                    }
+                    logisticsOrderMapper.update(null, new LambdaUpdateWrapper<KwtLogisticsOrder>()
+                            .eq(KwtLogisticsOrder::getId, logisticsOrder.getId())
+                            .set(KwtLogisticsOrder::getStatus, LogisticsOrderEnum.CANCEL_ORDER.getCode())
+                            .set(KwtLogisticsOrder::getUpdateBy, LoginUserHolder.getUserId())
+                            .set(KwtLogisticsOrder::getUpdateTime, new Date()));
+                    updateOrderTrack(logisticsOrder.getId(), orderDto.getRemark(), LogisticsOrderEnum.CANCEL_ORDER);
+                    //mongodb更新
+                    SckwLogisticsOrder order = new SckwLogisticsOrder();
+                    order.set_id(logisticsOrder.getId());
+                    order.setLOrderId(logisticsOrder.getId());
+                    order.setStatus(LogisticsOrderEnum.CANCEL_ORDER.getStatus());
+                    order.setUpdateTime(new Date());
+                    order.setUpdateByName(LoginUserHolder.getUserName());
+                    order.setUpdateBy(LoginUserHolder.getUserId());
+                    SckwBusSum busSum = new SckwBusSum();
+                    //业务汇总类型
+                    busSum.setBusSumType(BusinessTypeEnum.LOGISTICS_ORDER_TYPE.getName());
+                    //操作对象（1新增/2修改）
+                    busSum.setMethod(NumberConstant.TWO);
+                    //业务汇总数据对象
+                    busSum.setObject(order);
+                    streamBridge.send("sckw-busSum", JSON.toJSONString(busSum));
+                } else {
+                    /**即代表存在分包,当次是属于被分包.需要将数据回归到上游数据。*/
+                    Long pid = logisticsOrder.getPid();
+                    /**指的是上游单据进行回归*/
+                    KwtLogisticsOrder order = logisticsOrderMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrder>()
+                            .eq(KwtLogisticsOrder::getId, pid));
+                    //上游分配量
+                    BigDecimal amount = logisticsOrder.getAmount();
+                    //已经完成的量
+                    BigDecimal loadAmount = logisticsOrder.getLoadAmount();
+                    //未完成的量
+                    BigDecimal subtract = amount.subtract(loadAmount);
+                    //.setScale(2,BigDecimal.ROUND_HALF_DOWN)
+                    BigDecimal add = order.getSubcontractAmount().subtract(amount);
+                    logisticsOrderMapper.update(null, new LambdaUpdateWrapper<KwtLogisticsOrder>()
+                            .eq(KwtLogisticsOrder::getId, order.getId())
+                            .set(KwtLogisticsOrder::getDelFlag, NumberConstant.ZERO)
+                            .set(KwtLogisticsOrder::getSubcontractAmount, add)
+                            .set(KwtLogisticsOrder::getUpdateBy, LoginUserHolder.getUserId())
+                            .set(KwtLogisticsOrder::getUpdateTime, new Date()));
+                    //            updateOrderTrack(logisticsOrder.getId(),orderDto.getRemark(),LogisticsOrderEnum.CANCEL_ORDER);
+                    /**下游订单进行状态改变*/
+                    logisticsOrderMapper.update(null, new LambdaUpdateWrapper<KwtLogisticsOrder>()
+                            .eq(KwtLogisticsOrder::getId, logisticsOrder.getId())
+                            .set(KwtLogisticsOrder::getStatus, LogisticsOrderEnum.CANCEL_ORDER.getCode())
+                            .set(KwtLogisticsOrder::getUpdateBy, LoginUserHolder.getUserId())
+                            .set(KwtLogisticsOrder::getUpdateTime, new Date()));
+                    updateOrderTrack(logisticsOrder.getId(), orderDto.getRemark(), LogisticsOrderEnum.CANCEL_ORDER);
+                    /**mongodb更新*/
+                    //父级
+                    SckwLogisticsOrder sckwLogisticsOrder = new SckwLogisticsOrder();
+                    sckwLogisticsOrder.set_id(order.getId());
+                    sckwLogisticsOrder.setLOrderId(order.getId());
+                    sckwLogisticsOrder.setSubcontractAmount(add);
+                    sckwLogisticsOrder.setUpdateTime(new Date());
+                    sckwLogisticsOrder.setUpdateByName(LoginUserHolder.getUserName());
+                    sckwLogisticsOrder.setUpdateBy(LoginUserHolder.getUserId());
+                    SckwBusSum busSum = new SckwBusSum();
+                    //业务汇总类型
+                    busSum.setBusSumType(BusinessTypeEnum.LOGISTICS_ORDER_TYPE.getName());
+                    //操作对象（1新增/2修改）
+                    busSum.setMethod(NumberConstant.TWO);
+                    //业务汇总数据对象
+                    busSum.setObject(sckwLogisticsOrder);
+                    //当前级
+                    streamBridge.send("sckw-busSum", JSON.toJSONString(busSum));
+                    SckwLogisticsOrder logisticsOrder1 = new SckwLogisticsOrder();
+                    logisticsOrder1.set_id(logisticsOrder.getId());
+                    logisticsOrder1.setLOrderId(logisticsOrder.getId());
+                    logisticsOrder1.setStatus(LogisticsOrderEnum.CANCEL_ORDER.getStatus());
+                    logisticsOrder1.setUpdateTime(new Date());
+                    logisticsOrder1.setUpdateByName(LoginUserHolder.getUserName());
+                    logisticsOrder1.setUpdateBy(LoginUserHolder.getUserId());
+                    SckwBusSum busSum1 = new SckwBusSum();
+                    //业务汇总类型
+                    busSum1.setBusSumType(BusinessTypeEnum.LOGISTICS_ORDER_TYPE.getName());
+                    //操作对象（1新增/2修改）
+                    busSum1.setMethod(NumberConstant.TWO);
+                    //业务汇总数据对象
+                    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);
@@ -455,25 +466,31 @@ public class TransportCommonService {
 //            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));
+                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);
-        commonService.newSendLogisticsOrderToMessage(consignUnit, carriageUnit, logisticsOrder.getLOrderNo(), logisticsOrder.getCreateBy(),
-                logisticsOrder.getEntId(),
-                messageUrlConfig.getPc().getConsignLogisticsAddOrderUrl(), messageUrlConfig.getApp().getConsignLogisticsAddOrderUrl(),
-                messageUrlConfig.getPc().getCarriageLogisticsAddOrderUrl(), messageUrlConfig.getApp().getCarriageLogisticsAddOrderUrl(),
-                MessageEnum.CANCELLATION_LOGISTICS, MessageEnum.CARRIAGE_CANCELLATION_LOGISTICS,
-                "1");
+                commonService.newSendLogisticsOrderToMessage(consignUnit, carriageUnit, logisticsOrder.getLOrderNo(), logisticsOrder.getCreateBy(),
+                        logisticsOrder.getEntId(),
+                        messageUrlConfig.getPc().getConsignLogisticsAddOrderUrl(), messageUrlConfig.getApp().getConsignLogisticsAddOrderUrl(),
+                        messageUrlConfig.getPc().getCarriageLogisticsAddOrderUrl(), messageUrlConfig.getApp().getCarriageLogisticsAddOrderUrl(),
+                        MessageEnum.CANCELLATION_LOGISTICS, MessageEnum.CARRIAGE_CANCELLATION_LOGISTICS,
+                        "1");
+            } finally {
+                redisLockUtil.unlock(key);
+            }
+        } else {
+            return HttpResult.error("当前数据不可重复提交");
+        }
         return result;
     }