采购订单-完结订单修改

mongodb字段修改

sckw-common/sckw-common-core/src/main/java/com/sckw/core/utils/ListUtils.java

@@ -0,0 +1,169 @@
+package com.sckw.core.utils;
+
+import java.util.*;
+
+/**
+ * @author lfdc
+ * @description listUtils
+ * @date 2023-08-08 11:08:11
+ */
+public class ListUtils {
+
+    /**
+     * 比较两个List集合是否相等
+     * <p>注：1. 如果一个List的引用为<code>null</code>，或者其包含的元素个数为0，那么该List在本逻辑处理中都算作空；
+     * <p>2. 泛型参数E涉及到对象，所以需要确保正确实现了对应对象的<code>equal()</code>方法。
+     *
+     * @param list1
+     * @param list2
+     * @return
+     */
+    public static <E> boolean isListEqual(List<E> list1, List<E> list2) {
+        // 两个list引用相同（包括两者都为空指针的情况）
+        if (list1 == list2) {
+            return true;
+        }
+
+        // 两个list都为空（包括空指针、元素个数为0）
+        if ((list1 == null && list2 != null && list2.size() == 0)
+                || (list2 == null && list1 != null && list1.size() == 0)) {
+            return true;
+        }
+
+        // 两个list元素个数不相同
+        if (list1.size() != list2.size()) {
+            return false;
+        }
+
+        // 两个list元素个数已经相同，再比较两者内容
+        // 采用这种可以忽略list中的元素的顺序
+        // 涉及到对象的比较是否相同时，确保实现了equals()方法
+        if (!list1.containsAll(list2) && !list2.containsAll(list1)) {
+            return false;
+        }
+
+        return true;
+    }
+
+    public static void main(String[] args) {
+        String sortTyp = "asc"; // desc-倒叙  asc-正序
+        // 组装测试数据
+        List<Map<String, Object>> list = initMapList();
+
+        // 单个map排序
+        Map<String, Object> map = list.get(0);
+        Map<String, Object> sortMap = sortMap(map, sortTyp);
+        // Map<String, Object> sortMap = sortByKey(map, false);
+        for (Map.Entry<String, Object> entry : sortMap.entrySet()) {
+            System.out.println("单个map排序" + sortTyp);
+            System.out.println(entry.getKey());
+        }
+
+        // List<map>根据某个字段排序
+        sortMapListByFeild(list, "age", sortTyp);
+        System.out.println("按年纪取最大的一条数据，其姓名是：" + list.get(0).get("name"));
+    }
+
+    /**
+     * List<Map>根据map字段排序
+     *
+     * @param list
+     * @param feild   排序字段
+     * @param sortTyp 排序方式 desc-倒序 asc-正序
+     * @return
+     */
+    public static List<Map<String, Object>> sortMapListByFeild(List<Map<String, Object>> list, String feild, String sortTyp) {
+        if (CollectionUtils.isNotEmpty(list)) {
+            // 方法1
+            list.sort((m1, m2) -> {
+                if ("desc".equals(sortTyp)) {
+                    return String.valueOf(m2.get(feild)).compareTo(String.valueOf(m1.get(feild)));
+                } else {
+                    return String.valueOf(m1.get(feild)).compareTo(String.valueOf(m2.get(feild)));
+                }
+            });
+
+            // 方法2 也ok噢
+            /*if (StringUtils.equals(sortTyp, "desc")) {
+                Collections.sort(list, (m1, m2)-> String.valueOf(m2.get(feild)).compareTo(String.valueOf(m1.get(feild)))); // lamuda排序
+            } else {
+                Collections.sort(list, (m1, m2)-> String.valueOf(m1.get(feild)).compareTo(String.valueOf(m2.get(feild)))); // lamuda排序
+            }*/
+        }
+
+        return list;
+    }
+
+    /**
+     * map排序
+     *
+     * @param map
+     * @return
+     */
+    public static Map<String, Object> sortMap(Map<String, Object> map, String sortTyp) {
+        try {
+            if ("desc".equals(sortTyp)) {
+
+                Set<String> sortSet = new TreeSet<>(Comparator.reverseOrder()); // 定义个倒叙的set
+                sortSet.addAll(map.keySet()); // 获取全部key，添加后就自然倒序了
+
+                Map<String, Object> resp = new LinkedHashMap<>();
+                for (String key : sortSet) {
+                    resp.put(key, map.get(key)); // 按顺序放入新map
+                }
+
+                return resp;
+            } else {
+                return new TreeMap<>(map); // TreeMap 本身就是正序的
+            }
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+        return map;
+    }
+
+    /**
+     * 根据map的key排序
+     *
+     * @param map    待排序的map
+     * @param isDesc 是否降序，true：降序，false：升序
+     * @param <K>
+     * @param <V>
+     * @return
+     */
+    public static <K extends Comparable<? super K>, V> Map<K, V> sortByKey(Map<K, V> map, boolean isDesc) {
+        Map<K, V> result = new LinkedHashMap<>();
+        if (isDesc) {
+            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey().reversed())
+                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
+        } else {
+            map.entrySet().stream().sorted(Map.Entry.<K, V>comparingByKey())
+                    .forEachOrdered(e -> result.put(e.getKey(), e.getValue()));
+        }
+        return result;
+    }
+
+    private static List<Map<String, Object>> initMapList() {
+        List<Map<String, Object>> lists = new ArrayList<>();
+
+        Map<String, Object> map = new HashMap<>();
+        map.put("name", "王五");
+        map.put("age", 55);
+        map.put("mobile", "15900001112");
+        lists.add(map);
+
+        Map<String, Object> map1 = new HashMap<>();
+        map1.put("name", "李四");
+        map1.put("age", 18);
+        map1.put("mobile", "15900001111");
+        lists.add(map1);
+
+        Map<String, Object> map2 = new HashMap<>();
+        map2.put("name", "赵六");
+        map2.put("age", 58);
+        map2.put("mobile", "13700001111");
+        lists.add(map2);
+
+        return lists;
+    }
+}

sckw-common/sckw-common-mongo/src/main/java/com/sckw/mongo/model/SckwLogisticsOrder.java

@@ -164,12 +164,12 @@ public class SckwLogisticsOrder {
     /**
      * 总卸货量（自己承运总卸货量+分包承运总卸货量）
      */
-    private BigDecimal unloadTotalAmount;
+    private BigDecimal totalUnloadAmount;
 
     /**
      * 总装货量（自己承运总装货量+分包承运总装货量）
      */
-    private BigDecimal loadTotalAmount;
+    private BigDecimal totalLoadAmount;
 
     /**
      * 总亏吨量（自己承运总亏吨量+分包承运总亏吨量）

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

@@ -18,23 +18,9 @@ import java.util.Map;
 
 @Mapper
 public interface KwtLogisticsOrderMapper extends BaseMapper<KwtLogisticsOrder> {
-    /**
-     * @param id
-     * @return
-     */
-    int deleteByPrimaryKey(Long id);
 
     int insert(KwtLogisticsOrder record);
 
-    int insertSelective(KwtLogisticsOrder record);
-
-    KwtLogisticsOrder selectByPrimaryKey(Long id);
-
-    int updateByPrimaryKeySelective(KwtLogisticsOrder record);
-
-    int updateByPrimaryKey(KwtLogisticsOrder record);
-
-//    void removeById(KwtLogisticsOrder logisticsOrder);
 
     /**
      * 查询物流订单数据

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

@@ -65,6 +65,11 @@ public class KwtLogisticsOrder implements Serializable {
      */
     private String pids;
 
+    /**
+     * 当前单据所属等级
+     */
+    private String level;
+
     /**
      * 结算周期(周结、月结、季结)
      */
@@ -163,6 +168,16 @@ public class KwtLogisticsOrder implements Serializable {
      */
     private BigDecimal deficitPrice;
 
+    /**
+     * 卸货-履约量（自己+下游承运总卸货量）
+     */
+    private BigDecimal totalUnloadAmount;
+
+    /**
+     * 装货-履约量（自己+下游承运总装货量）
+     */
+    private BigDecimal totalLoadAmount;
+
     /**
      * 实际开始时间（装货）
      */

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

@@ -875,6 +875,13 @@ public class AcceptCarriageOrderService {
                             .set(KwtLogisticsOrderCirculate::getStatus, NumberConstant.ONE)
                             .eq(KwtLogisticsOrderCirculate::getWOrderId, wOrderId));
 //                    /**更新MongoDB*/
+                    SckwWaybillOrder order = new SckwWaybillOrder();
+                    order.setStatus(NumberConstant.ONE);
+                    SckwBusSum busSum = new SckwBusSum();
+                    busSum.setBusSumType(BusinessTypeEnum.WAYBILL_ORDER_TYPE.getName());
+                    busSum.setMethod(NumberConstant.TWO);
+                    busSum.setObject(order);
+                    streamBridge.send("sckw-busSum", com.alibaba.fastjson2.JSON.toJSONString(busSum));
                     jsonObject.put("status", HttpStatus.SUCCESS_CODE);
                     jsonObject.put("message", "停止接单成功");
                 }

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

@@ -1580,8 +1580,8 @@ public class KwtWaybillOrderService {
         SckwLogisticsOrder lOrder = new SckwLogisticsOrder();
         lOrder.setLoadTime(waybillCount.getLoadTime());
         lOrder.setUnloadTime(waybillCount.getUnloadTime());
-        lOrder.setLoadTotalAmount(waybillCount.getLoadAmount());
-        lOrder.setUnloadTotalAmount(waybillCount.getUnloadAmount());
+        lOrder.setTotalLoadAmount(waybillCount.getLoadAmount());
+        lOrder.setTotalUnloadAmount(waybillCount.getUnloadAmount());
         lOrder.setDeficitTotalAmount(waybillCount.getDeficitAmount());
         BigDecimal deficitPrice = deficitPrice(waybillCount.getLoadAmount(), waybillCount.getDeficitAmount(),
                 logisticsOrder.getLoss(), logisticsOrder.getGoodsPrice());

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

@@ -44,7 +44,6 @@ import io.seata.core.context.RootContext;
 import jakarta.annotation.Resource;
 import lombok.extern.slf4j.Slf4j;
 import org.apache.dubbo.config.annotation.DubboReference;
-import org.springframework.beans.BeanUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.cloud.stream.function.StreamBridge;
 import org.springframework.stereotype.Service;
@@ -965,7 +964,7 @@ public class LogisticsConsignmentService {
      * @param type           类型
      * @return
      */
-//    @Transactional(rollbackFor = Exception.class)
+    @Transactional(rollbackFor = Exception.class)
 //    @GlobalTransactional(timeoutMills = 120000)
     public HttpResult orderFinish(OrderFinishDTO orderFinishDTO, String type) {
         HttpResult httpResult = ValidUtil.serviceValid(orderFinishDTO);
@@ -1019,73 +1018,281 @@ public class LogisticsConsignmentService {
         /**订单状态验证*/
         if (!LogisticsOrderEnum.WAIT_DELIVERY.getStatus().equals(String.valueOf(logisticsOrder.getStatus()))
                 && !LogisticsOrderEnum.IN_TRANSIT.getStatus().equals(String.valueOf(logisticsOrder.getStatus()))) {
-            throw new RuntimeException("当前运单并不属于【待派车】,【运输中】状态");
+            throw new BusinessException("当前运单并不属于【待派车】,【运输中】状态");
         }
-        //防止正序递归影响时长-先行判断当前物流订单
         //验证当前物流订单是否还存在进行的车辆运单
         boolean flag = judgmentWaybillOrderIsFinish(id);
         if (flag) {
             throw new BusinessException("您现在有车辆运单正在执行中,该订单目前不可完结,请先将运单执行完毕");
         }
-        //通过pids查看是否存在下游分包数据
+        //修改单据本身数据
+        logisticsOrder.setTotalLoadAmount(orderFinishDTO.getLoadAmount());
+        logisticsOrder.setTotalUnloadAmount(orderFinishDTO.getUnloadAmount());
+        logisticsOrder.setStatus(LogisticsOrderEnum.HAVE_FINISHED.getCode());
+        logisticsOrder.setUpdateTime(new Date());
+        logisticsOrder.setUpdateBy(LoginUserHolder.getUserId());
+        kwtLogisticsOrderMapper.updateById(logisticsOrder);
+        //修改mongodb的数据
+        updateMongoDbByLogisticsOrder(logisticsOrder, orderFinishDTO);
+        //获取物流订单下的子单
         /**完结订单-对应物流订单下子订单都要进行完结*/
         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));
-        //存在子集
-        if (CollectionUtils.isNotEmpty(kwtLogisticsOrders)) {
-            List<Long> collect = kwtLogisticsOrders.stream().map(KwtLogisticsOrder::getId).collect(Collectors.toList());
-            //验证 是否存在进行中车辆运单
-            List<KwtLogisticsOrder> kwtLogisticsOrderList = kwtLogisticsOrderMapper.selectList(new LambdaQueryWrapper<KwtLogisticsOrder>().in(KwtLogisticsOrder::getId, collect));
-            if (CollectionUtils.isNotEmpty(kwtLogisticsOrderList)) {
-                judgmentLogisticsOrderIsFinish(logisticsOrder);
-            }
-            // 按照父级ID分组
-            //判断是不是一级(一级的情况下，pid为null 方便处理，赋值为OL)
-            List<KwtLogisticsOrder> list = kwtLogisticsOrders.stream()
-                    .map(object -> {
-                        KwtLogisticsOrder LogisticsOrder = new KwtLogisticsOrder();
-                        BeanUtils.copyProperties(object, LogisticsOrder);
-                        if (LogisticsOrder.getPid() == null) {
-                            LogisticsOrder.setPid(0L);
+        //找到该订单下所有的物流订单
+        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的数据
+                updateMongoDbByLogisticsOrder(kwtLogisticsOrder,orderFinishDTO);
+            });
+        }
+        //todo 直接订单完结-不递归操作
+//
+//        //存在子集
+//        if (CollectionUtils.isNotEmpty(kwtLogisticsOrders)) {
+//            if (kwtLogisticsOrders.size() == 1 && !(kwtLogisticsOrders.get(0).getPids().contains(StringConstant.COMMA))) {
+//                //不存在子集
+//                /**
+//                 * 验证是否存在进行中的车辆运单
+//                 * 统计当前物流订单的 分配量/实装量/实卸量
+//                 * 验证当前贸易订单是否存在进行中的物流运单
+//                 * */
+//                judgmentLogisticsOrderIsFinish(logisticsOrder);
+//                //直接修改数据以及状态
+//            } else {
+//                //分组排序
+//                Map<String, List<KwtLogisticsOrder>> collect1 = kwtLogisticsOrders.stream().collect(Collectors.groupingBy(KwtLogisticsOrder::getLevel,
+//                        Collectors.collectingAndThen(Collectors.toList(),
+//                                logisticsOrders -> logisticsOrders.stream().sorted(Comparator.comparing(KwtLogisticsOrder::getLevel).reversed())
+//                                        .collect(Collectors.toList()))
+//                ));
+//                //查出来最原始的数据
+//                List<KwtLogisticsOrder> orderLists = new ArrayList<>();
+//                for (List<KwtLogisticsOrder> value : collect1.values()) {
+//                    orderLists.addAll(value);
+//                }
+//                //当前订单下的最大分包等级
+//                int maxLevel = kwtLogisticsOrderMapper.selectMaxLevel(id);
+//                List<Map<String, Object>> list = new ArrayList<>();
+//                for (int level = maxLevel; level > 0; level--) {
+//                    if (maxLevel == level) {
+//                        List<KwtLogisticsOrder> logisticsOrderList = collect1.get(String.valueOf(level));
+//                        //操作最底层数据，溯源父级
+//                        for (KwtLogisticsOrder kwtLogisticsOrder : logisticsOrderList) {
+//                            BigDecimal entrustAmount = kwtLogisticsOrder.getEntrustAmount();
+//                            BigDecimal subcontractAmount = kwtLogisticsOrder.getSubcontractAmount();
+//                            BigDecimal amount = kwtLogisticsOrder.getAmount();
+//                            BigDecimal loadAmount = kwtLogisticsOrder.getLoadAmount();
+//                            BigDecimal unloadAmount = kwtLogisticsOrder.getUnloadAmount();
+//                            //已完成的量
+//                            BigDecimal subtract = subcontractAmount.add(loadAmount);
+//                            //本身数据修改(剩余量=上游给的委托量-（分包量+实际装货）)
+//                            //剩余量
+//                            BigDecimal ignoreAmount = amount.subtract((subcontractAmount.add(loadAmount)));
+//                            kwtLogisticsOrderMapper.update(null, new LambdaUpdateWrapper<KwtLogisticsOrder>()
+//                                    .eq(KwtLogisticsOrder::getId, kwtLogisticsOrder.getId())
+//                                    .set(KwtLogisticsOrder::getIgnoreAmount, ignoreAmount)
+//                            );
+//                            //最底下根节点-获取父级
+//                            KwtLogisticsOrder selectOne = kwtLogisticsOrderMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrder>()
+//                                    .eq(KwtLogisticsOrder::getId, kwtLogisticsOrder.getPid())
+//                            );
+//                            BigDecimal amount1 = selectOne.getAmount();
+//                            BigDecimal loadAmount1 = selectOne.getLoadAmount();
+//                            BigDecimal subcontractAmount1 = selectOne.getSubcontractAmount();
+//                            BigDecimal ignoreAmount1 = selectOne.getIgnoreAmount();
+//                            subcontractAmount1 = subcontractAmount1.subtract(subtract);
+//                            ignoreAmount1 = amount1.subtract((subcontractAmount1.add(loadAmount1)));
+//                            kwtLogisticsOrderMapper.update(null, new LambdaUpdateWrapper<KwtLogisticsOrder>()
+//                                    .eq(KwtLogisticsOrder::getId, selectOne.getId())
+//                                    .set(KwtLogisticsOrder::getSubcontractAmount, subcontractAmount1)
+//                                    .set(KwtLogisticsOrder::getIgnoreAmount, ignoreAmount1)
+//                            );
+//                        }
+////                    List<KwtLogisticsOrder> collect = logisticsOrderList.stream().filter(item -> StringUtils.isNotBlank(item.getPid())).collect(Collectors.toList());
+//                    } else {
+//                        //不是一级,也不是最后一级
+//                        List<KwtLogisticsOrder> logisticsOrderList = collect1.get(String.valueOf(level));
+//                        if (CollectionUtils.isNotEmpty(logisticsOrderList)) {
+//                            for (KwtLogisticsOrder kwtLogisticsOrder : logisticsOrderList) {
+//                                Map<String, Object> map = new HashMap<>(NumberConstant.SIXTEEN);
+//                                List<Object> collect = list.stream().map(item -> item.get("level")).collect(Collectors.toList());
+//                                if (!collect.contains(kwtLogisticsOrder.getId())) {
+//                                    map.put("level", level);
+//                                    map.put("id", kwtLogisticsOrder.getId());
+//                                    list.add(map);
+//                                }
+//
+//                            }
+//                        }
+//                    }
+//                }
+//                lllll(list);
+//            }
+////
+////            List<Long> collect = kwtLogisticsOrders.stream().map(KwtLogisticsOrder::getId).collect(Collectors.toList());
+////            //验证 是否存在进行中车辆运单
+////            List<KwtLogisticsOrder> kwtLogisticsOrderList = kwtLogisticsOrderMapper.selectList(new LambdaQueryWrapper<KwtLogisticsOrder>().in(KwtLogisticsOrder::getId, collect));
+////            if (CollectionUtils.isNotEmpty(kwtLogisticsOrderList)) {
+////                judgmentLogisticsOrderIsFinish(logisticsOrder);
+////            }
+////            // 按照父级ID分组
+////            //判断是不是一级(一级的情况下，pid为null 方便处理，赋值为OL)
+////            List<KwtLogisticsOrder> list = kwtLogisticsOrders.stream()
+////                    .map(object -> {
+////                        KwtLogisticsOrder LogisticsOrder = new KwtLogisticsOrder();
+////                        BeanUtils.copyProperties(object, LogisticsOrder);
+////                        if (LogisticsOrder.getPid() == null) {
+////                            LogisticsOrder.setPid(0L);
+////                        }
+////                        return LogisticsOrder;
+////                    })
+////                    .collect(Collectors.toList());
+////            Map<Long, List<KwtLogisticsOrder>> groupByParentIdMap = list.stream().collect(Collectors.groupingBy(KwtLogisticsOrder::getPid));
+////            //存放:对应的当前节点ID数据
+////            Set<Long> topToLowerChildIdSet = new HashSet<>();
+////            // 取出顶级数据(也就是父级ID为0的数据  父级ID也可以自定义 当前赋值0L)
+////            List<KwtLogisticsOrder> topTreeNodes = groupByParentIdMap.get(0L);
+////            if (CollectionUtils.isEmpty(topTreeNodes)) {
+////                /**当前传输的代表不是一级 可能是二级或者三级
+////                 topTreeNodes = groupByParentIdMap.get(Long.parseLong(id));*/
+////                getMinimumChildIdArray(groupByParentIdMap, Long.parseLong(id), topToLowerChildIdSet);
+////                System.out.println("当前节点【" + id + "】节点下所有的根节点数据集合:" + topToLowerChildIdSet.toString());
+////                //根据等级分组倒序排序
+////                List<KwtLogisticsOrder> orderList = kwtLogisticsOrderMapper.selectList(new LambdaQueryWrapper<KwtLogisticsOrder>()
+////                        .in(KwtLogisticsOrder::getId, topToLowerChildIdSet)
+////                );
+////
+////            } else {
+////                for (KwtLogisticsOrder node : topTreeNodes) {
+////                    getMinimumChildIdArray(groupByParentIdMap, node.getId(), topToLowerChildIdSet);
+////                }
+////                System.out.println("0节点(传输为一级)下所有的根节点数据集合:" + topToLowerChildIdSet.toString());
+////            }
+////            //处理当前传递的id下  全部完结需要改的量
+////            BigDecimal decimals = new BigDecimal("0.00");
+////            BigDecimal decimal = judgmentOrderFinish(id, topToLowerChildIdSet, decimals, logisticsOrder);
+////            //返回给贸易订单实际装卸货量
+////            Map map = countOrderNumber(logisticsOrder.getTOrderId());
+////            //修改单据状态
+//////            updateLogisticOrderStatus(id,orderFinishDTO);
+//        } else {
+//            throw new BusinessException("不存在物流订单,不可操作！");
+//        }
+    }
+
+    /**
+     * 根据物流订单修改mongodb数据
+     *
+     * @param logisticsOrder
+     * @param orderFinishDTO
+     */
+    private void updateMongoDbByLogisticsOrder(KwtLogisticsOrder logisticsOrder, OrderFinishDTO orderFinishDTO) {
+        //更新mongodb
+        SckwLogisticsOrder lOrder = new SckwLogisticsOrder();
+        lOrder.set_id(logisticsOrder.getId());
+        lOrder.setLOrderId(logisticsOrder.getId());
+        lOrder.setStatus(LogisticsOrderEnum.HAVE_FINISHED.getStatus());
+        lOrder.setUpdateTime(new Date());
+        lOrder.setUpdateBy(LoginUserHolder.getUserId());
+        lOrder.setUpdateByName(LoginUserHolder.getUserName());
+        lOrder.setTotalLoadAmount(orderFinishDTO.getLoadAmount());
+        lOrder.setTotalUnloadAmount(orderFinishDTO.getUnloadAmount());
+        //rabbitMq业务汇总数据发送/消费对象
+        SckwBusSum busSum = new SckwBusSum();
+        //业务汇总类型
+        busSum.setBusSumType(BusinessTypeEnum.LOGISTICS_ORDER_TYPE.getName());
+        //操作对象（1新增/2修改/3替换数据）
+        busSum.setMethod(2);
+        //业务汇总数据对象
+        busSum.setObject(lOrder);
+        busSum.setBusSumType(BusinessTypeEnum.LOGISTICS_ORDER_TYPE.getName());
+        busSum.setMethod(NumberConstant.TWO);
+        streamBridge.send("sckw-busSum", JSON.toJSONString(busSum));
+    }
+
+    private void lllll(List<Map<String, Object>> list) {
+        if (!org.springframework.util.CollectionUtils.isEmpty(list) && list.size() > 0) {
+            //倒序排序
+//                List<Map<String, Object>> maps = ListUtils.sortMapListByFeild(list, "level", "desc");
+            int level = list.stream().mapToInt(m -> (Integer) m.getOrDefault("level", Long.MAX_VALUE)).max().getAsInt();
+            List<Long> ids = new ArrayList<>();
+            for (int i = level; i > 0; i--) {
+                for (Map<String, Object> map : list) {
+                    if (CollectionUtils.isEmpty(list)) {
+                        continue;
+                    }
+                    if (String.valueOf(i).equals(String.valueOf(map.get("level")))) {
+                        List<KwtLogisticsOrder> orderList = kwtLogisticsOrderMapper.selectList(new LambdaQueryWrapper<KwtLogisticsOrder>()
+                                .eq(KwtLogisticsOrder::getId, map.get("id"))
+                        );
+                        if (CollectionUtils.isNotEmpty(orderList)) {
+                            //操作最底层数据，溯源父级
+                            for (KwtLogisticsOrder kwtLogisticsOrder : orderList) {
+                                BigDecimal entrustAmount = kwtLogisticsOrder.getEntrustAmount();
+                                BigDecimal subcontractAmount = kwtLogisticsOrder.getSubcontractAmount();
+                                BigDecimal amount = kwtLogisticsOrder.getAmount();
+                                BigDecimal loadAmount = kwtLogisticsOrder.getLoadAmount();
+                                BigDecimal unloadAmount = kwtLogisticsOrder.getUnloadAmount();
+                                //剩余未完成的量
+                                BigDecimal subtract = amount.subtract(loadAmount);
+                                //最底下根节点-获取父级
+                                if (kwtLogisticsOrder.getPid() == null && kwtLogisticsOrder.getPids().equals(String.valueOf(kwtLogisticsOrder.getId()))) {
+                                    //代表是一级
+                                    //todo 当前不做操作
+                                } else {
+                                    KwtLogisticsOrder selectOne = kwtLogisticsOrderMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrder>()
+                                            .eq(KwtLogisticsOrder::getId, kwtLogisticsOrder.getPid())
+                                    );
+                                    kwtLogisticsOrderMapper.update(null, new LambdaUpdateWrapper<KwtLogisticsOrder>()
+                                            .eq(KwtLogisticsOrder::getId, selectOne.getId())
+                                            .set(KwtLogisticsOrder::getEntrustAmount, selectOne.getEntrustAmount().add(subtract))
+                                            .set(KwtLogisticsOrder::getSubcontractAmount, selectOne.getSubcontractAmount().subtract(subtract))
+                                    );
+                                }
+                                ids.add(kwtLogisticsOrder.getId());
+                            }
                         }
-                        return LogisticsOrder;
-                    })
-                    .collect(Collectors.toList());
-            Map<Long, List<KwtLogisticsOrder>> groupByParentIdMap = list.stream().collect(Collectors.groupingBy(KwtLogisticsOrder::getPid));
-            //存放:对应的当前节点ID数据
-            Set<Long> topToLowerChildIdSet = new HashSet<>();
-            // 取出顶级数据(也就是父级ID为0的数据  父级ID也可以自定义 当前赋值0L)
-            List<KwtLogisticsOrder> topTreeNodes = groupByParentIdMap.get(0L);
-            if (CollectionUtils.isEmpty(topTreeNodes)) {
-                /**当前传输的代表不是一级 可能是二级或者三级
-                 topTreeNodes = groupByParentIdMap.get(Long.parseLong(id));*/
-                getMinimumChildIdArray(groupByParentIdMap, Long.parseLong(id), topToLowerChildIdSet);
-                System.out.println("当前节点【" + id + "】节点下所有的根节点数据集合:" + topToLowerChildIdSet.toString());
-            } else {
-                for (KwtLogisticsOrder node : topTreeNodes) {
-                    getMinimumChildIdArray(groupByParentIdMap, node.getId(), topToLowerChildIdSet);
+                    } else {
+                        if (!ObjectUtils.isEmpty(map.get(String.valueOf(i)))) {
+                            List<KwtLogisticsOrder> orderList = kwtLogisticsOrderMapper.selectList(new LambdaQueryWrapper<KwtLogisticsOrder>()
+                                    .eq(KwtLogisticsOrder::getId, Long.parseLong((String) map.get("id")))
+                            );
+                            if (CollectionUtils.isNotEmpty(orderList)) {
+                                for (KwtLogisticsOrder kwtLogisticsOrder : orderList) {
+                                    Map<String, Object> maps = new HashMap<>(NumberConstant.SIXTEEN);
+                                    List<Object> collect = list.stream().map(item -> item.get("level")).collect(Collectors.toList());
+                                    if (!collect.contains(kwtLogisticsOrder.getId())) {
+                                        maps.put("level", level);
+                                        maps.put("id", kwtLogisticsOrder.getId());
+                                        list.add(maps);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                Iterator<Map<String, Object>> iterator = list.iterator();
+                while (iterator.hasNext()) {
+                    Map<String, Object> next = iterator.next();
+                    String key = String.valueOf(next.get(("id")));
+                    for (Long id : ids) {
+                        if (key.equals(String.valueOf(id))) {
+                            iterator.remove();
+                        }
+                    }
                 }
-                System.out.println("0节点(传输为一级)下所有的根节点数据集合:" + topToLowerChildIdSet.toString());
             }
-            //处理当前传递的id下  全部完结需要改的量
-            BigDecimal decimals = new BigDecimal("0.00");
-            BigDecimal decimal = judgmentOrderFinish(id, topToLowerChildIdSet, decimals,logisticsOrder);
-            //返回给贸易订单实际装卸货量
-            Map map = countOrderNumber(logisticsOrder.getTOrderId());
-            //修改单据状态
-//            updateLogisticOrderStatus(id,orderFinishDTO);
-        } else {
-            //不存在子集
-            /**
-             * 验证是否存在进行中的车辆运单
-             * 统计当前物流订单的 分配量/实装量/实卸量
-             * 验证当前贸易订单是否存在进行中的物流运单
-             * */
-            judgmentLogisticsOrderIsFinish(logisticsOrder);
+            lllll(list);
         }
     }
 
+
     private Map countOrderNumber(Long tOrderId) {
         Map<String, BigDecimal> map = new HashMap<>();
         BigDecimal loadAmountTotal = new BigDecimal("0.00");
@@ -1100,29 +1307,19 @@ public class LogisticsConsignmentService {
         return map;
     }
 
-    private void updateLogisticOrderStatus(String id, OrderFinishDTO orderFinishDTO) {
-        /**完结订单-对应物流订单下子订单都要进行完结*/
-        List<KwtLogisticsOrder> kwtLogisticsOrders = kwtLogisticsOrderMapper.selectList(new LambdaQueryWrapper<KwtLogisticsOrder>()
-                .eq(KwtLogisticsOrder::getDelFlag, NumberConstant.ZERO)
-                .apply(id != null, "FIND_IN_SET ('" + id + "', pids)"));
-        for (KwtLogisticsOrder kwtLogisticsOrder : kwtLogisticsOrders) {
-            updateLogisticOrderAndTrack(kwtLogisticsOrder.getId(), orderFinishDTO);
-        }
-    }
-
     /**
      * 处理当前传递的id下  全部完结
      *
      * @param id                   当前完结物流订单传递id
      * @param topToLowerChildIdSet 当前传递的下的最末一级的物流订单主键id
-     * @param  logisticsOrder 本省物流订单
+     * @param logisticsOrder       本身物流订单
      */
-    private BigDecimal judgmentOrderFinish(String id, Set<Long> topToLowerChildIdSet, BigDecimal amount,KwtLogisticsOrder logisticsOrder) {
-        //代表是否是子订单都已经完结，需要完结父订单状态
+    private BigDecimal judgmentOrderFinish(String id, Set<Long> topToLowerChildIdSet, BigDecimal amount, KwtLogisticsOrder logisticsOrder) {
         if (CollectionUtils.isNotEmpty(topToLowerChildIdSet)) {
             List<KwtLogisticsOrder> kwtLogisticsOrderList = kwtLogisticsOrderMapper.selectList(new LambdaQueryWrapper<KwtLogisticsOrder>()
                     .in(KwtLogisticsOrder::getId, topToLowerChildIdSet)
             );
+            List<KwtLogisticsOrder> logisticsOrders = new ArrayList<>();
             if (CollectionUtils.isNotEmpty(kwtLogisticsOrderList)) {
                 for (KwtLogisticsOrder kwtLogisticsOrder : kwtLogisticsOrderList) {
                     BigDecimal entrustAmount = kwtLogisticsOrder.getEntrustAmount();
@@ -1140,37 +1337,22 @@ public class LogisticsConsignmentService {
                                 .set(KwtLogisticsOrder::getSubcontractAmount, selectOne.getSubcontractAmount().subtract(kwtLogisticsOrder.getSubcontractAmount()))
                         );
                     } else {
-                        continue;
+                        logisticsOrders.add(kwtLogisticsOrder);
                     }
                 }
             }
-        }
-        return amount;
-    }
 
-    private void ssssssss(String id, KwtLogisticsOrder kwtLogisticsOrder, BigDecimal amount) {
-        String pid = String.valueOf(kwtLogisticsOrder.getPid());
-        Long lOrderId = kwtLogisticsOrder.getId();
-        BigDecimal amount1 = kwtLogisticsOrder.getAmount();
-        BigDecimal entrustAmount = kwtLogisticsOrder.getEntrustAmount();
-        BigDecimal subcontractAmount = kwtLogisticsOrder.getSubcontractAmount();
-        BigDecimal subtract = amount1.subtract(entrustAmount.add(subcontractAmount));
-        amount = amount.add(subtract);
-        KwtLogisticsOrder logisticsOrder = kwtLogisticsOrderMapper.selectOne(new LambdaQueryWrapper<KwtLogisticsOrder>()
-                .eq(KwtLogisticsOrder::getId, lOrderId)
-        );
-        if (!id.equals(pid)) {
-            id = String.valueOf(lOrderId);
-            ssssssss(id, kwtLogisticsOrder, amount);
         }
+        return amount;
     }
 
 
-    private void updateLogisticOrderAndTrack(Long lOrderId, OrderFinishDTO orderFinishDTO) {
+    private void updateLogisticOrderAndTrack(Long lOrderId, OrderFinishDTO orderFinishDTO, BigDecimal ignoreAmount) {
         Integer code = LogisticsOrderEnum.HAVE_FINISHED.getCode();
         kwtLogisticsOrderMapper.update(null, new LambdaUpdateWrapper<KwtLogisticsOrder>()
                 .set(KwtLogisticsOrder::getStatus, code)
                 .set(KwtLogisticsOrder::getUpdateBy, LoginUserHolder.getUserId())
+                .set(KwtLogisticsOrder::getIgnoreAmount, ignoreAmount)
                 .set(KwtLogisticsOrder::getUpdateTime, new Date())
                 .eq(KwtLogisticsOrder::getId, lOrderId)
         );
@@ -1181,6 +1363,8 @@ public class LogisticsConsignmentService {
             kwtLogisticsOrderTrackMapper.update(null, new LambdaUpdateWrapper<KwtLogisticsOrderTrack>()
                     .set(KwtLogisticsOrderTrack::getUpdateBy, LoginUserHolder.getUserId())
                     .set(KwtLogisticsOrderTrack::getUpdateTime, new Date())
+                    .set(KwtLogisticsOrderTrack::getRemark, orderFinishDTO.getRemark())
+                    .eq(KwtLogisticsOrderTrack::getId, track.getId())
             );
         } else {
             KwtLogisticsOrderTrack orderTrack = new KwtLogisticsOrderTrack();

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

@@ -10,6 +10,9 @@
         <result column="l_order_no" jdbcType="VARCHAR" property="lOrderNo"/>
         <result column="pid" jdbcType="BIGINT" property="pid"/>
         <result column="pids" jdbcType="VARCHAR" property="pids"/>
+        <result column="level" jdbcType="VARCHAR" property="level"/>
+        <result column="total_load_amount" jdbcType="VARCHAR" property="totalLoadAmount"/>
+        <result column="total_unload_amount" jdbcType="VARCHAR" property="totalUnloadAmount"/>
         <result column="settlement_cycle" jdbcType="BIGINT" property="settlementCycle"/>
         <result column="billing_mode" jdbcType="BIGINT" property="billingMode"/>
         <result column="price" jdbcType="DECIMAL" property="price"/>
@@ -41,7 +44,7 @@
     </resultMap>
     <sql id="Base_Column_List">
         id
-        , ent_id, t_order_id,type, t_order_no, l_order_no, pid,pids, settlement_cycle, price, price_type,billing_mode,
+        , ent_id, t_order_id,type,level,total_load_amount,total_unload_amount, t_order_no, l_order_no, pid,pids, settlement_cycle, price, price_type,billing_mode,
     amount, unit, loss, loss_unit, goods_price, goods_price_unit, start_time, end_time,
     subcontract_amount, entrust_amount, unload_amount, load_amount, ignore_amount, deficit_amount,
     deficit_price, payment, tax_rate, remark, `status`, create_by, create_time, update_by,