Merge remote-tracking branch 'origin/div' into 2.1.2

admin

2020-05-20 98b1a0affd69bbe63223c21fdd2c404e8bedfccb

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

@@ -1,248 +1,362 @@
package com.yeshi.fanli.service.impl.count;



import java.math.BigDecimal;

import java.text.DecimalFormat;

import java.util.ArrayList;

import java.util.HashMap;

import java.util.List;

import java.util.Map;



import javax.annotation.Resource;



import org.springframework.stereotype.Service;

import org.yeshi.utils.DateUtil;



import com.yeshi.fanli.dao.mybatis.order.CommonOrderCountMapper;

import com.yeshi.fanli.dao.mybatis.taobao.TaoBaoOrderMapper;

import com.yeshi.fanli.dao.mybatis.taobao.TaoBaoWeiQuanOrderMapper;

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



@Service

public class CommonOrderCountServiceImpl implements CommonOrderCountService {





   @Resource

   private TaoBaoWeiQuanOrderMapper taoBaoWeiQuanOrderMapper;



   @Resource

   private TaoBaoOrderMapper taoBaoOrderMapper;

	
   @Resource

   private CommonOrderCountMapper commonOrderCountMapper;

	
	
   @Override

   public Long countByState(Integer state) {

      return    commonOrderCountMapper.countByState(state);

   }

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



      List<Map<String, Object>> listObject = new ArrayList<Map<String, Object>>();



      if (startTime.equals(endTime)) {



         Map<String, Object> map = list.get(0);

         Object total = map.get("showValue");

         if (total == null) {

            map.put("showValue", 0);

         }

         listObject.add(map);

         return listObject;

      }



      String plusDay = "";

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

         if (i == 0) {

            plusDay = startTime;

         } else {

            plusDay = DateUtil.plusDay(i, startTime);

         }



         Map<String, Object> mapObject = new HashMap<String, Object>();

         Object total = null;



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

            Map<String, Object> map = list.get(j);

            Object createDate = map.get("showDate");

            String month = createDate.toString();

            if (plusDay.equalsIgnoreCase(month)) {

               total = map.get("showValue");

               break;

            }

         }



         if (total == null) {

            total = 0;

         }

         mapObject.put("showValue", total);



         mapObject.put("showDate", plusDay);



         listObject.add(mapObject);



         if (plusDay.equals(endTime)) {

            break; // 时间结束

         }

      }



      return listObject;

   }



   public List<Map<String, Object>> monthFactory(List<Map<String, Object>> list) {



      List<Map<String, Object>> listObject = new ArrayList<Map<String, Object>>();

      // 12 个月处理

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

         Map<String, Object> mapObject = new HashMap<String, Object>();

         Object total = null;



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

            Map<String, Object> map = list.get(j);

            Object createDate = map.get("showDate");

            String month = createDate.toString();

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

               total = map.get("showValue");

               break;

            }

         }



         if (total == null) {

            total = 0;

         }

         mapObject.put("showValue", total);

			
         if (i <10) {

            mapObject.put("showDate", "0"+ i);

         } else {

            mapObject.put("showDate", i);

         }



         listObject.add(mapObject);

      }

      return listObject;

   }



   public List<Map<String, Object>> yearFactory(List<Map<String, Object>> list) {



      List<Map<String, Object>> listObject = new ArrayList<Map<String, Object>>();



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

         Map<String, Object> map = list.get(i);

         Object total = map.get("showValue");



         if (total == null) {

            total = 0;

         }

         map.put("showValue", total);



         listObject.add(map);

      }



      return listObject;

   }

	
   @Override

   public List<Map<String, Object>> getTrackAccuracyRate(Integer dateType, String year, String startTime,

         String endTime) throws Exception{

		
      List<Map<String, Object>> result_list = null;

		
      // 用户订单

      List<Map<String, Object>> listTotal = commonOrderCountMapper.countOrderNumber(dateType, year,

            startTime, endTime);

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

         return result_list;

      } 
		
      // 淘宝联盟

      List<Map<String, Object>> type_list = taoBaoOrderMapper.countOrderNumber(dateType, year, 
            startTime, endTime);

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

         return null;

      }

		
      switch (dateType){

         case 1: // 按天处理

            result_list = dayFactory(startTime, endTime, type_list);

            break;

         case 2: // 按月处理

            result_list = monthFactory(type_list);

            break;

         case 3: 
            result_list =  yearFactory(type_list);

            break;

         default: 
            break;

      }

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

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

			
         double proportion = 0;

         Map<String, Object> resultMap = result_list.get(i);

			
         Object showDate = resultMap.get("showDate");

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

            Map<String, Object> innerMap = listTotal.get(j);

            Object innerDate = innerMap.get("showDate");

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

               Object innerValue = innerMap.get("showValue");

               long innerData = Long.parseLong(innerValue.toString());

					
               Object showValue = resultMap.get("showValue");

               long showData = Long.parseLong(showValue.toString());

					
               if (showData > 0) {

                  proportion =  innerData/(double)showData;

               }

					
               break; // 结束内部循环

            }

         }

			
         resultMap.put("showValue", Double.parseDouble(df.format(proportion *100)));

      }

		
      return result_list;

   }



   @Override

   public List<Map<String, Object>> countWeiQaunOrderMoney(Integer dateType, String year, String startTime,

         String endTime) throws Exception{

      return taoBaoWeiQuanOrderMapper.countWeiQaunOrderMoney(dateType, year, startTime, endTime);

   }

	
	
   @Override

   public List<Map<String, Object>> countWeiQaunOrderNumber(Integer dateType, String year, String startTime,

         String endTime) throws Exception{

      return taoBaoWeiQuanOrderMapper.countWeiQaunOrderNumber(dateType, year, startTime, endTime);

   }

	
   @Override

   public Map<String, Object> countOrderNumberBySettleTime(Long uid, Integer state, Integer day) {

      return commonOrderCountMapper.countOrderNumberBySettleTime(uid, state, day);

   }

	
	
   /**

    * 根据结算时间筛选 上个月已结算的订订单数量

    * @param uid

    * @return

    */

   @Override

   public Map<String, Object> lastMonthSettleOrderNumber(Long uid) {

      return countOrderNumberBySettleTime(uid, 2, 4); // 根据

   }

	
   @Override

   public BigDecimal getMoneyByOrderNo(String orderNo) {

      return commonOrderCountMapper.getMoneyByOrderNo(orderNo);

   }

	
	
}

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

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

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

import com.yeshi.fanli.dao.mybatis.jd.JDOrderItemMapper;
import com.yeshi.fanli.dao.mybatis.order.CommonOrderCountMapper;
import com.yeshi.fanli.dao.mybatis.pdd.PDDOrderMapper;
import com.yeshi.fanli.dao.mybatis.taobao.TaoBaoOrderMapper;
import com.yeshi.fanli.dao.mybatis.taobao.TaoBaoWeiQuanOrderMapper;
import com.yeshi.fanli.dao.user.count.CountOrderInfoDao;
import com.yeshi.fanli.dao.user.count.CountOrderTrackRateDao;
import com.yeshi.fanli.dto.ChartTDO;
import com.yeshi.fanli.dto.order.CountOrderDTO;
import com.yeshi.fanli.entity.admin.count.CountOrderTrackRate;
import com.yeshi.fanli.entity.admin.count.CountOrderTrackRate.OrderTrackRateEnum;
import com.yeshi.fanli.service.inter.order.CommonOrderCountService;
import com.yeshi.fanli.util.Constant;
import com.yeshi.fanli.util.StringUtil;
import com.yeshi.fanli.util.TimeUtil;

@Service
public class CommonOrderCountServiceImpl implements CommonOrderCountService {

   @Resource
   private TaoBaoWeiQuanOrderMapper taoBaoWeiQuanOrderMapper;

   @Resource
   private TaoBaoOrderMapper taoBaoOrderMapper;

   @Resource
   private JDOrderItemMapper jdOrderItemMapper;

   @Resource
   private PDDOrderMapper pddOrderMapper;

   @Resource
   private CommonOrderCountMapper commonOrderCountMapper;
	
	
   @Resource
   private CountOrderInfoDao countOrderInfoDao;
	
	
   @Resource
   private CountOrderTrackRateDao countOrderTrackRateDao;
	

   @Override
   public Long countByState(Integer state) {
      return commonOrderCountMapper.countByState(state);
   }
	
   @Override
   public Integer countOderByUidAndLess10(Long uid) {
      return commonOrderCountMapper.countOderByUidAndLess10(uid);
   }

   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 showDate = chartTDO.getShowDate();
            if (plusDay.equalsIgnoreCase(showDate)) {
               total = chartTDO.getShowValue();
               break;
            }
         }
         if (total == null) {
            total = "0";
         }
         ChartTDO chartTDO = new ChartTDO();
         chartTDO.setShowDate(plusDay);
         chartTDO.setShowValue(total);
         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 showValue = chartTDO.getShowValue();
         if (showValue == null) {
            chartTDO.setShowValue("0");
         }
         listObject.add(chartTDO);
      }
      return listObject;
   }


   @Override
   public List<ChartTDO> countWeiQaunOrderMoney(Integer dateType, String year, String startTime, String endTime)
         throws Exception {
      return taoBaoWeiQuanOrderMapper.countWeiQaunOrderMoney(dateType, year, startTime, endTime);
   }

   @Override
   public List<ChartTDO> countWeiQaunOrderNumber(Integer dateType, String year, String startTime, String endTime)
         throws Exception {
      return taoBaoWeiQuanOrderMapper.countWeiQaunOrderNumber(dateType, year, startTime, endTime);
   }

   @Override
   public Map<String, Object> countOrderNumberBySettleTime(Long uid, Integer state, Integer day) {
      return commonOrderCountMapper.countOrderNumberBySettleTime(uid, state, day);
   }

   /**
    * 根据结算时间筛选 上个月已结算的订订单数量
    * 
    * @param uid
    * @return
    */
   @Override
   public Map<String, Object> lastMonthSettleOrderNumber(Long uid) {
      return countOrderNumberBySettleTime(uid, 2, 4); // 根据
   }

   @Override
   public BigDecimal getMoneyByOrderNo(String orderNo) {
      return commonOrderCountMapper.getMoneyByOrderNo(orderNo);
   }

   @Override
   public long countValidOrderByDate(Long uid, String dateTime) {
      return commonOrderCountMapper.countValidOrderByDate(uid, dateTime);
   }

   @Override
   public long countSameShopOrderByUidAndHongBaoType(List<Integer> typeList, Long uid, int minSameShopGoodsCount) {
      return commonOrderCountMapper.countSameShopOrderByUidAndHongBaoType(typeList, uid, minSameShopGoodsCount);
   }

   @Override
   public long countSameGoodsOrderByUidAndHongBaoType(List<Integer> typeList, Long uid, int minSameGoodsOrderCount) {
      return commonOrderCountMapper.countSameGoodsOrderByUidAndHongBaoType(typeList, uid, minSameGoodsOrderCount);
   }

	
   @Override
   public List<Long> getSameShopOrderByUidAndHongBaoType(List<Integer> typeList, Long uid, int minSameShopGoodsCount) {
      return commonOrderCountMapper.getSameShopOrderByUidAndHongBaoType(typeList, uid, minSameShopGoodsCount);
   }

   @Override
   public List<Long> getSameGoodsOrderByUidAndHongBaoType(List<Integer> typeList, Long uid, int minSameGoodsOrderCount) {
      return commonOrderCountMapper.getSameGoodsOrderByUidAndHongBaoType(typeList, uid, minSameGoodsOrderCount);
   }
	
	
   @Override
   public Integer countOderByUidAndDate(Date preDay, Long uid) {
      return commonOrderCountMapper.countOderByUidAndDate(preDay, uid);
   }
	
   @Override
   public List<CountOrderDTO> countValidOrderByDay(String preDay) {
      return commonOrderCountMapper.countValidOrderByDay(preDay);
   }
	
   @Override
   public List<Long> getUidByValidOrderByDay(String preDay) {
      return commonOrderCountMapper.getUidByValidOrderByDay(preDay);
   }
	
	
   @Override
   public Integer countDownOrderUserByUidAndDate(Date preDay, List<Long> list) {
      return commonOrderCountMapper.countDownOrderUserByUidAndDate(preDay, list);
   }
	
   @Override
   public List<Long> getDownOrderUserByListUidAndDate(Date preDay, List<Long> list) {
      return commonOrderCountMapper.getDownOrderUserByListUidAndDate(preDay, list);
   }
	
	
   @Override
   public List<CountOrderDTO> countCommissionByDay(String preDay) {
      return commonOrderCountMapper.countCommissionByDay(preDay);
   }
	
	
   @Override
   public Integer countOderByDate(String preDay) {
      return commonOrderCountMapper.countOderByDate(preDay);
   }
	
   @Override
   public BigDecimal countCommissionByDate(String preDay) {
      return commonOrderCountMapper.countCommissionByDate(preDay);
   }
	
	
	
   @Override
   public List<CountOrderTrackRate> getOrderTrackRate(int type, Date startTime, Date endTime) {
		
      OrderTrackRateEnum trackRateEnum = null;
      if (type == 1) {
         trackRateEnum = OrderTrackRateEnum.taobao;
      } else if (type == 2) {
         trackRateEnum = OrderTrackRateEnum.jd;
      } else if (type == 3) {
         trackRateEnum = OrderTrackRateEnum.pdd;
      } else {
         trackRateEnum = OrderTrackRateEnum.taobao;
      }

      // 重新查询统计今日以及空缺
      initOrderTrackRate(trackRateEnum);
		
      return countOrderTrackRateDao.query(trackRateEnum, startTime, endTime);
   }

   // 初始化统计
   private void initOrderTrackRate(OrderTrackRateEnum trackRateEnum) {
      try {
         CountOrderTrackRate lastRecord = countOrderTrackRateDao.getMaxDate(trackRateEnum);
         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++) {
               addOrderTrackRateCount(DateUtil.plusDay(i, lastDay), trackRateEnum);
            }
         } else {
            // 重新统计昨日
            addOrderTrackRateCount(DateUtil.reduceDay2(1, lastDay), trackRateEnum);
            // 重新统计今日
            addOrderTrackRateCount(TimeUtil.getGernalTime(today.getTime()), trackRateEnum);
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
	
	
	

   private void addOrderTrackRateCount(String preDay, OrderTrackRateEnum trackRateEnum) throws Exception {
      int value = trackRateEnum.getValue();
      Long count = commonOrderCountMapper.countOrderBySourceTypeAndDay(preDay,value);
      if (count == null) {
         count = 0L;
      }
		
      Long total = null;
      switch (value) {
      case Constant.SOURCE_TYPE_TAOBAO:
         total = taoBaoOrderMapper.countOrderByDay(preDay);
         break;
      case Constant.SOURCE_TYPE_JD:
         total = jdOrderItemMapper.countOrderByDay(preDay);
         break;
      case Constant.SOURCE_TYPE_PDD:
         total = pddOrderMapper.countOrderByDay(preDay);
         break;
      }
		
      if(total == null)
         total = 0L;
		
      CountOrderTrackRate record = new CountOrderTrackRate();
      record.setNum(count);
      record.setTotalNum(total);
      record.setDay(TimeUtil.parse(preDay));
      record.setType(trackRateEnum.name());
      record.setId(StringUtil.Md5(preDay + trackRateEnum.name()));
      countOrderTrackRateDao.save(record);
   }
	
		
   @Override
   public Long countOrderBySourceTypeAndDay(int source, String preDay) {
      return commonOrderCountMapper.countOrderBySourceTypeAndDay(preDay, source);
   }
	
   @Override
   public long countOrderBySourceAndNearDay(Long uid, int source, int day) {
      Long count = commonOrderCountMapper.countOrderBySourceAndNearDay(uid, source, day);
      if (count  == null) {
         count = 0L;
      }
      return count;
   }
	
	
}