工业级运维app手机api
fengxiang
2017-11-15 9f05f3d2055151bd172d252fa33a4868d171068b
src/main/java/com/moral/monitor/service/impl/ScreenServiceImpl.java
@@ -1,25 +1,227 @@
package com.moral.monitor.service.impl;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Date;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
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 org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.time.DateUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import org.springframework.util.ObjectUtils;
import com.moral.monitor.dao.AccountEntityMapper;
import com.moral.monitor.dao.HistoryEntityMapper;
import com.moral.monitor.entity.AccountEntity;
import com.moral.monitor.entity.AccountEntityExample;
import com.moral.monitor.service.OrganizationService;
import com.moral.monitor.service.ScreenService;
import com.moral.monitor.util.BusinessException;
import com.moral.monitor.util.ResourceUtil;
@Service
@SuppressWarnings("unused")
public class ScreenServiceImpl implements ScreenService {
   @Autowired
   private AccountEntityMapper accountDao;
   private AccountEntityMapper accountMapper;
   @Autowired
   private HistoryEntityMapper historyMapper;
   @Autowired
   private OrganizationService organizationService;
   public List<AccountEntity> getAccountLists(String account, String password) {
      AccountEntityExample example = new AccountEntityExample();
      example.or().andAccountEqualTo(account).andPasswordEqualTo(password);
      return accountDao.selectByExample(example);
      return accountMapper.selectByExample(example);
   }
   public Map<String, Object> getMonthDataByEquipment(final Map<String, Object> parameters) throws Exception {
      Map<String, Object> resultMap = new HashMap<String, Object>();
      // 1.0 实际标准值
      resultMap.put("standard", ResourceUtil.getValue(parameters.get("macKey") + "-standard"));
      // 2.0 AQI 指数
      Date date = new Date();
      // 昨日00:00:00
      parameters.put("start", DateUtils.truncate(DateUtils.addDays(date, -1), Calendar.DATE));
      // 今日00:00:00
      parameters.put("end", DateUtils.truncate(date, Calendar.DATE));
      String[] macKeys = { "e1", "e2", "e10", "e11", "e15", "e16" };
      final String[] IAQIValues = ResourceUtil.getArrValue("IAQI");
      ExecutorService threadPool = Executors.newCachedThreadPool();
      CompletionService<Double> cs = new ExecutorCompletionService<Double>(threadPool);
      for (final String macKey : macKeys) {
         cs.submit(new Callable<Double>() {
            @Override
            public Double call() throws Exception {
               Double result = null;
               double avg = 0, minMacKey = 0, maxMacKey = 0, minIAQI = 0, maxIAQI = 0;
               Map<String, Object> map = new HashMap<String, Object>(parameters);
               map.put("macKey", macKey);
               Map<String, Object> average = historyMapper.getMonthAverageBySensor(map);
               if (!ObjectUtils.isEmpty(average)) {
                  avg = (Double) average.get("average");
                  String[] macKeyValues = ResourceUtil.getArrValue(macKey);
                  int index = -1;
                  for (int i = 0; i < macKeyValues.length; i++) {
                     if (avg <= Double.valueOf(macKeyValues[i])) {
                        if (i == 0) {
                           index = i;
                        } else {
                           index = i - 1;
                        }
                        break;
                     }
                  }
                  if (index == -1) {
                     result = Double.MAX_VALUE;
                  } else {
                     minMacKey = Double.valueOf(macKeyValues[index]);
                     maxMacKey = Double.valueOf(macKeyValues[index + 1]);
                     minIAQI = Double.valueOf(IAQIValues[index]);
                     maxIAQI = Double.valueOf(IAQIValues[index + 1]);
                     result = calculateIAQI(maxIAQI, minIAQI, maxMacKey, minMacKey, avg);
                  }
               }
               return result;
            }
         });
      }
      // 3.0 本月平均值
      Map<String, Object> average = null;
      Map<String, Object> map = new HashMap<String, Object>(parameters);
      // 每月一日的数据取上月的数据
      if (1 == Calendar.getInstance().get(Calendar.DAY_OF_MONTH)) {
         // 上个月1日00:00:00
         map.put("start", DateUtils.truncate(DateUtils.addMonths(date, -1), Calendar.MONTH));
      } else {
         // 这个月1日00:00:00
         map.put("start", DateUtils.truncate(date, Calendar.MONTH));
      }
      average = historyMapper.getMonthAverageBySensor(map);
      if (ObjectUtils.isEmpty(average)) {
         resultMap.put("average", "N/A");
      } else {
         resultMap.put("average", String.format("%.2f", average.get("average")));
      }
      List<Double> IAQIs = new ArrayList<Double>();
      for (String macKey : macKeys) {
         IAQIs.add(cs.take().get());
      }
      if (ObjectUtils.isEmpty(IAQIs)) {
         resultMap.put("AQI", "N/A");
      } else {
         Double AQI = Collections.max(IAQIs);
         if (AQI == Double.MAX_VALUE) {
            resultMap.put("AQI", IAQIValues[IAQIValues.length - 1]);
         } else {
            resultMap.put("AQI", String.format("%.0f", AQI));
         }
      }
      return resultMap;
   }
   public Map<String, Object> getAverageByAll(Map<String, Object> parameters) {
      Map<String, Object> result = new LinkedHashMap<String, Object>();
      setOrgIdsByAccount(parameters);
      parameters.put("macKey", "all");
      Date date = new Date();
      // 当前时间 -10分钟
      parameters.put("start", DateUtils.addMinutes(date, -10));
      // 当前时间 -5分钟
      parameters.put("end", DateUtils.addMinutes(date, -5));
      List<Map<String, Object>> averageByAll = historyMapper.getAverageByAll(parameters);
      for (Map<String, Object> map : averageByAll) {
         result.put((String) map.get("mac_key"), map.get("avg"));
      }
      return result;
   }
   @Override
   public Map<String, Object> getEquipmentStates(Map<String, Object> parameters) {
      Map<String, Object> result = new HashMap<String, Object>();
      setOrgIdsByAccount(parameters);
      List<Map<String, Object>> list = historyMapper.getEquipmentStates(parameters);
      Long all = 0L, normal = 0L, abnormal = 0L, stop = 0L;
      for (Map<String, Object> map : list) {
         Long count = (Long) map.get("count");
         all += count;
         switch ((Integer) map.get("state")) {
         case 0:
            normal = count;
            break;
         case 4:
            stop = count;
            break;
         default:
            abnormal += count;
         }
      }
      result.put("all", all);
      result.put("normal", normal);
      result.put("abnormal", abnormal);
      result.put("stop", stop);
      return result;
   }
   public void setOrgIdsByAccount(Map<String, Object> parameters) {
      String accountId = (String) parameters.get("accountId");
      if (!StringUtils.isNumeric((String) parameters.get("accountId"))) {
         throw new BusinessException("accountId 参数不合法!");
      }
      AccountEntity account = accountMapper.selectByPrimaryKey((Integer.valueOf(accountId)));
      if (ObjectUtils.isEmpty(account)) {
         throw new BusinessException(accountId + "该账号不存在!");
      }
      String orgId = account.getOrganization();
      // 不是摩瑞尔账号的需要根据组织来获取数据权限
      if (!("-1".equals(orgId) || ResourceUtil.getValue("orgId").equals(orgId))) {
         Set<String> orgIds = organizationService.getChildOrganizationIds(orgId);
         parameters.put("orgIds", orgIds);
      }
   }
   private double calculateIAQI(double maxIAQI, double minIAQI, double maxMacKey, double minMacKey, double avg) {
      return (maxIAQI - minIAQI) * (avg - minMacKey) / (maxMacKey - minMacKey) + minIAQI;
   }
   @Override
   public Map<String, Object> getAverageBySensor(Map<String, Object> parameters) {
      Map<String, Object> result = new LinkedHashMap<String, Object>();
      setOrgIdsByAccount(parameters);
      Date date = new Date();
      // 当前时间 -1小时
      parameters.put("start", DateUtils.addHours(date, -1));
      parameters.put("end", date);
      List<Map<String, Object>> averageByAll = historyMapper.getAverageByAll(parameters);
      for (Map<String, Object> map : averageByAll) {
         result.put((String) map.get("name"), map.get("avg"));
      }
      return result;
   }
}