Bailian-Al/ruoyi-demo/src/main/java/com/ruoyi/demo/service/impl/ChannelAnalyseServiceImpl.java

package com.ruoyi.demo.service.impl;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.ruoyi.demo.entity.Brand;
import com.ruoyi.demo.entity.ManageType;
import com.ruoyi.demo.entity.StoreWd;
import com.ruoyi.demo.entity.WdInfo;
import com.ruoyi.demo.entity.bo.Histogram;
import com.ruoyi.demo.entity.bo.StoreWdCategoryCount;
import com.ruoyi.demo.entity.bo.StoreWdCategoryCountBody;
import com.ruoyi.demo.entity.vo.ChannelAnalyseAceeptVo;
import com.ruoyi.demo.entity.vo.ChannelMapAceeptVo;
import com.ruoyi.demo.entity.vo.TagAnalyse;
import com.ruoyi.demo.mapper.BrandMapper;
import com.ruoyi.demo.mapper.StoreWdDao;
import com.ruoyi.demo.mapper.WdInfoDao;
import com.ruoyi.demo.mapper.WdTopologicalInfoDao;
import com.ruoyi.demo.service.ChannelAnalyseService;
import com.ruoyi.demo.utils.InitMapUtil;
import com.ruoyi.demo.utils.WdRedisStoreage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.data.geo.Circle;
import org.springframework.data.geo.Distance;
import org.springframework.data.geo.GeoResults;
import org.springframework.data.geo.Point;
import org.springframework.data.redis.connection.RedisGeoCommands;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;

import java.math.BigDecimal;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.ExecutorService;
import java.util.stream.Collectors;

@Service
public class ChannelAnalyseServiceImpl implements ChannelAnalyseService {

    @Autowired
    WdInfoDao wdInfoDao;

    @Autowired
    InitMapUtil initMapUtil;

    @Autowired
    BrandMapper brandMapper;

    @Autowired
    WdTopologicalInfoDao wdTopologicalInfoDao;

    @Autowired
    private WdRedisStoreage wdRedisStoreage;

    @Autowired
    private StoreWdDao storeWdDao;


    @Autowired
    @Qualifier("executor")
    ExecutorService executor;


    @Override
    public HashMap cityTier(ChannelMapAceeptVo channelMapAceeptVo) {
        //1.统计结果
        HashMap<String, Long> result = new HashMap<>();
        result.put("一线", 0L);
        result.put("新一线", 0L);
        result.put("二线", 0L);
        result.put("三线", 0L);
        result.put("四线", 0L);
        result.put("五线", 0L);
        result.put("其他", 0L);


        //1.获取所有符合条件的网点信息
        QueryWrapper<WdInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("addr_code","count(*) as audit");
        assembleQueryWrapper(queryWrapper,channelMapAceeptVo);
        queryWrapper.groupBy("addr_code");
        List<WdInfo> wdInfos = wdInfoDao.selectList(queryWrapper);

        for (WdInfo wdInfo : wdInfos) {
            String initCityTierMap = initMapUtil.getInitCityTierMap(wdInfo.getAddrCode());
            if (initCityTierMap != null) {
                result.put(initCityTierMap, result.get(initCityTierMap) + wdInfo.getAudit());
            } else
                result.put("其他", result.get("其他") + wdInfo.getAudit());
        }


        return result;
    }

    @Override
    public PageInfo<Brand> brandList(ChannelAnalyseAceeptVo channelAnalyseAceeptVo) {
        String text = "";
        if (channelAnalyseAceeptVo.getSearchText() != null)
            text = channelAnalyseAceeptVo.getSearchText();
        PageHelper.startPage(channelAnalyseAceeptVo.getPageNum(), channelAnalyseAceeptVo.getPageSize());
        List<Brand> brands = brandMapper.searchList(text);
        PageInfo<Brand> pageInfo = new PageInfo<>(brands);
        return pageInfo;
    }


    //TODO 待测试（redis版本）
    @Override
    public HashMap<String, Object> tagAnalyse(ChannelMapAceeptVo channelMapAceeptVo) {
        //1.根据条件的到位网点信息
        QueryWrapper<WdInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("wd_id");
        assembleQueryWrapper(queryWrapper,channelMapAceeptVo);
        List<WdInfo> queryWd = wdInfoDao.selectList(queryWrapper);

        //2.获取网点周边标签，并进行统计
        Hashtable<String, Integer> hashtable = new Hashtable<>();
        hashtable.put("total",0);
        CompletableFuture<Void> future = null;
        for (WdInfo wdInfo : queryWd) {
            future = CompletableFuture.runAsync(()->{
                List<String> wdTag = wdRedisStoreage.getWdTag(wdInfo);
                if (wdTag != null){
                    for (String s : wdTag) {
                        s += "边";
                        Integer integer = hashtable.get(s);
                        if (integer == null)
                            hashtable.put(s,1);
                        else
                            hashtable.put(s,integer+1);
                        hashtable.put("total",hashtable.get("total")+1);
                    }
                }
            },executor);
        }
        try {
            future.get();
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        } catch (ExecutionException e) {
            throw new RuntimeException(e);
        }

        //3.封装统计值
        HashMap<String, Object> result = new HashMap<>();
        List<TagAnalyse> list = new ArrayList<>();
        Integer total = hashtable.get("total");
        for (String s : hashtable.keySet()) {
            if (s.equals("total"))
                continue;

            TagAnalyse tagAnalyse = new TagAnalyse();
            tagAnalyse.setName(s);
            tagAnalyse.setCount(hashtable.get(s));
            BigDecimal bigDecimal = new BigDecimal((double) tagAnalyse.getCount() / total);
            double v = bigDecimal.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();
            tagAnalyse.setRadio(v);
            list.add(tagAnalyse);
        }

        //4.对结果集进行排序
        Collections.sort(list, new Comparator<TagAnalyse>() {
            @Override
            public int compare(TagAnalyse o1, TagAnalyse o2) {
                return o2.getCount() - o1.getCount();
            }
        });


        //5.分页返回结果集
        int i = 1;
        int start = 0,end = 6;
        while(start<list.size()){
            if(end>=list.size())
                end = list.size();
            result.put(""+i++,new ArrayList(list.subList(start,end)));
            start=end;
            end+=6;
        }
        result.put("pages",i-1);
        result.put("total",total);
        return result;
    }

    @Override
    public List<StoreWdCategoryCount> category(ChannelMapAceeptVo channelMapAceeptVo) {

        //2.组装条件构造器找到网点信息网点
        QueryWrapper<WdInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("wd_id");
        assembleQueryWrapper(queryWrapper,channelMapAceeptVo);

        //门店
        queryWrapper.and(queryWrapper1 -> {
            queryWrapper1.eq("wd_type_code","1");
        });
        List<WdInfo> wdInfos = wdInfoDao.selectList(queryWrapper);


        List<String> collect = wdInfos.stream().map(wdInfo -> {
            return wdInfo.getWdId();
        }).collect(Collectors.toList());
        QueryWrapper<StoreWd> queryWrapper1 = new QueryWrapper<>();
        queryWrapper1.select("manage_type_code","count(*) as comment_count")
            .in("wd_id",collect)
            .groupBy("manage_type_code");

        //5.查询周边网点结果，并统计
        List<StoreWd> storeWds = storeWdDao.selectList(queryWrapper1);
        HashMap<String,StoreWdCategoryCount> hashMap = new HashMap<>();
        for (StoreWd wdInfo : storeWds) {
            if(wdInfo.getManageTypeCode() == null || wdInfo.getManageTypeCode().equals(""))
                continue;

            String s = wdInfo.getManageTypeCode().substring(0, 4) + "00";
            StoreWdCategoryCount storeWdCategoryCount = hashMap.get(s);

            ManageType initManageType = initMapUtil.getInitManageType(wdInfo.getManageTypeCode());
            if (storeWdCategoryCount == null){
                StoreWdCategoryCountBody storeWdCategoryCountBody = new StoreWdCategoryCountBody();
                if(initManageType.getSubCategory() != null && !initManageType.getSubCategory().equals("")){
                    storeWdCategoryCountBody.setName(initManageType.getSubCategory());
                }else if(initManageType.getMidCategory() != null && !initManageType.getMidCategory().equals("")){
                    storeWdCategoryCountBody.setName(initManageType.getMidCategory());
                }else if (initManageType.getBigCategory() != null && !initManageType.getBigCategory().equals("")){
                    storeWdCategoryCountBody.setName(initManageType.getBigCategory());
                }
                storeWdCategoryCountBody.setManageTypeCode(wdInfo.getManageTypeCode());
                storeWdCategoryCountBody.setCount(wdInfo.getCommentCount());

                StoreWdCategoryCount storeWdCategoryCount1 = new StoreWdCategoryCount();
                storeWdCategoryCount1.setManageTypeCode(s);
                storeWdCategoryCount1.setName(initMapUtil.getInitManageType(s).getMidCategory());
                storeWdCategoryCount1.setCount(wdInfo.getCommentCount());
                ArrayList<StoreWdCategoryCountBody> list = new ArrayList<>();
                list.add(storeWdCategoryCountBody);
                storeWdCategoryCount1.setStoreWdCategoryCountBodyList(list);
                hashMap.put(s,storeWdCategoryCount1);
            }else {
                StoreWdCategoryCountBody storeWdCategoryCountBody = new StoreWdCategoryCountBody();
                if(initManageType.getSubCategory() != null && !initManageType.getSubCategory().equals("")){
                    storeWdCategoryCountBody.setName(initManageType.getSubCategory());
                }else if(initManageType.getMidCategory() != null && !initManageType.getMidCategory().equals("")){
                    storeWdCategoryCountBody.setName(initManageType.getMidCategory());
                }else if (initManageType.getBigCategory() != null && !initManageType.getBigCategory().equals("")){
                    storeWdCategoryCountBody.setName(initManageType.getBigCategory());
                }
                storeWdCategoryCountBody.setManageTypeCode(wdInfo.getManageTypeCode());
                storeWdCategoryCountBody.setCount(wdInfo.getCommentCount());

                storeWdCategoryCount.getStoreWdCategoryCountBodyList().add(storeWdCategoryCountBody);
                storeWdCategoryCount.setCount(storeWdCategoryCountBody.getCount()+storeWdCategoryCount.getCount());
                //hashMap.put(s,storeWdCategoryCount);
            }
        }

        //6.组装结果集
        List<StoreWdCategoryCount> storeWdCategoryCounts = new ArrayList<>();
        for (String s : hashMap.keySet()) {
            storeWdCategoryCounts.add(hashMap.get(s));
        }


        return storeWdCategoryCounts;
    }

    @Override
    public HashMap<String,Integer> businessStatusAnalyse(ChannelMapAceeptVo channelMapAceeptVo) {
        QueryWrapper<WdInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("wd_id");
        assembleQueryWrapper(queryWrapper,channelMapAceeptVo);
        queryWrapper.and(queryWrapper1 -> {
            queryWrapper1.eq("wd_type_code","1");
        });
        List<WdInfo> wdInfos = wdInfoDao.selectList(queryWrapper);

        List<String> collect = wdInfos.stream().map(wdInfo -> {
            return wdInfo.getWdId();
        }).collect(Collectors.toList());
        QueryWrapper<StoreWd> queryWrapper1 = new QueryWrapper<>();
        queryWrapper1.select("business_status","count(*) as comment_count")
            .in("wd_id",collect)
            .groupBy("business_status");
        List<StoreWd> storeWds = storeWdDao.selectList(queryWrapper1);
        HashMap<String,Integer> hashMap = new HashMap<>();
        int total = 0;
        for (StoreWd storeWd : storeWds) {
            total+=storeWd.getCommentCount();
            hashMap.put(storeWd.getBusinessStatus(),storeWd.getCommentCount());
        }
        hashMap.put("total",total);
        return hashMap;
    }

    @Override
    public ArrayList<Histogram> aroundBuildAnalyse(ChannelMapAceeptVo channelMapAceeptVo) {
        QueryWrapper<WdInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("type_code_by","count(*) as audit");
        assembleQueryWrapper(queryWrapper,channelMapAceeptVo);
        queryWrapper.and(queryWrapper1 -> {
            queryWrapper1.eq("wd_type_code","3");
        });
        queryWrapper.groupBy("type_code_by");
        List<WdInfo> wdInfos = wdInfoDao.selectList(queryWrapper);
        int total = 0;
        HashMap<String,Integer> hashMap = new HashMap<>();
        for (WdInfo wdInfo : wdInfos) {
            if(wdInfo.getTypeCodeBy() == null)
                continue;
            String typeCodeBy = wdInfo.getTypeCodeBy().substring(0,2);
            Integer integer = hashMap.get(typeCodeBy);
            if (integer == null){
                hashMap.put(typeCodeBy,wdInfo.getAudit());
            }else {
                hashMap.put(typeCodeBy,hashMap.get(typeCodeBy)+wdInfo.getAudit());
            }
            total+=wdInfo.getAudit();
        }
        ArrayList<Histogram> list = new ArrayList<>();
        for (String s : hashMap.keySet()) {
            Integer integer = hashMap.get(s);
            String initTypeByMap = initMapUtil.getInitTypeByMap(s + "0000").replace(":","");
            Histogram histogram = new Histogram();
            histogram.setName(initTypeByMap);
            histogram.setCount(integer);
            list.add(histogram);
        }

        return list;
    }

    @Override
    public ArrayList<Histogram> perCapitaConsumpAnalyse(ChannelMapAceeptVo channelMapAceeptVo) {
        QueryWrapper<WdInfo> queryWrapper = new QueryWrapper<>();
        queryWrapper.select("wd_id");
        assembleQueryWrapper(queryWrapper,channelMapAceeptVo);
        queryWrapper.and(queryWrapper1 -> {
            queryWrapper1.eq("wd_type_code","1");
        });
        List<WdInfo> wdInfos = wdInfoDao.selectList(queryWrapper);

        List<String> collect = wdInfos.stream().map(item -> {
            return item.getWdId();
        }).collect(Collectors.toList());

        HashMap<String, Integer> hashMap = new HashMap<>();
        hashMap.put("0~20",0);
        hashMap.put("20~50",0);
        hashMap.put("50~100",0);
        hashMap.put("100~200",0);
        hashMap.put("200以上",0);
        if (!collect.isEmpty()){
            QueryWrapper<StoreWd> queryWrapper1 = new QueryWrapper<>();
            queryWrapper1.select("per_capita_consumption");
            //queryWrapper1.in("wd_id",collect);
            for (String s : collect) {
                queryWrapper1.eq("wd_id",s).or();
            }
            List<StoreWd> storeWds = storeWdDao.selectList(queryWrapper1);
            for (StoreWd storeWd : storeWds) {
                if (storeWd.getPerCapitaConsumption() != null){
                    if (storeWd.getPerCapitaConsumption() >= 0 && storeWd.getPerCapitaConsumption()<20){
                        hashMap.put("0~20",hashMap.get("0~20")+1);
                    }else if(storeWd.getPerCapitaConsumption() >= 20 && storeWd.getPerCapitaConsumption()<50){
                        hashMap.put("20~50",hashMap.get("20~50")+1);
                    }else if(storeWd.getPerCapitaConsumption() >= 50 && storeWd.getPerCapitaConsumption()< 100){
                        hashMap.put("50~100",hashMap.get("50~1000")+1);
                    }else if(storeWd.getPerCapitaConsumption() >= 100 && storeWd.getPerCapitaConsumption()< 200){
                        hashMap.put("100~200",hashMap.get("100~200")+1);
                    }else {
                        hashMap.put("200以上",hashMap.get("200以上")+1);
                    }
                }
            }
        }

        ArrayList<Histogram> list = new ArrayList<>();
        for (String s : hashMap.keySet()) {
            Histogram histogram = new Histogram();
            histogram.setName(s);
            histogram.setCount(hashMap.get(s));
            list.add(histogram);
        }
        return list;
    }

    public void assembleQueryWrapper(QueryWrapper<WdInfo> queryWrapper,ChannelMapAceeptVo channelMapAceeptVo){
        //1.根据不同级别得到需要查询的 地区码
        List<String> addrCodeList = new ArrayList<>();
        if ("province".equals(channelMapAceeptVo.getRankType())) {
            //省码
            for (String s : channelMapAceeptVo.getAddrCode()) {
                String substring = s.substring(0, 2);
                addrCodeList.add(substring);
            }
        } else if ("city".equals(channelMapAceeptVo.getRankType())) {
            //省的所有市
            for (String s : channelMapAceeptVo.getAddrCode()) {
                String substring = s.substring(0, 2);
                addrCodeList.add(substring);
            }
        } else if ("zone".equals(channelMapAceeptVo.getRankType())) {
            //市的所有区
            for (String s : channelMapAceeptVo.getAddrCode()) {
                String substring = s.substring(0, 4);
                addrCodeList.add(substring);
            }
        } else if ("district".equals(channelMapAceeptVo.getRankType())){
            //区的所有街道
            for (String s : channelMapAceeptVo.getAddrCode()) {
                String substring = s.substring(0, 6);
                addrCodeList.add(substring);
            }
        }else {
            //省码
            for (String s : channelMapAceeptVo.getAddrCode()) {
                String substring = s.substring(0, 2);
                addrCodeList.add(substring);
            }
        }

        queryWrapper.in("wd_type_code", channelMapAceeptVo.getChannel()).and(originWdInfoQueryWrapper -> {
            for (String s : addrCodeList) {
                originWdInfoQueryWrapper.likeRight("addr_code", s).or();
            }
        });

        //搜索字段
        if (channelMapAceeptVo.getSearchText() != null && !channelMapAceeptVo.getSearchText() .trim().equals("")) {
            queryWrapper.and(originWdInfoQueryWrapper -> {
                originWdInfoQueryWrapper.like("wd_name", channelMapAceeptVo.getSearchText() );
            });
        }

        //城市等级分类
        if(channelMapAceeptVo.getCityTier() != null && channelMapAceeptVo.getCityTier().length > 0){
            List<String> tierCode = new ArrayList<>();
            for (String s : channelMapAceeptVo.getCityTier()) {
                List<String> list = initMapUtil.getInitCityTierListMap(s);
                if (list != null){
                    tierCode.addAll(list);
                }
            }
            queryWrapper.and(wdInfoQueryWrapper -> {
                for (String s : tierCode) {
                    wdInfoQueryWrapper.likeRight("addr_code", s).or();
                }
            });
        }

        //排序字段查询
        if (channelMapAceeptVo.getOrderby() != null && !channelMapAceeptVo.getOrderby().trim().equals("")) {
            PageHelper.orderBy(channelMapAceeptVo.getOrderby());
        }

    }



}