工业级后台API v2
blame | history | patch | commit | commitdiff | ignore whitespace
ZhuDongming
2019-08-12 a332264920c9cd9226d566c19e36e5d5b5549c1b 
 src/main/java/com/moral/service/impl/HistoryServiceImpl.java


@@ -1,21 +1,44 @@


package com.moral.service.impl;







import java.time.Instant;



import java.time.LocalDate;



import java.time.LocalDateTime;



import java.util.*;



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.Arrays;



import java.util.Calendar;



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 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.googlecode.aviator.AviatorEvaluator;



import com.googlecode.aviator.Expression;



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.ProfessionMapper;



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;







@Service



public class HistoryServiceImpl implements HistoryService {



@@ -33,7 +56,7 @@


   private SensorMapper sensorMapper;







    @Resource



    private ProfessionMapper professionMapper;



    private ProfessionService professionService;







   @Override



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



@@ -93,37 +116,72 @@


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







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



      String regionType = "village_code";



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



      String regionType = "village";



      String nextLevel = "";



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



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



            regionType = "province_code";



            regionType = "province";



            nextLevel = "city";



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



            regionType = "city_code";



            regionType = "city";



            nextLevel = "area";



         } else {



            regionType = "area_code";



            regionType = "area";



            nextLevel = "town";



         }



      } else {



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



            regionType = "town_code";



            regionType = "town";



            nextLevel = "village";



         }



      }



      parameters.put("regionType", regionType);



      parameters.put("nextLevel", nextLevel);



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







      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 = professionMapper.selectAll();



         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;



               }



            }



@@ -135,28 +193,187 @@


            result.add(map);



         }



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



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



         for (int i = result.size() - 1; i >= 0; i--) {



            Map<String, Object> map = result.get(i);



            for (Map<String, Object> region : regions) {



               if ((map.get("code") == null)) {



                  result.remove(map);



                  break;



               } 


               if (map.get("code").equals(region.get("code"))) {



                  map.put("name", region.get("name"));



                  regions.remove(region);



                  break;



               }



         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 (Map<String, Object> region : regions) {



         for (String region : regions) {



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



            map.put("name", region.get("name"));



            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;



   }







   @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}", "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;



   }







   @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";



      }



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



      System.out.println(map);



      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;



   }



}