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

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/contant/enumerate/OrderReceivedStatisticsSignEnum.java

@@ -65,7 +65,7 @@ public enum  OrderReceivedStatisticsSignEnum {
                return resultMap;
           }
      },
-     ORDER_TOTAL_REAL_AMOUNT("ad_otra","实际收入"){
+    /* ORDER_TOTAL_REAL_AMOUNT("ad_otra","实际收入"){
           @Override
           Map<String, List<OrderReceivedStatisticsVo>> wrapToMap(Map<Object, List<OrderReceivedStatisticsBase>> orderMap) {
                Map<String, List<OrderReceivedStatisticsVo>> resultMap = new HashMap<>();
@@ -80,8 +80,8 @@ public enum  OrderReceivedStatisticsSignEnum {
                resultMap.put(getSign(),orderReceivedStatisticsVos);
                return resultMap;
           }
-     },
-     ORDER_REAL_AVG_AMOUNT("ae_oravga","实际arpu"){
+     },*/
+   /*  ORDER_REAL_AVG_AMOUNT("ae_oravga","实际arpu"){
           @Override
           Map<String, List<OrderReceivedStatisticsVo>> wrapToMap(Map<Object, List<OrderReceivedStatisticsBase>> orderMap) {
                Map<String, List<OrderReceivedStatisticsVo>> resultMap = new HashMap<>();
@@ -103,7 +103,7 @@ public enum  OrderReceivedStatisticsSignEnum {
                resultMap.put(getSign(),orderReceivedStatisticsVos);
                return resultMap;
           }
-     };
+     }*/;
      private String sign;
      private String desc;
      private static  Map<String,OrderReceivedStatisticsSignEnum> orderReceivedStatisticsSignEnumMap;

xx-order/xx-order-api/src/main/java/com/xxfc/platform/order/contant/enumerate/OrderRentVehicleReceivedStatisticsSignEnum.java

@@ -5,7 +5,6 @@ import com.xxfc.platform.order.entity.OrderRentVehicleReceivedStatistics;
 import com.xxfc.platform.order.pojo.vo.OrderReceivedStatisticsVo;
 
 import java.math.BigDecimal;
-import java.math.RoundingMode;
 import java.util.*;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Function;
@@ -72,7 +71,7 @@ public enum OrderRentVehicleReceivedStatisticsSignEnum{
              return resultMap;
          }
      },
-     RENT_VEHICLE_REAL_TOTAL_AMOUNT("bd_rvrta","实际租车金额") {
+/*     RENT_VEHICLE_REAL_TOTAL_AMOUNT("bd_rvrta","实际租车金额") {
          @Override
          Map<String, List<OrderReceivedStatisticsVo>> wrapToMap(Map<Object, List<OrderReceivedStatisticsBase>> orderMap) {
              Map<String, List<OrderReceivedStatisticsVo>> resultMap = new HashMap<>();
@@ -87,8 +86,8 @@ public enum OrderRentVehicleReceivedStatisticsSignEnum{
              resultMap.put(getSign(),orderReceivedStatisticsVos);
              return resultMap;
          }
-     },
-     RENT_VEHICLE_REAL_AVG_AMOUNT("be_rvravga","实际租车arpu") {
+     },*/
+/*     RENT_VEHICLE_REAL_AVG_AMOUNT("be_rvravga","实际租车arpu") {
          @Override
          Map<String, List<OrderReceivedStatisticsVo>> wrapToMap(Map<Object, List<OrderReceivedStatisticsBase>> orderMap) {
              Map<String, List<OrderReceivedStatisticsVo>> resultMap = new HashMap<>();
@@ -110,7 +109,7 @@ public enum OrderRentVehicleReceivedStatisticsSignEnum{
              resultMap.put(getSign(),orderReceivedStatisticsVos);
              return resultMap;
          }
-     };
+     }*/;
     private String sign;
     private String desc;
     private static  Map<String,OrderRentVehicleReceivedStatisticsSignEnum> orderRentVehicleReceivedStatisticsSignEnumMap;

xx-order/xx-order-api/src/main/java/com/xxfc/platform/order/contant/enumerate/StatisticsStatusEnum.java

@@ -21,14 +21,20 @@ public enum  StatisticsStatusEnum {
     public static final int FINISH = 6;
     public static final int CANCEL = 2;
     public static final int UNFINISH = 3;
+    public static final int DEFAULT_COMPANY=1;
+    public static final int ORDER_MEMBER_TYPE=3;
+    public static final int ORDER_RENT_VEHICLE_TYPE=1;
+    public static final int ORDER_TOUR_TYPE=2;
+    public static final String UN_PAY_STATE="0";
+    public static final int NO_PAY_WAY=99;
 
     public static List<String> orderStates;
     public static List<String> orderOrigins;
     public static List<String> orderPayWays;
 
     static {
-         // 2 取消  3未完成   6 已完成
-        orderStates = Lists.newArrayList("2","3","6");
+         // 0 未支付 1 已支付
+        orderStates = Lists.newArrayList("0","1");
         // 1 app   2 小程序  3 其他
         orderOrigins = Lists.newArrayList("1","2","3");
         // 1 微信  2 支付宝
@@ -53,7 +59,7 @@ public enum  StatisticsStatusEnum {
             for (String orderPayWay : orderPayWays) {
                 for (String orderState : orderStates) {
                     //订单来源-支付方式-订单状态
-                    orderStatisticsStateGroups.add(String.format("%s-%s-%s",orderOrigin,orderPayWay,orderState));
+                    orderStatisticsStateGroups.add(String.format("%s-%s-%s",orderOrigin,orderState==UN_PAY_STATE?String.valueOf(NO_PAY_WAY):orderPayWay,orderState));
                 }
             }
         }
@@ -61,7 +67,7 @@ public enum  StatisticsStatusEnum {
     }
     public static List<String> getOtherStatisticsStateGroup(List<Integer> companyIdList,List<String> statisticsStates){
         List<String> stateGroupList = CollectionUtils.isEmpty(companyIdList)?statisticsStateGroup():statisticsSateGroupWithCompanys(companyIdList);
-        stateGroupList.retainAll(statisticsStates);
+        stateGroupList.removeAll(statisticsStates);
         return stateGroupList;
     }
 
@@ -73,7 +79,7 @@ public enum  StatisticsStatusEnum {
         String[] status = stateGroup.split("-");
         targetObj.setCrtTime(new Date());
         targetObj.setCompanyId(Integer.valueOf(status[0]));
-        targetObj.setIsFinish(Integer.valueOf(status[3]));
+        targetObj.setHasPay(Integer.valueOf(status[3]));
         targetObj.setOrderOrigin(Integer.valueOf(status[1]));
         targetObj.setPayWay(Integer.valueOf(status[2]));
         targetObj.setDate(date);

xx-order/xx-order-api/src/main/java/com/xxfc/platform/order/entity/OrderReceivedStatistics.java

@@ -28,11 +28,4 @@ public class OrderReceivedStatistics extends OrderReceivedStatisticsBase impleme
     private Integer totalQuantity;
 
 
-	    /**
-     *  实际收入
-     */
-    @Column(name = "real_amount")
-	@ApiModelProperty(value = "实际收入")
-    private BigDecimal realAmount;
-
 }

xx-order/xx-order-api/src/main/java/com/xxfc/platform/order/entity/OrderReceivedStatisticsBase.java

@@ -62,11 +62,15 @@ public class OrderReceivedStatisticsBase  {
     protected BigDecimal totalAmount;
 
     /**
-     * 是否完成 1 完成  0 未完成
+     * 订单总量
      */
-    @Column(name = "is_finish")
-    @ApiModelProperty(value = "是否完成 1 完成  0 未完成")
-    protected Integer isFinish;
+    @Column(name = "total_quantity")
+    @ApiModelProperty(value = "订单总量")
+    private Integer totalQuantity;
+
+    @Column(name = "has_pay")
+    @ApiModelProperty(value = "是否支付 1已经支付 0未支付")
+    protected Integer hasPay;
 
     /**
      * '支付来源 1--app；2--小程序',

xx-order/xx-order-api/src/main/java/com/xxfc/platform/order/entity/OrderRentVehicleReceivedStatistics.java

@@ -28,11 +28,4 @@ public class OrderRentVehicleReceivedStatistics extends OrderReceivedStatisticsB
     @ApiModelProperty(value = "订单总量")
     private Integer totalQuantity;
 
-    /**
-     * 实际收入
-     */
-    @Column(name = "real_amount")
-    @ApiModelProperty(value = "实际收入")
-    private BigDecimal realAmount;
-
 }

xx-order/xx-order-api/src/main/java/com/xxfc/platform/order/entity/OrderTourReceivedStatistics.java

@@ -21,12 +21,7 @@ import java.util.Date;
 public class OrderTourReceivedStatistics extends OrderReceivedStatisticsBase implements Serializable {
     private static final long serialVersionUID = 1L;
 
-    /**
-     * 订单总量
-     */
-    @Column(name = "total_quantity")
-    @ApiModelProperty(value = "订单总量")
-    private Integer totalQuantity;
+
 
 
 }

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;
@@ -29,9 +30,17 @@ public class OrderDTO {
     private Date crtTime;
     private Integer companyId;
     private String stateGroup;
+    private Integer hasPay;
     /**
      * 会员相关
      */
     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;
 import com.google.common.collect.Lists;
@@ -33,80 +32,127 @@ 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.beginOfDay(date);
-        List<OrderDTO> orders = baseOrderBiz.selectOrdersByTypeAndTime(Arrays.asList(3), startDate, endDate);
 
-        //数据处理 把 完成状态6 取消状态2 的其他数据转换成状态为未完成3
-        Map<String, Map<Integer, List<OrderDTO>>> ordersMap = orders.stream().peek(x -> {
-            Integer status = x.getStatus() == StatisticsStatusEnum.CANCEL ? StatisticsStatusEnum.CANCEL : x.getStatus() == StatisticsStatusEnum.FINISH ? StatisticsStatusEnum.FINISH : StatisticsStatusEnum.UNFINISH;
-            x.setStatus(status);
-            x.setStateGroup(String.format("%d-%d-%d-%d", 1, x.getOrderOrigin(), x.getPayWay(), x.getStatus()));
-        })
-                .collect(Collectors.groupingBy(OrderDTO::getStateGroup, Collectors.groupingBy(OrderDTO::getMemberLevel, Collectors.toList())));
+        //根据时间范围查询出会员单
+        List<OrderDTO> orders = baseOrderBiz.selectOrdersByTypeAndTime(Arrays.asList(StatisticsStatusEnum.ORDER_TOUR_TYPE), startDate, endDate);
+
+        //数据处理 把状态组合
+        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);
+                orderMemberReceivedStatistics.setTotalQuantity(totalQuantity);
                 orderMemberReceivedStatistics.setTotalAmount(totalAmount);
+
                 orderMemberReceivedStatisticsList.add(orderMemberReceivedStatistics);
             }
         }
         //创建剩余状态数据
         List stisticsActiveState = ordersMap.isEmpty() ? Collections.EMPTY_LIST : Lists.newArrayList(ordersMap.keySet());
-        List<OrderMemberReceivedStatistics> otherStatisticsStateGroupList = createOtherStatisticsStateGroupList(startDate, stisticsActiveState, 1);
+        List<OrderMemberReceivedStatistics> otherStatisticsStateGroupList = createOtherStatisticsStateGroupList(startDate, stisticsActiveState, StatisticsStatusEnum.DEFAULT_COMPANY);
         orderMemberReceivedStatisticsList.addAll(otherStatisticsStateGroupList);
         //保存
         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);
-        for (String stateGroup : otherStatisticsStateGroup) {
-            orderMemberReceivedStatistics = StatisticsStatusEnum.wrapStatisticsObject(startDate, stateGroup, new 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);
@@ -114,11 +160,14 @@ public class OrderMemberReceivedStatisticsBiz extends BaseBiz<OrderMemberReceive
         orderMemberReceivedStatistics.setTotalGoldAmount(BigDecimal.ZERO);
         orderMemberReceivedStatistics.setTotalDiamondQuantity(0);
         orderMemberReceivedStatistics.setTotalDiamondAmmount(BigDecimal.ZERO);
-            orderMemberReceivedStatisticsList.add(orderMemberReceivedStatistics);
-        }
-        return orderMemberReceivedStatisticsList;
+        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

@@ -63,55 +63,55 @@ public class OrderReceivedStatisticsBiz extends BaseBiz<OrderReceivedStatisticsM
         //标题样式
         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++){
+        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++) {
+            for (int cellIndex = 1; cellIndex <= signs.size(); cellIndex++) {
                 Cell dataCell = dataRow.createCell(cellIndex);
                 dataCell.setCellStyle(cellStyle);
-               String sign = signs.get(cellIndex-1);
+                String sign = signs.get(cellIndex - 1);
                 List<OrderReceivedStatisticsVo> orderReceivedStatisticsVos = data.get(sign);
-               if (CollectionUtils.isEmpty(orderReceivedStatisticsVos) || i>orderReceivedStatisticsVos.size()){
+                if (CollectionUtils.isEmpty(orderReceivedStatisticsVos) || i > orderReceivedStatisticsVos.size()) {
                     continue;
                 }
                 OrderReceivedStatisticsVo orderReceivedStatisticsVo = orderReceivedStatisticsVos.get(i);
-               if (sign.endsWith("q")){
+                if (sign.endsWith("q")) {
                     dataCell.setCellValue(String.valueOf(orderReceivedStatisticsVo.getOrderNum()));
                 }
-               if (sign.endsWith("a")){
+                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 (cellIndex == 1) {
+                    if (ReceivedStatisticsEnum.DAY.getWayCode() == statisticalWay) {
+                        firstCell.setCellValue(DateUtil.format(orderReceivedStatisticsVo.getDate(), "yyyy.MM.dd"));
                     }
-                     if (ReceivedStatisticsEnum.WEEK.getWayCode()==statisticalWay){
+                    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 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));
+                        firstCell.setCellValue(String.format("%s~%s", startDateStr, endDateStr));
                     }
-                     if (ReceivedStatisticsEnum.MONTH.getWayCode()==statisticalWay){
+                    if (ReceivedStatisticsEnum.MONTH.getWayCode() == statisticalWay) {
                         StringBuilder sb = new StringBuilder(orderReceivedStatisticsVo.getMonth());
-                         sb.insert(4,".");
+                        sb.insert(4, ".");
                         firstCell.setCellValue(sb.toString());
                     }
                 }
@@ -119,29 +119,29 @@ public class OrderReceivedStatisticsBiz extends BaseBiz<OrderReceivedStatisticsM
         }
     }
 
-    private void createHeader(Row row, CellStyle cellStyle,List<String> 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++) {
+        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,45 +160,99 @@ 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) {

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;
@@ -7,9 +8,11 @@ import com.xxfc.platform.order.entity.OrderRentVehicleReceivedStatistics;
 import com.xxfc.platform.order.mapper.OrderRentVehicleReceivedStatisticsMapper;
 import com.xxfc.platform.order.pojo.account.OrderAccountBo;
 import com.xxfc.platform.order.pojo.account.OrderAccountDetail;
+import com.xxfc.platform.order.pojo.dto.OrderDTO;
 import com.xxfc.platform.order.pojo.dto.OrderReceivedStatisticsFindDTO;
 import com.xxfc.platform.vehicle.feign.VehicleFeign;
 import lombok.RequiredArgsConstructor;
+import org.apache.commons.collections.CollectionUtils;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 import org.springframework.transaction.annotation.Transactional;
@@ -30,27 +33,45 @@ import java.util.stream.Collectors;
 @RequiredArgsConstructor(onConstructor = @__(@Autowired))
 public class OrderRentVehicleReceivedStatisticsBiz extends BaseBiz<OrderRentVehicleReceivedStatisticsMapper, OrderRentVehicleReceivedStatistics> {
 
+    private final BaseOrderBiz baseOrderBiz;
     private final OrderAccountBiz orderAccountBiz;
     private final VehicleFeign vehicleFeign;
-    private final int PAY_ORDER=101;
+    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);
     }
 
-    public void orderRentVehicleReceivedStatistics(Date startDate,Date endDate) {
+    /**
+     * 租车统计处理
+     * @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()));
+        })
+                .collect(Collectors.groupingBy(OrderDTO::getStateGroup, Collectors.counting()));
+
         //订单账目信息
-        List<OrderAccountBo> orderAccountBoList = orderAccountBiz.selectByDate(startDate,endDate);
-        //数据处理 把 完成状态6 取消状态2 的其他数据转换成状态为未完成3
-        Map<String, List<OrderAccountBo>> orderAccountBoMap = orderAccountBoList.stream().peek(x -> {
-            Integer status = x.getStatus() == StatisticsStatusEnum.CANCEL ? StatisticsStatusEnum.CANCEL : x.getStatus() == StatisticsStatusEnum.FINISH ? StatisticsStatusEnum.FINISH : StatisticsStatusEnum.UNFINISH;
-            x.setStatus(status);
-            x.setStateGroup(String.format("%d-%d-%d-%d", 1, x.getOrderOrigin(), x.getPayWay() == null ? 1 : x.getPayWay(), x.getStatus()));
+        List<OrderAccountBo> orderAccountBoList = orderAccountBiz.selectByDate(startDate, endDate);
+        //账目数据处理 状态组合
+        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()));
 
-        if (!orderAccountBoMap.isEmpty()) {
-            Set<Map.Entry<String, List<OrderAccountBo>>> ordersSet = orderAccountBoMap.entrySet();
+        Set<Map.Entry<String, List<OrderAccountBo>>> ordersSet = ordersMap.entrySet();
         for (Map.Entry<String, List<OrderAccountBo>> orderEntry : ordersSet) {
             String orderKey = orderEntry.getKey();
             List<OrderAccountBo> orderAccountBos = orderEntry.getValue();
@@ -65,39 +86,80 @@ public class OrderRentVehicleReceivedStatisticsBiz extends BaseBiz<OrderRentVehi
                     refundAmount.add(accountDetailEntity.getOrderAmount()).add(accountDetailEntity.getDepositAmount());
                 }
             }
-                orderRentVehicleReceivedStatistics.setTotalAmount(totalAmount);
-                orderRentVehicleReceivedStatistics.setRealAmount(totalAmount.subtract(refundAmount));
-                orderRentVehicleReceivedStatistics.setTotalQuantity(orderAccountBos.size());
-            }
+            orderRentVehicleReceivedStatistics.setTotalAmount(totalAmount.subtract(refundAmount));
+            Long totalQuantity = stateGroupMap == null ? 0L : stateGroupMap.get(orderKey) == null ? 0L : stateGroupMap.get(orderKey);
+            orderRentVehicleReceivedStatistics.setTotalQuantity(totalQuantity.intValue());
         }
+
+        //未支付单
+        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 = orderAccountBoMap.isEmpty() ? Collections.EMPTY_LIST : Lists.newArrayList(orderAccountBoMap.keySet());
-        List<OrderRentVehicleReceivedStatistics> otherStatisticsStateGroupList = createOtherStatisticsStateGroupList(startDate,stisticsActiveState,companyIds);
+        //创建剩余状态组合的租车统计对象
+        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, List<String> statisticsStateGroups, List<Integer> companyIds) {
+    private List<OrderRentVehicleReceivedStatistics> createOtherStatisticsStateGroupList(Date startDate,
+                                                                                         List<String> statisticsStateGroups,
+                                                                                         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());
-            orderRentVehicleReceivedStatistics.setRealAmount(BigDecimal.ZERO);
+        //创建租车统计克隆对象
+        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;
-        }).collect(Collectors.toList());
-        orderRentVehicleReceivedStatisticsList.addAll(result==null?Collections.EMPTY_LIST:result);
-        return orderRentVehicleReceivedStatisticsList;
     }
+
+    /**
+     * 批量插入数据
+     * @param orderRentVehicleReceivedStatistics
+     */
     public void insertMemberReceivedStatisticsBatch(List<OrderRentVehicleReceivedStatistics> orderRentVehicleReceivedStatistics) {
         mapper.insertList(orderRentVehicleReceivedStatistics);
     }

xx-order/xx-order-server/src/main/resources/mapper/BaseOrderMapper.xml

@@ -355,9 +355,9 @@
 
     <select id="selectOrdersByTypeAndTime" resultType="com.xxfc.platform.order.pojo.dto.OrderDTO">
         select bo.*,omd.memberLevel,IFNULL(orvd.start_company_id,otd.start_company_id) AS `companyId` from (select `id`,`type`,`status`,`order_amount` AS `orderAmount`, `real_amount`AS
-        `realAmount`,`order_origin` AS `orderOrigin`,
+        `realAmount`,`order_origin` AS `orderOrigin`, `has_pay` AS `hasPay`,
         `pay_way` AS `payWay`,`crt_time`AS `crtTime`
-        from `base_order` where `has_pay`=1 and `crt_time` between #{startDate} and #{endDate} and `type` IN <foreach collection="types"
+        from `base_order` where (`crt_time` between #{startDate} and #{endDate} or `pay_time` between #{startDate} and #{endDate} ) and `type` IN <foreach collection="types"
                                                                                                       item="type"
                                                                                                       open="(" close=")"
                                                                                                       separator=",">

xx-order/xx-order-server/src/test/java/ServiceTest.java

@@ -2,6 +2,7 @@ import com.xxfc.platform.order.OrderApplication;
 import com.xxfc.platform.order.biz.DailyOrderStatisticsBiz;
 import com.xxfc.platform.order.biz.OrderMemberReceivedStatisticsBiz;
 import com.xxfc.platform.order.jobhandler.BaseOrderStatisticsJobHandler;
+import com.xxfc.platform.universal.utils.DateUtil;
 import org.joda.time.DateTime;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -41,7 +42,8 @@ public class ServiceTest {
 
     @Test
     public void testMemberStatisticsInsert(){
-        orderMemberReceivedStatisticsBiz.orderMemberReceivedStatistics();
+        Date date = cn.hutool.core.date.DateTime.of("2019-11-17", "yyyy-MM-dd").toJdkDate();
+        orderMemberReceivedStatisticsBiz.orderMemberReceivedStatistics(date);
     }