风机报警和升压站报警功能修改优化

alarm-web/pom.xml

@@ -0,0 +1,189 @@
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+    <parent>
+        <artifactId>alarmNew</artifactId>
+        <groupId>com.gyee</groupId>
+        <version>1.0-SNAPSHOT</version>
+    </parent>
+    <modelVersion>4.0.0</modelVersion>
+
+    <artifactId>alarm-web</artifactId>
+    <packaging>jar</packaging>
+
+    <name>alarm-web</name>
+
+
+    <!-- 统一管理jar包版本 -->
+    <properties>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+        <junit.version>4.12</junit.version>
+        <log4j.version>2.15.0</log4j.version>
+        <lombok.version>1.18.16</lombok.version>
+        <mysql.version>5.1.45</mysql.version>
+        <druid.version>1.2.5</druid.version>
+        <mybatis.spring.boot.version>1.3.2</mybatis.spring.boot.version>
+        <mybatis-plus.boot.starter.version>3.2.0</mybatis-plus.boot.starter.version>
+        <mybatis-plus.generator.version>3.3.2</mybatis-plus.generator.version>
+        <pgsql.version>42.2.5</pgsql.version>
+        <groovy.version>3.0.8</groovy.version>
+        <springframework.boot.version>2.2.2.RELEASE</springframework.boot.version>
+
+    </properties>
+
+
+    <dependencies>
+        <dependency>
+            <groupId>com.opencsv</groupId>
+            <artifactId>opencsv</artifactId>
+            <version>4.4</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-web</artifactId>
+            <version>${springframework.boot.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-actuator</artifactId>
+            <version>${springframework.boot.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-test</artifactId>
+            <version>${springframework.boot.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-starter-data-redis</artifactId>
+            <version>${springframework.boot.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.boot</groupId>
+            <artifactId>spring-boot-autoconfigure</artifactId>
+            <version>${springframework.boot.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.projectlombok</groupId>
+            <artifactId>lombok</artifactId>
+            <optional>true</optional>
+            <version>${lombok.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>druid</artifactId>
+            <version>1.1.10</version>
+        </dependency>
+        <dependency>
+            <groupId>com.oracle</groupId>
+            <artifactId>ojdbc6</artifactId>
+            <version>11.2.0.3</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.springframework.data</groupId>
+            <artifactId>spring-data-redis</artifactId>
+            <version>2.3.6.RELEASE</version>
+        </dependency>
+        <dependency>
+            <groupId>com.baomidou</groupId>
+            <artifactId>mybatis-plus-boot-starter</artifactId>
+            <version>${mybatis-plus.boot.starter.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.baomidou</groupId>
+            <artifactId>mybatis-plus-generator</artifactId>
+            <version>${mybatis-plus.generator.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>com.baomidou</groupId>
+            <artifactId>dynamic-datasource-spring-boot-starter</artifactId>
+            <version>3.5.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.freemarker</groupId>
+            <artifactId>freemarker</artifactId>
+            <version>2.3.28</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.gyee</groupId>
+            <artifactId>common</artifactId>
+            <version>1.0-SNAPSHOT</version>
+            <scope>compile</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.alibaba</groupId>
+            <artifactId>fastjson</artifactId>
+            <version>1.2.17</version>
+            <scope>compile</scope>
+        </dependency>
+        <!-- ********************** plugin ********************** -->
+        <!-- groovy-all -->
+        <dependency>
+            <groupId>org.codehaus.groovy</groupId>
+            <artifactId>groovy</artifactId>
+            <version>${groovy.version}</version>
+        </dependency>
+        <!-- xxl-job-core -->
+        <dependency>
+            <groupId>com.xuxueli</groupId>
+            <artifactId>xxl-job-core</artifactId>
+            <version>2.3.1-SNAPSHOT</version>
+        </dependency>
+        <dependency>
+            <groupId>com.google.code.gson</groupId>
+            <artifactId>gson</artifactId>
+            <version>2.8.6</version>
+        </dependency>
+        <dependency>
+            <groupId>io.netty</groupId>
+            <artifactId>netty-all</artifactId>
+            <version>4.1.55.Final</version>
+        </dependency>
+        <dependency>
+            <groupId>org.postgresql</groupId>
+            <artifactId>postgresql</artifactId>
+            <version>${pgsql.version}</version>
+        </dependency>
+        <dependency>
+            <groupId>org.apache.poi</groupId>
+            <artifactId>poi</artifactId>
+            <version>3.17</version>
+        </dependency>
+        <dependency>
+            <groupId>cn.hutool</groupId>
+            <artifactId>hutool-all</artifactId>
+            <version>5.1.1</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.taosdata.jdbc</groupId>
+            <artifactId>taos-jdbcdriver</artifactId>
+            <version>3.2.2</version>
+        </dependency>
+
+    </dependencies>
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>org.springframework.boot</groupId>
+                <artifactId>spring-boot-maven-plugin</artifactId>
+                <version>2.7.1</version>
+                <configuration>
+                    <!--maven编译时将本地引用的jar包一起打包-->
+                    <includeSystemScope>true</includeSystemScope>
+                </configuration>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+    </build>
+</project>

alarm-web/src/main/java/com/gyee/alarm/AlarmWeb.java

@@ -0,0 +1,16 @@
+package com.gyee.alarm;
+
+import org.mybatis.spring.annotation.MapperScan;
+import org.springframework.boot.SpringApplication;
+import org.springframework.boot.autoconfigure.SpringBootApplication;
+
+
+@SpringBootApplication
+@MapperScan("com.gyee.alarm.mapper")
+public class AlarmWeb {
+    public static void main(String[] args) throws Exception {
+        SpringApplication.run(AlarmWeb.class, args);
+
+        System.out.println("完成");
+    }
+}

alarm-web/src/main/java/com/gyee/alarm/init/CacheContext.java

@@ -0,0 +1,634 @@
+package com.gyee.alarm.init;
+
+
+import com.alibaba.fastjson.JSONObject;
+import com.alibaba.fastjson.TypeReference;
+import com.gyee.alarm.model.vo.AlarmCustomType;
+import com.gyee.alarm.model.vo.AlarmTypeValue;
+import com.gyee.alarm.model.vo.AlarmVo;
+import com.gyee.common.model.StringUtils;
+import com.gyee.alarm.model.auto.*;
+import com.gyee.alarm.service.auto.*;
+
+import com.gyee.alarm.init.redis.RedisService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Value;
+import org.springframework.boot.CommandLineRunner;
+import org.springframework.stereotype.Component;
+
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.stream.Collectors;
+
+/**
+ * @ClassName : CacheContext
+ * @Author : xieshengjie
+ * @Date: 2021/5/18 9:35
+ * @Description : 缓存
+ */
+@Component
+public class CacheContext implements CommandLineRunner {
+    Logger logger = LoggerFactory.getLogger(CacheContext.class);
+
+    @Resource
+    private IProBasicEquipmentService proBasicEquipmentService;
+    @Resource
+    private IProBasicLineService proBasicLineService;
+    @Resource
+    private IProBasicProjectService proBasicProjectService;
+
+    @Resource
+    private IProBasicPowerstationService proBasicWindpowerstationService;
+    @Resource
+    private IProBasicMeterPointService proBasicMeterPointService;
+    @Resource
+    private IProEconEquipmentmodelService proEconEquipmentmodelService;
+
+    @Resource
+    private IProEconWtPowerCurveFittingService proEconWtPowerCurveFittingService;
+
+    @Resource
+    private IProBasicWindturbinePowerService proBasicWindturbinePowerService;
+    @Resource
+    private RedisService redisService;
+    @Resource
+    private IProBasicModelPowerService proBasicModelPowerService;
+    @Resource
+    private IProBasicSubStationService proBasicSubStationService;
+    @Resource
+    private IProBasicSquareService proBasicSquareService;
+    @Resource
+    private IProBasicCompanyService proBasicCompanyService;
+    @Resource
+    private IProBasicRegionService proBasicRegionService;
+
+
+    @Resource
+    private IProBasicModelPowerRdService proBasicModelPowerRdService;
+    @Resource
+    private IProBasicWeatherStationService proBasicWeatherStationService;
+    @Resource
+    private IProBasicBranchService proBasicBranchService;
+    @Resource
+    private IProBasicEnergyGroupService proBasicEnergyGroupService;
+    @Resource
+    private IProEconStateAiService proEconStateAiService;
+
+    @Resource
+    private IProBasicStatusPointService proBasicStatusPointService;
+
+    @Resource
+    private IProEconAlarmConfigurationService proEconAlarmConfigurationService;
+    @Value("${runWindpowerstation}")
+    private String runWindpowerstation;
+
+    @Resource
+    private IProEconAlarmRuleService proEconAlarmRuleService;
+
+    public static Map<String, List<ProEconAlarmRule>> alarmRulesMap = new HashMap<>();
+    public static List<ProBasicEquipment> wtls = new ArrayList<>();
+    public static List<ProBasicEquipment> wt_fjls = new ArrayList<>();
+    public static List<ProBasicProject> pjls = new ArrayList<>();
+    public static List<ProBasicLine> lnls = new ArrayList<>();
+    public static List<ProBasicSubStation> subwpls = new ArrayList<>();
+
+    public static Map<String, ProBasicSubStation> subwpmap = new HashMap<>();
+    public static List<ProBasicWeatherStation> wswpls = new ArrayList<>();
+
+    public static List<ProBasicSquare> sqls = new ArrayList<>();
+    public static List<ProBasicPowerstation> wpls = new ArrayList<>();
+    public static List<ProBasicPowerstation> zwpls = new ArrayList<>();
+    public static List<ProBasicCompany> cpls = new ArrayList<>();
+    public static List<ProBasicRegion> rgls = new ArrayList<>();
+    public static List<ProBasicEnergyGroup> egls = new ArrayList<>();
+    public static Map<String, ProBasicProject> pjmap = new HashMap<>();
+    public static Map<String, ProBasicLine> lnmap = new HashMap<>();
+    public static Map<String, ProBasicRegion> rgmap = new HashMap<>();
+    public static Map<String, ProBasicEnergyGroup> egmap = new HashMap<>();
+    public static Map<String, ProBasicCompany> cpmap = new HashMap<>();
+
+    public static Map<String, List<ProBasicPowerstation>> cpwpmap = new HashMap<>();
+
+    public static Map<String, List<ProBasicCompany>> rgcpmap = new HashMap<>();
+    public static Map<String, ProBasicSquare> sqmap = new HashMap<>();
+    public static Map<String, ProBasicPowerstation> wpmap = new HashMap<>();
+    public static List<ProBasicMeterPoint> meterpoints = new ArrayList<>();
+    public static Map<String, ProBasicMeterPoint> meterpointMap = new HashMap<>();
+    public static Map<String, List<ProBasicProject>> wppromap = new HashMap<>();
+    public static Map<String, List<ProBasicLine>> prolinemap = new HashMap<>();
+    public static Map<String, List<ProBasicEquipment>> wpwtmap = new HashMap<>();
+    public static Map<String, List<ProBasicEquipment>> pjwtmap = new HashMap<>();
+    public static Map<String, List<ProBasicEquipment>> lnwtmap = new HashMap<>();
+    public static List<ProBasicWeatherStation> wsls = new ArrayList<>();
+    public static Map<String, List<ProBasicWeatherStation>> poWsStationMap = new HashMap<>();
+
+    public static Map<String, List<ProBasicEquipment>> sqwtmap = new HashMap<>();
+    public static Map<String, Map<String, ProBasicEquipmentPoint>> wtpAimap = new HashMap<>();// 风电机测点AI表
+    public static Map<String, Map<String, ProBasicPowerstationPoint>> linepointmap = new HashMap<>();
+    public static Map<String, Map<String, ProBasicPowerstationPoint>> propointmap = new HashMap<>();
+    public static Map<String, Map<String, ProBasicPowerstationPoint>> wppointmap = new HashMap<>();
+    public static Map<String, Map<String, ProBasicPowerstationPoint>> subwppointmap = new HashMap<>();
+    public static Map<String, Map<String, ProBasicPowerstationPoint>> wswppointmap = new HashMap<>();
+    public static Map<String, Map<String, ProBasicPowerstationPoint>> companypointmap = new HashMap<>();
+    public static Map<String, Map<String, ProBasicPowerstationPoint>> regionpointmap = new HashMap<>();
+    public static Map<String, Map<String, ProBasicPowerstationPoint>> grouppointmap = new HashMap<>();
+
+    public static Map<String, Map<Double, Double>> zbzglMap = new HashMap<>();
+    public static Map<String, ProEconEquipmentmodel> modelMap = new HashMap<>();
+    public static Map<String, Map<Double, Double>> zzsglMap = new HashMap<>();
+    public static Map<String, Double> modelpower = new HashMap<>();
+
+    public static Map<String, String> wtstandardmap = new HashMap<>();
+    public static Map<String, ProBasicEquipment> wtmap = new HashMap<>();
+
+    public static Map<String, Map<Double, ProBasicModelPower>> modelpowermap = new TreeMap<>();
+
+    public static List<ProBasicModelPower> mpls = new ArrayList<>();
+
+    public static List<ProEconEquipmentmodel> equipmentmodels = new ArrayList<>();
+
+    public static Map<String, List<ProBasicEquipment>> subWtsMap = new HashMap<>();
+    public static List<ProBasicModelPowerRd> theoreticalPowerList = new ArrayList<>();
+    public static Map<String, Map<Double, ProBasicModelPowerRd>> theoreticalPowerMap = new HashMap<>(); //理论，保证功率
+    public static Map<String, Map<Double, ProEconWtPowerCurveFitting>> curveFittingPowerMap = new HashMap<>(); //自算，最优功率
+    public static Map<String, List<ProBasicStatusPoint>> statusMap = new HashMap<>();
+    public static Map<String, Map<String, ProBasicPowerstationPoint>> wspointmap = new HashMap<>();
+    public static Map<String, Map<String, ProBasicEquipmentPoint>> zlpointmap = new HashMap<>();
+    public static Map<String, Map<Integer, Integer>> aistateMap = new HashMap<>();
+
+    public static Map<String, Integer> redisDbMap = new HashMap<>();
+
+    public static List<ProBasicStatusPoint> pointdis = new ArrayList<>();
+
+
+    public static List<ProEconAlarmConfiguration> btalarmls = new ArrayList<>();
+    public static List<ProEconAlarmConfiguration> wtalarmls = new ArrayList<>();
+    public static List<ProEconAlarmConfiguration> customalarmls = new ArrayList<>();
+    public static Map<String, Map<String, ProBasicStatusPoint>> pointdismap = new HashMap<>();
+
+    public static Map<String,List<ProEconAlarmConfiguration>> wtAlarmMap=new HashMap<>();
+    public static Map<String,ProEconAlarmConfiguration> alarmMap=new HashMap<>();
+
+    public static List<AlarmVo> alarmWtList=new ArrayList<>();
+    public static Map<String,AlarmVo> alarmWtMap=new HashMap<>();
+
+    public static List<AlarmVo> alarmBtList=new ArrayList<>();
+    public static Map<String,AlarmVo> alarmBtMap=new HashMap<>();
+
+    public static List<AlarmVo> alarmCtList=new ArrayList<>();
+    public static Map<String,AlarmVo> alarmCtMap=new HashMap<>();
+
+    @Override
+
+    public void run(String... args) throws Exception {
+        logger.info("缓存开始------------------------------------------------------------");
+
+
+
+        List<String> runWpids = Arrays.asList(runWindpowerstation.split(","));
+        logger.info(runWpids.get(0) + "------------------" + runWpids.size());
+        wsls = proBasicWeatherStationService.list().stream().filter(i -> runWpids.contains(i.getWindpowerstationId()) && i.getIsAble() == 1).collect(Collectors.toList());
+        if (!wsls.isEmpty()) {
+
+            for (ProBasicWeatherStation ws : wsls) {
+                if (poWsStationMap.containsKey(ws.getWindpowerstationId())) {
+                    List<ProBasicWeatherStation> ls = poWsStationMap.get(ws.getWindpowerstationId());
+                    ls.add(ws);
+                    poWsStationMap.put(ws.getWindpowerstationId(), ls);
+
+                } else {
+                    List<ProBasicWeatherStation> ls = new ArrayList<>();
+                    ls.add(ws);
+                    poWsStationMap.put(ws.getWindpowerstationId(), ls);
+                }
+            }
+        }
+        theoreticalPowerList = proBasicModelPowerRdService.list();
+        equipmentmodels = proEconEquipmentmodelService.list();
+        equipmentmodels.stream().forEach(e -> {
+            modelMap.put(e.getId(), e);
+        });
+        mpls = proBasicModelPowerService.list();
+        mpls.sort(Comparator.comparing(ProBasicModelPower::getSpeed));
+        if (!mpls.isEmpty()) {
+
+            for (ProBasicModelPower mp : mpls) {
+                if (modelpowermap.containsKey(mp.getModelId())) {
+                    Map<Double, ProBasicModelPower> tempmap = modelpowermap.get(mp.getModelId());
+                    tempmap.put(mp.getSpeed(), mp);
+
+                } else {
+                    Map<Double, ProBasicModelPower> tempmap = new HashMap<>();
+                    tempmap.put(mp.getSpeed(), mp);
+                    modelpowermap.put(mp.getModelId(), tempmap);
+                }
+            }
+        }
+        sqls = proBasicSquareService.list().stream().filter(i -> runWpids.contains(i.getWindpowerstationId()) && i.getIsAble() == 1).collect(Collectors.toList());
+        if (!sqls.isEmpty()) {
+            for (ProBasicSquare sq : sqls) {
+                sqmap.put(sq.getId(), sq);
+            }
+        }
+
+        cpls = proBasicCompanyService.list().stream().filter(i -> i.getIsAble().equals(1)).collect(Collectors.toList());
+        if (!cpls.isEmpty()) {
+            for (ProBasicCompany sq : cpls) {
+                cpmap.put(sq.getId(), sq);
+
+                if (redisService.hasKey(sq.getId() + "0")) {
+                    String cp0String = redisService.get(sq.getId() + "0");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp0String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    companypointmap.put(sq.getId() + "0", stringWindpowerstationpointnewMap);
+                }
+                if (redisService.hasKey(sq.getId() + "-1")) {
+                    String cp1String = redisService.get(sq.getId() + "-1");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp1String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    companypointmap.put(sq.getId() + "-1", stringWindpowerstationpointnewMap);
+                }
+                if (redisService.hasKey(sq.getId() + "-2")) {
+                    String cp2String = redisService.get(sq.getId() + "-2");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp2String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    companypointmap.put(sq.getId() + "-2", stringWindpowerstationpointnewMap);
+                }
+
+
+            }
+
+        }
+
+
+        rgls = proBasicRegionService.list().stream().filter(i -> i.getIsAble() == 1).collect(Collectors.toList());
+        if (!rgls.isEmpty()) {
+            for (ProBasicRegion sq : rgls) {
+                rgmap.put(sq.getId(), sq);
+
+                if (redisService.hasKey(sq.getId() + "0")) {
+                    String cp0String = redisService.get(sq.getId() + "0");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp0String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    regionpointmap.put(sq.getId() + "0", stringWindpowerstationpointnewMap);
+                }
+                if (redisService.hasKey(sq.getId() + "-1")) {
+                    String cp1String = redisService.get(sq.getId() + "-1");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp1String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    regionpointmap.put(sq.getId() + "-1", stringWindpowerstationpointnewMap);
+                }
+                if (redisService.hasKey(sq.getId() + "-2")) {
+                    String cp2String = redisService.get(sq.getId() + "-2");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp2String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    regionpointmap.put(sq.getId() + "-2", stringWindpowerstationpointnewMap);
+                }
+            }
+        }
+
+        egls = proBasicEnergyGroupService.list().stream().filter(i -> i.getIsAble() == 1 && !i.getParentid().equals("0")).collect(Collectors.toList());
+        if (!egls.isEmpty()) {
+            for (ProBasicEnergyGroup sq : egls) {
+                egmap.put(sq.getId(), sq);
+
+                if (redisService.hasKey(sq.getId() + "0")) {
+                    String eg0String = redisService.get(sq.getId() + "0");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(eg0String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    grouppointmap.put(sq.getId() + "0", stringWindpowerstationpointnewMap);
+                }
+                if (redisService.hasKey(sq.getId() + "-1")) {
+                    String eg1String = redisService.get(sq.getId() + "-1");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(eg1String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    grouppointmap.put(sq.getId() + "-1", stringWindpowerstationpointnewMap);
+                }
+                if (redisService.hasKey(sq.getId() + "-2")) {
+                    String eg2String = redisService.get(sq.getId() + "-2");
+                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(eg2String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+                    });
+                    grouppointmap.put(sq.getId() + "-2", stringWindpowerstationpointnewMap);
+                }
+            }
+        }
+
+
+        for (ProBasicCompany cp : cpls) {
+            if (rgcpmap.containsKey(cp.getRegionId())) {
+                rgcpmap.get(cp.getRegionId()).add(cp);
+            } else {
+                List<ProBasicCompany> wps = new ArrayList<>();
+                wps.add(cp);
+                rgcpmap.put(cp.getRegionId(), wps);
+            }
+        }
+
+        for (ProBasicPowerstation wp : wpls) {
+            if (cpwpmap.containsKey(wp.getCompanyId())) {
+                cpwpmap.get(wp.getCompanyId()).add(wp);
+            } else {
+                List<ProBasicPowerstation> wps = new ArrayList<>();
+                wps.add(wp);
+                cpwpmap.put(wp.getCompanyId(), wps);
+            }
+        }
+
+        wsls.stream().forEach(p -> {
+
+
+            String wsString = redisService.get(p.getId());
+            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(wsString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+            });
+            wspointmap.put(p.getId(), stringWindpowerstationpointnewMap);
+
+        });
+//        //支路
+//        List<ProBasicBranch> basicBranches = proBasicBranchService.list();
+//        if (basicBranches != null && basicBranches.size() > 0) {
+//            basicBranches.stream().forEach(b -> {
+//                String wsString = redisService.get(b.getId());
+//                Map<String, ProBasicEquipmentPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(wsString, new TypeReference<Map<String, ProBasicEquipmentPoint>>() {
+//                });
+//                zlpointmap.put(b.getId(), stringWindpowerstationpointnewMap);
+//            });
+//        }
+
+        wtls = proBasicEquipmentService.list().stream().filter(i -> runWpids.contains(i.getWindpowerstationId()) && i.getIsable() == 1).collect(Collectors.toList());
+        logger.info(wtls.size() + "");
+        wtls.forEach(wt -> {
+            if (modelMap.containsKey(wt.getModelId())) {
+                ProEconEquipmentmodel equipmentmodel = modelMap.get(wt.getModelId());
+                modelpower.put(wt.getModelId(), equipmentmodel.getPowerProduction().doubleValue());
+            }
+
+            if (wt.getId().contains("_F_")) {
+                wt_fjls.add(wt);
+            }
+
+            wtmap.put(wt.getId(), wt);
+            //标杆风机初始化
+            wtstandardmap.put(wt.getId(), wt.getId());
+            String wtString = redisService.get(wt.getId());
+            Map<String, ProBasicEquipmentPoint> stringWindturbinetestingpointnewMap = JSONObject.parseObject(wtString, new TypeReference<Map<String, ProBasicEquipmentPoint>>() {
+            });
+            wtpAimap.put(wt.getId(), stringWindturbinetestingpointnewMap);
+
+
+            if (wpwtmap.containsKey(wt.getWindpowerstationId())) {
+                wpwtmap.get(wt.getWindpowerstationId()).add(wt);
+            } else {
+                List<ProBasicEquipment> wps = new ArrayList<>();
+                wps.add(wt);
+                wpwtmap.put(wt.getWindpowerstationId(), wps);
+            }
+
+            if (pjwtmap.containsKey(wt.getProjectId())) {
+                pjwtmap.get(wt.getProjectId()).add(wt);
+            } else {
+                List<ProBasicEquipment> pjs = new ArrayList<>();
+                pjs.add(wt);
+                pjwtmap.put(wt.getProjectId(), pjs);
+            }
+            if (lnwtmap.containsKey(wt.getLineId())) {
+                lnwtmap.get(wt.getLineId()).add(wt);
+            } else {
+                List<ProBasicEquipment> lnls = new ArrayList<>();
+                lnls.add(wt);
+                lnwtmap.put(wt.getLineId(), lnls);
+            }
+
+            if (sqwtmap.containsKey(wt.getSquareId())) {
+                sqwtmap.get(wt.getSquareId()).add(wt);
+            } else {
+                List<ProBasicEquipment> lnls = new ArrayList<>();
+                lnls.add(wt);
+                sqwtmap.put(wt.getSquareId(), lnls);
+            }
+        });
+
+        //初始化标杆风机
+        for (ProBasicEquipment wt : wtls) {
+            if (wpwtmap.containsKey(wt.getLineId())) {
+                List<ProBasicEquipment> wts = wpwtmap.get(wt.getLineId());
+                for (ProBasicEquipment w : wts) {
+                    if (StringUtils.notEmp(w.getIsStandard()) && w.getIsStandard() != 0) {
+                        wtstandardmap.put(wt.getId(), w.getId());
+                        break;
+                    }
+                }
+            }
+            if (pjwtmap.containsKey(wt.getLineId())) {
+                List<ProBasicEquipment> wts = pjwtmap.get(wt.getLineId());
+                for (ProBasicEquipment w : wts) {
+                    if (StringUtils.notEmp(w.getIsStandard()) && w.getIsStandard() != 0) {
+                        wtstandardmap.put(wt.getId(), w.getId());
+                        break;
+                    }
+                }
+            }
+            if (lnwtmap.containsKey(wt.getLineId())) {
+                List<ProBasicEquipment> wts = lnwtmap.get(wt.getLineId());
+                for (ProBasicEquipment w : wts) {
+                    if (StringUtils.notEmp(w.getIsStandard()) && w.getIsStandard() != 0) {
+                        wtstandardmap.put(wt.getId(), w.getId());
+                        break;
+                    }
+                }
+            }
+        }
+
+
+        pjls = proBasicProjectService.list().stream().filter(i -> runWpids.contains(i.getWindpowerstationId()) && i.getIsAble() == 1).collect(Collectors.toList());
+        pjls.stream().forEach(p -> {
+            pjmap.put(p.getId(), p);
+            if (wppromap.containsKey(p.getWindpowerstationId())) {
+                wppromap.get(p.getWindpowerstationId()).add(p);
+            } else {
+                List<ProBasicProject> prolist = new ArrayList<>();
+                prolist.add(p);
+                wppromap.put(p.getWindpowerstationId(), prolist);
+            }
+            String pjString = redisService.get(p.getId());
+            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(pjString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+            });
+            propointmap.put(p.getId(), stringWindpowerstationpointnewMap);
+
+        });
+
+        subwpls = proBasicSubStationService.list().stream().filter(i -> runWpids.contains(i.getWindpowerstationId()) && i.getIsAble() == 1).collect(Collectors.toList());
+        subwpls.stream().forEach(sub -> {
+
+            subwpmap.put(sub.getId(),sub);
+            String subString = redisService.get(sub.getId());
+            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(subString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+            });
+            subwppointmap.put(sub.getId(), stringWindpowerstationpointnewMap);
+
+            List<ProBasicEquipment> collect = wtls.stream().filter(wt -> wt.getSubstationId().equals(sub.getId())).collect(Collectors.toList());
+            subWtsMap.put(sub.getId(), collect);
+
+        });
+
+        wswpls = proBasicWeatherStationService.list().stream().filter(i -> runWpids.contains(i.getWindpowerstationId()) && i.getIsAble() == 1).collect(Collectors.toList());
+        wswpls.stream().forEach(ws -> {
+
+            String subString = redisService.get(ws.getId());
+            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(subString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+            });
+            wswppointmap.put(ws.getId(), stringWindpowerstationpointnewMap);
+
+//            List<ProBasicEquipment> collect = wtls.stream().filter(wt -> wt.getSubstationId().equals(sub.getId())).collect(Collectors.toList());
+//            subWtsMap.put(sub.getId(),collect);
+
+        });
+
+        List<ProEconStateAi> proEconStateAis = proEconStateAiService.list();
+        proEconStateAis.stream().forEach(ai -> {
+            if (aistateMap.containsKey(ai.getModelid())) {
+                aistateMap.get(ai.getModelid()).put(ai.getOriginalState(), ai.getMappingState());
+            } else {
+                Map<Integer, Integer> stateMap = new HashMap<>();
+                stateMap.put(ai.getOriginalState(), ai.getMappingState());
+                aistateMap.put(ai.getModelid(), stateMap);
+            }
+        });
+
+        lnls = proBasicLineService.list().stream().filter(i -> StringUtils.isNotNull(pjmap.get(i.getProjectId())) && runWpids.contains(pjmap.get(i.getProjectId()).getWindpowerstationId()) && i.getIsAble() == 1).collect(Collectors.toList());
+        lnls.stream().forEach(l -> {
+            lnmap.put(l.getId(), l);
+            if (prolinemap.containsKey(l.getProjectId())) {
+                prolinemap.get(l.getProjectId()).add(l);
+            } else {
+                List<ProBasicLine> lineList = new ArrayList<>();
+                lineList.add(l);
+                prolinemap.put(l.getProjectId(), lineList);
+            }
+            String lnString = redisService.get(l.getId());
+            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(lnString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+            });
+            linepointmap.put(l.getId(), stringWindpowerstationpointnewMap);
+        });
+
+
+        zwpls = proBasicWindpowerstationService.list().stream().filter(i -> runWpids.contains(i.getId()) && i.getIsAble() == 1).collect(Collectors.toList());
+        wpls = proBasicWindpowerstationService.list().stream().filter(i -> runWpids.contains(i.getId()) && i.getIsAble() == 1).collect(Collectors.toList());
+        ;
+        meterpoints = proBasicMeterPointService.list().stream().filter(i -> runWpids.contains(i.getWindpowerstationId()) && i.getIsAble() == 1).collect(Collectors.toList());
+        meterpoints.stream().forEach(meterpoint -> {
+            meterpointMap.put(meterpoint.getNemCode(), meterpoint);
+        });
+
+
+        wpls.stream().forEach(wp -> {
+
+            wpmap.put(wp.getId(), wp);
+            String wpString = redisService.get(wp.getId());
+            Map<String, ProBasicPowerstationPoint> stringMapMap = JSONObject.parseObject(wpString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
+            });
+            wppointmap.put(wp.getId(), stringMapMap);
+        });
+
+
+//        String llglString = redisService.get("ZLLGL");
+//        theoreticalPowerMap = JSONObject.parseObject(llglString, new TypeReference<Map<String, Map<Double, ProBasicModelPowerRd>>>() {
+//        });
+//
+//        String sszzt = redisService.get("SSZZT");
+//        statusMap = JSONObject.parseObject(sszzt, new TypeReference<Map<String, List<ProBasicStatusPoint>>>() {
+//        });
+//
+//        List<ProEconWtPowerCurveFitting> econWtPowerCurveFittings = proEconWtPowerCurveFittingService.list();
+//        if (StringUtils.isNotNull(econWtPowerCurveFittings)) {
+//            econWtPowerCurveFittings.stream().forEach(curveFitting -> {
+//                if (curveFittingPowerMap.containsKey(curveFitting.getWindturbineId())) {
+//                    curveFittingPowerMap.get(curveFitting.getWindturbineId()).put(curveFitting.getSpeed(), curveFitting);
+//                } else {
+//                    Map<Double, ProEconWtPowerCurveFitting> powerMap = new HashMap<>();
+//                    powerMap.put(curveFitting.getSpeed(), curveFitting);
+//                    curveFittingPowerMap.put(curveFitting.getWindturbineId(), powerMap);
+//                }
+//            });
+//        }
+//        for (int i = 0; i < 9; i++) {
+//            Set<String> keys = redisService.keys(i);
+//
+//            for (String key : keys) {
+//                redisDbMap.put(key, i);
+//            }
+//        }
+//
+//        pointdis = proBasicStatusPointService.list();
+//
+//        Map<String, ProBasicStatusPoint> items = null;
+//        if (pointdis != null && !pointdis.isEmpty()) {
+//            for (int i = 0; i < pointdis.size(); i++) {
+//                ProBasicStatusPoint point = pointdis.get(i);
+//                if (pointdismap.containsKey(point.getWindturbineId())) {
+//                    items = pointdismap.get(point.getWindturbineId());
+//                    items.put(point.getUniformCode(), point);
+//                } else {
+//                    items = new HashMap<String, ProBasicStatusPoint>();
+//                    pointdismap.put(point.getWindturbineId(), items);
+//                    items.put(point.getUniformCode(), point);
+//                }
+//
+//            }
+//        }
+
+        List<ProEconAlarmRule> customls =proEconAlarmRuleService.list().stream().filter(i -> i.getEnable()).collect(Collectors.toList());
+
+        List<ProEconAlarmRule> wtCustomls=new ArrayList<>();
+        List<ProEconAlarmRule> wpCustomls=new ArrayList<>();
+//        List<ProEconAlarmRule> btCustomls=new ArrayList<>();
+        if(!customls.isEmpty())
+        {
+            for(ProEconAlarmRule vo: customls)
+            {
+                if(vo.getCategory().equals(AlarmCustomType.WT.getCode()))
+                {
+                    wtCustomls.add(vo);
+                }else  if(vo.getCategory().equals(AlarmCustomType.WP.getCode()))
+                {
+                    wpCustomls.add(vo);
+                }
+
+            }
+        }
+        alarmRulesMap.put(AlarmCustomType.WT.getCode(),wtCustomls);
+        alarmRulesMap.put(AlarmCustomType.WP.getCode(),wpCustomls);
+
+
+        List<ProEconAlarmConfiguration> templs = proEconAlarmConfigurationService.list().stream().filter(i -> i.getEnable()).collect(Collectors.toList());
+        if (!templs.isEmpty()) {
+            for (ProEconAlarmConfiguration alarm : templs) {
+                if (alarm.getAlarmType().equals(AlarmTypeValue.WT.getCode())) {
+                    wtalarmls.add(alarm);
+                    alarmMap.put(alarm.getId(),alarm);
+                    StringBuilder sb=new StringBuilder();
+                    sb.append(alarm.getStationId()).append(alarm.getModelId());
+
+                    if(wtAlarmMap.containsKey(String.valueOf(sb)))
+                    {
+                        List<ProEconAlarmConfiguration> ls=wtAlarmMap.get(String.valueOf(sb));
+                        ls.add(alarm);
+                    }else
+                    {
+                        List<ProEconAlarmConfiguration> ls=new ArrayList<>();
+                        ls.add(alarm);
+                        wtAlarmMap.put(String.valueOf(sb),ls);
+                    }
+                } else if (alarm.getAlarmType().equals(AlarmTypeValue.BT.getCode())) {
+                    btalarmls.add(alarm);
+
+                }
+            }
+        }
+
+
+
+//        inputOrOutPutService.initialInputOrOutputSpeed();
+        logger.info("缓存结束------------------------------------------------------------");
+    }
+}

alarm-web/src/main/java/com/gyee/alarm/init/redis/RedisAutoConfiguration.java

@@ -0,0 +1,44 @@
+package com.gyee.alarm.init.redis;
+
+import org.springframework.boot.autoconfigure.condition.ConditionalOnClass;
+import org.springframework.boot.autoconfigure.condition.ConditionalOnMissingBean;
+import org.springframework.boot.autoconfigure.data.redis.RedisProperties;
+import org.springframework.boot.context.properties.EnableConfigurationProperties;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisOperations;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.core.StringRedisTemplate;
+
+import java.net.UnknownHostException;
+
+@Configuration
+@ConditionalOnClass(RedisOperations.class)
+@EnableConfigurationProperties(RedisProperties.class)
+public class RedisAutoConfiguration {
+
+
+    @Bean
+    @ConditionalOnMissingBean(name = "redisTemplate")
+    public RedisTemplate<Object, Object> redisTemplate(
+            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
+        RedisTemplate<Object, Object> template = new RedisTemplate<>();
+        template.setConnectionFactory(redisConnectionFactory);
+        return template;
+
+    }
+
+
+    @Bean
+    @ConditionalOnMissingBean
+    public StringRedisTemplate stringRedisTemplate(
+            RedisConnectionFactory redisConnectionFactory) throws UnknownHostException {
+        StringRedisTemplate template = new StringRedisTemplate();
+        template.setConnectionFactory(redisConnectionFactory);
+        return template;
+
+    }
+
+
+}

alarm-web/src/main/java/com/gyee/alarm/init/redis/RedisConfig.java

@@ -0,0 +1,47 @@
+package com.gyee.alarm.init.redis;
+
+import com.fasterxml.jackson.annotation.JsonAutoDetect;
+import com.fasterxml.jackson.annotation.PropertyAccessor;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.data.redis.connection.RedisConnectionFactory;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
+import org.springframework.data.redis.serializer.StringRedisSerializer;
+
+
+/**
+
+/**
+ *@ClassName RedisConfig
+ *@Description TODO
+ *@Author 谢生杰
+ *@Date 2020/9/14 10:42
+ *@Version 1.0
+ **/
+@Configuration
+public class RedisConfig {
+    @Bean
+    @SuppressWarnings("all")
+    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
+        RedisTemplate<String, Object> template = new RedisTemplate<String, Object>();
+        template.setConnectionFactory(factory);
+        Jackson2JsonRedisSerializer jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer(Object.class);
+        ObjectMapper om = new ObjectMapper();
+        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
+        om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
+        jackson2JsonRedisSerializer.setObjectMapper(om);
+        StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();
+        // key采用String的序列化方式
+        template.setKeySerializer(stringRedisSerializer);
+        // hash的key也采用String的序列化方式
+        template.setHashKeySerializer(stringRedisSerializer);
+        // value序列化方式采用jackson
+        template.setValueSerializer(jackson2JsonRedisSerializer);
+        // hash的value序列化方式采用jackson
+        template.setHashValueSerializer(jackson2JsonRedisSerializer);
+        template.afterPropertiesSet();
+        return template;
+    }
+}

alarm-web/src/main/java/com/gyee/alarm/init/redis/RedisService.java

@@ -0,0 +1,69 @@
+package com.gyee.alarm.init.redis;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public interface RedisService {
+
+
+    /**
+     * set存数据
+     * @param key
+     * @param value
+     * @return
+     */
+    boolean set(String key, String value);
+
+
+
+    /**
+     * get获取数据
+     * @param key
+     * @return
+     */
+    String get(String key);
+
+//    void getList(String key,int start,int end);
+
+    /**
+     * 设置有效天数
+     * @param key
+     * @param expire
+     * @return
+     */
+    boolean expire(String key, long expire);
+
+    /**
+     * 移除数据
+     * @param key
+     * @return
+     */
+    boolean remove(String key);
+
+
+    /**
+     * 插入对象
+     */
+    void setObject(Object o);
+
+
+    boolean hasKey(String key);
+
+    boolean hasKey(String key,String value);
+    void select(Integer dbIndex);
+
+    Set<String> keys(Integer dbIndex);
+
+    Object getHashObj(final String key,final String value);
+
+    void putHashAllObj(final String key,final Map<String,Object> value);
+    Map<Object,Object> getHashEntries(final String key);
+
+    void putHashAllPipeObj(final Map<String,Map<String,Object> >map);
+
+    Map<String,Map<String,String>> hgetall(Map<Integer, List<String>> pointmap);
+
+    void  unbindConnection();
+
+}

alarm-web/src/main/java/com/gyee/alarm/init/redis/RedisServiceImpl.java

@@ -0,0 +1,252 @@
+package com.gyee.alarm.init.redis;
+
+import org.springframework.dao.DataAccessException;
+import org.springframework.data.redis.connection.RedisConnection;
+import org.springframework.data.redis.connection.lettuce.LettuceConnectionFactory;
+import org.springframework.data.redis.core.RedisCallback;
+import org.springframework.data.redis.core.RedisConnectionUtils;
+import org.springframework.data.redis.core.RedisTemplate;
+import org.springframework.data.redis.serializer.RedisSerializer;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.lang.reflect.Field;
+import java.util.*;
+import java.util.concurrent.TimeUnit;
+
+@Service("redisService")
+public class RedisServiceImpl implements RedisService {
+    @Resource
+    private RedisTemplate<String, ?> redisTemplate;
+
+    @Override
+    public boolean set(final String key, final String value) {;
+
+
+        boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
+            @Override
+            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
+                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
+                connection.set(serializer.serialize(key), serializer.serialize(value));
+                return true;
+            }
+        });
+        return result;
+    }
+
+
+    @Override
+    public String get(final String key) {
+
+        String result = redisTemplate.execute(new RedisCallback<String>() {
+            @Override
+            public String doInRedis(RedisConnection connection) throws DataAccessException {
+                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
+                byte[] value = connection.get(serializer.serialize(key));
+                return serializer.deserialize(value);
+            }
+        });
+        return result;
+    }
+
+
+
+    @Override
+    public boolean expire(final String key, long expire) {
+
+
+        return redisTemplate.expire(key, expire, TimeUnit.SECONDS);
+    }
+
+    @Override
+    public boolean remove(final String key) {
+
+        boolean result = redisTemplate.execute(new RedisCallback<Boolean>() {
+            @Override
+            public Boolean doInRedis(RedisConnection connection) throws DataAccessException {
+                RedisSerializer<String> serializer = redisTemplate.getStringSerializer();
+                connection.del(key.getBytes());
+                return true;
+            }
+        });
+        return result;
+    }
+
+    @Override
+    public boolean hasKey(final String key) {
+
+        try {
+            return redisTemplate.hasKey(key);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+    @Override
+    public boolean hasKey(String key,String value){
+
+        try {
+            return redisTemplate.opsForHash().hasKey(key,value);
+        } catch (Exception e) {
+            e.printStackTrace();
+            return false;
+        }
+    }
+    @Override
+    public void setObject(Object obj) {
+        Field[] fields = obj.getClass().getDeclaredFields();
+        for(int i = 0 , len = fields.length; i < len; i++) {
+            // 对于每个属性，获取属性名
+            String varName = fields[i].getName();
+            try {
+                // 获取原来的访问控制权限
+                boolean accessFlag = fields[i].isAccessible();
+                // 修改访问控制权限
+                fields[i].setAccessible(true);
+                // 获取在对象f中属性fields[i]对应的对象中的变量
+                Object o;
+                try {
+                    o = fields[i].get(obj);
+                    if (o!=null){
+                        set(varName, String.valueOf(o));
+                    }else {
+                        set(varName,"");
+                    }
+
+                    //System.err.println("传入的对象中包含一个如下的变量：" + varName + " = " + o);
+                } catch (IllegalAccessException e) {
+                    // TODO Auto-generated catch block
+                    e.printStackTrace();
+                }
+                // 恢复访问控制权限
+                fields[i].setAccessible(accessFlag);
+            } catch (IllegalArgumentException ex) {
+                ex.printStackTrace();
+            }
+        }
+
+    }
+
+    public void select(Integer dbIndex) {
+
+        if (dbIndex == null || dbIndex > 15 || dbIndex < 0) {
+            dbIndex = 0;
+        }
+        LettuceConnectionFactory jedisConnectionFactory = (LettuceConnectionFactory) redisTemplate
+                .getConnectionFactory();
+        jedisConnectionFactory.setDatabase(dbIndex);
+        redisTemplate.setConnectionFactory(jedisConnectionFactory);
+        jedisConnectionFactory.afterPropertiesSet();
+        jedisConnectionFactory.resetConnection();
+
+    }
+
+
+    public Set<String> keys(Integer dbIndex) {
+        select(dbIndex);
+        return redisTemplate.keys("*");
+
+    }
+
+
+    public Object getHashObj(final String key,String value) {
+
+
+        Object result = redisTemplate.opsForHash().get(key,value);
+        return result;
+    }
+
+    public Map<Object,Object> getHashEntries(final String key) {
+
+
+        Map<Object,Object> result = redisTemplate.opsForHash().entries(key);
+        return result;
+    }
+
+    public void putHashAllObj(final String key,final Map<String,Object> value)
+    {
+
+        redisTemplate.opsForHash().putAll(key,value);
+    }
+
+    public void putHashAllPipeObj(final Map<String,Map<String,Object> >map)
+    {
+        RedisSerializer keySerializer = redisTemplate.getHashKeySerializer();
+        RedisSerializer valueSerializer = redisTemplate.getHashValueSerializer();
+        redisTemplate.executePipelined((RedisCallback) connection -> {
+            map.forEach((k, v) -> {
+                Map<byte[], byte[]> byteMap =new HashMap<>();
+                v.forEach((k2, v2) -> {
+                    byteMap.put(valueSerializer.serialize(k2),valueSerializer.serialize(v2));
+                });
+
+                connection.hMSet(keySerializer.serialize( k), byteMap);
+            });
+            return null;
+        });
+    }
+
+    /**
+     * 批量取hash数据
+     *
+     * @param hashKeys
+     * @return
+     */
+    public List<Object> hashGetBatch(List<String> hashKeys) {
+
+        List list = redisTemplate.executePipelined(new RedisCallback<String>() {
+            @Override
+            public String doInRedis(RedisConnection connection) throws DataAccessException {
+                for (String hashKey : hashKeys) {
+                    Map<byte[], byte[]> map= connection.hGetAll(hashKey.getBytes());
+                }
+                return null;
+            }
+        });
+        return list;
+    }
+
+    public Map<String,Map<String,String>> hgetall(Map<Integer,List<String>> pointmap) {
+
+        Map<String,Map<String,String> >map=new LinkedHashMap<>();
+
+        for(Map.Entry<Integer,List<String>> entry:pointmap.entrySet()){
+
+
+            select(entry.getKey());
+
+            redisTemplate.execute((RedisCallback<Map<String,Map<String,String>>>) con -> {
+
+
+
+                for(String key:entry.getValue())
+                {
+                    Map<byte[], byte[]> result = con.hGetAll(key.getBytes());
+                    if (result.isEmpty()) {
+                        return new HashMap<>(0);
+                    }
+
+                    Map<String, String> ans = new HashMap<>(result.size());
+                    for (Map.Entry<byte[], byte[]> entry2 : result.entrySet()) {
+                        ans.put(new String(entry2.getKey()), new String(entry2.getValue()));
+                    }
+                    map.put(key,ans);
+                }
+
+
+
+                return map;
+            });
+
+
+        };
+
+        return map;
+    }
+
+    public void unbindConnection() {
+
+
+        RedisConnectionUtils.unbindConnection(redisTemplate.getConnectionFactory());
+    }
+}

alarm-web/src/main/java/com/gyee/alarm/service/AlarmHistoryService.java

@@ -0,0 +1,109 @@
+package com.gyee.alarm.service;
+
+
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.baomidou.mybatisplus.core.metadata.IPage;
+import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
+
+import com.gyee.alarm.mapper.auto.AlarmTsMapper;
+import com.gyee.alarm.model.auto.ProEconElectricaltestPoint;
+import com.gyee.alarm.model.vo.AlarmSuperTalbeType;
+import com.gyee.alarm.model.vo.AlarmTsVo;
+import com.gyee.alarm.model.vo.AlarmTypeValue;
+import com.gyee.alarm.model.vo.AlarmVo;
+import com.gyee.common.model.StringUtils;
+import org.apache.ibatis.annotations.Param;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.*;
+import java.util.stream.Collectors;
+
+
+@Service
+
+public class AlarmHistoryService   {
+
+    @Resource
+    private AlarmTsMapper alarmTsMapper;
+
+
+    /**
+     * 查询报警信息接口
+     * @param begin 开始时间
+     * @param end 结束时间
+     * @param alarmType 报警类型
+     * @param stationid 场站
+     * @param description 描述
+     * @param pageNum 页数
+     * @param pageSize 每页多少条
+     * @return
+     */
+    public Map<String,Object> findAlarmlist(String modelId, long begin,long end ,String alarmType,String stationid,String deviceid,String description, int pageNum, int pageSize) {
+
+        Map<String,Object> map=new HashMap<>();
+
+        List<AlarmVo> vos =new ArrayList<>();
+        String superTableName= null;
+        StringBuilder descriptionSql=new StringBuilder();
+        if(StringUtils.notEmp(alarmType) && StringUtils.notEmp(begin) && StringUtils.notEmp(end) )
+        {
+
+//            whereSql.append(" where  ts>=").append(begin).append("  and ts<= ").append(end);
+//
+//            whereSql.append(" and alarmtype=CONCAT('',").append(alarmType).append(",'')");
+
+           if(AlarmTypeValue.BT.getCode().equals(alarmType))
+           {
+               superTableName= AlarmSuperTalbeType.BT.getCode();
+
+           }else if(AlarmTypeValue.WT.getCode().equals(alarmType))
+           {
+               superTableName= AlarmSuperTalbeType.WT.getCode();
+
+           }else if(AlarmTypeValue.CT.getCode().equals(alarmType))
+           {
+               superTableName= AlarmSuperTalbeType.CT.getCode();
+
+           }
+        }
+
+//        if(StringUtils.notEmp(stationid)  )
+//        {
+//            whereSql.append(" and stationid=CONCAT('',").append(stationid).append(",'')");
+//
+//        }
+//        if(StringUtils.notEmp(deviceid)  )
+//        {
+//            whereSql.append(" and deviceid= CONCAT('',").append(deviceid).append(",'')");
+//
+//        }
+//
+        if(StringUtils.notEmp(description)  )
+        {
+            descriptionSql.append("  %").append(description).append("%");
+            description=String.valueOf(descriptionSql);
+        }
+        if(StringUtils.empty(deviceid)  )
+        {
+            deviceid=null;
+        }
+
+        if(StringUtils.empty(modelId)  )
+        {
+            modelId=null;
+        }
+
+        if(StringUtils.empty(description)  )
+        {
+            description=null;
+        }
+        vos = alarmTsMapper.selectByWtLimit(begin,end,modelId,superTableName, alarmType, stationid, deviceid, description, pageNum*pageSize, (pageNum*pageSize+pageSize));
+        map.put("ls",vos);
+        int total=alarmTsMapper.selectByWtCount(begin,end,modelId,superTableName, alarmType, stationid, deviceid, description);
+        map.put("total",total);
+        return map;
+    }
+
+}

alarm-web/src/main/java/com/gyee/alarm/service/AlarmReportService.java

@@ -0,0 +1,174 @@
+package com.gyee.alarm.service;
+
+import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
+import com.gyee.alarm.init.CacheContext;
+import com.gyee.alarm.mapper.auto.AlarmTsMapper;
+import com.gyee.alarm.model.auto.ProBasicEarlyWarnScore;
+import com.gyee.alarm.model.auto.ProBasicEquipment;
+import com.gyee.alarm.model.auto.ProEconAlarmConfiguration;
+import com.gyee.alarm.model.vo.AlarmSuperTalbeType;
+import com.gyee.alarm.model.vo.AlarmTsVo;
+import com.gyee.alarm.model.vo.EarlyWarnScoreVo;
+import com.gyee.alarm.service.auto.IProBasicEarlyWarnScoreService;
+import com.gyee.alarm.util.DateUtils;
+import com.gyee.alarm.util.SnowflakeGenerator;
+
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+
+import java.util.Date;
+import java.util.List;
+
+
+@Service
+public class AlarmReportService {
+
+    @Resource
+    private AlarmTsMapper alarmTsMapper;
+
+    @Resource
+    private IProBasicEarlyWarnScoreService proBasicEarlyWarnScoreService;
+
+
+
+    public boolean startCount() throws Exception{
+
+
+            Date currentDate = DateUtils.truncate(DateUtils.addDays(new Date(), -1));
+            Date endData=DateUtils.truncate(new Date());
+            List<ProBasicEquipment> wtList = CacheContext.wtls;
+
+            for (ProBasicEquipment wt : wtList) {
+
+                    ProBasicEarlyWarnScore ews = new ProBasicEarlyWarnScore();
+                    ews.setId(SnowflakeGenerator.generateId() + "");
+                    ews.setWindturbineId(wt.getId());
+                    ews.setStatdate(currentDate);
+                    
+                  
+                    List<AlarmTsVo> listInfo = alarmTsMapper.selectByWtGroup(AlarmSuperTalbeType.WT.getCode(),wt.getId(), currentDate.getTime(),endData.getTime());
+
+                    if (listInfo != null && listInfo.size() > 0) {
+                        for (AlarmTsVo aci : listInfo) {
+
+
+                            if(CacheContext.alarmMap.containsKey(aci.getAlarmid()))
+                            {
+                                ProEconAlarmConfiguration alarm=CacheContext.alarmMap.get(aci.getAlarmid());
+
+                                EarlyWarnScoreVo scoreOne = getEarlyWarnScoreOne(alarm,aci);
+                                ews.setTotalScore(ews.getTotalScore() + scoreOne.getTotalscore());
+                                ews.setBjxtScore(ews.getBjxtScore() + scoreOne.getBjxtscore());
+                                ews.setZcScore(ews.getZcScore() + scoreOne.getCdlscore());
+                                ews.setCfxtScore(ews.getCfxtScore() + scoreOne.getCfxtscore());
+                                ews.setClxScore(ews.getClxScore() + scoreOne.getClxscore());
+                                ews.setFdjScore(ews.getFdjScore() + scoreOne.getFdjscore());
+                                ews.setZkgScore(ews.getZkgScore() + scoreOne.getZkgscore());
+                                ews.setJcScore(ews.getJcScore() + scoreOne.getJcscore());
+                                ews.setSensorScore(ews.getSensorScore() + scoreOne.getSensorscore());
+                                ews.setPartsScore(ews.getPartsScore() + scoreOne.getPartsscore());
+                                ews.setControlScore(ews.getControlScore() + scoreOne.getControlscore());
+                                ews.setPerformanceScore(ews.getPerformanceScore() + scoreOne.getPerformancescore());
+                                ews.setOtherScore(ews.getOtherScore() + scoreOne.getOtherscore());
+
+                            }
+
+
+                        }
+                    }
+
+                    proBasicEarlyWarnScoreService.save(ews);
+
+
+            }
+
+        return true;
+    }
+
+    private EarlyWarnScoreVo getEarlyWarnScoreOne( ProEconAlarmConfiguration alarm,AlarmTsVo info) {
+        EarlyWarnScoreVo scoreOne = new EarlyWarnScoreVo();
+        double score = getScore(info);
+        scoreOne.setTotalscore(score);
+        if (alarm.getCharacteristic() == null) {
+            scoreOne.setOtherscore(score);
+        } else {
+            switch (alarm.getCharacteristic()) {
+                case "sensors":
+                    scoreOne.setSensorscore(score);
+                    break;
+                case "parts":
+                    scoreOne.setPartsscore(score);
+                    break;
+                case "control":
+                    scoreOne.setControlscore(score);
+                    break;
+                case "performance":
+                    scoreOne.setPerformancescore(score);
+                    break;
+                default:
+                    scoreOne.setOtherscore(score);
+            }
+        }
+        if (alarm.getComponents() == null) {
+            scoreOne.setJcscore(score);
+        } else {
+            switch (alarm.getComponents()) {
+                case "CFXT":
+                    scoreOne.setCfxtscore(score);
+                    break;
+                case "CLX":
+                    scoreOne.setClxscore(score);
+                    break;
+                case "FDJ":
+                    scoreOne.setFdjscore(score);
+                    break;
+                case "CDL":
+                    scoreOne.setCdlscore(score);
+                    break;
+                case "BJXT":
+                    scoreOne.setBjxtscore(score);
+                    break;
+                case "ZKG":
+                    scoreOne.setZkgscore(score);
+                    break;
+                default:
+                    scoreOne.setJcscore(score);
+            }
+
+        }
+        return scoreOne;
+    }
+
+    private double getScore(AlarmTsVo info) {
+        if (info.getRank() == null) {
+            return 1;
+        }
+        switch (info.getRank()) {
+            case 5:
+                return getFreqScore(info, 10);
+            case 4:
+                return getFreqScore(info, 7);
+            case 3:
+                return getFreqScore(info, 4);
+            default:
+                return 1;
+        }
+    }
+
+    private double getFreqScore(AlarmTsVo info, double baseScore) {
+
+
+        if (info.getTimeLong() > 60)
+            return baseScore;
+        else if (info.getTimeLong() > 10)
+            return baseScore - 1;
+        else {
+            if (info.getVal() > 10)
+                return baseScore - 1;
+            else
+                return baseScore - 2;
+        }
+    }
+
+}

alarm-web/src/main/java/com/gyee/alarm/service/initalcache/CacheService.java

@@ -0,0 +1,268 @@
+package com.gyee.alarm.service.initalcache;/*
+@author   谢生杰
+@date   2022/11/3-9:14
+*/
+
+import com.alibaba.fastjson.JSONObject;
+import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
+import com.gyee.alarm.model.auto.*;
+import com.gyee.alarm.service.auto.*;
+import com.gyee.alarm.init.redis.RedisService;
+import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.stereotype.Service;
+
+import javax.annotation.Resource;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Collectors;
+
+@Service
+@Slf4j
+public class CacheService {
+
+    @Autowired
+    private RedisService redisService;
+    @Autowired
+    private IProBasicEquipmentService windturbineService;
+    @Autowired
+    private IProBasicLineService lineService;
+    @Autowired
+    private IProBasicProjectService projectService;
+    @Resource
+    private IProBasicSubStationService subStationService;
+    @Autowired
+    private IProBasicPowerstationService windpowerstationService;
+    @Autowired
+    private IProBasicEquipmentPointService windturbinetestingpointnewService;
+    @Autowired
+    private IProBasicPowerstationPointService windpowerstationpointnewService;
+    @Autowired
+    private IProBasicCompanyService companyService;
+    @Autowired
+    private IProBasicRegionService regionsService;
+    @Resource
+    private IProBasicModelPowerRdService proBasicModelPowerRdService;
+    @Resource
+    private IProBasicStatusPointService proBasicStatusPointService;
+    @Resource
+    private IProBasicWeatherStationService proBasicWeatherStationService;
+    @Resource
+    private IProBasicSquareService proBasicSquareService;
+    @Resource
+    private IProBasicBranchService proBasicBranchService;
+    @Resource
+    private IProBasicEnergyGroupService energyGroupService;
+
+
+    public void initRedisCache(){
+        log.info("--------------------------redisWT");
+        List<ProBasicEquipment> windturbineList = windturbineService.list().stream().filter(i->i.getIsable().equals(1)).collect(Collectors.toList());
+        windturbineList.stream().forEach(i->{
+            Map<String, ProBasicEquipmentPoint> codeaimap = new HashMap<>();
+            QueryWrapper<ProBasicEquipmentPoint> qw = new QueryWrapper<>();
+            qw.eq("windturbine_id",i.getId());
+            List<ProBasicEquipmentPoint> windturbinetestingpointai2List = windturbinetestingpointnewService.list(qw);
+            windturbinetestingpointai2List.stream().forEach(x->{
+                codeaimap.put(x.getUniformCode(),x);
+            });
+            String s = JSONObject.toJSONString(codeaimap);
+            redisService.set(i.getId(),s);
+        });
+
+        log.info("--------------------------redisZL");
+//        List<ProBasicBranch> branchList = proBasicBranchService.list().stream().filter(i->i.getIsAble().equals(1)).collect(Collectors.toList());
+//        if (StringUtils.isNotEmpty(branchList)){
+//            branchList.stream().forEach(i->{
+//                Map<String, ProBasicEquipmentPoint> codeaimap = new HashMap<>();
+//                QueryWrapper<ProBasicEquipmentPoint> qw = new QueryWrapper<>();
+//                qw.eq("windturbine_id",i.getId());
+//                List<ProBasicEquipmentPoint> windturbinetestingpointai2List = windturbinetestingpointnewService.list(qw);
+//                windturbinetestingpointai2List.stream().forEach(x->{
+//                    codeaimap.put(x.getUniformCode(),x);
+//                });
+//                String s = JSONObject.toJSONString(codeaimap);
+//                redisService.set(i.getId(),s);
+//            });
+//        }
+
+        log.info("--------------------------redisSQ");
+        List<ProBasicSquare> squareList = proBasicSquareService.list().stream().filter(i->i.getIsAble().equals(1)).collect(Collectors.toList());
+        squareList.stream().forEach(i->{
+            Map<String, ProBasicPowerstationPoint> codeaimap = new HashMap<>();
+            QueryWrapper<ProBasicPowerstationPoint> qw = new QueryWrapper<>();
+            qw.eq("windpowerstation_id",i.getId());
+            List<ProBasicPowerstationPoint> windpowerstationtestingpoint2List = windpowerstationpointnewService.list(qw);
+            windpowerstationtestingpoint2List.stream().forEach(x->{
+                codeaimap.put(x.getUniformCode(),x);
+            });
+            String s = JSONObject.toJSONString(codeaimap);
+            redisService.set(i.getId(),s);
+        });
+
+        log.info("--------------------------redisLN");
+        List<ProBasicLine> lineList = lineService.list().stream().filter(i->i.getIsAble().equals(1)).collect(Collectors.toList());
+        lineList.stream().forEach(i->{
+            Map<String, ProBasicPowerstationPoint> codeaimap = new HashMap<>();
+            QueryWrapper<ProBasicPowerstationPoint> qw = new QueryWrapper<>();
+            qw.eq("windpowerstation_id",i.getId());
+            List<ProBasicPowerstationPoint> windpowerstationtestingpoint2List = windpowerstationpointnewService.list(qw);
+            windpowerstationtestingpoint2List.stream().forEach(x->{
+                codeaimap.put(x.getUniformCode(),x);
+            });
+            String s = JSONObject.toJSONString(codeaimap);
+            redisService.set(i.getId(),s);
+        });
+
+
+
+        log.info("--------------------------redisPJ");
+        List<ProBasicProject> projectList = projectService.list().stream().filter(i->i.getIsAble().equals(1)).collect(Collectors.toList());
+        projectList.stream().forEach(i->{
+            Map<String, ProBasicPowerstationPoint> codeaimap = new HashMap<>();
+            QueryWrapper<ProBasicPowerstationPoint> qw = new QueryWrapper<>();
+            qw.eq("windpowerstation_id",i.getId());
+            List<ProBasicPowerstationPoint> windpowerstationtestingpoint2List = windpowerstationpointnewService.list(qw);
+            windpowerstationtestingpoint2List.stream().forEach(x->{
+                codeaimap.put(x.getUniformCode(),x);
+            });
+            String s = JSONObject.toJSONString(codeaimap);
+            redisService.set(i.getId(),s);
+        });
+
+        log.info("--------------------------redisSubWP");
+        List<ProBasicSubStation> subStationList = subStationService.list().stream().filter(i->i.getIsAble().equals(1)).collect(Collectors.toList());
+        subStationList.stream().forEach(i->{
+            Map<String, ProBasicPowerstationPoint> codeaimap = new HashMap<>();
+            QueryWrapper<ProBasicPowerstationPoint> qw = new QueryWrapper<>();
+            qw.eq("windpowerstation_id",i.getId());
+            List<ProBasicPowerstationPoint> windpowerstationtestingpoint2List = windpowerstationpointnewService.list(qw);
+            windpowerstationtestingpoint2List.stream().forEach(x->{
+                codeaimap.put(x.getUniformCode(),x);
+            });
+            String s = JSONObject.toJSONString(codeaimap);
+            redisService.set(i.getId(),s);
+        });
+
+        log.info("--------------------------redisWeatherWP");
+        List<ProBasicWeatherStation> weatherStationList = proBasicWeatherStationService.list().stream().filter(i->i.getIsAble().equals(1)).collect(Collectors.toList());
+        weatherStationList.stream().forEach(i->{
+            Map<String, ProBasicPowerstationPoint> codeaimap = new HashMap<>();
+            QueryWrapper<ProBasicPowerstationPoint> qw = new QueryWrapper<>();
+            qw.eq("windpowerstation_id",i.getId());
+            List<ProBasicPowerstationPoint> windpowerstationtestingpoint2List = windpowerstationpointnewService.list(qw);
+            windpowerstationtestingpoint2List.stream().forEach(x->{
+                codeaimap.put(x.getUniformCode(),x);
+            });
+            String s = JSONObject.toJSONString(codeaimap);
+            redisService.set(i.getId(),s);
+        });
+
+        log.info("--------------------------redisWP");
+        List<ProBasicPowerstation> wpList = windpowerstationService.list().stream().filter(i->i.getIsAble().equals(1)).collect(Collectors.toList());
+
+        wpList.stream().forEach(i->{
+            Map<String, ProBasicPowerstationPoint> codeaimap = new HashMap<>();
+            QueryWrapper<ProBasicPowerstationPoint> qw = new QueryWrapper<>();
+            qw.eq("windpowerstation_id",i.getId());
+            List<ProBasicPowerstationPoint> windpowerstationtestingpoint2List = windpowerstationpointnewService.list(qw);
+            windpowerstationtestingpoint2List.stream().forEach(x->{
+                codeaimap.put(x.getUniformCode(),x);
+            });
+            String s = JSONObject.toJSONString(codeaimap);
+            redisService.set(i.getId(),s);
+        });
+
+        log.info("--------------------------redisCOMPANY");
+        List<ProBasicCompany> coms = companyService.list().stream().filter(i->i.getIsAble().equals(1)).collect(Collectors.toList());
+//        List<String> comList = coms.stream().map(i->i.getId()).collect(Collectors.toList());
+        List<String> comList = new ArrayList<>();
+        coms.stream().forEach(company -> {
+            comList.add(company.getId()+"0");
+            comList.add(company.getId()+"-1");
+            comList.add(company.getId()+"-2");
+        });
+        comList.stream().forEach(i->{
+            Map<String, ProBasicPowerstationPoint> codeaimap = new HashMap<>();
+            QueryWrapper<ProBasicPowerstationPoint> qw = new QueryWrapper<>();
+            qw.eq("windpowerstation_id",i);
+            List<ProBasicPowerstationPoint> windpowerstationtestingpoint2List = windpowerstationpointnewService.list(qw);
+            windpowerstationtestingpoint2List.stream().forEach(x->{
+                codeaimap.put(x.getUniformCode(),x);
+            });
+            String s = JSONObject.toJSONString(codeaimap);
+            redisService.set(i,s);
+        });
+
+        log.info("--------------------------redisREGION");
+        List<ProBasicRegion> regs = regionsService.list().stream().filter(i->i.getIsAble().equals(1)).collect(Collectors.toList());
+        List<String> regList = new ArrayList<>();
+//        List<String> regList = regs.stream().map(i->i.getId()).collect(Collectors.toList());
+        regs.stream().forEach(region -> {
+            regList.add(region.getId()+"0");
+            regList.add(region.getId()+"-1");
+            regList.add(region.getId()+"-2");
+        });
+        regList.stream().forEach(i->{
+            Map<String, ProBasicPowerstationPoint> codeaimap = new HashMap<>();
+            QueryWrapper<ProBasicPowerstationPoint> qw = new QueryWrapper<>();
+            qw.eq("windpowerstation_id",i);
+            List<ProBasicPowerstationPoint> windpowerstationtestingpoint2List = windpowerstationpointnewService.list(qw);
+            windpowerstationtestingpoint2List.stream().forEach(x->{
+                codeaimap.put(x.getUniformCode(),x);
+            });
+            String s = JSONObject.toJSONString(codeaimap);
+            redisService.set(i,s);
+        });
+        log.info("--------------------------redisGroup");
+        List<ProBasicEnergyGroup> groups = energyGroupService.list().stream().filter(i->i.getIsAble().equals(1) && !i.getParentid().equals("0")).collect(Collectors.toList());
+        List<String> groupList = new ArrayList<>();
+//        List<String> regList = regs.stream().map(i->i.getId()).collect(Collectors.toList());
+        groups.stream().forEach(group -> {
+            groupList.add(group.getId()+"0");
+            groupList.add(group.getId()+"-1");
+            groupList.add(group.getId()+"-2");
+        });
+        groupList.stream().forEach(i->{
+            Map<String, ProBasicPowerstationPoint> codeaimap = new HashMap<>();
+            QueryWrapper<ProBasicPowerstationPoint> qw = new QueryWrapper<>();
+            qw.eq("windpowerstation_id",i);
+            List<ProBasicPowerstationPoint> windpowerstationtestingpoint2List = windpowerstationpointnewService.list(qw);
+            windpowerstationtestingpoint2List.stream().forEach(x->{
+                codeaimap.put(x.getUniformCode(),x);
+            });
+            String s = JSONObject.toJSONString(codeaimap);
+            redisService.set(i,s);
+        });
+        log.info("--------------------------redis理论保证功率");
+        Map<String, Map<Double,ProBasicModelPowerRd>> powerrdMap = new HashMap<>();
+
+        List<ProBasicModelPowerRd> proBasicModelPowerRds = proBasicModelPowerRdService.list();
+        proBasicModelPowerRds.stream().forEach(powerrd->{
+            if (powerrdMap.containsKey(powerrd.getModelId())){
+                powerrdMap.get(powerrd.getModelId()).put(powerrd.getSpeed(),powerrd);
+            }else {
+                Map<Double,ProBasicModelPowerRd> powerMap = new HashMap<>();
+                powerMap.put(powerrd.getSpeed(),powerrd);
+                powerrdMap.put(powerrd.getModelId(),powerMap);
+            }
+        });
+        redisService.set("ZLLGL", JSONObject.toJSONString(powerrdMap));
+
+        log.info("--------------------------redis十三种状态");
+        Map<String,List<ProBasicStatusPoint>> sszztMap = new HashMap<>();
+        List<ProBasicStatusPoint> windturbinestatusdis = proBasicStatusPointService.list();
+        windturbinestatusdis.stream().forEach(w->{
+            if (sszztMap.containsKey(w.getWindturbineId())){
+                sszztMap.get(w.getWindturbineId()).add(w);
+            }else {
+                List<ProBasicStatusPoint> wdisList = new ArrayList<>();
+                wdisList.add(w);
+                sszztMap.put(w.getWindturbineId(),wdisList);
+            }
+        });
+        redisService.set("SSZZT",JSONObject.toJSONString(sszztMap));
+    }
+}