波动补偿

于紫祥_1901

2020-12-24 f28149d8183a62f87fa9c8df9ae589070d83f612

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

@@ -1,26 +1,19 @@
package com.moral.service.impl;



import java.math.BigDecimal;

import java.text.ParseException;

import java.text.SimpleDateFormat;

import java.time.Instant;

import java.time.LocalDate;

import java.time.LocalDateTime;

import java.time.ZoneId;

import java.time.ZoneOffset;

import java.time.format.DateTimeFormatter;

import java.time.temporal.ChronoUnit;

import java.time.temporal.TemporalAdjusters;

import java.util.ArrayList;

import java.util.Arrays;

import java.util.Collections;

import java.util.Comparator;

import java.util.Date;

import java.util.HashMap;

import java.util.LinkedHashMap;

import java.util.List;

import java.util.Map;

import java.util.*;



import javax.annotation.Resource;



import org.springframework.stereotype.Service;

import org.springframework.util.ObjectUtils;



import com.alibaba.fastjson.JSON;

import com.alibaba.fastjson.JSONObject;

@@ -32,311 +25,691 @@
import com.moral.entity.Sensor;

import com.moral.mapper.DeviceMapper;

import com.moral.mapper.HistoryMapper;

import com.moral.mapper.HistoryMinutelyMapper;

import com.moral.mapper.MonitorPointMapper;

import com.moral.mapper.OrganizationRelationMapper;

import com.moral.mapper.SensorMapper;

import com.moral.mapper.SensorUnitMapper;

import com.moral.service.AccountService;

import com.moral.service.HistoryService;

import com.moral.service.ProfessionService;

import com.moral.util.AQICalculation;

import com.moral.util.DatesUtil;



import org.apache.commons.collections.CollectionUtils;

import org.springframework.stereotype.Service;

import org.springframework.util.ObjectUtils;



@Service

public class HistoryServiceImpl implements HistoryService {



   @Resource

   private AccountService accountService;

    @Resource

    private AccountService accountService;



   @Resource

   private HistoryMapper historyMapper;

    @Resource

    private HistoryMapper historyMapper;



   @Resource

   private DeviceMapper deviceMapper;

    @Resource

    private HistoryMinutelyMapper historyMinutelyMapper;



   @Resource

   private SensorMapper sensorMapper;

    @Resource

    private DeviceMapper deviceMapper;



    @Resource

    private SensorMapper sensorMapper;



    @Resource

    private ProfessionService professionService;



   @Override

   public Map<String, Object> getAllSensorAverageByDevice(Map<String, Object> parameters) throws Exception {

      ValidateUtil.notNull(parameters.get("areaCode"), "param.is.null");

      ValidateUtil.notNull(parameters.get("accountId"), "param.is.null");

      Map<String,Object> resultMap = new LinkedHashMap<String, Object>();

      accountService.setOrgIdsByAccount(parameters);

      LocalDateTime time = LocalDateTime.now();

      // 当前时间 -10分钟

      parameters.put("start", time.minusMinutes(10));

      // 当前时间 -5分钟

      parameters.put("end", time.minusMinutes(5));

      List<Sensor> Sensors = sensorMapper.getSensorsByCriteria(parameters);

      List<String> sensorKeys = new ArrayList<String>();

      for (Sensor sensor : Sensors) {

         sensorKeys.add(sensor.getSensorKey());

      }

      parameters.put("sensorKeys", sensorKeys);

      List<Map<String, Object>> list = historyMapper.getAreaAllDataByAccount(parameters);

      resultMap.putAll(list.get(0));

      return resultMap;

   }

    @Resource

    private OrganizationRelationMapper organizationRelationMapper;



   @Override

   public Map<String, Object> getDeviceRankingBySensorAverage(Map<String, Object> parameters) {

      ValidateUtil.notNull(parameters.get("areaCode"), "param.is.null");

      ValidateUtil.notNull(parameters.get("accountId"), "param.is.null");

      Object macKey = parameters.get("macKey");

      ValidateUtil.notNull(macKey, "param.is.null");

    @Resource

    private MonitorPointMapper monitorPointMapper;



      Map<String, Object> result = new LinkedHashMap<String, Object>();

      accountService.setOrgIdsByAccount(parameters);

      LocalDateTime time = LocalDateTime.now();

      // 当前时间 -1小时

      parameters.put("start", time.minusHours(1));

      parameters.put("end", time);

      List<String> sensorKeys = new ArrayList<String>();

      sensorKeys.add(macKey.toString());

      parameters.put("sensorKeys", sensorKeys);

      List<Map<String, Object>> list = historyMapper.getAreaAllDataByAccount(parameters);

    @Override

    public Map<String, Object> getAllSensorAverageByDevice(Map<String, Object> parameters) throws Exception {

        ValidateUtil.notNull(parameters.get("areaCode"), "param.is.null");

        ValidateUtil.notNull(parameters.get("accountId"), "param.is.null");

        Map<String, Object> resultMap = new LinkedHashMap<String, Object>();

        accountService.setOrgIdsByAccount(parameters);

        LocalDateTime time = LocalDateTime.now();

        parameters.put("end", time);

        // 当前时间 -5分钟

        LocalDateTime start = time.minusMinutes(5);

        parameters.put("start", start);

        List<Sensor> Sensors = sensorMapper.getSensorsByCriteria(parameters);

        List<String> sensorKeys = new ArrayList<String>();

        for (Sensor sensor : Sensors) {

            sensorKeys.add(sensor.getSensorKey());

        }

        parameters.put("sensorKeys", sensorKeys);

        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyyMM");

        parameters.put("timeUnits", "five_minutely_" + df.format(time));

        List<Map<String, Object>> list = historyMapper.getAreaAllDataByAccount(parameters);

        resultMap.putAll(list.get(0));

        return resultMap;

    }



      for (Map<String, Object> map : list) {

         result.put((String) map.get("name"), map.get(macKey.toString()));

      }

      return result;

   }

   @Override

   public String queryValueByMacAndTime(String mac, Date time){

      return  historyMapper.selectValueByMacAndTime(mac, time);

   }

    @Override

    public Map<String, Object> getDeviceRankingBySensorAverage(Map<String, Object> parameters) {

        ValidateUtil.notNull(parameters.get("areaCode"), "param.is.null");

        ValidateUtil.notNull(parameters.get("accountId"), "param.is.null");

        Object macKey = parameters.get("macKey");

        ValidateUtil.notNull(macKey, "param.is.null");



   @Override

   public List<Map<String, Object>> getRegionRankingData(Map<String, Object> parameters) {

      ValidateUtil.notNull(parameters.get("regionCode"), "param.is.null");

      ValidateUtil.notNull(parameters.get("dimension"), "param.is.null");

      ValidateUtil.notNull(parameters.get("sensorKey"), "param.is.null");

      ValidateUtil.notNull(parameters.get("accountId"), "param.is.null");

        Map<String, Object> result = new LinkedHashMap<String, Object>();

        accountService.setOrgIdsByAccount(parameters);

        LocalDateTime time = LocalDateTime.now();

        // 当前时间 -1小时

        parameters.put("start", time.minusHours(1));

        parameters.put("end", time);

        List<String> sensorKeys = new ArrayList<String>();

        sensorKeys.add(macKey.toString());

        parameters.put("sensorKeys", sensorKeys);

        parameters.put("timeUnits", "hourly");

        List<Map<String, Object>> list = historyMapper.getAreaAllDataByAccount(parameters);

        for (Map<String, Object> map : list) {

            result.put((String) map.get("name"), map.get(macKey.toString()));

        }

        return result;

    }



      String regionCode = parameters.get("regionCode").toString();

      parameters.put("provinceCode", regionCode.substring(0,2).concat("0000"));

      String regionType = "village";

      String nextLevel = "";

      if (regionCode.length() == 6) {

         if (regionCode.endsWith("0000")) {

            regionType = "province";

            nextLevel = "city";

         } else if (regionCode.endsWith("00")) {

            regionType = "city";

            nextLevel = "area";

         } else {

            regionType = "area";

            nextLevel = "town";

         }

      } else {

         if (regionCode.endsWith("000")) {

            regionType = "town";

            nextLevel = "village";

         }

      }

      parameters.put("regionType", regionType);

      parameters.put("nextLevel", nextLevel);

    @Override

    public String queryValueByMacAndTime(String mac, Date time) {

        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");

        String timeUnits = sdf.format(time);

        return historyMapper.selectValueByMacAndTime(mac, time, timeUnits);

    }



      LocalDate localDate = LocalDate.now();

      Object timeType = parameters.get("timeType");

      String table = "history";

      String column = "value";

      if ("month".equals(timeType)) {

         if (1 != localDate.getDayOfMonth()) {

            table = "history_daily";

            column = "json";

         }

         parameters.put("start", localDate.with(TemporalAdjusters.firstDayOfMonth()));

      } else if ("day".equals(timeType)) {

         parameters.put("start", localDate);

      } else if ("hour".equals(timeType)) {

         parameters.put("start", LocalDateTime.now().truncatedTo(ChronoUnit.HOURS));

      } else {

         parameters.put("start", LocalDateTime.now().minusMinutes(5));

      }

      parameters.put("table", table);

      parameters.put("column", column);

		
      String dimension = "";

      if ("discharge".equals(parameters.get("dimension"))) {

         dimension = "discharge";

         parameters.put("dimension","monitorPoint");

      }

		
      accountService.setOrgIdsByAccount(parameters);

		
      List<Map<String, Object>> result = historyMapper.getRegionRankingData(parameters);

      for (Map<String, Object> map : result) {

         if (ObjectUtils.isEmpty(map.get("avg"))) {

            map.put("avg", 0);

         }

      }

      if ("profession".equals(parameters.get("dimension"))) {

         List<Profession> professions = professionService.getProfessiontList(parameters);

         for (Map<String, Object> map : result) {

            for (Profession profession : professions) {

               if (map.get("name").equals(profession.getName())) {

                  professions.remove(profession);

    public String getValueByMacAndTime(String mac, String time, String time1) {

        String timeUnits = time1.substring(0, 10).replace("-", "");

        return historyMapper.getValueByMacAndTime(mac, time, time1, timeUnits);

    }



    @Override

    public List<Map<String, Object>> getRegionRankingData(Map<String, Object> parameters) {

        ValidateUtil.notNull(parameters.get("regionCode"), "param.is.null");

        ValidateUtil.notNull(parameters.get("dimension"), "param.is.null");

        ValidateUtil.notNull(parameters.get("sensorKey"), "param.is.null");

        ValidateUtil.notNull(parameters.get("accountId"), "param.is.null");



        String regionCode = parameters.get("regionCode").toString();

        parameters.put("provinceCode", regionCode.substring(0, 2).concat("0000"));

        String regionType = "village";

        String nextLevel = "";

        if (regionCode.length() == 6) {

            if (regionCode.endsWith("0000")) {

                regionType = "province";

                nextLevel = "city";

            } else if (regionCode.endsWith("00")) {

                regionType = "city";

                nextLevel = "area";

            } else {

                regionType = "area";

                nextLevel = "town";

            }

        } else {

            if (regionCode.endsWith("000")) {

                regionType = "town";

                nextLevel = "village";

            }

        }

        parameters.put("regionType", regionType);

        parameters.put("nextLevel", nextLevel);



        LocalDate localDate = LocalDate.now();

        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyyMM");

        Object timeType = parameters.get("timeType");



        String table = "history";

        String column = "json";

        /*if ("month".equals(timeType)) {

            if (1 != localDate.getDayOfMonth()) {

                table = "history_daily";

                column = "json";

            }

            parameters.put("start", localDate.with(TemporalAdjusters.firstDayOfMonth()));

        } else if ("day".equals(timeType)) {

            parameters.put("start", localDate);

        } else if ("hour".equals(timeType)) {

            parameters.put("start", LocalDateTime.now().truncatedTo(ChronoUnit.HOURS));

        } else {

            parameters.put("start", LocalDateTime.now().minusMinutes(5));

        }*/



        if ("month".equals(timeType)) {

            table = "history_daily";

            parameters.put("start", localDate.with(TemporalAdjusters.firstDayOfMonth()));

        } else if ("day".equals(timeType)) {

            table = "history_hourly";

            parameters.put("start", localDate);

        } else if ("hour".equals(timeType)) {

            table = "history_minutely_" + df.format(localDate);

            parameters.put("start", LocalDateTime.now().truncatedTo(ChronoUnit.HOURS));

        }



        parameters.put("table", table);

        parameters.put("column", column);



        String dimension = "";

        if ("discharge".equals(parameters.get("dimension"))) {

            dimension = "discharge";

            parameters.put("dimension", "monitorPoint");

        }



        accountService.setOrgIdsByAccount(parameters);

        List<Map<String, Object>> result = historyMapper.getRegionRankingData(parameters);

        for (Map<String, Object> map : result) {

            if (ObjectUtils.isEmpty(map.get("avg"))) {

                map.put("avg", 0);

            }

        }

        if ("profession".equals(parameters.get("dimension"))) {

            List<Profession> professions = professionService.getProfessiontList(parameters);

            for (Map<String, Object> map : result) {

                for (Profession profession : professions) {

                    if (map.get("name").equals(profession.getName())) {

                        professions.remove(profession);

//                  if (ObjectUtils.isEmpty(map.get("avg"))) {

//                     map.put("avg", 0);

//                  }

                  break;

               }

            }

         }

         for (Profession profession : professions) {

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

            map.put("name", profession.getName());

            map.put("avg", 0);

            result.add(map);

         }

      } else if ("region".equals(parameters.get("dimension"))) {

         List<String> regions = historyMapper.selectNextLevelRegion(parameters);

         for (Map<String, Object> map : result) {

            if (regions.contains(map.get("name"))) {

               regions.remove(map.get("name"));

                        break;

                    }

                }

            }

            for (Profession profession : professions) {

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

                map.put("name", profession.getName());

                map.put("avg", 0);

                result.add(map);

            }

        } else if ("region".equals(parameters.get("dimension"))) {

            List<String> regions = historyMapper.selectNextLevelRegion(parameters);

            for (Map<String, Object> map : result) {

                if (regions.contains(map.get("name"))) {

                    regions.remove(map.get("name"));

//               if (ObjectUtils.isEmpty(map.get("avg"))) {

//                  map.put("avg", 0);

//               }

            }

				
         }

         for (String region : regions) {

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

            map.put("name", region);

            map.put("avg", 0);

            result.add(map);

         }

      }

      if ("discharge".equals(dimension)) {

         parameters.put("year", LocalDate.now().getYear());

         List<Map<String, Object>> discharges = historyMapper.getDischargeByRegion(parameters);

         for (Map<String, Object> map : result) {

            for (Map<String, Object> discharge : discharges) {

               if (map.get("name").equals(discharge.get("name"))) {

                  map.put("value", discharge.get("value"));

                  discharges.remove(discharge);

                  break;

               } 
            }

         }

         Collections.sort(result, new Comparator<Map<String, Object>>() {

            @Override

            public int compare(Map<String, Object> o1, Map<String, Object> o2) {

               return Double.compare(((Double) o2.get("avg"))- Double.valueOf((String) o2.get("value")),

                     ((Double) o1.get("avg")) - Double.valueOf((String) o1.get("value")));

            }

         });

      }

      return result;

   }

	
                }



            }

            for (String region : regions) {

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

                map.put("name", region);

                map.put("avg", 0);

                result.add(map);

            }

        }

        if ("discharge".equals(dimension)) {

            parameters.put("year", LocalDate.now().getYear());

            List<Map<String, Object>> discharges = historyMapper.getDischargeByRegion(parameters);

            for (Map<String, Object> map : result) {

                for (Map<String, Object> discharge : discharges) {

                    if (map.get("name").equals(discharge.get("name"))) {

                        map.put("value", discharge.get("value"));

                        discharges.remove(discharge);

                        break;

                    }

                }

            }

            Collections.sort(result, new Comparator<Map<String, Object>>() {

                @Override

                public int compare(Map<String, Object> o1, Map<String, Object> o2) {

                    return Double.compare(((Double) o2.get("avg")) - Double.valueOf((String) o2.get("value")),

                            ((Double) o1.get("avg")) - Double.valueOf((String) o1.get("value")));

                }

            });

        }

        return result;

    }



    @Override

   public List<Map<String, Object>> getSensorsDataByDevice(Map<String, Object> parameters) {

      ValidateUtil.notNull(parameters.get("deviceVersionId"), "param.is.null");

      ValidateUtil.notNull(parameters.get("mac"), "param.is.null");

      ValidateUtil.notNull(parameters.get("deviceId"), "param.is.null");

       List<Map<String, Object>> sensors = sensorMapper.getSensorsByDeviceVersionId(parameters);

       parameters.put("size", 1);

       List<Map<String, Object>> values = historyMapper.getValueByMacAndSize(parameters);

       JSONObject map = null;

       if (!ObjectUtils.isEmpty(values)) {

          map = JSON.parseObject(values.get(0).get("value").toString());

      }

       Device device = deviceMapper.selectByPrimaryKey(Integer.valueOf((String) parameters.get("deviceId")));

       Map<String, Object> sensorUnits = getSensorUnitByDeviceMac(parameters);

       for (Map<String, Object> sensor : sensors) {

          Object sensorKey = sensor.get("sensor_key");

          sensor.put("name", sensor.get("description"));

          sensor.put("state", device.getState());

          if (!ObjectUtils.isEmpty(map)) {

             sensor.put("value", map.remove(sensor.get("sensor_key")));

         }

          if (sensorUnits.containsKey(sensorKey)) {

             Map<String, Object> sensorUnit  = (Map<String, Object>) sensorUnits.get(sensorKey);

             sensor.put("unit", sensorUnit.get("name"));

             if (sensor.containsKey("value")) {

                Object value = sensor.get("value");

                String rules = sensorUnit.get("rules").toString();

                rules = rules.replace("d", "").replace("{0}", "value");

                Expression expression = AviatorEvaluator.compile(rules);

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

                env.put("value", Double.valueOf(value.toString()));

                value = expression.execute(env);

                sensor.put("value",String.format("%.2f", value));

            }

         }

       }

      return sensors;

   }

    public List<Map<String, Object>> getSensorsDataByDevice(Map<String, Object> parameters) {

        ValidateUtil.notNull(parameters.get("deviceVersionId"), "param.is.null");

        ValidateUtil.notNull(parameters.get("mac"), "param.is.null");

        ValidateUtil.notNull(parameters.get("deviceId"), "param.is.null");

        List<Map<String, Object>> sensors = sensorMapper.getSensorsByDeviceVersionId(parameters);

        parameters.put("size", 1);

        Date date = new Date();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");

        String timeUnits = sdf.format(date);

        parameters.put("timeUnits", timeUnits);

        List<Map<String, Object>> values = historyMapper.getValueByMacAndSize(parameters);

        JSONObject map = null;

        if (!ObjectUtils.isEmpty(values)) {

            map = JSON.parseObject(values.get(0).get("value").toString());

        }

        Device device = deviceMapper.selectByPrimaryKey(Integer.valueOf((String) parameters.get("deviceId")));

        Map<String, Object> sensorUnits = getSensorUnitByDeviceMac(parameters);

        for (Map<String, Object> sensor : sensors) {

            Object sensorKey = sensor.get("sensor_key");

            sensor.put("name", sensor.get("description"));

            sensor.put("state", device.getState());

            if (!ObjectUtils.isEmpty(map)) {

                sensor.put("value", map.remove(sensor.get("sensor_key")));

            }

            if (sensorUnits.containsKey(sensorKey)) {

                Map<String, Object> sensorUnit = (Map<String, Object>) sensorUnits.get(sensorKey);

                sensor.put("unit", sensorUnit.get("name"));

                if (sensor.containsKey("value")) {

                    Object value = sensor.get("value");

                    String rules = sensorUnit.get("rules").toString();

                    rules = rules.replace("d", "").replace("{0}", "value");

                    Expression expression = AviatorEvaluator.compile(rules);

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

                    env.put("value", Double.valueOf(value.toString()));

                    value = expression.execute(env);

                    sensor.put("value", String.format("%.2f", value));

                }

            }

        }

        return sensors;

    }



   @Override

   public List<Map<String, Object>> getSensorDataBySensorKey(Map<String, Object> parameters) {

      Object sensorKey = parameters.get("sensorKey");

      ValidateUtil.notNull(sensorKey, "param.is.null");

      ValidateUtil.notNull(parameters.get("mac"), "param.is.null");

      ValidateUtil.notNull(parameters.get("size"), "param.is.null");

      parameters.put("size", Integer.valueOf(parameters.remove("size").toString()));

      List<Map<String, Object>> values = historyMapper.getValueByMacAndSize(parameters);

      Map<String, Object> sensorUnits = getSensorUnitByDeviceMac(parameters);

      for (Map<String, Object> value : values) {

         JSONObject json = JSON.parseObject(value.remove("value").toString());

         Object sensorKeyValue = json.get(sensorKey);

         if (sensorUnits.containsKey(sensorKey)) {

            Map<String, Object> sensorUnit  = (Map<String, Object>) sensorUnits.get(sensorKey);

            String rules = sensorUnit.get("rules").toString();

            rules = rules.replace("d", "").replace("{0}", "sensorKeyValue");

            Expression expression = AviatorEvaluator.compile(rules);

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

            env.put("value", Double.valueOf(sensorKeyValue.toString()));

            sensorKeyValue = expression.execute(env);

            sensorKeyValue = String.format("%.2f", sensorKeyValue);

         }

         value.put("value", sensorKeyValue);

      }

      return values;

   }

    @Override

    public List<Map<String, Object>> getSensorDataBySensorKey(Map<String, Object> parameters) {

        Object sensorKey = parameters.get("sensorKey");

        ValidateUtil.notNull(sensorKey, "param.is.null");

        ValidateUtil.notNull(parameters.get("mac"), "param.is.null");

        ValidateUtil.notNull(parameters.get("size"), "param.is.null");

        parameters.put("size", Integer.valueOf(parameters.remove("size").toString()));

        Date date = new Date();

        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMMdd");

        String timeUnits = sdf.format(date);

        parameters.put("timeUnits", timeUnits);

        List<Map<String, Object>> values = historyMapper.getValueByMacAndSize(parameters);

        Map<String, Object> sensorUnits = getSensorUnitByDeviceMac(parameters);

        for (Map<String, Object> value : values) {

            JSONObject json = JSON.parseObject(value.remove("value").toString());

            Object sensorKeyValue = json.get(sensorKey);

            if (sensorUnits.containsKey(sensorKey)) {

                Map<String, Object> sensorUnit = (Map<String, Object>) sensorUnits.get(sensorKey);

                String rules = sensorUnit.get("rules").toString();

                rules = rules.replace("d", "").replace("{0}", "value");

                Expression expression = AviatorEvaluator.compile(rules);

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

                env.put("value", Double.valueOf(sensorKeyValue.toString()));

                sensorKeyValue = expression.execute(env);

                sensorKeyValue = String.format("%.2f", sensorKeyValue);

            }

            value.put("value", sensorKeyValue);

        }

        return values;

    }



   @Override

   public Map<String, Object> getActualDataByRegion(Map<String, Object> parameters) {

      Object sensorKey = parameters.get("sensorKey");

      ValidateUtil.notNull(sensorKey, "param.is.null");

      ValidateUtil.notNull(parameters.get("accountId"), "param.is.null");

      ValidateUtil.notNull(parameters.get("interval"), "param.is.null");

      Integer interval = Integer.valueOf(parameters.get("interval").toString());

      LocalDateTime start, end;

      if (!parameters.containsKey("time")) {

         end = LocalDateTime.now();

         int second = end.getSecond() / interval * interval;

         end = end.truncatedTo(ChronoUnit.MINUTES).plusSeconds(second);

         start = end.minusSeconds(interval);

      } else {

         //start = LocalDateTime.ofEpochSecond(Long.valueOf(parameters.get("time").toString()) / 1000, 0, ZoneOffset.ofHours(8));

         start = LocalDateTime.ofInstant(Instant.ofEpochMilli(Long.valueOf(parameters.get("time").toString())),ZoneId.of("+8"));

         end = start.plusSeconds(interval);

      }

      parameters.put("start", start);

      parameters.put("end", end);

      parameters.put("sensorKeys", Arrays.asList(((String) sensorKey).split(",")));

      accountService.setOrgIdsByAccount(parameters);

      Map<String, Object> result = historyMapper.getActualDataByRegion(parameters);

      if (ObjectUtils.isEmpty(result)) {

         result = new HashMap<String, Object>();

      }

      result.put("time", end.toInstant(ZoneOffset.of("+8")).toEpochMilli());

      return result;

   }

    @Override

    public Map<String, Object> getActualDataByRegion(Map<String, Object> parameters) {

        Object sensorKey = parameters.get("sensorKey");

        ValidateUtil.notNull(sensorKey, "param.is.null");

        ValidateUtil.notNull(parameters.get("accountId"), "param.is.null");

        ValidateUtil.notNull(parameters.get("interval"), "param.is.null");

        Integer interval = Integer.valueOf(parameters.get("interval").toString());

        LocalDateTime start, end;

        if (!parameters.containsKey("time")) {

            end = LocalDateTime.now();

            int second = end.getSecond() / interval * interval;

            end = end.truncatedTo(ChronoUnit.MINUTES).plusSeconds(second);

            start = end.minusSeconds(interval);

        } else {

            //start = LocalDateTime.ofEpochSecond(Long.valueOf(parameters.get("time").toString()) / 1000, 0, ZoneOffset.ofHours(8));

            start = LocalDateTime.ofInstant(Instant.ofEpochMilli(Long.valueOf(parameters.get("time").toString())), ZoneId.of("+8"));

            end = start.plusSeconds(interval);

        }

        parameters.put("start", start);

        parameters.put("end", end);

        parameters.put("sensorKeys", Arrays.asList(((String) sensorKey).split(",")));

        accountService.setOrgIdsByAccount(parameters);

        DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyyMMdd");

        //从history年月日表获取

        parameters.put("timeUnits", df.format(start));

        Map<String, Object> result = historyMapper.getActualDataByRegion(parameters);

        if (ObjectUtils.isEmpty(result)) {

            result = new HashMap<String, Object>();

        }

        result.put("time", end.toInstant(ZoneOffset.of("+8")).toEpochMilli());

        return result;

    }



   @Resource

   private SensorUnitMapper sensorUnitMapper;

   @Override

   public Map<String, Object> getSensorUnitByDeviceMac(Map<String, Object> parameters){

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

      List<Map<String, Object>> list = sensorUnitMapper.getSensorUnitByDeviceMac(parameters);

      for (Map<String, Object> map : list) {

         resultMap.put(map.remove("sensor_key").toString(), map);

      }

      return resultMap;

		
   }

    @Resource

    private SensorUnitMapper sensorUnitMapper;



    @Override

    public Map<String, Object> getSensorUnitByDeviceMac(Map<String, Object> parameters) {

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

        List<Map<String, Object>> list = sensorUnitMapper.getSensorUnitByDeviceMac(parameters);

        for (Map<String, Object> map : list) {

            resultMap.put(map.remove("sensor_key").toString(), map);

        }

        return resultMap;

    }



    @Override

    public Map<String, Object> gitHourlyAQIByMacAndTimeslot(Map<String, Object> parameters) {

        String mac = parameters.get("mac").toString();

        //获取日期

        LocalDate localDate = LocalDate.now();

        Calendar c = Calendar.getInstance();//可以对每个时间域单独修改

        int endHour = c.get(Calendar.HOUR_OF_DAY);

        String endTime = localDate + " " + endHour + ":00:00";



        String startTime;

        if (endHour == 0) {

            LocalDate startDate = localDate.minusDays(1);

            startTime = startDate + " " + "23:00:00";

        } else {

            int startHour = endHour - 1;

            startTime = localDate + " " + startHour + ":00:00";

        }

        //从不同history日表获取数据

        String timeUnits = startTime.substring(0, 10).replace("-", "");

        Map<String, Object> map = historyMapper.getAVGValueByMacAndTimeslot(mac, startTime, endTime, timeUnits);

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

        if (ObjectUtils.isEmpty(map) || map.isEmpty()) {

             returnMap.put("AQI", "N/V");

             return returnMap;

        } else {

            Map<String, Double> AQIMap = new HashMap<>();

            for (Map.Entry<String, Object> entry : map.entrySet()) {

                String key = entry.getKey();

                if (entry.getValue() != null) {

                    Double value = Double.parseDouble(entry.getValue().toString());

                    AQIMap.put(key, value);

                }

            }

            returnMap = AQICalculation.hourlyAQI(AQIMap);

        }

        long aqi = Math.round(Double.valueOf(returnMap.get("AQI").toString()));

        returnMap.put("AQI", aqi);

        return returnMap;

    }



    @Override

    public List<Map<String, Object>> getMointorPointRankByOrganizationId(Map<String, Object> parameters) {

        //获取组织id

        String organizationId = parameters.get("organization_id").toString();

        //声明一个集合存放要查询站点数据的组织id

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

        organizationIdList.add(organizationId);

        //声明一个集合存放父组织id

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

        parentIdList.add(organizationId);



        //进行循环

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

            if (!parentIdList.isEmpty()) {

                //或去该组织下的子组织

                List<Map<String, Object>> childIdList = organizationRelationMapper.getChildIdByParentId(parentIdList);

                //清空父组织id集合

                parentIdList.clear();

                //将子组织id放入到集合中

                for (Map<String, Object> map : childIdList) {

                    organizationIdList.add(map.get("child_id"));

                    parentIdList.add(map.get("child_id"));

                }

            } else {

                break;

            }

        }



        //根据组织id获取站点id

        List<Map<String, Object>> monitorPointIdListMap = monitorPointMapper.getIdByOrganizationId(organizationIdList);

        //将List<Map<String, Object>>装换为List<Object>

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

        for (Map<String, Object> map : monitorPointIdListMap) {

            monitorPointIdList.add(map.get("id"));

        }



        //通过站点id获取设备因子的排名

        //获取系统当前时间

        Calendar rightNow = Calendar.getInstance();

        //获取五分钟前的时间

        Calendar beforeTime = Calendar.getInstance();

        beforeTime.add(Calendar.MINUTE, -5);// 5分钟之前的时间

        Date beforeD = beforeTime.getTime();

        Date end = rightNow.getTime();

        String endTime = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(end);

        String before5Time = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(beforeD);  // 前五分钟时间

        String sensor = parameters.get("sensor").toString();

        String timeUnits1 = before5Time.substring(0, 10).replace("-", "");

        List<Map<String, Object>> result1 = historyMapper.getAVGSensorRankByMonitorPointIdList(sensor, monitorPointIdList, before5Time, endTime, timeUnits1);

        String timeUnits2 = before5Time.substring(0, 10).replace("-", "");

        List<Map<String, Object>> result2 = historyMapper.getAVGSensorRankByMonitorPointIdList(sensor, monitorPointIdList, before5Time, endTime, timeUnits2);

        if (result1.isEmpty()) {

            return result2;

        } else if (result2.isEmpty()) {

            return result1;

        } else {

            for (Map<String, Object> map1 : result1) {

                Object name1 = map1.get("name");

                double value1 = Double.parseDouble(map1.get("sensor").toString());

                double avg = 0.0;

                for (Map<String, Object> map2 : result2) {

                    Object name2 = map2.get("name");

                    double value2 = Double.parseDouble(map2.get("sensor").toString());

                    if (name1.equals(name2)) {

                        avg = (value1 + value2) / 2;

                        map1.put("sensor", avg);

                    }

                }

            }

        }

        return result1;

    }



    @Override

    public Map<String, Object> gitHourlyAQIByMonitorPointIdAndTimeslot(Map<String, Object> parameters) {

        String monitor_point_id = parameters.get("monitor_point_id").toString();

        //获取日期

        LocalDate localDate = LocalDate.now();

        Calendar c = Calendar.getInstance();//可以对每个时间域单独修改

        int endHour = c.get(Calendar.HOUR_OF_DAY);

        String endTime = localDate + " " + endHour + ":00:00";



        String startTime;

        if (endHour == 0) {

            LocalDate startDate = localDate.minusDays(1);

            startTime = startDate + " " + "23:00:00";

        } else {

            int startHour = endHour - 1;

            startTime = localDate + " " + startHour + ":00:00";

        }

        //从不同history日表获取数据

        String timeUnits = startTime.substring(0, 10).replace("-", "");



        Map<String, Object> map = historyMapper.getMonitorPointAVGValueByMonitorPointIdAndTimeslot(monitor_point_id, startTime, endTime, timeUnits);

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

        if (map.isEmpty()) {

            returnMap.put("AQI", "N/V");

        } else {

            Map<String, Double> AQIMap = new HashMap<>();

            for (Map.Entry<String, Object> entry : map.entrySet()) {

                String key = entry.getKey();

                Double value = Double.parseDouble(entry.getValue().toString());

                AQIMap.put(key, value);

            }

            returnMap = AQICalculation.hourlyAQI(AQIMap);

        }



        return returnMap;

    }



    @Override

    public List<List<Map<String, Object>>> getCarSensorData(Map<String, Object> parameters) throws Exception {

        String startTime = parameters.get("startTime").toString();

        DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

        LocalDateTime startTimeLocalDateTime = LocalDateTime.parse(startTime, dateTimeFormatter);

        SimpleDateFormat sdf = new SimpleDateFormat("yyyyMM");

        int format = Integer.parseInt(sdf.format(new Date()));

        int year = startTimeLocalDateTime.getYear();

        int month = startTimeLocalDateTime.getMonthValue();

        String monthStr = month < 10 ? ("0" + month) : month + "";

        String yearAndMonth = year + monthStr;

        List<Sensor> sensors = sensorMapper.getSensorsByMac(parameters);

        List<String> sensorKeys = new ArrayList<>();

        for (Sensor sensor : sensors) {

            sensorKeys.add(sensor.getSensorKey());

        }

        parameters.put("sensorKeys", sensorKeys);

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

        listMap = historyMapper.getCarSensorData(parameters);

        if (CollectionUtils.isEmpty(listMap)) {

            if (year <= 2019) {

                listMap = historyMinutelyMapper.getSensorData(parameters);

            } else {

                if (Integer.parseInt(yearAndMonth) <= format) {

                    parameters.put("yearAndMonth", yearAndMonth);

                    listMap = historyMinutelyMapper.getSensorData2020(parameters);

                }

            }

        }

        //}

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

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

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

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

        if (CollectionUtils.isNotEmpty(listMap)) {

            for (Map<String, Object> map : listMap) {

                Map<String, Object> mapAvg = new LinkedHashMap<>();

                Map<String, Object> mapMin = new LinkedHashMap<>();

                Map<String, Object> mapMax = new LinkedHashMap<>();

                mapAvg.put("time", map.get("time"));

                mapMin.put("time", map.get("time"));

                mapMax.put("time", map.get("time"));

                for (Map.Entry<String, Object> entry : map.entrySet()) {

                    for (Sensor sensor : sensors) {

                        if (sensor.getSensorKey().equals(entry.getKey())) {

                            if (entry.getValue() != null) {

                                mapAvg.put(entry.getKey(), new BigDecimal(entry.getValue().toString().replace("\"", "")).stripTrailingZeros().toPlainString() + sensor.getUnit());

                            }

                        } else if (("min" + sensor.getSensorKey()).equals(entry.getKey())) {

                            mapMin.put(entry.getKey().substring(3), new BigDecimal(entry.getValue().toString().replace("\"", "")).stripTrailingZeros().toPlainString());

                        } else if (("max" + sensor.getSensorKey()).equals(entry.getKey())) {

                            mapMax.put(entry.getKey().substring(3), new BigDecimal(entry.getValue().toString().replace("\"", "")).stripTrailingZeros().toPlainString());

                        }

                    }

                }

                if ("0°".equals(mapAvg.get("e76")) || "0".equals(mapMin.get("e76")) || "0".equals(mapMax.get("e76")) || "0°".equals(mapAvg.get("e77")) || "0".equals(mapMin.get("e77")) || "0".equals(mapMax.get("e77"))) {

                    continue;

                }

                listMapAvg.add(mapAvg);

                listMapMin.add(mapMin);

                listMapMax.add(mapMax);

            }

            listMaps.add(listMapAvg);

            listMaps.add(listMapMin);

            listMaps.add(listMapMax);

        }

        return listMaps;

    }



    @Override

    public List<Map<String, Object>> getUavSensorData(Map<String, Object> parameters) {

        List<Sensor> sensors = sensorMapper.getSensorsByMac(parameters);

        List<String> sensorKeys = new ArrayList<>();

        for (Sensor sensor : sensors) {

            sensorKeys.add(sensor.getSensorKey());

        }

        parameters.put("sensorKeys", sensorKeys);

        List<Map<String, Object>> uavSensorData = historyMapper.getUavSensorData(parameters);

        for (Map<String, Object> dataMap : uavSensorData) {

            for (Map.Entry<String, Object> entry : dataMap.entrySet()) {

                for (Sensor sensor : sensors) {

                    if (sensor.getSensorKey().equals(entry.getKey())) {

                        if (entry.getValue() != null) {

                            dataMap.put(entry.getKey(), new BigDecimal(entry.getValue().toString().replace("\"", "")).stripTrailingZeros().toPlainString() + sensor.getUnit());

                        }

                    }

                }

            }

        }

        Map<String, Object> map = sensorMapper.getSensorBySensorKey(parameters.get("sensorKey").toString());

        parameters.put("unit", map.get("unit"));

        parameters.put("description", map.get("description"));

        return uavSensorData;

    }



    @Override

    public List<Map<String, Object>> getO3AVG(Map<String, Object> parameters) {

        String mac = (String) parameters.get("mac");

        String stime = (String) parameters.get("time");

        SimpleDateFormat format = new SimpleDateFormat("yyyy-MM");

        Date time = null;

        try {

            time = format.parse(stime);

        } catch (ParseException e) {

            e.printStackTrace();

        }

        List<String> stringListDate = DatesUtil.getAllTheDateOftheMonth(time);

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

        for (String date : stringListDate) {

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

            DateTimeFormatter df = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");

            LocalDateTime time1 = LocalDateTime.parse(date + " 00:00:00", df);

            LocalDateTime time2 = time1.plusDays(1);

            String time3 = time2.toString().substring(0, 10);

            String nextDate = time3 + " 07:00:00";

            parm.put("date", date);

            parm.put("nextDate", nextDate);

            parm.put("mac", mac);

            List<Map<String, Object>> listMap = historyMapper.getO3AVG(parm);

            List list = new ArrayList();

            DatesUtil.getList(listMap, list);

            List list1 = new ArrayList();

            String maxO3 = "";

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

                List elist = new ArrayList();

                Double sum = 0.0;

                Double avg = 0.0;

                for (Object o : (List) list.get(i)) {

                    Iterator<Map.Entry> iterator = ((Map) o).entrySet().iterator();

                    while (iterator.hasNext()) {

                        Map.Entry entry = iterator.next();

                        if (entry.getKey().equals("e15")) {

                            elist.add(entry.getValue());

                        }

                    }

                }

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

                    sum += Double.parseDouble((String) elist.get(j));

                    if (listMap.size() <= 8 && listMap.size() > 0) {

                        avg = sum / listMap.size();

                    } else {

                        avg = sum / 8;

                    }

                }

                if (avg == 0.0) {

                    list1.add("");

                } else {

                    BigDecimal b = new BigDecimal(avg);

                    double avg1 = b.setScale(4, BigDecimal.ROUND_HALF_UP).doubleValue();

                    list1.add(avg1);

                }

            }

            String timef = date + " 00:00:00";

            String timea = date + " 23:59:59";

            int num = historyMapper.getNum(timef, timea);

            if (num == 0) {

                maxO3 = "";

            } else {

                if (list1.size() != 0) {

                    maxO3 = "" + Collections.max(list1);

                } else {

                    maxO3 = "";

                }

            }

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

            avgMap.put("time", date);

            avgMap.put("e15", maxO3);

            maxList.add(avgMap);

        }

        return maxList;

    }



    @Override

    public String getJsonData(String mac, String time, String table) {

        return historyMapper.getJsonData(mac, time, table);

    }



}