淘宝转链接口更新

admin

2025-02-25 30d8e227e8d823b6c38c3b9c90ac2df03b63befe

 fanli/src/main/java/com/yeshi/fanli/service/impl/count/UserInfoCountServiceImpl.java

@@ -1,1141 +1,1002 @@
package com.yeshi.fanli.service.impl.count;



import java.math.BigDecimal;

import java.text.DecimalFormat;

import java.util.ArrayList;

import java.util.Date;

import java.util.List;



import javax.annotation.Resource;



import org.springframework.stereotype.Service;

import org.yeshi.utils.DateUtil;



import com.yeshi.fanli.dao.mybatis.UserInfoCountMapper;

import com.yeshi.fanli.dao.mybatis.UserInfoMapper;

import com.yeshi.fanli.dao.user.count.CountOrderInfoDao;

import com.yeshi.fanli.dao.user.count.CountUserInfoDao;

import com.yeshi.fanli.dto.ChartTDO;

import com.yeshi.fanli.dto.order.CountOrderDTO;

import com.yeshi.fanli.entity.admin.count.CountOrderInfo;

import com.yeshi.fanli.entity.admin.count.CountOrderInfo.CountOrderEnum;

import com.yeshi.fanli.entity.admin.count.CountUserInfo;

import com.yeshi.fanli.entity.admin.count.CountUserInfo.CountUserEnum;

import com.yeshi.fanli.entity.bus.user.UserInfoRegister;

import com.yeshi.fanli.entity.system.ChannelEnum;

import com.yeshi.fanli.service.inter.count.HongBaoV2CountService;

import com.yeshi.fanli.service.inter.count.UserInfoCountService;

import com.yeshi.fanli.service.inter.order.CommonOrderCountService;

import com.yeshi.fanli.service.inter.order.LostOrderService;

import com.yeshi.fanli.service.inter.order.UserOrderWeiQuanRecordService;

import com.yeshi.fanli.service.inter.user.UserInfoRegisterService;

import com.yeshi.fanli.util.MoneyBigDecimalUtil;

import com.yeshi.fanli.util.StringUtil;

import com.yeshi.fanli.util.TimeUtil;

import com.yeshi.fanli.vo.user.UserGoldCoinVO;



@Service

public class UserInfoCountServiceImpl implements UserInfoCountService {



   @Resource

   private UserInfoMapper userInfoMapper;



   @Resource

   private UserInfoCountMapper userInfoCountMapper;



   @Resource

   private CountUserInfoDao countUserInfoDao;



   @Resource

   private CountOrderInfoDao countOrderInfoDao;



   @Resource

   private CommonOrderCountService commonOrderCountService;

	
   @Resource

   private HongBaoV2CountService hongBaoV2CountService;



   @Resource

   private UserOrderWeiQuanRecordService userOrderWeiQuanRecordService;

	
   @Resource

   private LostOrderService lostOrderService;

	
   @Resource

   private UserInfoRegisterService userInfoRegisterService;

	
	
	
	
   @Override

   public long countNewUser(Integer isToday, Integer isMonth) {

      return userInfoMapper.countNewUser(isToday, isMonth);

   }



   @Override

   public long countRank(Integer rank) {

      return userInfoMapper.countRank(rank);

   }



   @Override

   public BigDecimal countAllMoney(Double rank) {

      return userInfoMapper.countAllMoney(rank);

   }



   @Override

   public long countLoseUser(int daysNum) {

      return userInfoMapper.countLoseUser(daysNum);

   }



   @Override

   public long countHasOrderUser() {

      return userInfoMapper.countHasOrderUser();

   }



   @Override

   public List<ChartTDO> countNewUserByDate(String channel, Integer type, String years, String startTime,

         String endTime) throws Exception {

      return userInfoMapper.countNewUserByDate(channel, type, years, startTime, endTime);



   }



   @Override

   public List<ChartTDO> getTodayBuyRate(String channel, Integer dateType, String years, String startTime,

         String endTime) throws Exception {



      List<ChartTDO> result_list = null;



      List<ChartTDO> listToday = userInfoMapper.getTodayHasOrder(channel, dateType, years, startTime, endTime);



      if (listToday == null || listToday.size() == 0) {

         return result_list;

      }



      List<ChartTDO> listTotal = userInfoMapper.countNewUserByDate(channel, dateType, years, startTime, endTime);



      if (listTotal == null || listTotal.size() == 0) {

         return result_list;

      }



      switch (dateType) {

      case 1: // 按天处理

         result_list = dayFactory(startTime, endTime, listTotal);

         break;

      case 2: // 按月处理

         result_list = monthFactory(listTotal);

         break;

      case 3:

         result_list = yearFactory(listTotal);

         break;

      default:

         break;

      }



      DecimalFormat df = new DecimalFormat("#.00");



      for (int i = 0; i < result_list.size(); i++) {

         double proportion = 0;

         ChartTDO chartTDO = result_list.get(i);

         String showDate = chartTDO.getShowDate();

         for (int j = 0; j < listToday.size(); j++) {

            ChartTDO innerTDO = listToday.get(j);

            String innerDate = innerTDO.getShowDate();

            if (innerDate != null && innerDate.equals(showDate)) {

               String innerValue = innerTDO.getShowValue();

               long innerData = Long.parseLong(innerValue);



               String showValue = chartTDO.getShowValue();

               long showData = Long.parseLong(showValue);



               if (showData > 0) {

                  proportion = innerData / (double) showData;

               }

               break; // 结束内部循环

            }

         }

         chartTDO.setShowValue(Double.parseDouble(df.format(proportion * 100)) + "");

      }

      return result_list;

   }



   @Override

   public List<Object> getWeekBuyRate(String channel, String startTime, String endTime, Integer orderNum,

         List<String> dateList) throws Exception {

      List<Object> resultList = new ArrayList<Object>();

      if (dateList == null || dateList.size() == 0) {

         return resultList;

      }



      List<ChartTDO> totalList = userInfoMapper.countNewUserByDate(channel, 1, null, startTime, endTime);

      if (totalList == null || totalList.size() == 0) {

         return resultList;

      }



      DecimalFormat df = new DecimalFormat("#.00");

      for (int i = 0; i < dateList.size(); i++) {

         double proportion = 0;

         String showDate = dateList.get(i);

         String plusDay = DateUtil.plusDay(7, showDate);

         ChartTDO chartTDO = userInfoMapper.getWeekHasOrder(channel, showDate, plusDay, orderNum);



         String showValue = null;

         if (chartTDO != null) {

            showValue = chartTDO.getShowValue();

            if (showValue != null) {

               for (int j = 0; j < totalList.size(); j++) {

                  ChartTDO chart = totalList.get(j);

                  String reslutTime = chart.getShowDate();

                  if (showDate.equalsIgnoreCase(reslutTime)) {

                     String totalObject = chart.getShowValue();

                     long hasCount = Long.parseLong(showValue);

                     long total = Long.parseLong(totalObject);



                     if (total > 0) {

                        proportion = hasCount / (double) total;

                     }



                     break;

                  }

               }

            }

         }

         resultList.add(Double.parseDouble(df.format(proportion * 100)));

      }



      return resultList;

   }



   public List<ChartTDO> dayFactory(String startTime, String endTime, List<ChartTDO> list) throws Exception {

      List<ChartTDO> listObject = new ArrayList<ChartTDO>();

      if (startTime.equals(endTime)) {

         ChartTDO chartTDO = list.get(0);

         String showValue = chartTDO.getShowValue();

         if (showValue == null) {

            chartTDO.setShowValue("0");

         }

         listObject.add(chartTDO);

         return listObject;

      }



      String plusDay = "";

      for (int i = 0; i < 1000; i++) {

         if (i == 0) {

            plusDay = startTime;

         } else {

            plusDay = DateUtil.plusDay(i, startTime);

         }



         String total = null;

         for (int j = 0; j < list.size(); j++) {

            ChartTDO chartTDO = list.get(j);

            String month = chartTDO.getShowDate();

            if (plusDay.equalsIgnoreCase(month)) {

               total = chartTDO.getShowValue();

               break;

            }

         }



         if (total == null) {

            total = "0";

         }

         ChartTDO chartTDO = new ChartTDO();

         chartTDO.setShowValue(total);

         chartTDO.setShowDate(plusDay);

         listObject.add(chartTDO);



         if (plusDay.equals(endTime)) {

            break; // 时间结束

         }

      }



      return listObject;

   }



   public List<ChartTDO> monthFactory(List<ChartTDO> list) {

      List<ChartTDO> listObject = new ArrayList<ChartTDO>();

      // 12 个月处理

      for (int i = 1; i <= 12; i++) {

         String total = null;

         for (int j = 0; j < list.size(); j++) {

            ChartTDO chartTDO = list.get(j);

            String month = chartTDO.getShowDate();

            if ((i + "").equalsIgnoreCase(month) || i == Integer.parseInt(month)) {

               total = chartTDO.getShowValue();

               break;

            }

         }



         if (total == null) {

            total = "0";

         }



         ChartTDO chartTDO = new ChartTDO();

         chartTDO.setShowValue(total);



         if (i < 10) {

            chartTDO.setShowDate("0" + i);

         } else {

            chartTDO.setShowDate("" + i);

         }

         listObject.add(chartTDO);

      }

      return listObject;

   }



   public List<ChartTDO> yearFactory(List<ChartTDO> list) {

      List<ChartTDO> listObject = new ArrayList<ChartTDO>();

      for (int i = 0; i < list.size(); i++) {

         ChartTDO chartTDO = list.get(i);

         String total = chartTDO.getShowValue();

         if (total == null) {

            total = "0";

         }

         chartTDO.setShowValue(total);

         listObject.add(chartTDO);

      }

      return listObject;

   }



   @Override

   public List<UserGoldCoinVO> listByUserGoldCoin(long start, int count, int type, String key) {

      return userInfoCountMapper.listByUserGoldCoin(start, count, type, key);

   }



   @Override

   public long countByUserGoldCoin(int type, String key) {

      return userInfoCountMapper.countByUserGoldCoin(type, key);

   }



   @Override

   public List<UserGoldCoinVO> listByHasGoldCoin(long start, int count, String key) {

      return userInfoCountMapper.listByHasGoldCoin(start, count, key);

   }



   @Override

   public long countByHasGoldCoin(String key) {

      return userInfoCountMapper.countByHasGoldCoin(key);

   }



   @Override

   public List<CountUserInfo> getNewUserData(Date startTime, Date endTime, String channel) {

      // 重新查询统计今日以及空缺

      initChannelUserCount();



      return countUserInfoDao.query(CountUserEnum.newUser, startTime, endTime, channel);

   }



   // 初始化统计

   @Override

   public void initChannelUserCount() {

      CountUserInfo lastRecord = countUserInfoDao.getMaxDate(CountUserEnum.newUser);

      Date lastDay = null;

      if (lastRecord != null && lastRecord.getDay() != null) {

         lastDay = lastRecord.getDay();

      }

      try {

         if (lastDay == null) {

            lastDay = TimeUtil.parse("2017-05-14");

         }



         Date today = new Date();

         int betweenDays = DateUtil.daysBetween2(lastDay, today);

         // 统计今日之前的

         if (betweenDays > 0) {

            for (int i = 0; i <= betweenDays; i++) {

               addRecordCount(DateUtil.plusDay(i, lastDay));

            }

         }

         // 重新统计今日

         addRecordCount(TimeUtil.getGernalTime(today.getTime()));

      } catch (Exception e) {

         e.printStackTrace();

      }

   }



   private void addRecordCount(String preDay) throws Exception {

      ChannelEnum[] channels = ChannelEnum.values();

      for (int i = 0; i < channels.length; i++) {

         Integer count = userInfoRegisterService.countByChannelAndDay(channels[i].getVlaue(), preDay);

         if (count == null) {

            count = 0;

         }

         CountUserInfo record = new CountUserInfo();

         record.setNum(count);

         record.setChannel(channels[i].name());

         record.setId(StringUtil.Md5(preDay + channels[i].name() + CountUserEnum.newUser.name()));

         record.setDay(TimeUtil.parse(preDay));

         record.setType(CountUserEnum.newUser);

         countUserInfoDao.save(record);

      }

   }



	
   @Override

   public List<CountOrderInfo> countOderByChannel(String channel, Date startTime, Date endTime) {

      // 重新查询统计今日以及空缺

      initOrderCount();



      return countOrderInfoDao.query(CountOrderEnum.channelTotal, startTime, endTime, channel);

   }



   // 初始化统计

   private void initOrderCount() {

      try {

         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.channelTotal);

         Date lastDay = null;

         if (lastRecord != null && lastRecord.getDay() != null) {

            lastDay = lastRecord.getDay();

         }



         if (lastDay == null) {

            lastDay = TimeUtil.parse("2018-01-01");

         }



         Date today = new Date();

         int betweenDays = DateUtil.daysBetween2(lastDay, today);

         if (betweenDays > 0) {

            for (int i = 0; i <= betweenDays; i++) {

               addRecordOrderCount(DateUtil.plusDay(i, lastDay));

            }

         } else {

            // 重新统计昨日

            addRecordOrderCount(DateUtil.reduceDay2(1, lastDay));

            // 重新统计今日

            addRecordOrderCount(TimeUtil.getGernalTime(today.getTime()));

         }

      } catch (Exception e) {

         e.printStackTrace();

      }

   }

	
	
   private void addRecordOrderCount(String preDay) throws Exception {

      ChannelEnum[] channels = ChannelEnum.values();

      for (int i = 0; i < channels.length; i++) {

         int count = 0;

         String channelVlaue = channels[i].getVlaue();

		
         List<CountOrderDTO> listOrder = commonOrderCountService.countValidOrderByDay(preDay);

         if (listOrder != null && listOrder.size() > 0) {

            List<Long> listUid = new ArrayList<>();

            for (CountOrderDTO countOrderDTO: listOrder) {

               listUid.add(countOrderDTO.getUid());

            }

				
            List<UserInfoRegister> listRegister = userInfoRegisterService.listByMultipleUids(listUid);

            if (listRegister != null && listRegister.size() > 0) {

               for (int m = 0; m <listRegister.size(); m ++) {

                  boolean reduce = false;

                  Long uid = listRegister.get(m).getId();

                  String vlaue = listRegister.get(m).getChannel().getVlaue();

						
                  for (int n = 0; n <listOrder.size(); n ++) {

                     if (channelVlaue.equalsIgnoreCase(vlaue) && uid.longValue() == listOrder.get(n).getUid()) {

                        Integer totalOrder = listOrder.get(n).getTotalOrder();

                        if (totalOrder != null)

                           count += totalOrder;

								
                        listOrder.remove(n);

                        n--;

                        reduce = true;

                     }

                  }

						
                  if (reduce) {

                     listRegister.remove(m);

                     m--;

                  }

               }

            }

         }

			
         CountOrderInfo record = new CountOrderInfo();

         record.setNum(count);

         record.setChannel(channels[i].name());

         record.setDay(TimeUtil.parse(preDay));

         record.setType(CountOrderEnum.channelTotal.name());

         record.setId(StringUtil.Md5(preDay + channels[i].name() + CountOrderEnum.channelTotal.name()));

         countOrderInfoDao.save(record);

      }

   }

	
	
   @Override

   public List<CountOrderInfo> count24HOderByChannel(String channel, Date startTime, Date endTime) {

      // 重新查询统计今日以及空缺

      init24HOrderCount();



      return countOrderInfoDao.query(CountOrderEnum.oder24H, startTime, endTime, channel);

   }



   // 初始化统计

   private void init24HOrderCount() {

      try {

         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.oder24H);

         Date lastDay = null;

         if (lastRecord != null && lastRecord.getDay() != null) {

            lastDay = lastRecord.getDay();

         }



         if (lastDay == null) {

            lastDay = TimeUtil.parse("2018-01-01");

         }



         Date today = new Date();

         int betweenDays = DateUtil.daysBetween2(lastDay, today);

         if (betweenDays > 0) {

            for (int i = 0; i <= betweenDays; i++) {

               addRecord24HOrderCount(DateUtil.plusDay(i, lastDay));

            }

         } else {

            // 重新统计昨日

            addRecord24HOrderCount(DateUtil.reduceDay2(1, lastDay));

            // 重新统计今日

            addRecord24HOrderCount(TimeUtil.getGernalTime(today.getTime()));

         }

      } catch (Exception e) {

         e.printStackTrace();

      }

   }



   private void addRecord24HOrderCount(String preDay) throws Exception {

      ChannelEnum[] channels = ChannelEnum.values();

      for (int i = 0; i < channels.length; i++) {

         int count = 0;

         List<UserInfoRegister> list = userInfoRegisterService.listByChannelAndDay(channels[i].getVlaue(), preDay);

         if (list != null && list.size() > 0) {

            // 统计24小时产生订单数量

            for (UserInfoRegister user : list) {

               Date limitDay = DateUtil.plusDayDate(1, user.getCreateTime());

               Integer total = commonOrderCountService.countOderByUidAndDate(limitDay, user.getId());

               if (total != null)

                  count += total;

            }

         }

         CountOrderInfo record = new CountOrderInfo();

         record.setNum(count);

         record.setChannel(channels[i].name());

         record.setDay(TimeUtil.parse(preDay));

         record.setType(CountOrderEnum.oder24H.name());

         record.setId(StringUtil.Md5(preDay + channels[i].name() + CountOrderEnum.oder24H.name()));

         countOrderInfoDao.save(record);

      }

   }



	
   @Override

   public List<CountOrderInfo> countHongBaoByChannel(String channel, Date startTime, Date endTime) {

      // 重新查询统计今日以及空缺

      initHongBaoCount();



      return countOrderInfoDao.query(CountOrderEnum.channelCommission, startTime, endTime, channel);

   }



   // 初始化统计

   private void initHongBaoCount() {

      try {

         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.channelCommission);

         Date lastDay = null;

         if (lastRecord != null && lastRecord.getDay() != null) {

            lastDay = lastRecord.getDay();

         }



         if (lastDay == null) {

            lastDay = TimeUtil.parse("2018-01-01");

         }



         Date today = new Date();

         int betweenDays = DateUtil.daysBetween2(lastDay, today);

         if (betweenDays > 0) {

            for (int i = 0; i <= betweenDays; i++) {

               addRecordHongBaoCount(DateUtil.plusDay(i, lastDay));

            }

         } else {

            // 重新统计昨日

            addRecordHongBaoCount(DateUtil.reduceDay2(1, lastDay));

            // 重新统计今日

            addRecordHongBaoCount(TimeUtil.getGernalTime(today.getTime()));

         }

      } catch (Exception e) {

         e.printStackTrace();

      }

   }



   private void addRecordHongBaoCount(String preDay) throws Exception {

      ChannelEnum[] channels = ChannelEnum.values();

      for (int i = 0; i < channels.length; i++) {

         BigDecimal money = new BigDecimal(0);

         String channelVlaue = channels[i].getVlaue();

		
         List<CountOrderDTO> listOrder = commonOrderCountService.countCommissionByDay(preDay);

         if (listOrder != null && listOrder.size() > 0) {

            List<Long> listUid = new ArrayList<>();

            for (CountOrderDTO countOrderDTO: listOrder) {

               listUid.add(countOrderDTO.getUid());

            }

				
            List<UserInfoRegister> listRegister = userInfoRegisterService.listByMultipleUids(listUid);

            if (listRegister != null && listRegister.size() > 0) {

               for (int m = 0; m <listRegister.size(); m ++) {

                  boolean reduce = false;

                  Long uid = listRegister.get(m).getId();

                  String vlaue = listRegister.get(m).getChannel().getVlaue();

						
                  for (int n = 0; n <listOrder.size(); n ++) {

                     if (channelVlaue.equalsIgnoreCase(vlaue) && uid.longValue() == listOrder.get(n).getUid()) {

                        BigDecimal commission = listOrder.get(n).getCommission();

                        if (commission != null)

                           MoneyBigDecimalUtil.add(money, commission);

								
                        listOrder.remove(n);

                        n--;

                        reduce = true;

                     }

                  }

						
                  if (reduce) {

                     listRegister.remove(m);

                     m--;

                  }

               }

            }

         }

			
			
         CountOrderInfo record = new CountOrderInfo();

         record.setMoney(money);

         record.setChannel(channels[i].name());

         record.setDay(TimeUtil.parse(preDay));

         record.setType(CountOrderEnum.channelCommission.name());

         record.setId(StringUtil.Md5(preDay + channels[i].name() + CountOrderEnum.channelCommission.name()));

         countOrderInfoDao.save(record);

      }

   }

	
	
   @Override

   public List<CountOrderInfo> countWeiQuanOrder(Date startTime, Date endTime) {

      // 重新查询统计今日以及空缺

      initWeiQuanCount();



      return countOrderInfoDao.query(CountOrderEnum.weiQuanNum, startTime, endTime);

   }



   // 初始化统计

   private void initWeiQuanCount() {

      try {

         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.weiQuanNum);

         Date lastDay = null;

         if (lastRecord != null && lastRecord.getDay() != null) {

            lastDay = lastRecord.getDay();

         }



         if (lastDay == null) {

            lastDay = TimeUtil.parse("2019-01-01");

         }



         Date today = new Date();

         int betweenDays = DateUtil.daysBetween2(lastDay, today);

         if (betweenDays > 0) {

            for (int i = 0; i <= betweenDays; i++) {

               addRecordWeiQuanCount(DateUtil.plusDay(i, lastDay));

            }

         } else {

            // 重新统计昨日

            addRecordWeiQuanCount(DateUtil.reduceDay2(1, lastDay));

            // 重新统计今日

            addRecordWeiQuanCount(TimeUtil.getGernalTime(today.getTime()));

         }

      } catch (Exception e) {

         e.printStackTrace();

      }

   }



   private void addRecordWeiQuanCount(String preDay) throws Exception {

      Integer count = userOrderWeiQuanRecordService.countWeiQaunOrderNumberByDate(preDay);

      if (count == null)

         count = 0;

      CountOrderInfo record = new CountOrderInfo();

      record.setNum(count);

      record.setDay(TimeUtil.parse(preDay));

      record.setType(CountOrderEnum.weiQuanNum.name());

      record.setId(StringUtil.Md5(preDay + CountOrderEnum.weiQuanNum.name()));

      countOrderInfoDao.save(record);

   }

	
	
   @Override

   public List<CountOrderInfo> countWeiQuanOrderMoney(Date startTime, Date endTime) {

      // 重新查询统计今日以及空缺

      initWeiQuanMoneyCount();



      return countOrderInfoDao.query(CountOrderEnum.weiQuanMoney, startTime, endTime);

   }



   // 初始化统计

   private void initWeiQuanMoneyCount() {

      try {

         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.weiQuanMoney);

         Date lastDay = null;

         if (lastRecord != null && lastRecord.getDay() != null) {

            lastDay = lastRecord.getDay();

         }



         if (lastDay == null) {

            lastDay = TimeUtil.parse("2019-01-01");

         }



         Date today = new Date();

         int betweenDays = DateUtil.daysBetween2(lastDay, today);

         if (betweenDays > 0) {

            for (int i = 0; i <= betweenDays; i++) {

               addRecordWeiQuanMoneyCount(DateUtil.plusDay(i, lastDay));

            }

         } else {

            // 重新统计昨日

            addRecordWeiQuanMoneyCount(DateUtil.reduceDay2(1, lastDay));

            // 重新统计今日

            addRecordWeiQuanMoneyCount(TimeUtil.getGernalTime(today.getTime()));

         }

      } catch (Exception e) {

         e.printStackTrace();

      }

   }



   private void addRecordWeiQuanMoneyCount(String preDay) throws Exception {

      BigDecimal money = userOrderWeiQuanRecordService.countWeiQaunOrderMoneyByDate(preDay);

      if (money == null)

         money = new BigDecimal(0);

      CountOrderInfo record = new CountOrderInfo();

      record.setMoney(money);

      record.setDay(TimeUtil.parse(preDay));

      record.setType(CountOrderEnum.weiQuanMoney.name());

      record.setId(StringUtil.Md5(preDay + CountOrderEnum.weiQuanMoney.name()));

      countOrderInfoDao.save(record);

   }

	
	
   @Override

   public List<CountOrderInfo> counOrderTotalNum(Date startTime, Date endTime) {

      // 重新查询统计今日以及空缺

      initOrderTotalNum();



      return countOrderInfoDao.query(CountOrderEnum.totalNum, startTime, endTime);

   }



   // 初始化统计

   private void initOrderTotalNum() {

      try {

         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.totalNum);

         Date lastDay = null;

         if (lastRecord != null && lastRecord.getDay() != null) {

            lastDay = lastRecord.getDay();

         }



         if (lastDay == null) {

            lastDay = TimeUtil.parse("2019-01-01");

         }



         Date today = new Date();

         int betweenDays = DateUtil.daysBetween2(lastDay, today);

         if (betweenDays > 0) {

            for (int i = 0; i <= betweenDays; i++) {

               addRecordOrderTotalNum(DateUtil.plusDay(i, lastDay));

            }

         } else {

            // 重新统计昨日

            addRecordOrderTotalNum(DateUtil.reduceDay2(1, lastDay));

            // 重新统计今日

            addRecordOrderTotalNum(TimeUtil.getGernalTime(today.getTime()));

         }

      } catch (Exception e) {

         e.printStackTrace();

      }

   }



   private void addRecordOrderTotalNum(String preDay) throws Exception {

      Integer num = commonOrderCountService.countOderByDate(preDay);

      if (num == null)

         num = 0;

      CountOrderInfo record = new CountOrderInfo();

      record.setNum(num);

      record.setDay(TimeUtil.parse(preDay));

      record.setType(CountOrderEnum.totalNum.name());

      record.setId(StringUtil.Md5(preDay + CountOrderEnum.totalNum.name()));

      countOrderInfoDao.save(record);

   }

	
	
	
	
   @Override

   public List<CountOrderInfo> counOrderTotalCommission(Date startTime, Date endTime) {

      // 重新查询统计今日以及空缺

      initTotalCommission();



      return countOrderInfoDao.query(CountOrderEnum.totalCommission, startTime, endTime);

   }



   // 初始化统计

   private void initTotalCommission() {

      try {

         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.totalCommission);

         Date lastDay = null;

         if (lastRecord != null && lastRecord.getDay() != null) {

            lastDay = lastRecord.getDay();

         }



         if (lastDay == null) {

            lastDay = TimeUtil.parse("2019-01-01");

         }



         Date today = new Date();

         int betweenDays = DateUtil.daysBetween2(lastDay, today);

         if (betweenDays > 0) {

            for (int i = 0; i <= betweenDays; i++) {

               addRecordTotalCommission(DateUtil.plusDay(i, lastDay));

            }

         } else {

            // 重新统计昨日

            addRecordTotalCommission(DateUtil.reduceDay2(1, lastDay));

            // 重新统计今日

            addRecordTotalCommission(TimeUtil.getGernalTime(today.getTime()));

         }

      } catch (Exception e) {

         e.printStackTrace();

      }

   }



   private void addRecordTotalCommission(String preDay) throws Exception {

      BigDecimal money = commonOrderCountService.countCommissionByDate(preDay);

      if (money == null)

         money = new BigDecimal("0");

      CountOrderInfo record = new CountOrderInfo();

      record.setMoney(money);

      record.setDay(TimeUtil.parse(preDay));

      record.setType(CountOrderEnum.totalCommission.name());

      record.setId(StringUtil.Md5(preDay + CountOrderEnum.totalCommission.name()));

      countOrderInfoDao.save(record);

   }

	
   @Override

   public List<CountOrderInfo> counOrderLastNum(Date startTime, Date endTime) {

      // 重新查询统计今日以及空缺

      initOrderLastNum();



      return countOrderInfoDao.query(CountOrderEnum.lastNum, startTime, endTime);

   }



   // 初始化统计

   private void initOrderLastNum() {

      try {

         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.lastNum);

         Date lastDay = null;

         if (lastRecord != null && lastRecord.getDay() != null) {

            lastDay = lastRecord.getDay();

         }



         if (lastDay == null) {

            lastDay = TimeUtil.parse("2019-01-01");

         }



         Date today = new Date();

         int betweenDays = DateUtil.daysBetween2(lastDay, today);

         if (betweenDays > 0) {

            for (int i = 0; i <= betweenDays; i++) {

               addRecordOrderLastNum(DateUtil.plusDay(i, lastDay));

            }

         } else {

            // 重新统计昨日

            addRecordOrderLastNum(DateUtil.reduceDay2(1, lastDay));

            // 重新统计今日

            addRecordOrderLastNum(TimeUtil.getGernalTime(today.getTime()));

         }

      } catch (Exception e) {

         e.printStackTrace();

      }

   }



   private void addRecordOrderLastNum(String preDay) throws Exception {

      Integer num = lostOrderService.countLostOrderNum(preDay);

      if (num == null)

         num = 0;

      CountOrderInfo record = new CountOrderInfo();

      record.setNum(num);

      record.setDay(TimeUtil.parse(preDay));

      record.setType(CountOrderEnum.lastNum.name());

      record.setId(StringUtil.Md5(preDay + CountOrderEnum.lastNum.name()));

      countOrderInfoDao.save(record);

   }

	
   @Override

   public List<CountOrderInfo> counOrderLastMoney(Date startTime, Date endTime) {

      // 重新查询统计今日以及空缺

      initOrderLastMoney();



      return countOrderInfoDao.query(CountOrderEnum.lastMoney, startTime, endTime);

   }



   // 初始化统计

   private void initOrderLastMoney() {

      try {

         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.lastMoney);

         Date lastDay = null;

         if (lastRecord != null && lastRecord.getDay() != null) {

            lastDay = lastRecord.getDay();

         }



         if (lastDay == null) {

            lastDay = TimeUtil.parse("2019-01-01");

         }



         Date today = new Date();

         int betweenDays = DateUtil.daysBetween2(lastDay, today);

         if (betweenDays > 0) {

            for (int i = 0; i <= betweenDays; i++) {

               addRecordOrderLastMoney(DateUtil.plusDay(i, lastDay));

            }

         } else {

            // 重新统计昨日

            addRecordOrderLastMoney(DateUtil.reduceDay2(1, lastDay));

            // 重新统计今日

            addRecordOrderLastMoney(TimeUtil.getGernalTime(today.getTime()));

         }

      } catch (Exception e) {

         e.printStackTrace();

      }

   }



   private void addRecordOrderLastMoney(String preDay) throws Exception {

      BigDecimal money = lostOrderService.countAppealMoney(preDay);

      if (money == null)

         money = new BigDecimal("0");

      CountOrderInfo record = new CountOrderInfo();

      record.setMoney(money);

      record.setDay(TimeUtil.parse(preDay));

      record.setType(CountOrderEnum.lastMoney.name());

      record.setId(StringUtil.Md5(preDay + CountOrderEnum.lastMoney.name()));

      countOrderInfoDao.save(record);

   }

	
	
   @Override

   public List<CountOrderInfo> countOrderType(Integer state, Date startTime, Date endTime) {

      // 重新查询统计今日以及空缺

      initOrderTypeCount();



      return countOrderInfoDao.query(CountOrderEnum.orderType, startTime, endTime, state);

   }



   // 初始化统计

   private void initOrderTypeCount() {

      try {

         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.orderType);

         Date lastDay = null;

         if (lastRecord != null && lastRecord.getDay() != null) {

            lastDay = lastRecord.getDay();

         }



         if (lastDay == null) {

            lastDay = TimeUtil.parse("2018-01-01");

         }



         Date today = new Date();

         int betweenDays = DateUtil.daysBetween2(lastDay, today);

         if (betweenDays > 0) {

            for (int i = 0; i <= betweenDays; i++) {

               addRecordOrderTypeCount(DateUtil.plusDay(i, lastDay));

            }

         } else {

            // 重新统计昨日

            addRecordOrderTypeCount(DateUtil.reduceDay2(1, lastDay));

            // 重新统计今日

            addRecordOrderTypeCount(TimeUtil.getGernalTime(today.getTime()));

         }

      } catch (Exception e) {

         e.printStackTrace();

      }

   }



   private void addRecordOrderTypeCount(String preDay) throws Exception {

      for (int i = 1; i < 4; i++) {

         Integer count = hongBaoV2CountService.countOrderByTypeAndDate(i, preDay);

         if (count == null)

            count = 0;

         CountOrderInfo record = new CountOrderInfo();

         record.setNum(count);

         record.setState(i);

         record.setDay(TimeUtil.parse(preDay));

         record.setType(CountOrderEnum.orderType.name());

         record.setId(StringUtil.Md5(preDay + CountOrderEnum.orderType.name()));

         countOrderInfoDao.save(record);

      }

   }

	
   @Override

   public List<CountUserInfo> countUserDownOrderByChannelAndToday(String channel, Date startTime, Date endTime) {

      // 重新查询统计今日以及空缺

      initTodayDownOrderCount();



      return countUserInfoDao.query(CountUserEnum.todayOrder, startTime, endTime, channel);

   }



   // 初始化统计

   private void initTodayDownOrderCount() {

      try {

         CountUserInfo lastRecord = countUserInfoDao.getMaxDate(CountUserEnum.todayOrder);

         Date lastDay = null;

         if (lastRecord != null && lastRecord.getDay() != null) {

            lastDay = lastRecord.getDay();

         }

         if (lastDay == null) {

            lastDay = TimeUtil.parse("2018-01-01");

         }



         Date today = new Date();

         int betweenDays = DateUtil.daysBetween2(lastDay, today);

         if (betweenDays > 0) {

            for (int i = 0; i <= betweenDays; i++) {

               addRecordTodayDownOrderCount(DateUtil.plusDay(i, lastDay));

            }

         } else {

            // 重新统计昨日

            addRecordTodayDownOrderCount(DateUtil.reduceDay2(1, lastDay));

            // 重新统计今日

            addRecordTodayDownOrderCount(TimeUtil.getGernalTime(today.getTime()));

         }

      } catch (Exception e) {

         e.printStackTrace();

      }

   }



   private void addRecordTodayDownOrderCount(String preDay) throws Exception {

      ChannelEnum[] channels = ChannelEnum.values();

      for (int i = 0; i < channels.length; i++) {

         int count = 0;

         String channelVlaue = channels[i].getVlaue();

		
         List<CountOrderDTO> listOrder = commonOrderCountService.countValidOrderByDay(preDay);

         if (listOrder != null && listOrder.size() > 0) {

            List<Long> listUid = new ArrayList<>();

            for (CountOrderDTO countOrderDTO: listOrder) {

               listUid.add(countOrderDTO.getUid());

            }

				
            List<UserInfoRegister> listRegister = userInfoRegisterService.listByMultipleUidAndDay(listUid, preDay);

            if (listRegister != null && listRegister.size() > 0) {

               for (int m = 0; m <listRegister.size(); m ++) {

                  boolean reduce = false;

                  Long uid = listRegister.get(m).getId();

                  String vlaue = listRegister.get(m).getChannel().getVlaue();

						
                  for (int n = 0; n <listOrder.size(); n ++) {

                     if (channelVlaue.equalsIgnoreCase(vlaue) && uid.longValue() == listOrder.get(n).getUid()) {

                        Integer totalOrder = listOrder.get(n).getTotalOrder();

                        if (totalOrder != null)

                           count += totalOrder;

								
                        listOrder.remove(n);

                        n--;

                        reduce = true;

                     }

                  }

						
                  if (reduce) {

                     listRegister.remove(m);

                     m--;

                  }

               }

            }

         }

			
         CountUserInfo record = new CountUserInfo();

         record.setNum(count);

         record.setChannel(channels[i].name());

         record.setDay(TimeUtil.parse(preDay));

         record.setType(CountUserEnum.todayOrder);

         record.setId(StringUtil.Md5(preDay + channels[i].name() + CountUserEnum.todayOrder.name()));

         countUserInfoDao.save(record);

      }

   }



   @Override

   public List<CountUserInfo> countUseByChannelAndWeekOrder(String channel, Date startTime, Date endTime) {

      return countUserInfoDao.query(CountUserEnum.weekOrder, startTime, endTime, channel);

   }



   @Override

   public List<CountUserInfo> countUseByChannelAndWeekThreeOrder(String channel, Date startTime, Date endTime) {

      return countUserInfoDao.query(CountUserEnum.weekThreeOrder, startTime, endTime, channel);

   }



   // 初始化统计

   @Override

   public void initCountUserWeekOrder() {

      try {

         CountUserInfo lastRecord = countUserInfoDao.getMaxDate(CountUserEnum.weekOrder);

         Date lastDay = null;

         if (lastRecord != null && lastRecord.getDay() != null) {

            lastDay = lastRecord.getDay();

         }

         if (lastDay == null) {

            lastDay = TimeUtil.parse("2018-01-01");

         }

         Date today = new Date();

         int betweenDays = DateUtil.daysBetween2(lastDay, today);

         if (betweenDays > 0) {

            for (int i = 0; i <= betweenDays; i++) {

               addRecordWeekOrderCount(DateUtil.plusDay(i, lastDay));

            }

         } else {

            // 重新统计昨日

            addRecordWeekOrderCount(DateUtil.reduceDay2(1, lastDay));

            // 重新统计今日

            addRecordWeekOrderCount(TimeUtil.getGernalTime(today.getTime()));

         }

      } catch (Exception e) {

         e.printStackTrace();

      }

   }



   private void addRecordWeekOrderCount(String preDay) throws Exception {

      ChannelEnum[] channels = ChannelEnum.values();

      for (int i = 0; i < channels.length; i++) {

         int count = 0;

         int count3 = 0;

         List<UserInfoRegister> list = userInfoRegisterService.listByChannelAndDay(channels[i].getVlaue(), preDay);

         if (list != null && list.size() > 0) {

            Date startDay = new Date(TimeUtil.convertDateToTemp2(preDay + " 23:59:59"));

            Date limitDay = DateUtil.plusDayDate(6, startDay);

            for (UserInfoRegister user : list) {

               Integer total = commonOrderCountService.countOderByUidAndDate(limitDay, user.getId());

               if (total != null && total > 0) {

                  count++;

                  if (total >= 3) {

                     count3++;

                  }

               }

            }

         }



         // 7天内产生有效订单

         CountUserInfo record = new CountUserInfo();

         record.setNum(count);

         record.setChannel(channels[i].name());

         record.setDay(TimeUtil.parse(preDay));

         record.setType(CountUserEnum.weekOrder);

         record.setId(StringUtil.Md5(preDay + channels[i].name() + CountUserEnum.weekOrder.name()));

         countUserInfoDao.save(record);



         // 7天内产生3单以上有效订单

         CountUserInfo record3 = new CountUserInfo();

         record3.setNum(count3);

         record3.setChannel(channels[i].name());

         record3.setDay(TimeUtil.parse(preDay));

         record3.setType(CountUserEnum.weekThreeOrder);

         record3.setId(StringUtil.Md5(preDay + channels[i].name() + CountUserEnum.weekThreeOrder.name()));

         countUserInfoDao.save(record);

      }

   }

	
}

package com.yeshi.fanli.service.impl.count;

import java.math.BigDecimal;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;

import javax.annotation.Resource;

import org.springframework.stereotype.Service;
import org.yeshi.utils.DateUtil;

import com.yeshi.fanli.dao.mybatis.UserInfoCountMapper;
import com.yeshi.fanli.dao.mybatis.UserInfoMapper;
import com.yeshi.fanli.dao.user.count.CountOrderInfoDao;
import com.yeshi.fanli.dao.user.count.CountUserInfoDao;
import com.yeshi.fanli.dto.ChartTDO;
import com.yeshi.fanli.dto.order.CountOrderDTO;
import com.yeshi.fanli.entity.admin.count.CountOrderInfo;
import com.yeshi.fanli.entity.admin.count.CountOrderInfo.CountOrderEnum;
import com.yeshi.fanli.entity.admin.count.CountUserInfo;
import com.yeshi.fanli.entity.admin.count.CountUserInfo.CountUserEnum;
import com.yeshi.fanli.entity.bus.user.UserInfoRegister;
import com.yeshi.fanli.entity.system.ChannelEnum;
import com.yeshi.fanli.service.inter.count.HongBaoV2CountService;
import com.yeshi.fanli.service.inter.count.UserInfoCountService;
import com.yeshi.fanli.service.inter.order.CommonOrderCountService;
import com.yeshi.fanli.service.inter.order.LostOrderService;
import com.yeshi.fanli.service.inter.order.UserOrderWeiQuanRecordService;
import com.yeshi.fanli.service.inter.user.UserInfoRegisterService;
import org.yeshi.utils.MoneyBigDecimalUtil;
import com.yeshi.fanli.util.StringUtil;
import org.yeshi.utils.TimeUtil;
import com.yeshi.fanli.vo.user.UserGoldCoinVO;

@Service
public class UserInfoCountServiceImpl implements UserInfoCountService {

   @Resource
   private UserInfoMapper userInfoMapper;

   @Resource
   private UserInfoCountMapper userInfoCountMapper;

   @Resource
   private CountUserInfoDao countUserInfoDao;

   @Resource
   private CountOrderInfoDao countOrderInfoDao;

   @Resource
   private CommonOrderCountService commonOrderCountService;
	
   @Resource
   private HongBaoV2CountService hongBaoV2CountService;

   @Resource
   private UserOrderWeiQuanRecordService userOrderWeiQuanRecordService;
	
   @Resource
   private LostOrderService lostOrderService;
	
   @Resource
   private UserInfoRegisterService userInfoRegisterService;
	
	
   @Override
   public long countNewUser(Integer isToday, Integer isMonth) {
      return userInfoMapper.countNewUser(isToday, isMonth);
   }

   @Override
   public long countRank(Integer rank) {
      return userInfoMapper.countRank(rank);
   }

   @Override
   public BigDecimal countAllMoney(Double rank) {
      return userInfoMapper.countAllMoney(rank);
   }

   @Override
   public long countLoseUser(int daysNum) {
      return userInfoMapper.countLoseUser(daysNum);
   }

   @Override
   public long countHasOrderUser() {
      return userInfoMapper.countHasOrderUser();
   }

   @Override
   public List<ChartTDO> countNewUserByDate(String channel, Integer type, String years, String startTime,
         String endTime) throws Exception {
      return userInfoMapper.countNewUserByDate(channel, type, years, startTime, endTime);

   }

   @Override
   public List<ChartTDO> getTodayBuyRate(String channel, Integer dateType, String years, String startTime,
         String endTime) throws Exception {

      List<ChartTDO> result_list = null;

      List<ChartTDO> listToday = userInfoMapper.getTodayHasOrder(channel, dateType, years, startTime, endTime);

      if (listToday == null || listToday.size() == 0) {
         return result_list;
      }

      List<ChartTDO> listTotal = userInfoMapper.countNewUserByDate(channel, dateType, years, startTime, endTime);

      if (listTotal == null || listTotal.size() == 0) {
         return result_list;
      }

      switch (dateType) {
      case 1: // 按天处理
         result_list = dayFactory(startTime, endTime, listTotal);
         break;
      case 2: // 按月处理
         result_list = monthFactory(listTotal);
         break;
      case 3:
         result_list = yearFactory(listTotal);
         break;
      default:
         break;
      }

      DecimalFormat df = new DecimalFormat("#.00");

      for (int i = 0; i < result_list.size(); i++) {
         double proportion = 0;
         ChartTDO chartTDO = result_list.get(i);
         String showDate = chartTDO.getShowDate();
         for (int j = 0; j < listToday.size(); j++) {
            ChartTDO innerTDO = listToday.get(j);
            String innerDate = innerTDO.getShowDate();
            if (innerDate != null && innerDate.equals(showDate)) {
               String innerValue = innerTDO.getShowValue();
               long innerData = Long.parseLong(innerValue);

               String showValue = chartTDO.getShowValue();
               long showData = Long.parseLong(showValue);

               if (showData > 0) {
                  proportion = innerData / (double) showData;
               }
               break; // 结束内部循环
            }
         }
         chartTDO.setShowValue(Double.parseDouble(df.format(proportion * 100)) + "");
      }
      return result_list;
   }

   @Override
   public List<Object> getWeekBuyRate(String channel, String startTime, String endTime, Integer orderNum,
         List<String> dateList) throws Exception {
      List<Object> resultList = new ArrayList<Object>();
      if (dateList == null || dateList.size() == 0) {
         return resultList;
      }

      List<ChartTDO> totalList = userInfoMapper.countNewUserByDate(channel, 1, null, startTime, endTime);
      if (totalList == null || totalList.size() == 0) {
         return resultList;
      }

      DecimalFormat df = new DecimalFormat("#.00");
      for (int i = 0; i < dateList.size(); i++) {
         double proportion = 0;
         String showDate = dateList.get(i);
         String plusDay = DateUtil.plusDay(7, showDate);
         ChartTDO chartTDO = userInfoMapper.getWeekHasOrder(channel, showDate, plusDay, orderNum);

         String showValue = null;
         if (chartTDO != null) {
            showValue = chartTDO.getShowValue();
            if (showValue != null) {
               for (int j = 0; j < totalList.size(); j++) {
                  ChartTDO chart = totalList.get(j);
                  String reslutTime = chart.getShowDate();
                  if (showDate.equalsIgnoreCase(reslutTime)) {
                     String totalObject = chart.getShowValue();
                     long hasCount = Long.parseLong(showValue);
                     long total = Long.parseLong(totalObject);

                     if (total > 0) {
                        proportion = hasCount / (double) total;
                     }

                     break;
                  }
               }
            }
         }
         resultList.add(Double.parseDouble(df.format(proportion * 100)));
      }

      return resultList;
   }

   public List<ChartTDO> dayFactory(String startTime, String endTime, List<ChartTDO> list) throws Exception {
      List<ChartTDO> listObject = new ArrayList<ChartTDO>();
      if (startTime.equals(endTime)) {
         ChartTDO chartTDO = list.get(0);
         String showValue = chartTDO.getShowValue();
         if (showValue == null) {
            chartTDO.setShowValue("0");
         }
         listObject.add(chartTDO);
         return listObject;
      }

      String plusDay = "";
      for (int i = 0; i < 1000; i++) {
         if (i == 0) {
            plusDay = startTime;
         } else {
            plusDay = DateUtil.plusDay(i, startTime);
         }

         String total = null;
         for (int j = 0; j < list.size(); j++) {
            ChartTDO chartTDO = list.get(j);
            String month = chartTDO.getShowDate();
            if (plusDay.equalsIgnoreCase(month)) {
               total = chartTDO.getShowValue();
               break;
            }
         }

         if (total == null) {
            total = "0";
         }
         ChartTDO chartTDO = new ChartTDO();
         chartTDO.setShowValue(total);
         chartTDO.setShowDate(plusDay);
         listObject.add(chartTDO);

         if (plusDay.equals(endTime)) {
            break; // 时间结束
         }
      }

      return listObject;
   }

   public List<ChartTDO> monthFactory(List<ChartTDO> list) {
      List<ChartTDO> listObject = new ArrayList<ChartTDO>();
      // 12 个月处理
      for (int i = 1; i <= 12; i++) {
         String total = null;
         for (int j = 0; j < list.size(); j++) {
            ChartTDO chartTDO = list.get(j);
            String month = chartTDO.getShowDate();
            if ((i + "").equalsIgnoreCase(month) || i == Integer.parseInt(month)) {
               total = chartTDO.getShowValue();
               break;
            }
         }

         if (total == null) {
            total = "0";
         }

         ChartTDO chartTDO = new ChartTDO();
         chartTDO.setShowValue(total);

         if (i < 10) {
            chartTDO.setShowDate("0" + i);
         } else {
            chartTDO.setShowDate("" + i);
         }
         listObject.add(chartTDO);
      }
      return listObject;
   }

   public List<ChartTDO> yearFactory(List<ChartTDO> list) {
      List<ChartTDO> listObject = new ArrayList<ChartTDO>();
      for (int i = 0; i < list.size(); i++) {
         ChartTDO chartTDO = list.get(i);
         String total = chartTDO.getShowValue();
         if (total == null) {
            total = "0";
         }
         chartTDO.setShowValue(total);
         listObject.add(chartTDO);
      }
      return listObject;
   }

   @Override
   public List<UserGoldCoinVO> listByUserGoldCoin(long start, int count, int type, String key) {
      return userInfoCountMapper.listByUserGoldCoin(start, count, type, key);
   }

   @Override
   public long countByUserGoldCoin(int type, String key) {
      return userInfoCountMapper.countByUserGoldCoin(type, key);
   }

   @Override
   public List<UserGoldCoinVO> listByHasGoldCoin(long start, int count, String key) {
      return userInfoCountMapper.listByHasGoldCoin(start, count, key);
   }

   @Override
   public long countByHasGoldCoin(String key) {
      return userInfoCountMapper.countByHasGoldCoin(key);
   }

   @Override
   public List<CountUserInfo> getNewUserData(Date startTime, Date endTime, String channel) {
      // 重新查询统计今日以及空缺

      return countUserInfoDao.query(CountUserEnum.newUser, startTime, endTime, channel);
   }



	
   @Override
   public List<CountOrderInfo> countOderByChannel(String channel, Date startTime, Date endTime) {
      // 重新查询统计今日以及空缺
      initOrderCount();

      return countOrderInfoDao.query(CountOrderEnum.channelTotal, startTime, endTime, channel);
   }

   // 初始化统计
   private void initOrderCount() {
      try {
         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.channelTotal);
         Date lastDay = null;
         if (lastRecord != null && lastRecord.getDay() != null) {
            lastDay = lastRecord.getDay();
         }

         if (lastDay == null) {
            lastDay = TimeUtil.parse("2018-01-01");
         }

         Date today = new Date();
         int betweenDays = DateUtil.daysBetween2(lastDay, today);
         if (betweenDays > 0) {
            for (int i = 0; i <= betweenDays; i++) {
               addRecordOrderCount(DateUtil.plusDay(i, lastDay));
            }
         } else {
            // 重新统计昨日
            addRecordOrderCount(DateUtil.reduceDay2(1, lastDay));
            // 重新统计今日
            addRecordOrderCount(TimeUtil.getGernalTime(today.getTime()));
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
	
	
   private void addRecordOrderCount(String preDay) throws Exception {
      ChannelEnum[] channels = ChannelEnum.values();
      for (int i = 0; i < channels.length; i++) {
         int count = 0;
         String channelVlaue = channels[i].getVlaue();
		
         List<CountOrderDTO> listOrder = commonOrderCountService.countValidOrderByDay(preDay);
         if (listOrder != null && listOrder.size() > 0) {
            List<Long> listUid = new ArrayList<>();
            for (CountOrderDTO countOrderDTO: listOrder) {
               listUid.add(countOrderDTO.getUid());
            }
				
            List<UserInfoRegister> listRegister = userInfoRegisterService.listByMultipleUids(listUid);
            if (listRegister != null && listRegister.size() > 0) {
               for (int m = 0; m <listRegister.size(); m ++) {
                  boolean reduce = false;
                  Long uid = listRegister.get(m).getId();
                  String vlaue = listRegister.get(m).getChannel();
						
                  for (int n = 0; n <listOrder.size(); n ++) {
                     if (channelVlaue.equalsIgnoreCase(vlaue) && uid.longValue() == listOrder.get(n).getUid()) {
                        Integer totalOrder = listOrder.get(n).getTotalOrder();
                        if (totalOrder != null)
                           count += totalOrder;
								
                        listOrder.remove(n);
                        n--;
                        reduce = true;
                     }
                  }
						
                  if (reduce) {
                     listRegister.remove(m);
                     m--;
                  }
               }
            }
         }
			
         CountOrderInfo record = new CountOrderInfo();
         record.setNum(count);
         record.setChannel(channels[i].name());
         record.setDay(TimeUtil.parse(preDay));
         record.setType(CountOrderEnum.channelTotal.name());
         record.setId(StringUtil.Md5(preDay + channels[i].name() + CountOrderEnum.channelTotal.name()));
         countOrderInfoDao.save(record);
      }
   }
	
	
   @Override
   public List<CountOrderInfo> count24HOderByChannel(String channel, Date startTime, Date endTime) {
      // 重新查询统计今日以及空缺
      init24HOrderCount();

      return countOrderInfoDao.query(CountOrderEnum.oder24H, startTime, endTime, channel);
   }

   // 初始化统计
   private void init24HOrderCount() {
      try {
         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.oder24H);
         Date lastDay = null;
         if (lastRecord != null && lastRecord.getDay() != null) {
            lastDay = lastRecord.getDay();
         }

         if (lastDay == null) {
            lastDay = TimeUtil.parse("2018-01-01");
         }

         Date today = new Date();
         int betweenDays = DateUtil.daysBetween2(lastDay, today);
         if (betweenDays > 0) {
            for (int i = 0; i <= betweenDays; i++) {
               addRecord24HOrderCount(DateUtil.plusDay(i, lastDay));
            }
         } else {
            // 重新统计昨日
            addRecord24HOrderCount(DateUtil.reduceDay2(1, lastDay));
            // 重新统计今日
            addRecord24HOrderCount(TimeUtil.getGernalTime(today.getTime()));
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }

   private void addRecord24HOrderCount(String preDay) throws Exception {
      ChannelEnum[] channels = ChannelEnum.values();
      for (int i = 0; i < channels.length; i++) {
         int count = 0;
         List<UserInfoRegister> list = userInfoRegisterService.listByChannelAndDay(channels[i].getVlaue(), preDay);
         if (list != null && list.size() > 0) {
            // 统计24小时产生订单数量
            for (UserInfoRegister user : list) {
               Date limitDay = DateUtil.plusDayDate(1, user.getCreateTime());
               Integer total = commonOrderCountService.countOderByUidAndDate(limitDay, user.getId());
               if (total != null)
                  count += total;
            }
         }
         CountOrderInfo record = new CountOrderInfo();
         record.setNum(count);
         record.setChannel(channels[i].name());
         record.setDay(TimeUtil.parse(preDay));
         record.setType(CountOrderEnum.oder24H.name());
         record.setId(StringUtil.Md5(preDay + channels[i].name() + CountOrderEnum.oder24H.name()));
         countOrderInfoDao.save(record);
      }
   }

	
   @Override
   public List<CountOrderInfo> countHongBaoByChannel(String channel, Date startTime, Date endTime) {
      // 重新查询统计今日以及空缺
      initHongBaoCount();

      return countOrderInfoDao.query(CountOrderEnum.channelCommission, startTime, endTime, channel);
   }

   // 初始化统计
   private void initHongBaoCount() {
      try {
         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.channelCommission);
         Date lastDay = null;
         if (lastRecord != null && lastRecord.getDay() != null) {
            lastDay = lastRecord.getDay();
         }

         if (lastDay == null) {
            lastDay = TimeUtil.parse("2018-01-01");
         }

         Date today = new Date();
         int betweenDays = DateUtil.daysBetween2(lastDay, today);
         if (betweenDays > 0) {
            for (int i = 0; i <= betweenDays; i++) {
               addRecordHongBaoCount(DateUtil.plusDay(i, lastDay));
            }
         } else {
            // 重新统计昨日
            addRecordHongBaoCount(DateUtil.reduceDay2(1, lastDay));
            // 重新统计今日
            addRecordHongBaoCount(TimeUtil.getGernalTime(today.getTime()));
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }

   private void addRecordHongBaoCount(String preDay) throws Exception {
      ChannelEnum[] channels = ChannelEnum.values();
      for (int i = 0; i < channels.length; i++) {
         BigDecimal money = new BigDecimal(0);
         String channelVlaue = channels[i].getVlaue();
		
         List<CountOrderDTO> listOrder = commonOrderCountService.countCommissionByDay(preDay);
         if (listOrder != null && listOrder.size() > 0) {
            List<Long> listUid = new ArrayList<>();
            for (CountOrderDTO countOrderDTO: listOrder) {
               listUid.add(countOrderDTO.getUid());
            }
				
            List<UserInfoRegister> listRegister = userInfoRegisterService.listByMultipleUids(listUid);
            if (listRegister != null && listRegister.size() > 0) {
               for (int m = 0; m <listRegister.size(); m ++) {
                  boolean reduce = false;
                  Long uid = listRegister.get(m).getId();
                  String vlaue = listRegister.get(m).getChannel();
						
                  for (int n = 0; n <listOrder.size(); n ++) {
                     if (channelVlaue.equalsIgnoreCase(vlaue) && uid.longValue() == listOrder.get(n).getUid()) {
                        BigDecimal commission = listOrder.get(n).getCommission();
                        if (commission != null)
                           MoneyBigDecimalUtil.add(money, commission);
								
                        listOrder.remove(n);
                        n--;
                        reduce = true;
                     }
                  }
						
                  if (reduce) {
                     listRegister.remove(m);
                     m--;
                  }
               }
            }
         }
			
			
         CountOrderInfo record = new CountOrderInfo();
         record.setMoney(money);
         record.setChannel(channels[i].name());
         record.setDay(TimeUtil.parse(preDay));
         record.setType(CountOrderEnum.channelCommission.name());
         record.setId(StringUtil.Md5(preDay + channels[i].name() + CountOrderEnum.channelCommission.name()));
         countOrderInfoDao.save(record);
      }
   }
	
	
   @Override
   public List<CountOrderInfo> countWeiQuanOrder(Date startTime, Date endTime) {
      // 重新查询统计今日以及空缺
      initWeiQuanCount();

      return countOrderInfoDao.query(CountOrderEnum.weiQuanNum, startTime, endTime);
   }

   // 初始化统计
   private void initWeiQuanCount() {
      try {
         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.weiQuanNum);
         Date lastDay = null;
         if (lastRecord != null && lastRecord.getDay() != null) {
            lastDay = lastRecord.getDay();
         }

         if (lastDay == null) {
            lastDay = TimeUtil.parse("2019-01-01");
         }

         Date today = new Date();
         int betweenDays = DateUtil.daysBetween2(lastDay, today);
         if (betweenDays > 0) {
            for (int i = 0; i <= betweenDays; i++) {
               addRecordWeiQuanCount(DateUtil.plusDay(i, lastDay));
            }
         } else {
            // 重新统计昨日
            addRecordWeiQuanCount(DateUtil.reduceDay2(1, lastDay));
            // 重新统计今日
            addRecordWeiQuanCount(TimeUtil.getGernalTime(today.getTime()));
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }

   private void addRecordWeiQuanCount(String preDay) throws Exception {
      Integer count = userOrderWeiQuanRecordService.countWeiQaunOrderNumberByDate(preDay);
      if (count == null)
         count = 0;
      CountOrderInfo record = new CountOrderInfo();
      record.setNum(count);
      record.setDay(TimeUtil.parse(preDay));
      record.setType(CountOrderEnum.weiQuanNum.name());
      record.setId(StringUtil.Md5(preDay + CountOrderEnum.weiQuanNum.name()));
      countOrderInfoDao.save(record);
   }
	
	
   @Override
   public List<CountOrderInfo> countWeiQuanOrderMoney(Date startTime, Date endTime) {
      // 重新查询统计今日以及空缺
      initWeiQuanMoneyCount();

      return countOrderInfoDao.query(CountOrderEnum.weiQuanMoney, startTime, endTime);
   }

   // 初始化统计
   private void initWeiQuanMoneyCount() {
      try {
         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.weiQuanMoney);
         Date lastDay = null;
         if (lastRecord != null && lastRecord.getDay() != null) {
            lastDay = lastRecord.getDay();
         }

         if (lastDay == null) {
            lastDay = TimeUtil.parse("2019-01-01");
         }

         Date today = new Date();
         int betweenDays = DateUtil.daysBetween2(lastDay, today);
         if (betweenDays > 0) {
            for (int i = 0; i <= betweenDays; i++) {
               addRecordWeiQuanMoneyCount(DateUtil.plusDay(i, lastDay));
            }
         } else {
            // 重新统计昨日
            addRecordWeiQuanMoneyCount(DateUtil.reduceDay2(1, lastDay));
            // 重新统计今日
            addRecordWeiQuanMoneyCount(TimeUtil.getGernalTime(today.getTime()));
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }

   private void addRecordWeiQuanMoneyCount(String preDay) throws Exception {
      BigDecimal money = userOrderWeiQuanRecordService.countWeiQaunOrderMoneyByDate(preDay);
      if (money == null)
         money = new BigDecimal(0);
      CountOrderInfo record = new CountOrderInfo();
      record.setMoney(money);
      record.setDay(TimeUtil.parse(preDay));
      record.setType(CountOrderEnum.weiQuanMoney.name());
      record.setId(StringUtil.Md5(preDay + CountOrderEnum.weiQuanMoney.name()));
      countOrderInfoDao.save(record);
   }
	
	
   @Override
   public List<CountOrderInfo> counOrderTotalNum(Date startTime, Date endTime) {
      // 重新查询统计今日以及空缺
      initOrderTotalNum();

      return countOrderInfoDao.query(CountOrderEnum.totalNum, startTime, endTime);
   }

   // 初始化统计
   private void initOrderTotalNum() {
      try {
         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.totalNum);
         Date lastDay = null;
         if (lastRecord != null && lastRecord.getDay() != null) {
            lastDay = lastRecord.getDay();
         }

         if (lastDay == null) {
            lastDay = TimeUtil.parse("2019-01-01");
         }

         Date today = new Date();
         int betweenDays = DateUtil.daysBetween2(lastDay, today);
         if (betweenDays > 0) {
            for (int i = 0; i <= betweenDays; i++) {
               addRecordOrderTotalNum(DateUtil.plusDay(i, lastDay));
            }
         } else {
            // 重新统计昨日
            addRecordOrderTotalNum(DateUtil.reduceDay2(1, lastDay));
            // 重新统计今日
            addRecordOrderTotalNum(TimeUtil.getGernalTime(today.getTime()));
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }

   private void addRecordOrderTotalNum(String preDay) throws Exception {
      Integer num = commonOrderCountService.countOderByDate(preDay);
      if (num == null)
         num = 0;
      CountOrderInfo record = new CountOrderInfo();
      record.setNum(num);
      record.setDay(TimeUtil.parse(preDay));
      record.setType(CountOrderEnum.totalNum.name());
      record.setId(StringUtil.Md5(preDay + CountOrderEnum.totalNum.name()));
      countOrderInfoDao.save(record);
   }
	
	
	
	
   @Override
   public List<CountOrderInfo> counOrderTotalCommission(Date startTime, Date endTime) {
      // 重新查询统计今日以及空缺
      initTotalCommission();

      return countOrderInfoDao.query(CountOrderEnum.totalCommission, startTime, endTime);
   }

   // 初始化统计
   private void initTotalCommission() {
      try {
         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.totalCommission);
         Date lastDay = null;
         if (lastRecord != null && lastRecord.getDay() != null) {
            lastDay = lastRecord.getDay();
         }

         if (lastDay == null) {
            lastDay = TimeUtil.parse("2019-01-01");
         }

         Date today = new Date();
         int betweenDays = DateUtil.daysBetween2(lastDay, today);
         if (betweenDays > 0) {
            for (int i = 0; i <= betweenDays; i++) {
               addRecordTotalCommission(DateUtil.plusDay(i, lastDay));
            }
         } else {
            // 重新统计昨日
            addRecordTotalCommission(DateUtil.reduceDay2(1, lastDay));
            // 重新统计今日
            addRecordTotalCommission(TimeUtil.getGernalTime(today.getTime()));
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }

   private void addRecordTotalCommission(String preDay) throws Exception {
      BigDecimal money = commonOrderCountService.countCommissionByDate(preDay);
      if (money == null)
         money = new BigDecimal("0");
      CountOrderInfo record = new CountOrderInfo();
      record.setMoney(money);
      record.setDay(TimeUtil.parse(preDay));
      record.setType(CountOrderEnum.totalCommission.name());
      record.setId(StringUtil.Md5(preDay + CountOrderEnum.totalCommission.name()));
      countOrderInfoDao.save(record);
   }
	
   @Override
   public List<CountOrderInfo> counOrderLastNum(Date startTime, Date endTime) {

      return countOrderInfoDao.query(CountOrderEnum.lastNum, startTime, endTime);
   }


	
   @Override
   public List<CountOrderInfo> counOrderLastMoney(Date startTime, Date endTime) {
      // 重新查询统计今日以及空缺
      initOrderLastMoney();

      return countOrderInfoDao.query(CountOrderEnum.lastMoney, startTime, endTime);
   }

   // 初始化统计
   private void initOrderLastMoney() {
      try {
         CountOrderInfo lastRecord = countOrderInfoDao.getMaxDate(CountOrderEnum.lastMoney);
         Date lastDay = null;
         if (lastRecord != null && lastRecord.getDay() != null) {
            lastDay = lastRecord.getDay();
         }

         if (lastDay == null) {
            lastDay = TimeUtil.parse("2019-01-01");
         }

         Date today = new Date();
         int betweenDays = DateUtil.daysBetween2(lastDay, today);
         if (betweenDays > 0) {
            for (int i = 0; i <= betweenDays; i++) {
               addRecordOrderLastMoney(DateUtil.plusDay(i, lastDay));
            }
         } else {
            // 重新统计昨日
            addRecordOrderLastMoney(DateUtil.reduceDay2(1, lastDay));
            // 重新统计今日
            addRecordOrderLastMoney(TimeUtil.getGernalTime(today.getTime()));
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }

   private void addRecordOrderLastMoney(String preDay) throws Exception {
      BigDecimal money = lostOrderService.countAppealMoney(preDay);
      if (money == null)
         money = new BigDecimal("0");
      CountOrderInfo record = new CountOrderInfo();
      record.setMoney(money);
      record.setDay(TimeUtil.parse(preDay));
      record.setType(CountOrderEnum.lastMoney.name());
      record.setId(StringUtil.Md5(preDay + CountOrderEnum.lastMoney.name()));
      countOrderInfoDao.save(record);
   }
	
	

	
   @Override
   public List<CountUserInfo> countUserDownOrderByChannelAndToday(String channel, Date startTime, Date endTime) {
      // 重新查询统计今日以及空缺
      initTodayDownOrderCount();

      return countUserInfoDao.query(CountUserEnum.todayOrder, startTime, endTime, channel);
   }

   // 初始化统计
   private void initTodayDownOrderCount() {
      try {
         CountUserInfo lastRecord = countUserInfoDao.getMaxDate(CountUserEnum.todayOrder);
         Date lastDay = null;
         if (lastRecord != null && lastRecord.getDay() != null) {
            lastDay = lastRecord.getDay();
         }
         if (lastDay == null) {
            lastDay = TimeUtil.parse("2018-01-01");
         }

         Date today = new Date();
         int betweenDays = DateUtil.daysBetween2(lastDay, today);
         if (betweenDays > 0) {
            for (int i = 0; i <= betweenDays; i++) {
               addRecordTodayDownOrderCount(DateUtil.plusDay(i, lastDay));
            }
         } else {
            // 重新统计昨日
            addRecordTodayDownOrderCount(DateUtil.reduceDay2(1, lastDay));
            // 重新统计今日
            addRecordTodayDownOrderCount(TimeUtil.getGernalTime(today.getTime()));
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }

   private void addRecordTodayDownOrderCount(String preDay) throws Exception {
      ChannelEnum[] channels = ChannelEnum.values();
      for (int i = 0; i < channels.length; i++) {
         int count = 0;
         String channelVlaue = channels[i].getVlaue();
		
         List<CountOrderDTO> listOrder = commonOrderCountService.countValidOrderByDay(preDay);
         if (listOrder != null && listOrder.size() > 0) {
            List<Long> listUid = new ArrayList<>();
            for (CountOrderDTO countOrderDTO: listOrder) {
               listUid.add(countOrderDTO.getUid());
            }
				
            List<UserInfoRegister> listRegister = userInfoRegisterService.listByMultipleUidAndDay(listUid, preDay);
            if (listRegister != null && listRegister.size() > 0) {
               for (int m = 0; m <listRegister.size(); m ++) {
                  boolean reduce = false;
                  Long uid = listRegister.get(m).getId();
                  String vlaue = listRegister.get(m).getChannel();
						
                  for (int n = 0; n <listOrder.size(); n ++) {
                     if (channelVlaue.equalsIgnoreCase(vlaue) && uid.longValue() == listOrder.get(n).getUid()) {
                        Integer totalOrder = listOrder.get(n).getTotalOrder();
                        if (totalOrder != null)
                           count += totalOrder;
								
                        listOrder.remove(n);
                        n--;
                        reduce = true;
                     }
                  }
						
                  if (reduce) {
                     listRegister.remove(m);
                     m--;
                  }
               }
            }
         }
			
         CountUserInfo record = new CountUserInfo();
         record.setNum(count);
         record.setChannel(channels[i].name());
         record.setDay(TimeUtil.parse(preDay));
         record.setType(CountUserEnum.todayOrder);
         record.setId(StringUtil.Md5(preDay + channels[i].name() + CountUserEnum.todayOrder.name()));
         countUserInfoDao.save(record);
      }
   }

   @Override
   public List<CountUserInfo> countUseByChannelAndWeekOrder(String channel, Date startTime, Date endTime) {
      return countUserInfoDao.query(CountUserEnum.weekOrder, startTime, endTime, channel);
   }

   @Override
   public List<CountUserInfo> countUseByChannelAndWeekThreeOrder(String channel, Date startTime, Date endTime) {
      return countUserInfoDao.query(CountUserEnum.weekThreeOrder, startTime, endTime, channel);
   }

   // 初始化统计
   @Override
   public void initCountUserWeekOrder() {
      try {
         CountUserInfo lastRecord = countUserInfoDao.getMaxDate(CountUserEnum.weekOrder);
         Date lastDay = null;
         if (lastRecord != null && lastRecord.getDay() != null) {
            lastDay = lastRecord.getDay();
         }
         if (lastDay == null) {
            lastDay = TimeUtil.parse("2018-01-01");
         }
         Date today = new Date();
         int betweenDays = DateUtil.daysBetween2(lastDay, today);
         if (betweenDays > 0) {
            for (int i = 0; i <= betweenDays; i++) {
               addRecordWeekOrderCount(DateUtil.plusDay(i, lastDay));
            }
         } else {
            // 重新统计昨日
            addRecordWeekOrderCount(DateUtil.reduceDay2(1, lastDay));
            // 重新统计今日
            addRecordWeekOrderCount(TimeUtil.getGernalTime(today.getTime()));
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }

   private void addRecordWeekOrderCount(String preDay) throws Exception {
      ChannelEnum[] channels = ChannelEnum.values();
      for (int i = 0; i < channels.length; i++) {
         int count = 0;
         int count3 = 0;
         List<UserInfoRegister> list = userInfoRegisterService.listByChannelAndDay(channels[i].getVlaue(), preDay);
         if (list != null && list.size() > 0) {
            Date startDay = new Date(TimeUtil.convertDateToTemp2(preDay + " 23:59:59"));
            Date limitDay = DateUtil.plusDayDate(6, startDay);
            for (UserInfoRegister user : list) {
               Integer total = commonOrderCountService.countOderByUidAndDate(limitDay, user.getId());
               if (total != null && total > 0) {
                  count++;
                  if (total >= 3) {
                     count3++;
                  }
               }
            }
         }

         // 7天内产生有效订单
         CountUserInfo record = new CountUserInfo();
         record.setNum(count);
         record.setChannel(channels[i].name());
         record.setDay(TimeUtil.parse(preDay));
         record.setType(CountUserEnum.weekOrder);
         record.setId(StringUtil.Md5(preDay + channels[i].name() + CountUserEnum.weekOrder.name()));
         countUserInfoDao.save(record);

         // 7天内产生3单以上有效订单
         CountUserInfo record3 = new CountUserInfo();
         record3.setNum(count3);
         record3.setChannel(channels[i].name());
         record3.setDay(TimeUtil.parse(preDay));
         record3.setType(CountUserEnum.weekThreeOrder);
         record3.setId(StringUtil.Md5(preDay + channels[i].name() + CountUserEnum.weekThreeOrder.name()));
         countUserInfoDao.save(record);
      }
   }
	
}