From b6b10b7d89092147ebd5ae1d3cc318205206ab8a Mon Sep 17 00:00:00 2001
From: jinpengyong <jpy123456>
Date: Fri, 18 Dec 2020 14:48:03 +0800
Subject: [PATCH] 走航车轨迹区域数据显示

---
 src/main/java/com/moral/controller/ScreenController.java |  663 +++++++++++++++++++++++++++++++++++++++++++++++++++++-
 1 files changed, 640 insertions(+), 23 deletions(-)

diff --git a/src/main/java/com/moral/controller/ScreenController.java b/src/main/java/com/moral/controller/ScreenController.java
index 3a5e467..e34c786 100644
--- a/src/main/java/com/moral/controller/ScreenController.java
+++ b/src/main/java/com/moral/controller/ScreenController.java
@@ -2,6 +2,7 @@
 
 import java.io.*;
 import java.lang.reflect.Array;
+import java.math.BigDecimal;
 import java.net.URLEncoder;
 import java.text.DateFormat;
 import java.text.DecimalFormat;
@@ -19,6 +20,7 @@
 import com.alibaba.fastjson.JSONArray;
 
 import com.alibaba.fastjson.JSONObject;
+import com.fasterxml.jackson.databind.ObjectMapper;
 import com.googlecode.aviator.AviatorEvaluator;
 import com.googlecode.aviator.Expression;
 import com.moral.common.bean.Constants;
@@ -36,6 +38,7 @@
 import com.moral.entity.alarm.AlarmSensorLevel;
 import com.moral.entity.charts.DataSortCondition;
 import com.moral.entity.layout.RealTimeDeviceLayout;
+import com.moral.mapper.HistoryMapper;
 import com.moral.service.*;
 import com.moral.util.*;
 
@@ -89,6 +92,9 @@
 @Api(tags = "Screen", description = "������������")
 public class ScreenController {
     public static Logger log = Logger.getLogger(ScreenController.class);
+
+    @Resource
+    private HistoryMapper historyMapper;
     @Resource
     AlarmConfigService alarmConfigService;
     @Resource
@@ -173,6 +179,12 @@
 
     @Resource
     private DeviceAdjustValueTimingService deviceAdjustValueTimingService;
+
+    @Resource
+    private PollutioSourcePointService pollutioSourcePointService;
+
+    @Resource
+    private HistoryFiveMinutelyService historyFiveMinutelyService;
 
     /**
      * Screen login. ������������
@@ -701,6 +713,9 @@
         //������������������������������������������������
         ParameterUtils.getTimeType4Time(parameters);
         String time1 = (String) parameters.get("time");
+        time1 = time1.replaceAll(" ", "");
+        parameters.put("time", time1);
+
         String mac1 = (String) parameters.get("mac");
         List<Map<String, Object>> list = null;
         if (mac1 != null && mac1.equals("p5dnd7a0392018") && time1.substring(0, 4).equals("2019")) {
@@ -711,13 +726,49 @@
             parameters.put("sensors", Arrays.asList(sensorKey));
             // monitorPointService.isCompensateCalculation(parameters);
             list = historyMinutelyService.getMonitorPointOrDeviceAvgData(parameters);
+            /* 0���������������������11������������0���������������������1-24������������������������0������������������������������������24������������
+                ������������������24���������������23-24���������24������������������������0���������������
+             */
+            /*������������start-------------------------------------------------------------------------*/
+            Iterator<Map<String, Object>> iterator = list.iterator();
+            while (iterator.hasNext()) {
+                Map<String, Object> next = iterator.next();
+                String hour = next.get("time").toString().substring(11, 13);
+                if ("00".equals(hour)) {
+                    iterator.remove();
+                }
+            }
+            SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+            SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy-MM-dd");
+            //���������������������yyyy-MM-dd HH:mm:ss
+            time1 = time1 + " 00:00:00";
+            Date date = sdf.parse(time1);
+            date = DateUtil.rollDay(date, 1);
+            //������������������������
+            String time2 = sdf2.format(date);
+            parameters.put("time", time2);
+            /*���������������0������������������24���������������������������*/
+            List<Map<String, Object>> nextDayList = historyMinutelyService.getMonitorPointOrDeviceAvgData(parameters);
+            if (!ObjectUtils.isEmpty(nextDayList)) {
+                time1 = time1.replaceAll(" 00:00:00", " 24");
+                for (Map<String, Object> map : nextDayList) {
+                    String time = map.get("time").toString().substring(11, 13);
+                    if("00".equals(time)){
+                        map.put("time", time1);
+                        list.add(map);
+                    }
+                }
+            }
+            /*������������end-------------------------------------------------------------------------*/
+
+
             for (Map<String, Object> map : list) {
                 String time = map.get("time").toString();
                 time = time.substring(time.length() - 2);
                 map.put("time", Integer.valueOf(time));
-                if (parameters.get("type").equals("day")) {
+             /*   if (parameters.get("type").equals("day")) {
                     map.put("time", Integer.valueOf(time) + 1);
-                }
+                }*/
                 map.put("value", map.remove(sensorKey));
             }
         }
@@ -1455,12 +1506,13 @@
     public ModelAndView pollutionSource(ModelAndView model, HttpServletRequest request) throws Exception {
         Map<String, Object> parameters = WebUtils.getParametersStartingWith(request, null);
         String timeStr = parameters.get("time").toString();
-        String YearAndDay = timeStr.substring(0, timeStr.lastIndexOf("-"));
+        String yearAndDay = timeStr.substring(0, timeStr.lastIndexOf("-"));
         String Hour = timeStr.substring(timeStr.lastIndexOf("-") + 1);
-        String time = YearAndDay + " " + Hour + ":00:00";
+        String time = yearAndDay + " " + Hour + ":00:00";
         DateTimeFormatter dateTimeFormatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
         LocalDateTime timeLocalDateTime = LocalDateTime.parse(time, dateTimeFormatter);
         int month = timeLocalDateTime.getMonth().getValue();
+        parameters.put("yearAndDay", yearAndDay);
         Point dirPoint = historyHourlyService.getDirPoint(parameters);
         Map<String, Object> getPollutionSourceData = historyHourlyService.getPollutionSourceDataByHour(parameters);
         if (MapUtils.isEmpty(getPollutionSourceData)) {
@@ -1570,6 +1622,50 @@
             //System.out.println(paramsJson);
             model.addObject("carTrajectoryParams", paramsJson);
             model.setViewName("cartrajectory");
+            return model;
+        } else {
+            StringBuilder msg = new StringBuilder();
+            msg.append(" param[0] mac:");
+            msg.append(mac);
+            log.warn(msg);
+            model.setViewName("403");
+            return model;
+        }
+    }
+
+    @GetMapping("/carTrajectoryNew")
+    @ApiOperation(value = "���������������������", notes = "���������������������")
+    @ApiImplicitParams(value = {
+            @ApiImplicitParam(name = "mac", value = "������mac������������p5dnd7a0392081���", required = true, paramType = "query", dataType = "String"),
+            @ApiImplicitParam(name = "startTime", value = "������������(���������2020-03-19-14)", required = true, paramType = "query", dataType = "String"),
+            @ApiImplicitParam(name = "endTime", value = "������������(���������2020-03-19-17)", required = true, paramType = "query", dataType = "String")
+    })
+    public ModelAndView carTrajectoryNew(ModelAndView model, HttpServletRequest request) throws Exception {
+        Map<String, Object> parameters = WebUtils.getParametersStartingWith(request, null);
+        String st = parameters.get("startTime").toString();
+        String startYearAndDay = st.substring(0, st.lastIndexOf("-"));
+        String startHour = st.substring(st.lastIndexOf("-") + 1);
+        String startTime = startYearAndDay + " " + startHour + ":00:00";
+        String et = parameters.get("endTime").toString();
+        String endYearAndDay = et.substring(0, st.lastIndexOf("-"));
+        String endHour = et.substring(et.lastIndexOf("-") + 1);
+        String endTime = endYearAndDay + " " + endHour + ":00:00";
+        parameters.put("startTime", startTime);
+        parameters.put("endTime", endTime);
+        String mac = parameters.get("mac").toString();
+        if (mac != null && mac.length() != 0) {
+            List<List<Map<String, Object>>> sensorData = historyService.getCarSensorData(parameters);
+            Map<String, String> sensorsMap = sensorService.getSensorsMap(parameters);
+            List<Map<String, Object>> sensorList = new ArrayList<>();
+            if (sensorData.size() == 3) {
+                sensorList = sensorData.get(0);
+            }
+            JSONObject params = new JSONObject();
+            params.put("sensorInfo", sensorList);
+            params.put("sensorsMap", sensorsMap);
+            String paramsJson = params.toJSONString();
+            model.addObject("carTrajectoryParams", paramsJson);
+            model.setViewName("cartrajectoryNew");
             return model;
         } else {
             StringBuilder msg = new StringBuilder();
@@ -2039,7 +2135,7 @@
         } else {
             mon = "" + month;
         }
-        String table = "history_minutely_" + year + mon;
+        String table = "history_five_minutely_" + year + mon;
         List list = deviceService.byMonitorIdGetDeviceAndWind(monitorPointId, table);
         return list;
     }
@@ -2060,7 +2156,7 @@
         } else {
             mon = "" + month;
         }
-        String table = "history_minutely_" + year + mon;
+        String table = "history_five_minutely_" + year + mon;
         List list = deviceService.byMonitorIdGetDeviceAndWindSpecial(monitorPointId, table);
         return list;
     }
@@ -2069,9 +2165,28 @@
     @ApiOperation(value = "���������������������������", notes = "���������������������������")
     @ApiImplicitParams(value = {
             @ApiImplicitParam(name = "monitorPointId", defaultValue = "1", value = "���������id", required = true, paramType = "query", dataType = "String"),
-            @ApiImplicitParam(name = "time", value = "���6���(���������2020-03-19)", required = true, paramType = "query", dataType = "String")})
+            @ApiImplicitParam(name = "time", value = "������(���������2020-03-19)", required = true, paramType = "query", dataType = "String")})
     public ResultBean<List<Map<String, Object>>> getWeatherNextDayDataByRegion(HttpServletRequest request) throws Exception {
         Map<String, Object> parameters = getParametersStartingWith(request, null);
+        List<String> sensorKeys = new ArrayList<>();
+        sensorKeys.add("e15");
+        parameters.put("sensorKeys", sensorKeys);
+        List<Map<String, Object>> resultList = weatherService.getForecastAndReal(parameters);
+        return new ResultBean<List<Map<String, Object>>>(resultList);
+    }
+
+
+    @GetMapping("forecastPM")
+    @ApiOperation(value = "������������������������������", notes = "������������������������������")
+    @ApiImplicitParams(value = {
+            @ApiImplicitParam(name = "monitorPointId", defaultValue = "1", value = "���������id", required = true, paramType = "query", dataType = "String"),
+            @ApiImplicitParam(name = "time", value = "������(���������2020-03-19)", required = true, paramType = "query", dataType = "String")})
+    public ResultBean<List<Map<String, Object>>> getForecastAndRealPM(HttpServletRequest request) throws Exception {
+        Map<String, Object> parameters = getParametersStartingWith(request, null);
+        List<String> sensorKeys = new ArrayList<>();
+        sensorKeys.add("e1");
+        sensorKeys.add("e2");
+        parameters.put("sensorKeys", sensorKeys);
         List<Map<String, Object>> resultList = weatherService.getForecastAndReal(parameters);
         return new ResultBean<List<Map<String, Object>>>(resultList);
     }
@@ -2577,26 +2692,26 @@
     }*/
 
     @PostMapping("insertAdjustValue")
-    public  int insertAdjustValue(@RequestBody HashMap map){
-        try{
+    public int insertAdjustValue(@RequestBody HashMap map) {
+        try {
             int device_id = Integer.parseInt(map.get("id").toString());
             String time = map.get("time").toString();
             String[] arr = time.split(":");
-            int seconds = Integer.parseInt(arr[0])*3600+Integer.parseInt(arr[1])*60+Integer.parseInt(arr[2]);
+            int seconds = Integer.parseInt(arr[0]) * 3600 + Integer.parseInt(arr[1]) * 60 + Integer.parseInt(arr[2]);
             //String t = URLEncoder.encode(������,"UTF-8")
             List list = (List) map.get("dataArray");
-            String val="";
-            for (int i = 0; i <list.size() ; i++) {
-                if (i==0){
-                    val=val+list.get(i);
-                }else {
-                    val=val+","+list.get(i);
+            String val = "";
+            for (int i = 0; i < list.size(); i++) {
+                if (i == 0) {
+                    val = val + list.get(i);
+                } else {
+                    val = val + "," + list.get(i);
                 }
             }
-            String value = "{"+val+"}";
-            deviceAdjustValueTimingService.insertData(device_id,seconds,value);
+            String value = "{" + val + "}";
+            deviceAdjustValueTimingService.insertData(device_id, seconds, value);
             return 1;
-        }catch (Exception e){
+        } catch (Exception e) {
             log.warn(e);
         }
         return 0;
@@ -2604,18 +2719,520 @@
 
     @RequestMapping("/biaozhun")
     @ResponseBody
-    public List<Device> queryDevice(String macOrName){
+    public List<Device> queryDevice(String macOrName) {
         List<Device> deviceList = new ArrayList<>();
-        if (!macOrName.equals("")){
-             deviceList= deviceService.getDevice(macOrName);
+        if (!macOrName.equals("")) {
+            deviceList = deviceService.getDevice(macOrName);
         }
         return deviceList;
     }
 
+    @RequestMapping("/getBiaoZhun")
+    @ResponseBody
+    public List<DeviceAdjustValueTiming> getBiaoZhun(String id) {
+        List<DeviceAdjustValueTiming> dataByDeviceid = deviceAdjustValueTimingService.getDataByDeviceid(Integer.parseInt(id));
+        for (DeviceAdjustValueTiming deviceAdjustValueTiming : dataByDeviceid) {
+            int seconds = Integer.parseInt(deviceAdjustValueTiming.getSeconds());
+            String hour = String.valueOf(seconds / 3600);
+            int millAndSeconds = seconds % 3600;
+            String mill = String.valueOf(millAndSeconds / 60);
+            String second = String.valueOf(millAndSeconds % 60);
+            if (hour.length() < 2) {
+                hour = "0" + hour;
+            }
+            if (mill.length() < 2) {
+                mill = "0" + mill;
+            }
+            if (second.length() < 2) {
+                second = "0" + second;
+            }
+            String time = hour + ":" + mill + ":" + second;
+            Map<String, String> value = deviceAdjustValueTiming.getValue();
+            Collection<String> values = value.values();
+            deviceAdjustValueTiming.setSeconds(time);
+        }
+        return dataByDeviceid;
+    }
+
+
     @RequestMapping("/getSensor")
     @ResponseBody
-    public  List<Map<String, Object>> getSensor(String id){
+    public List<Map<String, Object>> getSensor(String id) {
         List<Map<String, Object>> allSensors = sensorService.getSensorByDeviceId(id);
         return allSensors;
     }
+
+    @RequestMapping("/deleteBiaoZhun")
+    @ResponseBody
+    public int deleteBiaoZhun(String id) {
+        int i = deviceAdjustValueTimingService.delete(id);
+        return i;
+    }
+
+
+    @GetMapping("/monitorAVGData")
+    @ApiOperation(value = "monitor������������������", notes = "monitor������������������")
+    @ApiImplicitParams(value = {
+            @ApiImplicitParam(name = "monitorPointIds", value = "������monitorid", required = true, paramType = "query", dataType = "String"),
+            @ApiImplicitParam(name = "time", value = "������(���������2020-03-19)", required = true, paramType = "query", dataType = "String")})
+    public ResultBean<List<Map<String, Object>>> monitorAVGData(HttpServletRequest request) throws Exception {
+        Map<String, Object> parameters = getParametersStartingWith(request, null);
+        String monitorPointIds = (String) parameters.get("monitorPointIds");
+        String time = (String) parameters.get("time");
+        time = time + " 00:00:00";
+        SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd mm:HH:ss");//���������������MM
+        Date date = simpleDateFormat.parse(time);
+        Calendar calendar = new GregorianCalendar();
+        calendar.setTime(date);
+        calendar.add(calendar.DATE, +1);
+        String date1 = simpleDateFormat.format(date);
+        String date2 = simpleDateFormat.format(calendar.getTime());
+        String[] mIds = monitorPointIds.split(",");
+        List<List<Map<String, Object>>> lists = new ArrayList<>();
+        if (mIds.length == 1 && mIds.length != 0) {
+            String mId = mIds[0];
+            List<Map<String, Object>> dataAvbByMIdAndTime = historyHourlyService.getDataAvbByMIdAndTime(mId, date1, date2);
+            Double maxO3 = Double.parseDouble(dataAvbByMIdAndTime.get(dataAvbByMIdAndTime.size() - 1).get("maxO3").toString());
+            Map<String, Object> dailyAvgData = new HashMap<>();
+            if (dataAvbByMIdAndTime.get(dataAvbByMIdAndTime.size() - 2).get("data") != "") {
+                dailyAvgData = (Map<String, Object>) dataAvbByMIdAndTime.get(dataAvbByMIdAndTime.size() - 2).get("data");
+                dailyAvgData.put("maxO3_8h", new BigDecimal(maxO3).setScale(0, BigDecimal.ROUND_HALF_UP).doubleValue());
+            } else {
+                dailyAvgData = historyHourlyService.getAvgDataByMId(mId, date1, date2);
+                if (dailyAvgData != null) {
+                    dailyAvgData.put("maxO3_8h", new BigDecimal(maxO3).setScale(0, BigDecimal.ROUND_HALF_UP).doubleValue());
+                } else {
+                    dailyAvgData = new HashMap<>();
+                    dailyAvgData.put("PM2_5", "");
+                    dailyAvgData.put("NO2", "");
+                    dailyAvgData.put("SO2", "");
+                    dailyAvgData.put("PM10", "");
+                    dailyAvgData.put("O3_day", "");
+                    dailyAvgData.put("CO", "");
+                }
+            }
+            dataAvbByMIdAndTime.remove(dataAvbByMIdAndTime.size() - 1);
+            dataAvbByMIdAndTime.remove(dataAvbByMIdAndTime.size() - 1);
+            Map<String, Object> dayMap = new HashMap<>();
+            dayMap.put("data", dailyAvgData);
+            dayMap.put("time", date1.substring(0, 11));
+            dataAvbByMIdAndTime.add(dayMap);
+            for (int i = 0; i < dataAvbByMIdAndTime.size(); i++) {
+                if (i != dataAvbByMIdAndTime.size() - 1) {
+                    Map<String, Object> map1 = AQICalculation2.hourlyAQI((Map<String, Object>) dataAvbByMIdAndTime.get(i).get("data"));
+                    if (Double.parseDouble(map1.get("AQI").toString()) > 50.0) {
+                        ((Map<String, Object>) dataAvbByMIdAndTime.get(i).get("data")).put("primary_pollutants", map1.get("maxSensor"));
+                        ((Map<String, Object>) dataAvbByMIdAndTime.get(i).get("data")).put("AQI", map1.get("AQI"));
+                    } else {
+                        ((Map<String, Object>) dataAvbByMIdAndTime.get(i).get("data")).put("primary_pollutants", "-");
+                        ((Map<String, Object>) dataAvbByMIdAndTime.get(i).get("data")).put("AQI", map1.get("AQI"));
+                    }
+                } else {
+                    Map<String, Object> map1 = AQICalculation2.dayAQI((Map<String, Object>) dataAvbByMIdAndTime.get(i).get("data"));
+                    if (map1.get("AQI").toString().equals("")) {
+                        break;
+                    }
+                    if (Double.parseDouble(map1.get("AQI").toString()) > 50.0) {
+                        ((Map<String, Object>) dataAvbByMIdAndTime.get(i).get("data")).put("primary_pollutants", map1.get("maxSensor"));
+                        ((Map<String, Object>) dataAvbByMIdAndTime.get(i).get("data")).put("AQI", map1.get("AQI"));
+                    } else {
+                        ((Map<String, Object>) dataAvbByMIdAndTime.get(i).get("data")).put("primary_pollutants", "-");
+                        ((Map<String, Object>) dataAvbByMIdAndTime.get(i).get("data")).put("AQI", map1.get("AQI"));
+                    }
+                }
+            }
+            List timeList = new ArrayList();
+            for (int q = 0; q < dataAvbByMIdAndTime.size(); q++) {
+                timeList.add(dataAvbByMIdAndTime.get(q).get("time"));
+            }
+            if (dataAvbByMIdAndTime.size() < 25) {
+                for (int j = 1; j < 25; j++) {
+                    Map<String, Object> map = null;
+                    for (int q = 0; q < dataAvbByMIdAndTime.size(); q++) {
+                        if (dataAvbByMIdAndTime.get(q).get("time").toString().length() > 2) {
+                            continue;
+                        } else {
+                            // System.out.println(Integer.parseInt(dataAvbByMIdAndTime.get(q).get("time").toString())+"==="+j);
+                            String sj = "";
+                            if (j < 10) {
+                                sj = "0" + j;
+                            } else {
+                                if (j == 24) {
+                                    sj = "00";
+                                } else {
+                                    sj = "" + j;
+                                }
+                            }
+                            if (!timeList.contains(sj)) {
+                                map = new HashMap<>();
+                                map.put("time", sj);
+                                Map map1 = new HashMap();
+                                map1.put("PM2_5", "");
+                                map1.put("NO2", "");
+                                map1.put("primary_pollutants", "-");
+                                map1.put("SO2", "");
+                                map1.put("O3", "");
+                                map1.put("PM10", "");
+                                map1.put("O3_8h", "");
+                                map1.put("CO", "");
+                                map1.put("AQI", "");
+                                map.put("data", map1);
+                                dataAvbByMIdAndTime.add(map);
+                                break;
+                            } else {
+                                break;
+                            }
+                        }
+                    }
+                }
+            }
+             /* for (int i1 = 0; i1 < dataAvbByMIdAndTime.size(); i1++) {
+                    System.out.println(dataAvbByMIdAndTime.get(i1));
+                }*/
+            Collections.sort(dataAvbByMIdAndTime, new Comparator<Map<String, Object>>() {
+                public int compare(Map<String, Object> o1, Map<String, Object> o2) {
+                    String name1 = (String) o1.get("time");//name1���������list������������������������
+                    String name2 = (String) o2.get("time"); //name1���������list���������������������������name
+                    return name1.compareTo(name2);
+                }
+            });
+            Map map1 = dataAvbByMIdAndTime.get(0);
+            dataAvbByMIdAndTime.remove(0);
+            dataAvbByMIdAndTime.add(map1);
+            for (int j = 0; j < dataAvbByMIdAndTime.size(); j++) {
+                if (dataAvbByMIdAndTime.get(j).get("time").toString().length() > 2) {
+                    Map map2 = dataAvbByMIdAndTime.get(j);
+                    dataAvbByMIdAndTime.remove(j);
+                    dataAvbByMIdAndTime.add(map2);
+                }
+            }
+            if (dataAvbByMIdAndTime.size() == 1) {
+                dataAvbByMIdAndTime = null;
+            }
+            lists.add(dataAvbByMIdAndTime);
+            //List<Device> devicesByMonitorPointId = deviceService.getDevicesByMonitorPointId(Integer.valueOf(mId));
+        } else {
+            for (int i = 0; i < mIds.length; i++) {
+                List<Map<String, Object>> dataAvbByMIdAndTime = historyHourlyService.getDataAvbByMIdAndTime(mIds[i], date1, date2);
+                Double maxO3 = Double.parseDouble(dataAvbByMIdAndTime.get(dataAvbByMIdAndTime.size() - 1).get("maxO3").toString());
+                Map<String, Object> dailyAvgData = new HashMap<>();
+                if (dataAvbByMIdAndTime.get(dataAvbByMIdAndTime.size() - 2).get("data") != "") {
+                    dailyAvgData = (Map<String, Object>) dataAvbByMIdAndTime.get(dataAvbByMIdAndTime.size() - 2).get("data");
+                    dailyAvgData.put("maxO3_8h", new BigDecimal(maxO3).setScale(0, BigDecimal.ROUND_HALF_UP).doubleValue());
+                } else {
+                    dailyAvgData = historyHourlyService.getAvgDataByMId(mIds[i], date1, date2);
+                    if (dailyAvgData != null) {
+                        dailyAvgData.put("maxO3_8h", new BigDecimal(maxO3).setScale(0, BigDecimal.ROUND_HALF_UP).doubleValue());
+                    } else {
+                        dailyAvgData = new HashMap<>();
+                        dailyAvgData.put("PM2_5", "");
+                        dailyAvgData.put("NO2", "");
+                        dailyAvgData.put("SO2", "");
+                        dailyAvgData.put("PM10", "");
+                        dailyAvgData.put("O3_day", "");
+                        dailyAvgData.put("CO", "");
+                    }
+                }
+                dataAvbByMIdAndTime.remove(dataAvbByMIdAndTime.size() - 1);
+                dataAvbByMIdAndTime.remove(dataAvbByMIdAndTime.size() - 1);
+                Map<String, Object> dayMap = new HashMap<>();
+                dayMap.put("data", dailyAvgData);
+                dayMap.put("time", date1.substring(0, 11));
+                dataAvbByMIdAndTime.add(dayMap);
+                List timeList = new ArrayList();
+                for (int q = 0; q < dataAvbByMIdAndTime.size(); q++) {
+                    timeList.add(dataAvbByMIdAndTime.get(q).get("time"));
+                }
+                if (dataAvbByMIdAndTime.size() < 25) {
+                    for (int j = 1; j < 25; j++) {
+                        Map<String, Object> map = null;
+                        for (int q = 0; q < dataAvbByMIdAndTime.size(); q++) {
+                            if (dataAvbByMIdAndTime.get(q).get("time").toString().length() > 2) {
+                                continue;
+                            } else {
+                                // System.out.println(Integer.parseInt(dataAvbByMIdAndTime.get(q).get("time").toString())+"==="+j);
+                                String sj = "";
+                                if (j < 10) {
+                                    sj = "0" + j;
+                                } else {
+                                    if (j == 24) {
+                                        sj = "00";
+                                    } else {
+                                        sj = "" + j;
+                                    }
+                                }
+                                if (!timeList.contains(sj)) {
+                                    map = new HashMap<>();
+                                    map.put("time", sj);
+                                    Map map1 = new HashMap();
+                                    map1.put("PM2_5", "");
+                                    map1.put("NO2", "");
+                                    map1.put("SO2", "");
+                                    map1.put("O3", "");
+                                    map1.put("PM10", "");
+                                    map1.put("O3_8h", "");
+                                    map1.put("CO", "");
+                                    map.put("data", map1);
+                                    dataAvbByMIdAndTime.add(map);
+                                    break;
+                                } else {
+                                    break;
+                                }
+                            }
+                        }
+
+                    }
+                }
+                Collections.sort(dataAvbByMIdAndTime, new Comparator<Map<String, Object>>() {
+                    public int compare(Map<String, Object> o1, Map<String, Object> o2) {
+                        String name1 = (String) o1.get("time");//name1���������list������������������������
+                        String name2 = (String) o2.get("time"); //name1���������list���������������������������name
+                        return name1.compareTo(name2);
+                    }
+                });
+                Map map1 = dataAvbByMIdAndTime.get(0);
+                dataAvbByMIdAndTime.remove(0);
+                dataAvbByMIdAndTime.add(map1);
+                for (int j = 0; j < dataAvbByMIdAndTime.size(); j++) {
+                    if (dataAvbByMIdAndTime.get(j).get("time").toString().length() > 2) {
+                        Map map2 = dataAvbByMIdAndTime.get(j);
+                        dataAvbByMIdAndTime.remove(j);
+                        dataAvbByMIdAndTime.add(map2);
+                    }
+                }
+                lists.add(dataAvbByMIdAndTime);
+            }
+            List<Map<String, Object>> dataByMonitorPoints = historyHourlyService.getDataByMonitorPoints(mIds, date1, date2);
+            lists.add(dataByMonitorPoints);
+        }
+        List<Map<String, Object>> rList = new ArrayList<>();
+        if (lists.size() == 1 && lists.get(0) != null) {
+            for (int i = 0; i < lists.get(0).size(); i++) {
+                List list = new ArrayList();
+                list.add(lists.get(0).get(i).get("data"));
+                Map map = new HashMap();
+                map.put("data", list);
+                map.put("time", lists.get(0).get(i).get("time"));
+                rList.add(map);
+            }
+
+        } else if (lists.size() == 1 && lists.get(0) == null) {
+            rList.add(null);
+        } else {
+            for (int j = 0; j < lists.get(0).size(); j++) {
+                Map<String, Object> listMap = new HashMap();
+                List<Map> mapList = new ArrayList<>();
+                if (lists.get(0).size() == 1) {
+                    mapList.add(null);
+                } else {
+                    mapList.add((Map) lists.get(0).get(j).get("data"));
+                }
+                for (int i = 1; i < lists.size(); i++) {
+                    if (lists.get(i).size() == 1) {
+                        mapList.add(null);
+                        listMap.put("data", mapList);
+                    } else {
+                        if (lists.get(0).get(j).get("time").equals(lists.get(i).get(j).get("time"))) {
+                            mapList.add((Map) lists.get(i).get(j).get("data"));
+                        }
+                        listMap.put("time", lists.get(0).get(j).get("time"));
+                        listMap.put("data", mapList);
+                    }
+                }
+                rList.add(listMap);
+            }
+        }
+        return new ResultBean<List<Map<String, Object>>>(rList);
+    }
+
+    @PostMapping("byAccountGetDevices")
+    public List<Device> byAccountGetDevices(@RequestBody Map<String, Object> parameters) {
+        String id =parameters.get("id").toString();
+        List<Device> devicesList = deviceService.getDevicesByAccountId(id);
+        return devicesList;
+    }
+
+    @GetMapping("/unorganizedEmissionsFiveMinute")
+    @ApiOperation(value = "������������������������", notes = "������������������������")
+    @ApiImplicitParams(value = {
+            @ApiImplicitParam(name = "monitorPointId", value = "������Id", required = true, paramType = "query", dataType = "String"),
+            @ApiImplicitParam(name = "sensorKey", value = "������", required = true, paramType = "query", dataType = "String"),
+            @ApiImplicitParam(name = "realTime", value = "������", required = true, paramType = "query", dataType = "String"),
+            @ApiImplicitParam(name = "accountId", value = "������id", required = false, paramType = "query", dataType = "String")})
+    public ModelAndView unorganizedEmissionsBackupsV2(HttpServletRequest request, ModelAndView model) {
+        Map<String, Object> parameters = WebUtils.getParametersStartingWith(request, null);
+        String sensorKey = parameters.get("sensorKey").toString();
+        //������������������������������
+        PollutionSourcePoint pollutionSourcePoint = pollutioSourcePointService.selectByMonitorPointId(539);
+        //���������������������������
+        List<Device> deviceList = deviceService.getDevicesByMonitorPointId(539);
+        //���������������������
+        Map<String,Object> pa = new HashMap<>();
+        //���������������������������������
+        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
+        Calendar beforeTime = Calendar.getInstance();
+        Date newTime = beforeTime.getTime();
+        beforeTime.add(Calendar.MINUTE,-5);
+        Date startTime = beforeTime.getTime();
+        beforeTime.add(Calendar.MINUTE,6);
+        Date endTime = beforeTime.getTime();
+        //pa.put("sensorKey","e1");
+        pa.put("yearAndMonth",sdf.format(newTime).substring(0,7).replace("-",""));
+        pa.put("startTime",startTime);
+        pa.put("endTime",endTime);
+        List<String> macs = new ArrayList<>();
+        List<String> sensorKeys = new ArrayList<>();
+        for (Device device:deviceList) {
+            macs.add(device.getMac());
+        }
+        sensorKeys.add(sensorKey);
+        sensorKeys.add("e18");
+        sensorKeys.add("e23");
+        pa.put("macs",macs);
+        pa.put("sensorKeys",sensorKeys);
+        pa.put("macNumber",macs.size());
+        List<Map<String, Object>> fiveMinuteDataList = historyFiveMinutelyService.getFiveMinutesDataByMacsAndTimeSolt(pa);
+        //������������������������������������������
+        double[] allDeviceData = new double[fiveMinuteDataList.size()];
+        int i = 0;
+        //������������
+        List<Map<String,Object>> windList = new ArrayList<>();
+        for (Map map:fiveMinuteDataList) {
+            String[] wind_speed = map.get("e18").toString().split(",");
+            if (!map.containsKey("e23")){
+                continue;
+            }
+            String[] wind_direction = map.get("e23").toString().split(",");
+            Map<String,Object> windMap = new HashMap<>();
+            windMap.put("wind_speed",wind_speed[0].substring(1,wind_speed[0].length()));
+            windMap.put("wind_direction",wind_direction[0].substring(1,wind_direction[0].length()));
+            windList.add(windMap);
+            String[] sensorArr = map.get(sensorKey).toString().split(",");
+            double sensorData = Double.parseDouble(sensorArr[0].substring(1,sensorArr[0].length()));
+            allDeviceData[i] = sensorData;
+            i = i+1;
+        }
+        //���������������������������
+        Map<String,Double> res = WindUtils.getWind_direction_speed(windList);
+        //���������������������������������������������
+        Map<String,Double> angleMap = new HashMap();
+        MyLatLng pollutionSourcePoint_log_lat = new MyLatLng(pollutionSourcePoint.getLongitude(),pollutionSourcePoint.getLatitude());
+        for (Device device:deviceList) {
+            MyLatLng device_log_lat = new MyLatLng(device.getLongitude(),device.getLatitude());
+            //������������������������������������������������������
+            double angle = mapUtils.getAngle(device_log_lat,pollutionSourcePoint_log_lat);
+            angleMap.put(device.getMac(),angle);
+        }
+        Map<String,Double> disparityMap = new HashMap<>();
+        for (String key:angleMap.keySet()) {
+            double angleDisparity = Math.abs(angleMap.get(key)-res.get("wind_direction"));
+            if (angleDisparity>180){
+                angleDisparity = 360-angleDisparity;
+            }
+            disparityMap.put(key,angleDisparity);
+        }
+        Optional<Map.Entry<String, Double>> minDisparity = disparityMap.entrySet()
+                .stream()
+                .min(Map.Entry.comparingByValue());
+        //������������������������disparityMap������������minDisparity���������������key������������������������������������������
+        List<String> minAngleDisparityMacList = new ArrayList<>();
+        for (String key:disparityMap.keySet()) {
+            if (disparityMap.get(key) == minDisparity.get().getValue()){
+                minAngleDisparityMacList.add(minDisparity.get().getKey());
+            }
+        }
+        //������������map������������������
+        Map<String,Object> fiveMinuteDataMap = new HashMap();
+        if (minAngleDisparityMacList.size()<2){//���������������
+            for (Map fiveMinuteData:fiveMinuteDataList) {
+                if (fiveMinuteData.get("mac").toString().equals(minAngleDisparityMacList.get(0))){
+                    fiveMinuteDataMap.putAll(fiveMinuteData);
+                    break;
+                }
+            }
+        }else {
+
+        }
+        Device referenceDevice = new Device();
+        for (Device device:deviceList) {
+            if (device.getMac().equals(fiveMinuteDataMap.get("mac"))){
+                referenceDevice = device;
+            }
+        }
+        //���������������������
+        double sum = 0;
+        for (int j=0;j<allDeviceData.length;j++) {
+            sum = sum+allDeviceData[j];
+        }
+        double deviceDataAvg = sum/allDeviceData.length;
+        //���������������������������������������������
+        double distance = mapUtils.getDistance(pollutionSourcePoint.getLongitude(),pollutionSourcePoint.getLatitude(),referenceDevice.getLongitude(),referenceDevice.getLatitude());
+        //���������������������������x,y
+        double x = Math.cos(Math.toRadians(minDisparity.get().getValue()))*distance;
+        double y = Math.sin(Math.toRadians(minDisparity.get().getValue()))*distance;
+        //���������������������
+        String[] fiveMinuteData = fiveMinuteDataMap.get(sensorKey).toString().split(",");
+        double c = Double.parseDouble(fiveMinuteData[0].substring(1,fiveMinuteData[0].length()))-deviceDataAvg;
+        //������������
+        double pollutionSourceIntensity = EmissionDataUtil.getPollutionSourceIntensity(c,x,y,res.get("wind_speed"));
+
+        //���������������������
+        Map<String,Object> center = new HashMap<>();
+        center.put("lng",120.997119);
+        center.put("lat",31.451714);
+
+        //������������������������������������
+        List<Map<String,Double>> numericalValueList = new ArrayList<>();
+        Map<String,Double> numericalValueMap = new HashMap<>();
+        numericalValueMap.put("lng",120.997119);
+        numericalValueMap.put("lat",31.451714);
+        numericalValueMap.put("count",0.027);
+        numericalValueList.add(numericalValueMap);
+        Map<String,Double> numericalValueMap2 = new HashMap<>();
+        numericalValueMap2.put("lng",120.99516);
+        numericalValueMap2.put("lat",31.448664);
+        numericalValueMap2.put("count",0.029);
+        numericalValueList.add(numericalValueMap2);
+        Map<String,Double> numericalValueMap3 = new HashMap<>();
+        numericalValueMap3.put("lng",120.998538);
+        numericalValueMap3.put("lat",31.449289);
+        numericalValueMap3.put("count",0.033);
+        numericalValueList.add(numericalValueMap3);
+        Map<String,Double> numericalValueMap4 = new HashMap<>();
+        numericalValueMap4.put("lng",120.998628);
+        numericalValueMap4.put("lat",31.452027);
+        numericalValueMap4.put("count",0.025);
+        numericalValueList.add(numericalValueMap4);
+        Map<String,Double> numericalValueMap5 = new HashMap<>();
+        numericalValueMap5.put("lng",121.000383);
+        numericalValueMap5.put("lat",31.451469);
+        numericalValueMap5.put("count",0.05);
+        numericalValueList.add(numericalValueMap5);
+        Map<String,Double> numericalValueMap6 = new HashMap<>();
+        numericalValueMap6.put("lng",120.999908);
+        numericalValueMap6.put("lat",31.449389);
+        numericalValueMap6.put("count",0.04);
+        numericalValueList.add(numericalValueMap6);
+        Map<String,Double> numericalValueMap7 = new HashMap<>();
+        numericalValueMap7.put("lng",120.998519);
+        numericalValueMap7.put("lat",31.450588);
+        numericalValueMap7.put("count",0.10);
+        numericalValueList.add(numericalValueMap7);
+
+
+        JSONObject params = new JSONObject();
+        params.put("accountId",190);
+        params.put("level",17);
+        params.put("center",center);
+        params.put("points",numericalValueList);
+
+
+
+        //������������������
+        //JSONObject params=monitorPointService.getMonitorPointById(monitPointId,Time,3,sensor);
+        // model.addObject("params",params);
+        model.addObject("params", params);
+        model.setViewName("unorganizedMapV2");
+        return model;
+    }
 }
\ No newline at end of file

--
Gitblit v1.8.0