lizijie
2019-07-10 e97c393e23f4c015a44b5fef5fd26ae288bc6c0f
src/main/java/com/moral/service/impl/HistoryServiceImpl.java
@@ -1,30 +1,39 @@
package com.moral.service.impl;
import java.math.BigDecimal;
import java.math.RoundingMode;
import java.time.Instant;
import java.time.LocalDate;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.time.ZoneOffset;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAdjusters;
import java.util.ArrayList;
import java.util.Collection;
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.concurrent.Callable;
import java.util.concurrent.CompletionService;
import java.util.concurrent.ExecutorCompletionService;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import javax.annotation.Resource;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.moral.common.util.ValidateUtil;
import com.moral.entity.Device;
import com.moral.entity.Profession;
import com.moral.entity.Sensor;
import com.moral.mapper.DeviceMapper;
import com.moral.mapper.HistoryMapper;
import com.moral.mapper.SensorMapper;
import com.moral.service.AccountService;
import com.moral.service.HistoryService;
import com.moral.service.ProfessionService;
@Service
public class HistoryServiceImpl implements HistoryService {
@@ -41,98 +50,37 @@
   @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, Number[]> result = new HashMap<String, Number[]>();
      Map<String,Object> resultMap = new HashMap<String, Object>();
      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));
      parameters.put("macKey", "all");
      List<Integer> deviceVersionIds = deviceMapper.getDeviceVersionIdByAreaCode(parameters);
      ExecutorService threadPool = Executors.newCachedThreadPool();
      CompletionService<Map<String, Object>> cs = new ExecutorCompletionService<Map<String, Object>>(threadPool);
      for (Integer deviceVersionId : deviceVersionIds) {
         Map<String, Object> parameter = new HashMap<String, Object>(parameters);
         String queryColumns = "";
         List<Map<String, Object>> sensors = sensorMapper.getSensorsByDeviceVersionId(deviceVersionId);
         for (int i = 0; i < sensors.size(); i++) {
            String sensorKey = (String) sensors.get(i).get("sensor_key");
            queryColumns += "AVG(value -> '$." + sensorKey + "') " + sensorKey;
            if (i != sensors.size() - 1) {
               queryColumns += " ,";
            }
         }
         parameter.put("queryColumns", queryColumns);
         parameter.put("deviceVersionId", deviceVersionId);
         cs.submit(new Callable<Map<String, Object>>() {
            @Override
            public Map<String, Object> call() throws Exception {
               Map<String, Object> map = new HashMap<String, Object>();
               List<Map<String, Object>> list = historyMapper.getAreaAllDataByAccount(parameter);
               map.put(deviceVersionId.toString(), list.get(0));
               return map;
            }
         });
      List<Sensor> Sensors = sensorMapper.getSensorsByCriteria(parameters);
      List<String> sensorKeys = new ArrayList<String>();
      for (Sensor sensor : Sensors) {
         sensorKeys.add(sensor.getSensorKey());
      }
      List<Map<String, Object>> list = new ArrayList<Map<String,Object>>();
      for (Integer deviceVersionId : deviceVersionIds) {
         list.add(cs.take().get());
      }
      for (Map<String, Object> map : list) {
         Collection<Object> values = map.values();
         for (Object object : values) {
            Map<String, Object> result1 = (Map<String, Object>)object;
            for (String key : result1.keySet()) {
               Number[] numbers = new Number[2];
               Double sum = (Double) result1.get(key);
               Integer count = 1;
               if (result.containsKey(key)) {
                  numbers = result.get(key);
                  sum += (Double)numbers[0];
                  count += (Integer)numbers[1];
               }
               numbers[0] = sum;
               numbers[1] = count;
               result.put(key, numbers);
               resultMap.put(key, new BigDecimal(sum / count).setScale(3, RoundingMode.HALF_UP).doubleValue());
            }
         }
      }
      return resultMap;
      /*Date date = new Date();
      // 当前时间 -10分钟
      parameters.put("start", DateUtils.addMinutes(date, -10));
      // 当前时间 -5分钟
      parameters.put("end", DateUtils.addMinutes(date, -5));
      String queryColumns = "";
      for (int i = 1; i < 20; i++) {
         if (i == 1) {
            queryColumns += "AVG(value -> '$.e" + i + "') e" + i;
         } else {
            queryColumns += " , AVG(value -> '$.e" + i + "') e" + i;
         }
      }
      parameters.put("queryColumns", queryColumns);
      parameters.put("macKey", "all");
      parameters.put("sensorKeys", sensorKeys);
      List<Map<String, Object>> list = historyMapper.getAreaAllDataByAccount(parameters);
      return list.get(0);*/
      resultMap.putAll(list.get(0));
      return resultMap;
   }
   @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");
      ValidateUtil.notNull(parameters.get("macKey"), "param.is.null");
      Object macKey = parameters.get("macKey");
      ValidateUtil.notNull(macKey, "param.is.null");
      Map<String, Object> result = new LinkedHashMap<String, Object>();
      accountService.setOrgIdsByAccount(parameters);
@@ -140,14 +88,211 @@
      // 当前时间 -1小时
      parameters.put("start", time.minusHours(1));
      parameters.put("end", time);
      parameters.put("macKey", "'$." + parameters.get("macKey") + "'");
      List<String> sensorKeys = new ArrayList<String>();
      sensorKeys.add(macKey.toString());
      parameters.put("sensorKeys", sensorKeys);
      List<Map<String, Object>> list = historyMapper.getAreaAllDataByAccount(parameters);
      for (Map<String, Object> map : list) {
         result.put((String) map.get("name"), map.get("avg"));
         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 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();
      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);
//                  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"));
//               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;
   }
    @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")));
       for (Map<String, Object> sensor : sensors) {
          if (!ObjectUtils.isEmpty(map)) {
             sensor.put("value", map.remove(sensor.get("sensor_key")));
         }
          sensor.put("state", device.getState());
          sensor.put("name", sensor.get("description"));
       }
      return sensors;
   }
   @Override
   public List<Map<String, Object>> getSensorDataBySensorKey(Map<String, Object> parameters) {
      ValidateUtil.notNull(parameters.get("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);
      for (Map<String, Object> value : values) {
         JSONObject json = JSON.parseObject(value.remove("value").toString());
         value.put("value", json.get(parameters.get("sensorKey")));
      }
      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;
   }
}