报警配置 service

fengxiang

2018-05-10 95b2ec0857220478d6883eed582b67c758bc525a

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
package com.moral.service.impl;
 
import com.alibaba.fastjson.JSONReader;
import com.alibaba.fastjson.TypeReference;
import com.moral.common.bean.Constants;
import com.moral.common.util.RedisUtils;
import com.moral.entity.MonitorPoint;
import com.moral.entity.alarm.AlarmConfig;
import com.moral.entity.alarm.AlarmConfigValue;
import com.moral.entity.alarm.AlarmMode;
import com.moral.entity.alarm.AlarmSensorLevel;
import com.moral.mapper.AlarmConfigMapper;
import com.moral.service.AlarmConfigService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.autoconfigure.session.SessionProperties;
import org.springframework.stereotype.Service;
 
import javax.annotation.Resource;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
 
@Service
public class AlarmConfigServiceImpl implements AlarmConfigService{
    /** 缺省三级警报配置 .*/
    @Value(value = "classpath:system/alarmLevels.json")
    private org.springframework.core.io.Resource resource;
    private static AlarmConfigValue defaultAlarmConfigValue;
    @Autowired
    public AlarmConfigValue getDefaultAlarmConfigValue(){
        if(defaultAlarmConfigValue!=null){
            return defaultAlarmConfigValue;
        }else {
            InputStreamReader reader = null;
            AlarmConfigValue alarmConfigValue = null;
            try {
                reader = new InputStreamReader(resource.getInputStream());
                alarmConfigValue = new JSONReader(reader).readObject(new TypeReference<AlarmConfigValue>() {});
            } catch (IOException e) {
                e.printStackTrace();
            }
            return  alarmConfigValue;
        }
    }
    @Resource
    RedisUtils redisUtils;
    @Resource
    AlarmConfigMapper alarmConfigMapper;
    @Override
    public Optional<AlarmConfig> queryValueByOrganizationId(int organizationId) {
        String key = RedisUtils.getAlarmKey(organizationId);
        AlarmConfigValue alarmConfigValue = redisUtils.get(key,new TypeReference<AlarmConfigValue>(){});
        if(alarmConfigValue==null) {
            AlarmConfig alarmConfig = alarmConfigMapper.selectByOrganizationId(organizationId);
            if (alarmConfig != null && alarmConfig.getValue() != null) {
                return Optional.ofNullable(alarmConfig);
            } else {
                alarmConfigValue = getDefaultAlarmConfigValue();
            }
        }
        AlarmConfig alarmConfigNotWithId = new AlarmConfig();
        alarmConfigNotWithId.setValue(alarmConfigValue);
        return Optional.ofNullable(alarmConfigNotWithId);
    }
 
    @Override
    public Optional<AlarmConfig> queryByOrganizationId(int organizationId) {
        AlarmConfig alarmConfig = alarmConfigMapper.selectByOrganizationId(organizationId);
        if(alarmConfig==null){
            alarmConfig = new AlarmConfig();
            alarmConfig.setValue(getDefaultAlarmConfigValue());
        }
        return Optional.ofNullable(alarmConfig);
    }
 
    @Override
    public Optional<AlarmConfig> queryByMonitorPointId(int mpId) {
        AlarmConfig alarmConfig = alarmConfigMapper.selectByMonitorPointId(mpId);
        if(alarmConfig==null){
            alarmConfig = new AlarmConfig();
            alarmConfig.setValue(getDefaultAlarmConfigValue());
        }
        return Optional.ofNullable(alarmConfig);
    }
 
    @Override
    public void addOrModify(AlarmConfig alarmConfig) {
        try{
            if(alarmConfig.getId()==null){
                alarmConfig.setCreateTime(new Date());
                alarmConfig.setUpdateTime(new Date());
                alarmConfigMapper.insertSelective(alarmConfig);
            }else {
                alarmConfig.setUpdateTime(new Date());
                alarmConfigMapper.updateByPrimaryKeySelective(alarmConfig);
            }
            String key = RedisUtils.getAlarmKey(alarmConfig.getOrganizationId());
            redisUtils.set(key,simplifyAlarmConfigValue(alarmConfig.getValue()));
        }
        catch (Exception ex){
            throw  ex;
        }
    }
    public AlarmConfigValue simplifyAlarmConfigValue(AlarmConfigValue value){
          Map<String,AlarmSensorLevel> alarmSensorLevelMap = value.getAlarmLevels();
          List<String> cleanKeys = new ArrayList<>();
          for(String key:alarmSensorLevelMap.keySet()){
                 AlarmSensorLevel alarmSensorLevel = alarmSensorLevelMap.get(key);
                 if(!alarmSensorLevel.isEnable()){
                     cleanKeys.add(key);
                 }else{
                     List<Float> increments = alarmSensorLevel.getIncrement();
                     if(increments!=null){
                         boolean isIncrement =  increments.size()<3||
                                 (increments.get(0)==0&&increments.get(1)==0&&increments.get(2)==0);
                         if(isIncrement){
                             alarmSensorLevel.setIncrement(null);
                         }
                     }
                     if(alarmSensorLevel.isDegressEnable()){
                         List<Float> degressions = alarmSensorLevel.getDegression();
                         if(degressions!=null){
                             boolean isDegression =  degressions.size()<3||
                                     (degressions.get(0)==0&&degressions.get(1)==0&&degressions.get(2)==0);
                             if(isDegression){
                                 alarmSensorLevel.setDegression(null);
                             }
                         }
                     }else{
                         //未启用反向三级直接置空
                         alarmSensorLevel.setDegression(null);
                     }
                 }
          }
          for (String key:cleanKeys){
              alarmSensorLevelMap.remove(key);
          }
          AlarmMode alarmMode = value.getAlarmMode();
          if(!alarmMode.isEnable()){
              alarmMode.setLevel1(null);
              alarmMode.setLevel2(null);
              alarmMode.setLevel3(null);
          }else{
              if(alarmMode.getLevel1()!=null&&alarmMode.getLevel1().isEmpty()){
                  alarmMode.setLevel1(null);
              }
              if(alarmMode.getLevel2()!=null&&alarmMode.getLevel2().isEmpty()){
                  alarmMode.setLevel2(null);
              }
              if(alarmMode.getLevel3()!=null&&alarmMode.getLevel3().isEmpty()){
                  alarmMode.setLevel3(null);
              }
          }
          return value;
    }
}