租车订单统计

ace-common/src/main/java/com/github/wxiaoqi/security/common/enumconstant/LevelEnum.java

 package com.github.wxiaoqi.security.common.enumconstant;
 
+import java.util.EnumSet;
+import java.util.Map;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
 /**
  * @author libin
  * @version 1.0
@@ -16,8 +21,18 @@ public enum LevelEnum {
         this.desc = desc;
     }
 
+
+    public static LevelEnum getLevelEnumByLevel(Integer level){
+        return levelMap.get(level);
+    }
+
     private Integer level;
     private String desc;
+    private static  Map<Integer, LevelEnum> levelMap;
+
+    static {
+        levelMap = EnumSet.allOf(LevelEnum.class).stream().collect(Collectors.toMap(LevelEnum::getLevel, Function.identity()));
+    }
 
     public Integer getLevel() {
         return level;

xx-order/xx-order-api/src/main/java/com/xxfc/platform/order/pojo/dto/OrderDTO.java

 package com.xxfc.platform.order.pojo.dto;
 
+import com.github.wxiaoqi.security.common.enumconstant.LevelEnum;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
@@ -35,4 +36,11 @@ public class OrderDTO {
      */
     private Integer memberLevel;
 
+    private LevelEnum levelEnum;
+
+
+    public LevelEnum getLevelEnum(){
+        return LevelEnum.getLevelEnumByLevel(this.memberLevel);
+    }
+
 }

xx-order/xx-order-server/src/main/java/com/xxfc/platform/order/biz/OrderMemberReceivedStatisticsBiz.java

 package com.xxfc.platform.order.biz;
 
-import cn.hutool.core.date.DateTime;
-import cn.hutool.core.date.DateUtil;
 import cn.hutool.core.util.ObjectUtil;
 import com.github.wxiaoqi.security.common.biz.BaseBiz;
 import com.github.wxiaoqi.security.common.enumconstant.LevelEnum;
@@ -34,54 +32,59 @@ import java.util.stream.Collectors;
 public class OrderMemberReceivedStatisticsBiz extends BaseBiz<OrderMemberReceivedStatisticsMapper, OrderMemberReceivedStatistics> {
     private final BaseOrderBiz baseOrderBiz;
 
+    /**
+     * 会员统计查询
+     *
+     * @param orderReceivedStatisticsFindDTO
+     * @return
+     */
     public List<OrderMemberReceivedStatistics> selectOrderReceivedStatistics(OrderReceivedStatisticsFindDTO orderReceivedStatisticsFindDTO) {
         return mapper.selectOrderMemberReceivedStatistics(orderReceivedStatisticsFindDTO);
     }
 
-    public void orderMemberReceivedStatistics(Date date) {
+    /**
+     * 会员统计处理
+     *
+     * @param startDate  开始时间
+     * @param endDate  结束时间
+     */
+    public void orderMemberReceivedStatistics(Date startDate, Date endDate) {
         List<OrderMemberReceivedStatistics> orderMemberReceivedStatisticsList = new ArrayList<>(18);
-        DateTime yesterday = DateUtil.yesterday();
-        Date startDate = date == null ? DateUtil.beginOfDay(yesterday).toJdkDate() : DateUtil.beginOfDay(date);
-        Date endDate = date == null ? DateUtil.endOfDay(yesterday).toJdkDate() : DateUtil.endOfDay(date);
+
+        //根据时间范围查询出会员单
         List<OrderDTO> orders = baseOrderBiz.selectOrdersByTypeAndTime(Arrays.asList(StatisticsStatusEnum.ORDER_TOUR_TYPE), startDate, endDate);
 
-        //数据处理 把 完成状态6 取消状态2 的其他数据转换成状态为未完成3
-        Map<String, Map<Integer, List<OrderDTO>>> ordersMap = orders.stream().peek(x -> {
-            x.setStateGroup(String.format("%d-%d-%d-%d", StatisticsStatusEnum.DEFAULT_COMPANY, x.getOrderOrigin(), x.getPayWay()==null?StatisticsStatusEnum.NO_PAY_WAY:x.getPayWay(),x.getHasPay()));
-        }).collect(Collectors.groupingBy(OrderDTO::getStateGroup, Collectors.groupingBy(OrderDTO::getMemberLevel, Collectors.toList())));
+        //数据处理 把状态组合
+        Map<String, Map<LevelEnum, List<OrderDTO>>> ordersMap = orders.stream().peek(x -> {
+            x.setStateGroup(String.format("%d-%d-%d-%d", StatisticsStatusEnum.DEFAULT_COMPANY, x.getOrderOrigin(), x.getPayWay() == null ? StatisticsStatusEnum.NO_PAY_WAY : x.getPayWay(), x.getHasPay()));
+        }).collect(Collectors.groupingBy(OrderDTO::getStateGroup, Collectors.groupingBy(OrderDTO::getLevelEnum, Collectors.toList())));
 
         if (!ordersMap.isEmpty()) {
-            Set<Map.Entry<String, Map<Integer, List<OrderDTO>>>> orderSet = ordersMap.entrySet();
-            for (Map.Entry<String, Map<Integer, List<OrderDTO>>> orderEntry : orderSet) {
+            Set<Map.Entry<String, Map<LevelEnum, List<OrderDTO>>>> orderSet = ordersMap.entrySet();
+            for (Map.Entry<String, Map<LevelEnum, List<OrderDTO>>> orderEntry : orderSet) {
                 //获取状态
                 String orderStatisticsGroup = orderEntry.getKey();
-                Map<Integer, List<OrderDTO>> orderEntryValue = orderEntry.getValue();
+                Map<LevelEnum, List<OrderDTO>> orderEntryValue = orderEntry.getValue();
+                //创建会员统计对象
                 OrderMemberReceivedStatistics orderMemberReceivedStatistics = StatisticsStatusEnum.wrapStatisticsObject(startDate, orderStatisticsGroup, new OrderMemberReceivedStatistics());
-                //1.普通会员
-                List<OrderDTO> generalOrders = orderEntryValue.get(LevelEnum.GENERAL.getLevel());
-                generalOrders = CollectionUtils.isEmpty(generalOrders) ? Collections.EMPTY_LIST : generalOrders;
-                BigDecimal totalCommAmount = generalOrders.stream().map(OrderDTO::getRealAmount).reduce(BigDecimal.ZERO, (x, y) -> x.add(y));
-                orderMemberReceivedStatistics.setToalCommonAmmount(totalCommAmount);
-                orderMemberReceivedStatistics.setTotalCommonQuantity(generalOrders.size());
-
-                //2.黄金会员
-                List<OrderDTO> goldOrders = orderEntryValue.get(LevelEnum.GOLD.getLevel());
-                goldOrders = CollectionUtils.isEmpty(goldOrders) ? Collections.EMPTY_LIST : goldOrders;
-                BigDecimal totalGoldAmount = goldOrders.stream().map(OrderDTO::getRealAmount).reduce(BigDecimal.ZERO, (x, y) -> x.add(y));
-                orderMemberReceivedStatistics.setTotalGoldAmount(totalGoldAmount);
-                orderMemberReceivedStatistics.setTotalGoldQuantity(goldOrders.size());
+                //等级金额 和量 的计算
+                Set<Map.Entry<LevelEnum, List<OrderDTO>>> memberOrdersSet = orderEntryValue.entrySet();
+                for (Map.Entry<LevelEnum, List<OrderDTO>> levelEnumListEntry : memberOrdersSet) {
+                    orderMemberReceivedStatistics = wrapOrderMemberReceivedStatistics(levelEnumListEntry.getValue(), levelEnumListEntry.getKey(), orderMemberReceivedStatistics);
+                }
+                //总金额
+                BigDecimal totalAmount = orderMemberReceivedStatistics.getToalCommonAmmount()
+                        .add(orderMemberReceivedStatistics.getTotalGoldAmount())
+                        .add(orderMemberReceivedStatistics.getTotalDiamondAmmount());
 
-                //3.钻石会员
-                List<OrderDTO> diamondOrders = orderEntryValue.get(LevelEnum.DIAMOND.getLevel());
-                diamondOrders = CollectionUtils.isEmpty(diamondOrders) ? Collections.EMPTY_LIST : diamondOrders;
-                BigDecimal totalDiamondAmount = diamondOrders.stream().map(OrderDTO::getRealAmount).reduce(BigDecimal.ZERO, (x, y) -> x.add(y));
-                orderMemberReceivedStatistics.setTotalDiamondAmmount(totalDiamondAmount);
-                orderMemberReceivedStatistics.setTotalDiamondQuantity(diamondOrders.size());
+                //总量
+                Integer totalQuantity = orderMemberReceivedStatistics.getTotalCommonQuantity() +
+                        orderMemberReceivedStatistics.getTotalGoldQuantity() +
+                        orderMemberReceivedStatistics.getTotalDiamondQuantity();
 
-                BigDecimal totalAmount = totalCommAmount.add(totalGoldAmount).add(totalDiamondAmount);
-                Integer totalQuantity = orderMemberReceivedStatistics.getTotalCommonQuantity() + orderMemberReceivedStatistics.getTotalGoldQuantity() + orderMemberReceivedStatistics.getTotalDiamondQuantity();
                 orderMemberReceivedStatistics.setTotalQuantity(totalQuantity);
                 orderMemberReceivedStatistics.setTotalAmount(totalAmount);
+
                 orderMemberReceivedStatisticsList.add(orderMemberReceivedStatistics);
             }
         }
@@ -93,33 +96,78 @@ public class OrderMemberReceivedStatisticsBiz extends BaseBiz<OrderMemberReceive
         insertMemberReceivedStatisticsBatch(orderMemberReceivedStatisticsList);
     }
 
+    /**
+     * @param orders 某种状态下的会员单
+     * @param levelEnum 会员等级
+     * @param orderMemberReceivedStatistics 会员统计对象
+     * @return
+     */
+    private OrderMemberReceivedStatistics wrapOrderMemberReceivedStatistics(List<OrderDTO> orders, LevelEnum levelEnum, OrderMemberReceivedStatistics orderMemberReceivedStatistics) {
+        orders = CollectionUtils.isEmpty(orders) ? Collections.EMPTY_LIST : orders;
+        BigDecimal totalAmount = orders.stream().map(OrderDTO::getRealAmount).reduce(BigDecimal.ZERO, (x, y) -> x.add(y));
+        switch (levelEnum) {
+            case GENERAL:
+                orderMemberReceivedStatistics.setToalCommonAmmount(totalAmount);
+                orderMemberReceivedStatistics.setTotalCommonQuantity(orders.size());
+                break;
+            case GOLD:
+                orderMemberReceivedStatistics.setTotalGoldAmount(totalAmount);
+                orderMemberReceivedStatistics.setTotalGoldQuantity(orders.size());
+                break;
+            case DIAMOND:
+                orderMemberReceivedStatistics.setTotalDiamondAmmount(totalAmount);
+                orderMemberReceivedStatistics.setTotalDiamondQuantity(orders.size());
+                break;
+            default:
+                break;
+        }
+        return orderMemberReceivedStatistics;
+    }
+
     /**
      * 创建剩余状态数据
      *
-     * @param startDate
-     * @param statisticsStateGroups
-     * @param companyId
+     * @param startDate  时间
+     * @param statisticsStateGroups 状态组合 集合
+     * @param companyId  公司 id
      * @return
      */
     private List<OrderMemberReceivedStatistics> createOtherStatisticsStateGroupList(Date startDate, List<String> statisticsStateGroups, Integer companyId) {
         List<OrderMemberReceivedStatistics> orderMemberReceivedStatisticsList = new ArrayList<>();
-        OrderMemberReceivedStatistics orderMemberReceivedStatistics;
+        //获取剩余状态组合
         List<String> otherStatisticsStateGroup = StatisticsStatusEnum.getOtherStatisticsStateGroup(Arrays.asList(companyId), statisticsStateGroups);
-        OrderMemberReceivedStatistics orderMemberReceivedStatisticsClone = new OrderMemberReceivedStatistics();
-        for (String stateGroup : otherStatisticsStateGroup) {
-            orderMemberReceivedStatistics = StatisticsStatusEnum.wrapStatisticsObject(startDate, stateGroup, ObjectUtil.cloneByStream(orderMemberReceivedStatisticsClone));
-            orderMemberReceivedStatistics.setTotalAmount(BigDecimal.ZERO);
-            orderMemberReceivedStatistics.setTotalCommonQuantity(0);
-            orderMemberReceivedStatistics.setToalCommonAmmount(BigDecimal.ZERO);
-            orderMemberReceivedStatistics.setTotalGoldQuantity(0);
-            orderMemberReceivedStatistics.setTotalGoldAmount(BigDecimal.ZERO);
-            orderMemberReceivedStatistics.setTotalDiamondQuantity(0);
-            orderMemberReceivedStatistics.setTotalDiamondAmmount(BigDecimal.ZERO);
-            orderMemberReceivedStatisticsList.add(orderMemberReceivedStatistics);
-        }
+        //创建会员克隆统计对象
+        OrderMemberReceivedStatistics orderMemberReceivedStatistics = createDefaultOrderMemberReceivedStatistics();
+        //统计对象的生成
+        otherStatisticsStateGroup.parallelStream().peek(stateGroup -> {
+            OrderMemberReceivedStatistics orderMemberReceivedStatisticsClone = StatisticsStatusEnum.wrapStatisticsObject(startDate, stateGroup, ObjectUtil.cloneByStream(orderMemberReceivedStatistics));
+            orderMemberReceivedStatisticsList.add(orderMemberReceivedStatisticsClone);
+        }).count();
         return orderMemberReceivedStatisticsList;
     }
 
+    /**
+     * 创建默认的会员订单统计对象
+     *
+     * @return
+     */
+    private OrderMemberReceivedStatistics createDefaultOrderMemberReceivedStatistics() {
+        OrderMemberReceivedStatistics orderMemberReceivedStatistics = new OrderMemberReceivedStatistics();
+        orderMemberReceivedStatistics.setTotalAmount(BigDecimal.ZERO);
+        orderMemberReceivedStatistics.setTotalCommonQuantity(0);
+        orderMemberReceivedStatistics.setToalCommonAmmount(BigDecimal.ZERO);
+        orderMemberReceivedStatistics.setTotalGoldQuantity(0);
+        orderMemberReceivedStatistics.setTotalGoldAmount(BigDecimal.ZERO);
+        orderMemberReceivedStatistics.setTotalDiamondQuantity(0);
+        orderMemberReceivedStatistics.setTotalDiamondAmmount(BigDecimal.ZERO);
+        return orderMemberReceivedStatistics;
+    }
+
+    /**
+     * 批量插入
+     *
+     * @param orderMemberReceivedStatistics
+     */
     public void insertMemberReceivedStatisticsBatch(List<OrderMemberReceivedStatistics> orderMemberReceivedStatistics) {
         mapper.insertList(orderMemberReceivedStatistics);
     }

xx-order/xx-order-server/src/main/java/com/xxfc/platform/order/biz/OrderReceivedStatisticsBiz.java

@@ -60,88 +60,88 @@ public class OrderReceivedStatisticsBiz extends BaseBiz<OrderReceivedStatisticsM
         XSSFWorkbook workbook = new XSSFWorkbook();
         Sheet sheet = workbook.createSheet("订单统计");
         Row headerRow = sheet.createRow(0);
-         //标题样式
+        //标题样式
         CellStyle headerCellStyle = createCellStyle(workbook, true);
         //创建标题
-        createHeader(headerRow,headerCellStyle,orderReceivedStatisticsFindDTO.getStatisticalSigns());
+        createHeader(headerRow, headerCellStyle, orderReceivedStatisticsFindDTO.getStatisticalSigns());
         //创建数据样式
         CellStyle dataCellStyle = createCellStyle(workbook, false);
-        createData(orderReceivedStatisticsResult,orderReceivedStatisticsFindDTO.getStatisticalWay(),orderReceivedStatisticsFindDTO.getStatisticalSigns(),sheet,1,dataCellStyle);
+        createData(orderReceivedStatisticsResult, orderReceivedStatisticsFindDTO.getStatisticalWay(), orderReceivedStatisticsFindDTO.getStatisticalSigns(), sheet, 1, dataCellStyle);
         workbook.write(outputStream);
         workbook.close();
     }
 
-    private void createData(Map<String,List<OrderReceivedStatisticsVo>> data,Integer statisticalWay, List<String> signs,Sheet sheet,int rowIndex,CellStyle cellStyle){
-          //自然排序
+    private void createData(Map<String, List<OrderReceivedStatisticsVo>> data, Integer statisticalWay, List<String> signs, Sheet sheet, int rowIndex, CellStyle cellStyle) {
+        //自然排序
         Collections.sort(signs);
         int size = data.get(signs.get(0)).size();
-        for(int i=0;i<size;i++){
-           Row dataRow = sheet.createRow(rowIndex++);
-           Cell firstCell = dataRow.createCell(0);
-           firstCell.setCellStyle(cellStyle);
-           for (int cellIndex=1;cellIndex<=signs.size();cellIndex++) {
-               Cell dataCell = dataRow.createCell(cellIndex);
-               dataCell.setCellStyle(cellStyle);
-               String sign = signs.get(cellIndex-1);
-               List<OrderReceivedStatisticsVo> orderReceivedStatisticsVos = data.get(sign);
-               if (CollectionUtils.isEmpty(orderReceivedStatisticsVos) || i>orderReceivedStatisticsVos.size()){
-                   continue;
-               }
-               OrderReceivedStatisticsVo orderReceivedStatisticsVo = orderReceivedStatisticsVos.get(i);
-               if (sign.endsWith("q")){
-                   dataCell.setCellValue(String.valueOf(orderReceivedStatisticsVo.getOrderNum()));
-               }
-               if (sign.endsWith("a")){
-                   dataCell.setCellValue(String.valueOf(orderReceivedStatisticsVo.getOrderAmount()));
-               }
-               if (cellIndex ==1){
-                     if (ReceivedStatisticsEnum.DAY.getWayCode()==statisticalWay){
-                         firstCell.setCellValue(DateUtil.format(orderReceivedStatisticsVo.getDate(),"yyyy.MM.dd"));
-                     }
-                     if (ReceivedStatisticsEnum.WEEK.getWayCode()==statisticalWay){
-                         LocalDate localDate = LocalDate.of(Integer.valueOf(orderReceivedStatisticsVo.getYear()), Integer.valueOf(orderReceivedStatisticsVo.getMonth().replace(orderReceivedStatisticsVo.getYear(), "")), 1);
-                         int dayOfYear = localDate.getDayOfYear();
-                         int days = Integer.valueOf(orderReceivedStatisticsVo.getWeekOfYear().replace(orderReceivedStatisticsVo.getYear(),""))*7;
-                         int betweenDays = days - dayOfYear;
-                         LocalDate endLocalDate = localDate.withDayOfMonth(betweenDays);
-                         LocalDate startLocalDate = endLocalDate.minusDays(6);
-                         String startDateStr = startLocalDate.format(dateTimeFormatter);
-                         String endDateStr = endLocalDate.format(dateTimeFormatter);
-                         firstCell.setCellValue(String.format("%s~%s",startDateStr,endDateStr));
-                     }
-                     if (ReceivedStatisticsEnum.MONTH.getWayCode()==statisticalWay){
-                         StringBuilder sb = new StringBuilder(orderReceivedStatisticsVo.getMonth());
-                         sb.insert(4,".");
-                       firstCell.setCellValue(sb.toString());
-                     }
-               }
-           }
-       }
+        for (int i = 0; i < size; i++) {
+            Row dataRow = sheet.createRow(rowIndex++);
+            Cell firstCell = dataRow.createCell(0);
+            firstCell.setCellStyle(cellStyle);
+            for (int cellIndex = 1; cellIndex <= signs.size(); cellIndex++) {
+                Cell dataCell = dataRow.createCell(cellIndex);
+                dataCell.setCellStyle(cellStyle);
+                String sign = signs.get(cellIndex - 1);
+                List<OrderReceivedStatisticsVo> orderReceivedStatisticsVos = data.get(sign);
+                if (CollectionUtils.isEmpty(orderReceivedStatisticsVos) || i > orderReceivedStatisticsVos.size()) {
+                    continue;
+                }
+                OrderReceivedStatisticsVo orderReceivedStatisticsVo = orderReceivedStatisticsVos.get(i);
+                if (sign.endsWith("q")) {
+                    dataCell.setCellValue(String.valueOf(orderReceivedStatisticsVo.getOrderNum()));
+                }
+                if (sign.endsWith("a")) {
+                    dataCell.setCellValue(String.valueOf(orderReceivedStatisticsVo.getOrderAmount()));
+                }
+                if (cellIndex == 1) {
+                    if (ReceivedStatisticsEnum.DAY.getWayCode() == statisticalWay) {
+                        firstCell.setCellValue(DateUtil.format(orderReceivedStatisticsVo.getDate(), "yyyy.MM.dd"));
+                    }
+                    if (ReceivedStatisticsEnum.WEEK.getWayCode() == statisticalWay) {
+                        LocalDate localDate = LocalDate.of(Integer.valueOf(orderReceivedStatisticsVo.getYear()), Integer.valueOf(orderReceivedStatisticsVo.getMonth().replace(orderReceivedStatisticsVo.getYear(), "")), 1);
+                        int dayOfYear = localDate.getDayOfYear();
+                        int days = Integer.valueOf(orderReceivedStatisticsVo.getWeekOfYear().replace(orderReceivedStatisticsVo.getYear(), "")) * 7;
+                        int betweenDays = days - dayOfYear;
+                        LocalDate endLocalDate = localDate.withDayOfMonth(betweenDays);
+                        LocalDate startLocalDate = endLocalDate.minusDays(6);
+                        String startDateStr = startLocalDate.format(dateTimeFormatter);
+                        String endDateStr = endLocalDate.format(dateTimeFormatter);
+                        firstCell.setCellValue(String.format("%s~%s", startDateStr, endDateStr));
+                    }
+                    if (ReceivedStatisticsEnum.MONTH.getWayCode() == statisticalWay) {
+                        StringBuilder sb = new StringBuilder(orderReceivedStatisticsVo.getMonth());
+                        sb.insert(4, ".");
+                        firstCell.setCellValue(sb.toString());
+                    }
+                }
+            }
+        }
     }
 
-    private void createHeader(Row row, CellStyle cellStyle,List<String> signs){
-         //自然排序
-         Collections.sort(signs);
+    private void createHeader(Row row, CellStyle cellStyle, List<String> signs) {
+        //自然排序
+        Collections.sort(signs);
         Cell firstCell = row.createCell(0);
-         firstCell.setCellValue("时间");
-         firstCell.setCellStyle(cellStyle);
-        for (int i = 1; i <=signs.size(); i++) {
+        firstCell.setCellValue("时间");
+        firstCell.setCellStyle(cellStyle);
+        for (int i = 1; i <= signs.size(); i++) {
             Cell cell = row.createCell(i);
-            cell.setCellValue(signAndDescMap.get(signs.get(i-1)));
+            cell.setCellValue(signAndDescMap.get(signs.get(i - 1)));
             cell.setCellStyle(cellStyle);
         }
     }
 
-    private CellStyle createCellStyle(Workbook workbook,boolean bold){
+    private CellStyle createCellStyle(Workbook workbook, boolean bold) {
         CellStyle cellStyle = workbook.createCellStyle();
-        Font font = createFont(workbook,bold);
+        Font font = createFont(workbook, bold);
         cellStyle.setFont(font);
         cellStyle.setVerticalAlignment(VerticalAlignment.CENTER);
         cellStyle.setAlignment(HorizontalAlignment.CENTER);
         return cellStyle;
     }
 
-    private Font createFont(Workbook workbook,boolean bold){
+    private Font createFont(Workbook workbook, boolean bold) {
         Font font = workbook.createFont();
         font.setFontName("黑体");
         font.setBold(bold);
@@ -160,53 +160,107 @@ public class OrderReceivedStatisticsBiz extends BaseBiz<OrderReceivedStatisticsM
         List<String> statisticalSigns = orderReceivedStatisticsFindDTO.getStatisticalSigns();
 
         //订单统计
+        Map<String, List<OrderReceivedStatisticsVo>> orderReceivedStatisticsMap = orderReceivedStatistics(orderReceivedStatisticsFindDTO, statisticalSigns);
+
+        //租车订单统计
+        Map<String, List<OrderReceivedStatisticsVo>> orderRentVehicleReceivedStatisticsMap = orderRentVehicleRceicedStatistics(orderReceivedStatisticsFindDTO, statisticalSigns);
+
+        //旅游订单统计
+        Map<String, List<OrderReceivedStatisticsVo>> orderTourReceivedStatisticsMap = orderTourReceivedStatistcs(orderReceivedStatisticsFindDTO, statisticalSigns);
+
+        //会员订单统计
+        Map<String, List<OrderReceivedStatisticsVo>> orderMemberReceivedStatisticsMap = orderMemberReceivedStatistics(orderReceivedStatisticsFindDTO, statisticalSigns);
+
+        resultMap.putAll(orderReceivedStatisticsMap);
+        resultMap.putAll(orderRentVehicleReceivedStatisticsMap);
+        resultMap.putAll(orderTourReceivedStatisticsMap);
+        resultMap.putAll(orderMemberReceivedStatisticsMap);
+        return resultMap;
+    }
+
+
+    /**
+     * 订单统计
+     *
+     * @param orderReceivedStatisticsFindDTO
+     * @param statisticalSigns
+     * @return
+     */
+    private Map<String, List<OrderReceivedStatisticsVo>> orderReceivedStatistics(OrderReceivedStatisticsFindDTO orderReceivedStatisticsFindDTO, List<String> statisticalSigns) {
         if (CollectionUtil.containsAny(statisticalSigns, orderSigns)) {
             List<OrderReceivedStatistics> orderReceivedStatisticsList = selectOrderReceivedStatistics(orderReceivedStatisticsFindDTO);
             //日 周 月  的统计
             Map<Object, List<OrderReceivedStatisticsBase>> orderstatisticsMap = ReceivedStatisticsEnum.orderstatistics(orderReceivedStatisticsList, orderReceivedStatisticsFindDTO.getStatisticalWay());
             //统计项
             Map<String, List<OrderReceivedStatisticsVo>> orderReceivedStatisticsMap = OrderReceivedStatisticsSignEnum.orderReceivedStatistics(orderstatisticsMap, retainAll(orderSigns, statisticalSigns));
-            resultMap.putAll(orderReceivedStatisticsMap);
+            return orderReceivedStatisticsMap.isEmpty() ? Collections.EMPTY_MAP : orderReceivedStatisticsMap;
         }
+        return Collections.EMPTY_MAP;
+    }
 
-        //租车订单统计
+    /**
+     * 租车统计
+     *
+     * @param orderReceivedStatisticsFindDTO
+     * @param statisticalSigns
+     * @return
+     */
+    private Map<String, List<OrderReceivedStatisticsVo>> orderRentVehicleRceicedStatistics(OrderReceivedStatisticsFindDTO orderReceivedStatisticsFindDTO, List<String> statisticalSigns) {
         if (CollectionUtil.containsAny(statisticalSigns, orderRentVehicleSigns)) {
             List<OrderRentVehicleReceivedStatistics> orderRentVehicleReceivedStatisticsList = orderRentVehicleReceivedStatisticsBiz.selectOrderReceivedStatistics(orderReceivedStatisticsFindDTO);
             //日 周 月  的统计
             Map<Object, List<OrderReceivedStatisticsBase>> orderRentVehiclestatisticsMap = ReceivedStatisticsEnum.orderstatistics(orderRentVehicleReceivedStatisticsList, orderReceivedStatisticsFindDTO.getStatisticalWay());
             //统计项
             Map<String, List<OrderReceivedStatisticsVo>> orderRentVehicleReceivedStatisticsMap = OrderRentVehicleReceivedStatisticsSignEnum.orderMemberstatisticsMap(orderRentVehiclestatisticsMap, retainAll(orderRentVehicleSigns, statisticalSigns));
-            resultMap.putAll(orderRentVehicleReceivedStatisticsMap);
+            return orderRentVehicleReceivedStatisticsMap.isEmpty() ? Collections.EMPTY_MAP : orderRentVehicleReceivedStatisticsMap;
         }
+        return Collections.EMPTY_MAP;
+    }
 
-        //旅游订单统计
+    /**
+     * 旅游统计
+     *
+     * @param orderReceivedStatisticsFindDTO
+     * @param statisticalSigns
+     * @return
+     */
+    private Map<String, List<OrderReceivedStatisticsVo>> orderTourReceivedStatistcs(OrderReceivedStatisticsFindDTO orderReceivedStatisticsFindDTO, List<String> statisticalSigns) {
         if (CollectionUtil.containsAny(statisticalSigns, orderTourSigns)) {
             List<OrderTourReceivedStatistics> orderTourReceivedStatisticsList = orderTourReceivedStatisticsBiz.selectOrderReceivedStatistics(orderReceivedStatisticsFindDTO);
             //日 周 月  的统计
             Map<Object, List<OrderReceivedStatisticsBase>> orderTourstatisticsMap = ReceivedStatisticsEnum.orderstatistics(orderTourReceivedStatisticsList, orderReceivedStatisticsFindDTO.getStatisticalWay());
             //统计项
             Map<String, List<OrderReceivedStatisticsVo>> orderTourReceivedStatisticsMap = OrderTourReceivedStatisticsSignEnum.orderMemberstatisticsMap(orderTourstatisticsMap, retainAll(orderTourSigns, statisticalSigns));
-            resultMap.putAll(orderTourReceivedStatisticsMap);
+            return orderTourReceivedStatisticsMap.isEmpty() ? Collections.EMPTY_MAP : orderTourReceivedStatisticsMap;
         }
+        return Collections.EMPTY_MAP;
+    }
 
-        //会员订单统计
+    /**
+     * 会员统计
+     *
+     * @param orderReceivedStatisticsFindDTO
+     * @param statisticalSigns
+     * @return
+     */
+    private Map<String, List<OrderReceivedStatisticsVo>> orderMemberReceivedStatistics(OrderReceivedStatisticsFindDTO orderReceivedStatisticsFindDTO, List<String> statisticalSigns) {
         if (CollectionUtil.containsAny(statisticalSigns, orderMemberSigns)) {
             List<OrderMemberReceivedStatistics> orderMemberReceivedStatisticsList = orderMemberReceivedStatisticsBiz.selectOrderReceivedStatistics(orderReceivedStatisticsFindDTO);
             //日 周 月  的统计
             Map<Object, List<OrderReceivedStatisticsBase>> orderMemberstatisticsMap = ReceivedStatisticsEnum.orderstatistics(orderMemberReceivedStatisticsList, orderReceivedStatisticsFindDTO.getStatisticalWay());
             //统计项
             Map<String, List<OrderReceivedStatisticsVo>> orderMemberReceivedStatisticsMap = OrderMemberReceivedStatisticsSignEnum.orderMemberstatisticsMap(orderMemberstatisticsMap, retainAll(orderMemberSigns, statisticalSigns));
-            resultMap.putAll(orderMemberReceivedStatisticsMap);
+            return orderMemberReceivedStatisticsMap.isEmpty() ? Collections.EMPTY_MAP : orderMemberReceivedStatisticsMap;
         }
-        return resultMap;
+        return Collections.EMPTY_MAP;
     }
 
     private List<OrderReceivedStatistics> selectOrderReceivedStatistics(OrderReceivedStatisticsFindDTO orderReceivedStatisticsFindDTO) {
         return mapper.selectOrderReceivedStatisticsList(orderReceivedStatisticsFindDTO);
     }
 
-    /**取两个集合的交集
-     *
+    /**
+     * 取两个集合的交集
      *
      * @param source
      * @param target

xx-order/xx-order-server/src/main/java/com/xxfc/platform/order/biz/OrderRentVehicleReceivedStatisticsBiz.java

 package com.xxfc.platform.order.biz;
 
+import cn.hutool.core.util.ObjectUtil;
 import com.github.wxiaoqi.security.common.biz.BaseBiz;
 import com.google.common.collect.Lists;
 import com.xxfc.platform.order.contant.enumerate.StatisticsStatusEnum;
@@ -38,15 +39,26 @@ public class OrderRentVehicleReceivedStatisticsBiz extends BaseBiz<OrderRentVehi
     private final String NO_PAY_STATE_STR = String.format("%s-%d", "-", StatisticsStatusEnum.NO_PAY_WAY);
     private final int PAY_ORDER = 101;
 
+    /**
+     * 租车统计查询
+     * @param orderReceivedStatisticsFindDTO
+     * @return
+     */
     public List<OrderRentVehicleReceivedStatistics> selectOrderReceivedStatistics(OrderReceivedStatisticsFindDTO orderReceivedStatisticsFindDTO) {
         return mapper.selectOrderRentVehicleReceivedStatistics(orderReceivedStatisticsFindDTO);
     }
 
+    /**
+     * 租车统计处理
+     * @param startDate 开始时间
+     * @param endDate 结束时间
+     */
     public void orderRentVehicleReceivedStatistics(Date startDate, Date endDate) {
         List<OrderRentVehicleReceivedStatistics> orderRentVehicleReceivedStatisticsList = new ArrayList<>();
 
-
+        //根据租车订单类型 时间查询
         List<OrderDTO> orderDTOS = baseOrderBiz.selectOrdersByTypeAndTime(Arrays.asList(StatisticsStatusEnum.ORDER_RENT_VEHICLE_TYPE), startDate, endDate);
+        //数据处理 状态组合
         Map<String, Long> stateGroupMap = orderDTOS.stream().peek(x -> {
             x.setStateGroup(String.format("%d-%d-%d-%d", x.getCompanyId(), x.getOrderOrigin(), x.getPayWay() == null ? StatisticsStatusEnum.NO_PAY_WAY : x.getPayWay(), x.getStatus()));
         })
@@ -54,7 +66,7 @@ public class OrderRentVehicleReceivedStatisticsBiz extends BaseBiz<OrderRentVehi
 
         //订单账目信息
         List<OrderAccountBo> orderAccountBoList = orderAccountBiz.selectByDate(startDate, endDate);
-        //数据处理 把 未支付的单的支付方式 设置为 99
+        //账目数据处理 状态组合
         Map<String, List<OrderAccountBo>> ordersMap = orderAccountBoList.stream().peek(x -> {
             x.setStateGroup(String.format("%d-%d-%d-%d", x.getCompanyId(), x.getOrderOrigin(), x.getPayWay() == null ? StatisticsStatusEnum.NO_PAY_WAY : x.getPayWay(), x.getStatus()));
         }).collect(Collectors.groupingBy(OrderAccountBo::getStateGroup, Collectors.toList()));
@@ -80,24 +92,28 @@ public class OrderRentVehicleReceivedStatisticsBiz extends BaseBiz<OrderRentVehi
         }
 
         //未支付单
-        List<OrderDTO> noPayOrders = orderDTOS.stream().filter(x -> x.getPayWay() != null).collect(Collectors.toList());
-        BigDecimal totalNoPayAmount = CollectionUtils.isEmpty(noPayOrders) ? BigDecimal.ZERO : noPayOrders.stream().map(OrderDTO::getRealAmount).reduce(BigDecimal.ZERO, (x, y) -> x.add(y));
-        int totalNoPayOrderQuantity = CollectionUtils.isEmpty(noPayOrders) ? 0 : noPayOrders.size();
-
+        List<BigDecimal> noPayOrdersPrices = orderDTOS.stream().filter(x -> x.getPayWay() != null).map(OrderDTO::getRealAmount).collect(Collectors.toList());
+        BigDecimal totalNoPayAmount = CollectionUtils.isEmpty(noPayOrdersPrices) ? BigDecimal.ZERO : noPayOrdersPrices.stream().reduce(BigDecimal.ZERO, (x, y) -> x.add(y));
+        int totalNoPayOrderQuantity = CollectionUtils.isEmpty(noPayOrdersPrices) ? 0 : noPayOrdersPrices.size();
 
+        //查询分公司ids
         List<Integer> companyIds = vehicleFeign.findCompanyIdsByAreaId(null);
+        //创建剩余状态组合的租车统计对象
         List stisticsActiveState = ordersMap.isEmpty() ? Collections.EMPTY_LIST : Lists.newArrayList(ordersMap.keySet());
         List<OrderRentVehicleReceivedStatistics> otherStatisticsStateGroupList = createOtherStatisticsStateGroupList(startDate, stisticsActiveState, companyIds, totalNoPayAmount, totalNoPayOrderQuantity);
         orderRentVehicleReceivedStatisticsList.addAll(otherStatisticsStateGroupList);
+        //保存
         insertMemberReceivedStatisticsBatch(orderRentVehicleReceivedStatisticsList);
     }
 
     /**
      * 创建剩余状态数据
      *
-     * @param startDate
-     * @param statisticsStateGroups
-     * @param companyIds
+     * @param startDate  时间
+     * @param statisticsStateGroups 状态组合 集合
+     * @param companyIds  公司ids
+     * @param totalNoPayAmount  未支付金额
+     * @param totalNoPayOrderQuantity  未支付订单数
      * @return
      */
     private List<OrderRentVehicleReceivedStatistics> createOtherStatisticsStateGroupList(Date startDate,
@@ -105,23 +121,45 @@ public class OrderRentVehicleReceivedStatisticsBiz extends BaseBiz<OrderRentVehi
                                                                                          List<Integer> companyIds,
                                                                                          BigDecimal totalNoPayAmount,
                                                                                          Integer totalNoPayOrderQuantity) {
+
         List<OrderRentVehicleReceivedStatistics> orderRentVehicleReceivedStatisticsList = new ArrayList<>();
+         //获取剩余状态组合
         List<String> otherStatisticsStateGroup = StatisticsStatusEnum.getOtherStatisticsStateGroup(companyIds, statisticsStateGroups);
-        List<OrderRentVehicleReceivedStatistics> result = otherStatisticsStateGroup.parallelStream().map(stateGroup -> {
-            OrderRentVehicleReceivedStatistics orderRentVehicleReceivedStatistics = StatisticsStatusEnum.wrapStatisticsObject(startDate, stateGroup, new OrderRentVehicleReceivedStatistics());
-            if (stateGroup.contains(NO_PAY_STATE_STR)) {
-                orderRentVehicleReceivedStatistics.setTotalAmount(totalNoPayAmount);
-                orderRentVehicleReceivedStatistics.setTotalQuantity(totalNoPayOrderQuantity);
-            } else {
-                orderRentVehicleReceivedStatistics.setTotalAmount(BigDecimal.ZERO);
-                orderRentVehicleReceivedStatistics.setTotalQuantity(0);
-            }
-            return orderRentVehicleReceivedStatistics;
-        }).collect(Collectors.toList());
-        orderRentVehicleReceivedStatisticsList.addAll(result == null ? Collections.EMPTY_LIST : result);
+        //创建租车统计克隆对象
+        OrderRentVehicleReceivedStatistics orderRentVehicleReceivedStatistics = new OrderRentVehicleReceivedStatistics();
+        //统计对象的生成
+        otherStatisticsStateGroup.parallelStream().map(stateGroup -> {
+            OrderRentVehicleReceivedStatistics orderRentVehicleReceivedStatisticsClone = StatisticsStatusEnum.wrapStatisticsObject(startDate, stateGroup,ObjectUtil.cloneByStream(orderRentVehicleReceivedStatistics));
+            orderRentVehicleReceivedStatisticsClone = wrapOrderRentVehicleReceivedStatistics(stateGroup,totalNoPayAmount,totalNoPayOrderQuantity,orderRentVehicleReceivedStatisticsClone);
+            orderRentVehicleReceivedStatisticsList.add(orderRentVehicleReceivedStatisticsClone);
+            return orderRentVehicleReceivedStatisticsClone;
+        }).count();
         return orderRentVehicleReceivedStatisticsList;
     }
 
+    /**
+     *
+     * @param stateGroup  状态组合
+     * @param totalNoPayAmount 未支付金额
+     * @param totalNoPayOrderQuantity  未支付订单量
+     * @param orderRentVehicleReceivedStatistics 租车统计对象
+     * @return
+     */
+    private OrderRentVehicleReceivedStatistics wrapOrderRentVehicleReceivedStatistics(String stateGroup,BigDecimal totalNoPayAmount, Integer totalNoPayOrderQuantity,OrderRentVehicleReceivedStatistics orderRentVehicleReceivedStatistics){
+        if (stateGroup.contains(NO_PAY_STATE_STR)) {
+            orderRentVehicleReceivedStatistics.setTotalAmount(totalNoPayAmount);
+            orderRentVehicleReceivedStatistics.setTotalQuantity(totalNoPayOrderQuantity);
+        } else {
+            orderRentVehicleReceivedStatistics.setTotalAmount(BigDecimal.ZERO);
+            orderRentVehicleReceivedStatistics.setTotalQuantity(0);
+        }
+        return orderRentVehicleReceivedStatistics;
+    }
+
+    /**
+     * 批量插入数据
+     * @param orderRentVehicleReceivedStatistics
+     */
     public void insertMemberReceivedStatisticsBatch(List<OrderRentVehicleReceivedStatistics> orderRentVehicleReceivedStatistics) {
         mapper.insertList(orderRentVehicleReceivedStatistics);
     }