波动补偿

于紫祥_1901

2020-12-24 f28149d8183a62f87fa9c8df9ae589070d83f612

 src/main/java/com/moral/service/impl/MapPathServiceImpl.java

@@ -1,20 +1,21 @@
package com.moral.service.impl;

import com.alibaba.fastjson.JSON;
import com.moral.common.util.WebTokenUtils;
import com.moral.controller.ScreenController;
import com.moral.entity.Organization;
import com.moral.entity.WebProvince;
import com.moral.mapper.MapPathMapper;
import com.moral.entity.*;
import com.moral.mapper.*;
import com.moral.service.DictionaryDataService;
import com.moral.service.MapPathService;
import com.moral.service.MonitorPointService;
import com.moral.service.OrganizationService;
import org.apache.log4j.Logger;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;

import javax.annotation.Resource;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.*;

@Service
public class MapPathServiceImpl implements MapPathService {
@@ -23,6 +24,21 @@
    MapPathMapper mapPathMapper;
    @Resource
    OrganizationService organizationService;
    @Resource
    DictionaryDataService dictionaryDataService;
    @Resource
    MonitorPointService monitorPointService;
    @Resource
    ProvinceMapper provinceMapper;
    @Resource
    CityMapper cityMapper;
    @Resource
    AreaMapper areaMapper;
    @Resource
    MonitorPointMapper monitorPointMapper;
    @Resource
    RedisTemplate redisTemplate;


    /**
     * @Description: 根据用户token获取用户地图权限
@@ -33,25 +49,78 @@
     */
    @Override
    public List<WebProvince> getMapPath(String token) {
        List<WebProvince> results;
        try {
            Map<String, Object> params = new HashMap<>();
            Integer id = Integer.parseInt(WebTokenUtils.getIdBytoken(token));
            Organization organization = organizationService.getOrganizationByAccountId(id);

            Map<String, Object> regionCodeAndType = getRegionCodeAndTypeByOrg(organization);
            String regionType = (String) regionCodeAndType.get("regionType");
            String regionCode = (String) regionCodeAndType.get("regionCode");
            params.put(regionType, regionCode);
            results = mapPathMapper.getMapPathByRegionCode(params);
            return results;
        } catch (Exception e) {
            log.error(e.getMessage());
        Integer id = Integer.parseInt(WebTokenUtils.getIdBytoken(token));
        Organization organization = organizationService.getOrganizationByAccountId(id);
        List<MonitorPoint> monitorPoints;
        //判断是否属于超级组织，如果属于超级组织则返回所有存在设备的省市区，否则根据org下的站点进行查询。
        if (dictionaryDataService.querySupperOrgId().equals(organization.getId())) {
            monitorPoints = monitorPointMapper.selectAll();
        } else {
            Integer parentOrgId = organization.getId();
            Set<Integer> childOrgIds = organizationService.getChildOrganizationIds(parentOrgId);
            childOrgIds.add(parentOrgId);
            monitorPoints = monitorPointService.getMonitorPointsByOrganizationIds(childOrgIds);
        }
        return null;

        Set<Integer> provinceCodesSet = new HashSet<>();
        Set<Integer> cityCodesSet = new HashSet<>();
        Set<Integer> areaCodesSet = new HashSet<>();
        for (MonitorPoint monitorPoint : monitorPoints) {
            provinceCodesSet.add(monitorPoint.getProvinceCode());
            cityCodesSet.add(monitorPoint.getCityCode());
            areaCodesSet.add(monitorPoint.getAreaCode());
        }

        //Set转为List用于排序
        List<Integer> provinceCodes = new ArrayList<>(provinceCodesSet);
        List<Integer> cityCodes = new ArrayList<>(cityCodesSet);
        List<Integer> areaCodes = new ArrayList<>(areaCodesSet);
        provinceCodes.removeAll(Collections.singleton(null));
        cityCodes.removeAll(Collections.singleton(null));
        areaCodes.removeAll(Collections.singleton(null));
        Comparator<Integer> comparator = new ComparatorUtil();
        Collections.sort(provinceCodes, comparator);
        Collections.sort(cityCodes, comparator);
        Collections.sort(areaCodes, comparator);

        List<WebProvince> mapPath = new ArrayList<>();
        for (Integer provinceCode : provinceCodes) {
            String provinceCodeStr = String.valueOf(provinceCode);
            String provinceJSON = (String) redisTemplate.opsForHash().get("province_Map", String.valueOf(provinceCode));
            Province province = JSON.parseObject(provinceJSON).toJavaObject(Province.class);
            WebProvince webProvince = new WebProvince(province.getProvinceCode(), province.getProvinceName(), new ArrayList<>());
            for (Integer cityCode : cityCodes) {
                String cityCodeStr = String.valueOf(cityCode);
                //判断该市是否属于该省
                if (cityCodeStr.substring(0, 2).equals(provinceCodeStr.substring(0, 2))) {
                    String cityJSON = (String) redisTemplate.opsForHash().get("city_Map", String.valueOf(cityCode));
                    City city = JSON.parseObject(cityJSON).toJavaObject(City.class);
                    WebCity WebCity = new WebCity(city.getCityCode(), city.getCityName(), provinceCode, new ArrayList<>());
                    for (Integer areaCode : areaCodes) {
                        String areaCodeStr = String.valueOf(areaCode);
                        if (cityCodeStr.substring(0, 4).equals(areaCodeStr.substring(0, 4))) {
                            String areaJSON = (String) redisTemplate.opsForHash().get("area_Map", String.valueOf(areaCode));
                            Area area = JSON.parseObject(areaJSON).toJavaObject(Area.class);
                            WebCity.getAreas().add(area);
                        }
                    }
                    webProvince.getCities().add(WebCity);
                }
            }
            mapPath.add(webProvince);
        }
        return mapPath;
    }

    public static Map<String, Object> getRegionCodeAndTypeByOrg(Organization organization) {

    /**
     * @Description: 根据组织id，获取该组织地区的定位和类型。
     * @Param: [organization]
     * @return: java.util.Map<java.lang.String                               ,                               java.lang.Object>
     * @Author: 下雨听风
     * @Date: 2020/11/30
     */
    private Map<String, Object> getRegionCodeAndTypeByOrg(Organization organization) {
        Map<String, Object> result = new HashMap<>();
        String regionCode = "";
        String regionType = "";
@@ -77,4 +146,11 @@
        result.put("regionType", regionType);
        return result;
    }

    class ComparatorUtil implements Comparator<Integer> {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o1 - o2;
        }
    }
}