4dkankan-center-manage/src/main/java/com/fdkankan/manage/service/impl/DataService.java

package com.fdkankan.manage.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.fdkankan.manage.entity.User;
import com.fdkankan.manage.mapper.IDataMapper;
import com.fdkankan.manage.service.IDataService;
import com.fdkankan.manage.service.ISceneProService;
import com.fdkankan.manage.service.IUserService;
import com.fdkankan.manage.util.Dateutils;
import com.fdkankan.manage.vo.response.*;
import org.apache.commons.lang3.StringUtils;
import org.apache.poi.ss.formula.functions.Count;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.util.*;

@Service
public class DataService implements IDataService {

    static String dayFormat = "%Y-%m-%d";
    static String mouthFormat = "%Y-%m";
    static String yearFormat = "%Y";

   @Autowired
    IDataMapper dataMapper;
    @Autowired
    IUserService userService;
    @Autowired
    ISceneProService sceneProService;

    @Override
    public UserTotalVo getUserTotal() {
        UserTotalVo totalVo = new UserTotalVo();
        Long totalUserCount = dataMapper.totalUserCount("t_user",0);
        Long preMonthAddCount = dataMapper.preMonthAddCount("t_user",0);
        Long todayAddCount = dataMapper.todayAddCount("t_user",0);
        Long todayActiveCount = dataMapper.todayActiveCount();

        totalVo.setTotalUserCount(totalUserCount);
        totalVo.setPreMonthAddCount(preMonthAddCount);
        totalVo.setTodayAddCount(todayAddCount);
        totalVo.setTodayActiveCount(todayActiveCount);
        return totalVo;
    }

    @Override
    public SceneTotalVo sceneTotal() {
        SceneTotalVo totalVo = new SceneTotalVo();
        Long totalSceneCount = dataMapper.totalUserCount("t_scene_pro",1) + dataMapper.totalUserCount("t_scene_plus",0);
        Long preMonthAddCount = dataMapper.preMonthAddCount("t_scene_pro",1) + dataMapper.preMonthAddCount("t_scene_plus",0);
        Long todayAddCount = dataMapper.todayAddCount("t_scene_pro",1) + dataMapper.todayAddCount("t_scene_plus",0);

        totalVo.setTotalSceneCount(totalSceneCount);
        totalVo.setPreMonthAddCount(preMonthAddCount);
        totalVo.setTodayAddCount(todayAddCount);
        return totalVo;
    }

    @Override
    public OrderTotalVo orderTotal() {
        Long preMonthPowCount = dataMapper.preMonthAddCount("t_increment_order",2);
        Long preMonthDownCount = dataMapper.preMonthAddCount("t_download_order",2);
        Long preMonthPartCount = dataMapper.preMonthAddCount("t_order",3);
        OrderTotalVo totalVo = new OrderTotalVo();
        totalVo.setPreMonThPowCount(preMonthPowCount);
        totalVo.setPreMonThDownCount(preMonthDownCount);
        totalVo.setPreMonThPartCount(preMonthPartCount);

        return totalVo;
    }


    @Override
    public List<DataGroupByCount> userTrend(Integer type,Integer dataType,String startTime,String endTime) {
        startTime = Dateutils.formatStartTime(startTime);
        endTime = Dateutils.formatEndTime(endTime);

        List<DataGroupByCount> dataList = new ArrayList<>();
        List<DataGroupByCount> result = new ArrayList<>();
        int rule = Dateutils.DAY;
        String tb = "t_user";
        if(dataType == 2){
            tb = "t_login_log";
        }
        switch (type){
            case 0 :
                dataList = dataMapper.userDataGroupBy(tb, dayFormat, startTime, endTime);
                break;
            case 1 :
                rule = Dateutils.WEEK;
                dataList = dataMapper.userDataGroupByWeek(tb,startTime,endTime);
                break;
            case 2 :
                rule = Dateutils.MONTH;
                dataList =  dataMapper.userDataGroupBy(tb,mouthFormat,startTime,endTime);
                break;
        }
        Long totalCount = 0L;
        if(dataType == 1){          //累加
            LambdaQueryWrapper<User> wrapper = new LambdaQueryWrapper<>();
            wrapper.lt(User::getCreateTime,startTime);
            totalCount = userService.count(wrapper);
        }
        //查询从开始时间到结束时间为止所有天数，月份，不存在结果补零
        HashMap<String,Long> map = new HashMap<>();
        dataList.forEach(entity -> map.put(entity.getGroupKey(),entity.getCount()));
        List<String> dates = Dateutils.findDatesStr(Dateutils.getDate(startTime), Dateutils.getDate(endTime),rule );

        setListData(result,map,dates,dataType,totalCount);

        return result;
    }

    @Override
    public HashMap<String, Object> orderTrend(Integer type,Integer dataType,String startTime,String endTime) {
        startTime = Dateutils.formatStartTime(startTime);
        endTime = Dateutils.formatEndTime(endTime);

        HashMap<String,Object> map = new HashMap<>();
        if(dataType == 1){
            return getAmountSumOrder(map,type,startTime,endTime);
        }
        List<DataGroupByCount> incrementOrderList = new ArrayList<>();
        List<DataGroupByCount> downOrderList = new ArrayList<>();
        List<DataGroupByCount> partOrderList = new ArrayList<>();
        List<DataGroupByCount> incrementOrderResultList = new ArrayList<>();
        List<DataGroupByCount> downOrderResultList = new ArrayList<>();
        List<DataGroupByCount> partOrderResultList = new ArrayList<>();
        int rule = Dateutils.DAY;
        switch (type){
            case 0 :
                incrementOrderList = dataMapper.userDataGroupBy("t_increment_order",dayFormat,startTime,endTime);
                downOrderList = dataMapper.userDataGroupBy("t_download_order",dayFormat,startTime,endTime);
                partOrderList = dataMapper.userDataGroupBy("t_order",dayFormat,startTime,endTime);
                break;
            case 1 :
                rule = Dateutils.WEEK;
                incrementOrderList = dataMapper.userDataGroupByWeek("t_increment_order",startTime,endTime);
                downOrderList = dataMapper.userDataGroupByWeek("t_download_order",startTime,endTime);
                partOrderList = dataMapper.userDataGroupByWeek("t_order",startTime,endTime);
                break;
            case 2 :
                rule = Dateutils.MONTH;
                incrementOrderList = dataMapper.userDataGroupBy("t_increment_order",mouthFormat,startTime,endTime);
                downOrderList = dataMapper.userDataGroupBy("t_download_order",mouthFormat,startTime,endTime);
                partOrderList = dataMapper.userDataGroupBy("t_order",mouthFormat,startTime,endTime);
                break;
        }
        //查询从开始时间到结束时间为止所有天数，月份，不存在结果补零
        HashMap<String,Long> incrementMap = new HashMap<>();
        HashMap<String,Long> downOrderMap = new HashMap<>();
        HashMap<String,Long> partMap = new HashMap<>();
        incrementOrderList.forEach(entity -> incrementMap.put(entity.getGroupKey(),entity.getCount()));
        downOrderList.forEach(entity -> downOrderMap.put(entity.getGroupKey(),entity.getCount()));
        partOrderList.forEach(entity -> partMap.put(entity.getGroupKey(),entity.getCount()));

        List<String> dates = Dateutils.findDatesStr(Dateutils.getDate(startTime), Dateutils.getDate(endTime),rule );
        for (String date : dates) {
            DataGroupByCount groupByCount = new DataGroupByCount();
            groupByCount.setGroupKey(date);
            groupByCount.setCount(incrementMap.get(date)== null ?0 :incrementMap.get(date));
            incrementOrderResultList.add(groupByCount);

            DataGroupByCount groupByCount2 = new DataGroupByCount();
            groupByCount2.setGroupKey(date);
            groupByCount2.setCount(downOrderMap.get(date)== null ?0 :downOrderMap.get(date));
            downOrderResultList.add(groupByCount2);

            DataGroupByCount groupByCount3 = new DataGroupByCount();
            groupByCount3.setGroupKey(date);
            groupByCount3.setCount(partMap.get(date)== null ?0 :partMap.get(date));
            partOrderResultList.add(groupByCount3);
        }
        map.put("incrementOrder",incrementOrderResultList);
        map.put("downOrder",downOrderResultList);
        map.put("partOrder",partOrderResultList);
        return map;
    }

    private HashMap<String, Object> getAmountSumOrder(HashMap<String,Object> map,Integer type, String startTime, String endTime) {
        List<DataGroupBySum> incrementOrderList = new ArrayList<>();
        List<DataGroupBySum> downOrderList = new ArrayList<>();
        List<DataGroupBySum> partOrderList = new ArrayList<>();
        List<DataGroupBySum> incrementOrderResultList = new ArrayList<>();
        List<DataGroupBySum> downOrderResultList = new ArrayList<>();
        List<DataGroupBySum> partOrderResultList = new ArrayList<>();
        int rule = Dateutils.DAY;
        switch (type){
            case 0 :
                incrementOrderList = dataMapper.userDataSumGroupBy("t_increment_order",dayFormat,startTime,endTime);
                downOrderList = dataMapper.userDataSumGroupBy("t_download_order",dayFormat,startTime,endTime);
                partOrderList = dataMapper.userDataSumGroupBy("t_order",dayFormat,startTime,endTime);
                break;
            case 1 :
                rule = Dateutils.WEEK;
                incrementOrderList = dataMapper.userDataSumGroupByWeek("t_increment_order",startTime,endTime);
                downOrderList = dataMapper.userDataSumGroupByWeek("t_download_order",startTime,endTime);
                partOrderList = dataMapper.userDataSumGroupByWeek("t_order",startTime,endTime);
                break;
            case 2 :
                rule = Dateutils.MONTH;
                incrementOrderList = dataMapper.userDataSumGroupBy("t_increment_order",mouthFormat,startTime,endTime);
                downOrderList = dataMapper.userDataSumGroupBy("t_download_order",mouthFormat,startTime,endTime);
                partOrderList = dataMapper.userDataSumGroupBy("t_order",mouthFormat,startTime,endTime);
                break;
        }
        //查询从开始时间到结束时间为止所有天数，月份，不存在结果补零
        HashMap<String,String> incrementMap = new HashMap<>();
        HashMap<String,String> downOrderMap = new HashMap<>();
        HashMap<String,String> partMap = new HashMap<>();
        incrementOrderList.forEach(entity -> incrementMap.put(entity.getGroupKey(),entity.getCount()));
        downOrderList.forEach(entity -> downOrderMap.put(entity.getGroupKey(),entity.getCount()));
        partOrderList.forEach(entity -> partMap.put(entity.getGroupKey(),entity.getCount()));

        List<String> dates = Dateutils.findDatesStr(Dateutils.getDate(startTime), Dateutils.getDate(endTime),rule );
        for (String date : dates) {
            DataGroupBySum groupByCount = new DataGroupBySum();
            groupByCount.setGroupKey(date);
            groupByCount.setCount(incrementMap.get(date)== null ?"0" :incrementMap.get(date));
            incrementOrderResultList.add(groupByCount);

            DataGroupBySum groupByCount2 = new DataGroupBySum();
            groupByCount2.setGroupKey(date);
            groupByCount2.setCount(downOrderMap.get(date)== null ?"0" :downOrderMap.get(date));
            downOrderResultList.add(groupByCount2);

            DataGroupBySum groupByCount3 = new DataGroupBySum();
            groupByCount3.setGroupKey(date);
            groupByCount3.setCount(partMap.get(date)== null ?"0" :partMap.get(date));
            partOrderResultList.add(groupByCount3);
        }
        map.put("incrementOrder",incrementOrderResultList);
        map.put("downOrder",downOrderResultList);
        map.put("partOrder",partOrderResultList);
        return map;
    }

    @Override
    public HashMap<String, List<DataGroupByCount>> sceneTrend(Integer type,Integer dataType,String startTime,String endTime) {
        startTime = Dateutils.formatStartTime(startTime);
        endTime = Dateutils.formatEndTime(endTime);

        HashMap<String,List<DataGroupByCount>> map = new HashMap<>();
        List<DataGroupByCount> kkList = new ArrayList<>();
        List<DataGroupByCount> kjList = new ArrayList<>();
        List<DataGroupByCount> ssList = new ArrayList<>();
        List<DataGroupByCount> ssObjList = new ArrayList<>();
        List<DataGroupByCount> proList = new ArrayList<>();
        List<DataGroupByCount> plusList = new ArrayList<>();
        List<DataGroupByCount> proObjList = new ArrayList<>();
        List<DataGroupByCount> plusObjList = new ArrayList<>();
        int rule = Dateutils.DAY;
        switch (type){
            case 0 :
                proList = dataMapper.sceneGroupBy("t_scene_pro",dayFormat,startTime,endTime);
                plusList = dataMapper.sceneGroupBy("t_scene_plus",dayFormat,startTime,endTime);
                proObjList = dataMapper.sceneObjGroupBy("t_scene_pro",dayFormat,startTime,endTime);
                plusObjList = dataMapper.sceneObjGroupBy("t_scene_plus",dayFormat,startTime,endTime);
                break;
            case 1 :
                rule = Dateutils.WEEK;
                proList = dataMapper.sceneGroupByWeek("t_scene_pro",startTime,endTime);
                plusList = dataMapper.sceneGroupByWeek("t_scene_plus",startTime,endTime);
                proObjList = dataMapper.sceneObjGroupByWeek("t_scene_pro",startTime,endTime);
                plusObjList = dataMapper.sceneObjGroupByWeek("t_scene_plus",startTime,endTime);
                break;
            case 2 :
                rule = Dateutils.MONTH;
                proList = dataMapper.sceneGroupBy("t_scene_pro",mouthFormat,startTime,endTime);
                plusList = dataMapper.sceneGroupBy("t_scene_plus",mouthFormat,startTime,endTime);
                proObjList = dataMapper.sceneObjGroupBy("t_scene_pro",mouthFormat,startTime,endTime);
                plusObjList = dataMapper.sceneObjGroupBy("t_scene_plus",mouthFormat,startTime,endTime);
                break;
        }
        HashMap<String, Long> kkMap = new HashMap<>();
        HashMap<String, Long> kjMap = new HashMap<>();
        HashMap<String, Long> ssMap = new HashMap<>();
        HashMap<String, Long> ssObjMap = new HashMap<>();
        for (DataGroupByCount dataGroupByCount : proList) {
            if(dataGroupByCount.getGroupKey2().equals("3")){    //看见
                kjMap.merge(dataGroupByCount.getGroupKey(),dataGroupByCount.getCount(), Long:: sum);
            }
            if(dataGroupByCount.getGroupKey2().equals("4")){    //深时
                ssMap.merge(dataGroupByCount.getGroupKey(),dataGroupByCount.getCount(), Long:: sum);
            }
            if(Arrays.asList("1","2","12","13","14").contains(dataGroupByCount.getGroupKey2())){    //看看
                kkMap.merge(dataGroupByCount.getGroupKey(),dataGroupByCount.getCount(), Long:: sum);
            }
        }
        for (DataGroupByCount dataGroupByCount : plusList) {
            if(dataGroupByCount.getGroupKey2().equals("3")){    //看见
                kjMap.merge(dataGroupByCount.getGroupKey(),dataGroupByCount.getCount(), Long:: sum);
            }
            if(dataGroupByCount.getGroupKey2().equals("4")){    //深时
                ssMap.merge(dataGroupByCount.getGroupKey(),dataGroupByCount.getCount(), Long:: sum);
            }
            if(Arrays.asList("1","2","12","13","14").contains(dataGroupByCount.getGroupKey2())){    //看看
                kkMap.merge(dataGroupByCount.getGroupKey(),dataGroupByCount.getCount(), Long:: sum);
            }
        }
        for (DataGroupByCount dataGroupByCount : proObjList) {
            if(dataGroupByCount.getGroupKey2().equals("4")){    //深时
                ssObjMap.merge(dataGroupByCount.getGroupKey(),dataGroupByCount.getCount(), Long:: sum);
            }
        }
        for (DataGroupByCount dataGroupByCount : plusObjList) {
            if(dataGroupByCount.getGroupKey2().equals("4")){    //深时
                ssObjMap.merge(dataGroupByCount.getGroupKey(),dataGroupByCount.getCount(), Long:: sum);
            }
        }
        Long kkCount = 0L;
        Long KjCount = 0L;
        Long ssCount = 0L;
        Long ssObjCount = 0L;
        if(dataType == 1){
            kkCount = sceneProService.getKkCount(Arrays.asList("1","2","12","13","14"),startTime);
            KjCount = sceneProService.getKkCount(Arrays.asList("3"),startTime);
            ssCount = sceneProService.getSsCount(Arrays.asList("4"),startTime);
            ssObjCount = sceneProService.getSsObjCount(Arrays.asList("4"),startTime);
        }
        List<String> dates = Dateutils.findDatesStr(Dateutils.getDate(startTime), Dateutils.getDate(endTime),rule );
        setListData(kkList,kkMap,dates,dataType,kkCount);
        setListData(kjList,kjMap,dates,dataType,KjCount);
        setListData(ssList,ssMap,dates,dataType,ssCount);
        setListData(ssObjList,ssObjMap,dates,dataType,ssObjCount);

        map.put("kkList",kkList);
        map.put("kjList",kjList);
        map.put("ssList",ssList);
        map.put("ssobjList",ssObjList);
        return map;
    }


    private void setListData(List<DataGroupByCount> kkList, HashMap<String, Long> kkMap, List<String> dates,Integer dataType,Long totalCount) {
        for (String key : dates) {
            DataGroupByCount newCount = new DataGroupByCount();
            newCount.setGroupKey(key);
            Long count = kkMap.get(key) == null ? 0L : kkMap.get(key);
            if(dataType == 1){
                count += totalCount;
                totalCount = count;
            }
            newCount.setCount(count);
            kkList.add(newCount);
        }
    }
    private void setListData(List<DataGroupByCount> kkList, HashMap<String, Long> kkMap, List<String> dates) {
        for (String key : dates) {
            DataGroupByCount newCount = new DataGroupByCount();
            newCount.setGroupKey(key);
            Long count = kkMap.get(key) == null ? 0L : kkMap.get(key);
            newCount.setCount(count);
            kkList.add(newCount);
        }
    }

    @Override
    public HashMap<String, Object> cameraTrend(Integer type, String startTime, String endTime) {
        startTime = Dateutils.formatStartTime(startTime);
        endTime = Dateutils.formatEndTime(endTime);

        HashMap<String,Object> map = new HashMap<>();
        List<DataGroupByCount> allList = new ArrayList<>();
        List<DataGroupByCount> kkList = new ArrayList<>();
        List<DataGroupByCount> kjList = new ArrayList<>();
        List<DataGroupByCount> ssList = new ArrayList<>();
        int rule = Dateutils.DAY;
        switch (type){
            case 0 :
                allList = dataMapper.sceneOutTimeGroupBy("t_camera_detail",dayFormat,startTime,endTime);
                break;
            case 1 :
                rule = Dateutils.WEEK;
                allList = dataMapper.sceneOutTimeGroupByWeek("t_camera_detail",startTime,endTime);
                break;
            case 2 :
                rule = Dateutils.MONTH;
                allList = dataMapper.sceneOutTimeGroupBy("t_camera_detail",mouthFormat,startTime,endTime);
                break;
        }
        HashMap<String, Long> kkMap = new HashMap<>();
        HashMap<String, Long> kjMap = new HashMap<>();
        HashMap<String, Long> ssMap = new HashMap<>();
        for (DataGroupByCount dataGroupByCount : allList) {
            if(dataGroupByCount.getGroupKey2().equals("9")){    //看见
                kjMap.merge(dataGroupByCount.getGroupKey(),dataGroupByCount.getCount(), Long:: sum);
            }
            if(dataGroupByCount.getGroupKey2().equals("10")){    //深时
                ssMap.merge(dataGroupByCount.getGroupKey(),dataGroupByCount.getCount(), Long:: sum);
            }
            if(Arrays.asList("1").contains(dataGroupByCount.getGroupKey2())){    //看看
                kkMap.merge(dataGroupByCount.getGroupKey(),dataGroupByCount.getCount(), Long:: sum);
            }
        }
        List<String> dates = Dateutils.findDatesStr(Dateutils.getDate(startTime), Dateutils.getDate(endTime),rule );
        setListData(kkList,kkMap,dates);
        setListData(kjList,kjMap,dates);
        setListData(ssList,ssMap,dates);

        map.put("kkList",kkList);
        map.put("kjList",kjList);
        map.put("ssList",ssList);
        return map;
    }
}