sis/web/runeconomy-xk/src/main/java/com/gyee/runeconomy/init/CacheContext.java

package com.gyee.runeconomy.init;


import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.gyee.common.model.StringUtils;
import com.gyee.runeconomy.model.auto.*;
import com.gyee.runeconomy.service.auto.*;
import com.gyee.runeconomy.service.realtimelibrary.TheoreticalPowerService;
import com.gyee.runeconomy.util.redis.RedisService;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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);

    private final String QS = "0";

    @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 IProBasicWindturbinePowerService proBasicWindturbinePowerService;
    @Resource
    private RedisService redisService;
    @Resource
    private IProBasicModelPowerService proBasicModelPowerService;
    @Resource
    private IProBasicSubStationService proBasicSubStationService;
    @Resource
    private IProBasicWeatherStationService proBasicWeatherStationService;
    @Resource
    private IProBasicSquareService proBasicSquareService;
    @Resource
    private IProBasicCompanyService proBasicCompanyService;
    @Resource
    private IProBasicRegionService proBasicRegionService;
    @Resource
    private IProBasicEnergyGroupService proBasicEnergyGroupService;
    @Resource
    private TheoreticalPowerService theoreticalPowerService;

    @Resource
    private IProBasicModelPowerRdService proBasicModelPowerRdService;

    @Resource
    private IProBasicPowerstationPointService proBasicPowerstationPointService;

    @Resource
    private IProBasicEquipmentPointService proBasicEquipmentPointService;

    public static List<ProBasicEquipment> wtls = 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 List<ProBasicWeatherStation>  weawpls = new ArrayList<>();
    public static List<ProBasicSquare> sqls = new ArrayList<>();
    public static List<ProBasicPowerstation>  wpls = new ArrayList<>();
    public static List<ProBasicPowerstation>  wplsf = new ArrayList<>();
    public static List<ProBasicPowerstation>  wplsG = 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>  gpls = new ArrayList<>();
    public static List<ProBasicPowerstationPoint> powerpointls = new ArrayList<>();
    public static List<ProBasicEquipmentPoint> Equipmentpointls = 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,ProBasicCompany> cpmap = new HashMap<>();
    public static Map<String,ProBasicEnergyGroup> gpmap = new HashMap<>();

    public static Map<String,List<ProBasicPowerstation>> cpwpmap = new HashMap<>();
    public static Map<String,List<ProBasicPowerstation>> wpmapls = new HashMap<>();
    public static Map<String,List<ProBasicPowerstation>> stationls = 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<ProBasicProject>> projmap = 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 Map<String,List<ProBasicEquipment>> cmwtlsmap = new HashMap<>();
    public static Map<String,List<ProBasicEquipment>> rgwtlsmap = new HashMap<>();
    public static Map<String,Map<String,ProBasicEquipment>> cmwtmap = 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, ProBasicEquipmentPoint>> wtpointmap = new HashMap<>();//风机测点
    public static Map<String,Map<String, ProBasicPowerstationPoint>> linepointmap =new HashMap<>();
    public static Map<String,Map<String, ProBasicPowerstationPoint>> lnPointmap =new HashMap<>();//线路测点
    public static Map<String,Map<String, ProBasicPowerstationPoint>> propointmap =new HashMap<>();
    public static Map<String,Map<String, ProBasicPowerstationPoint>> pjPointmap =new HashMap<>(); //期次测点
    public static Map<String,Map<String, ProBasicPowerstationPoint>> wppointmap =new HashMap<>();
    public static Map<String,Map<String, ProBasicPowerstationPoint>> pointwpmap =new HashMap<>();
    public static Map<String,Map<String, ProBasicPowerstationPoint>> subwppointmap =new HashMap<>();
    public static Map<String,Map<String, ProBasicPowerstationPoint>> weatherwppointmap =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<>();

    @Override
    public void run(String... args) throws Exception {
        logger.info("缓存开始------------------------------------------------------------");

        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->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);
                }
            }
        }

        List<ProBasicEnergyGroup> energyGroups = proBasicEnergyGroupService.list();
        gpls = energyGroups.stream().filter(e->e.getIsAble()==1 && e.getId().endsWith("FGS")).collect(Collectors.toList());

        if  (!gpls.isEmpty())
        {
            for(ProBasicEnergyGroup gp:gpls)
            {
                gpmap.put(gp.getId(),gp);

                if (redisService.hasKey(gp.getId()+"0")){
                    String cp0String = redisService.get(gp.getId()+"0");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp0String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    grouppointmap.put(gp.getId()+"0",stringWindpowerstationpointnewMap);
                }
                if (redisService.hasKey(gp.getId()+"-1")){
                    String cp1String = redisService.get(gp.getId()+"-1");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp1String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    grouppointmap.put(gp.getId()+"-1",stringWindpowerstationpointnewMap);
                }
                if (redisService.hasKey(gp.getId()+"-2")){
                    String cp2String = redisService.get(gp.getId()+"-2");
                    Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(cp2String, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
                    });
                    grouppointmap.put(gp.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);
            }
        }


        wtls = proBasicEquipmentService.list().stream().filter(i->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.getId(),equipmentmodel.getPowerProduction().doubleValue());
            }


            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 (cmwtlsmap.containsKey(wt.getCompanyId())){
                cmwtlsmap.get(wt.getCompanyId()).add(wt);
            }else {
                List<ProBasicEquipment> cmls = new ArrayList<>();
                cmls.add(wt);
                cmwtlsmap.put(wt.getCompanyId(),cmls);
            }
            if (rgwtlsmap.containsKey(wt.getRegionId())){
                rgwtlsmap.get(wt.getRegionId()).add(wt);
            }else {
                List<ProBasicEquipment> rgls = new ArrayList<>();
                rgls.add(wt);
                rgwtlsmap.put(wt.getRegionId(),rgls);
            }

            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);
            }

            if (cmwtmap.containsKey(wt.getCompanyId())){
                cmwtmap.get(wt.getCompanyId()).put(wt.getId(),wt);
            }else {
                Map<String,ProBasicEquipment> map=new HashMap<>();
                map.put(wt.getId(),wt);
                cmwtmap.put(wt.getCompanyId(),map);
            }
        });

        //初始化标杆风机
        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-> 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);

        });
        projmap = pjls.stream().collect(Collectors.groupingBy(ProBasicProject::getWindpowerstationId));

        subwpls = proBasicSubStationService.list().stream().filter(i-> i.getIsAble()==1).collect(Collectors.toList());
        subwpls.stream().forEach(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);

        });

        weawpls = proBasicWeatherStationService.list().stream().filter(i-> i.getIsAble()==1).collect(Collectors.toList());
        weawpls.stream().forEach(weather->{

            String subString = redisService.get(weather.getId());
            Map<String, ProBasicPowerstationPoint> stringWindpowerstationpointnewMap = JSONObject.parseObject(subString, new TypeReference<Map<String, ProBasicPowerstationPoint>>() {
            });
            weatherwppointmap.put(weather.getId(),stringWindpowerstationpointnewMap);


        });
        //线路
        lnls = proBasicLineService.list().stream().filter(i-> StringUtils.isNotNull(pjmap.get(i.getProjectId())) && 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->i.getIsAble()==1).collect(Collectors.toList());;
        wpls = proBasicWindpowerstationService.list().stream().filter(i->i.getIsAble()==1).collect(Collectors.toList());;
        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);
            }
        }
        meterpoints = proBasicMeterPointService.list().stream().filter(i->i.getIsAble()==1).collect(Collectors.toList());
        meterpoints.stream().forEach(meterpoint -> {
            meterpointMap.put(meterpoint.getId(),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);
        });

        if (!wpls.isEmpty()) {
            for (ProBasicPowerstation wp : wpls) {
                if (wp.getId().endsWith("FDC_STA")) {
                    wplsf.add(wp);
                }
                if (wp.getId().endsWith("GDC_STA")) {
                    wplsG.add(wp);
                }

                if(wpmapls.containsKey(wp.getId()))
                {
                    List<ProBasicPowerstation> ls=wpmapls.get(wp.getId());
                    ls.add(wp);
                    wpmapls.put(wp.getId(),ls);
                }else {
                    List<ProBasicPowerstation> ls=new ArrayList<>();
                    ls.add(wp);
                    wpmapls.put(wp.getId(),ls);
                }


//                if(wp.getWindType().equals(-1) && wp.getWindType().equals(-2)){
//                    List<ProBasicPowerstation> ls = stationls.get(wp.getWindType());
//                    stationls.put(wp.getWindType()+QS,ls);
//                }


                wpmap.put(wp.getId(),wp);
            }
        }


        Map<String,ProBasicPowerstationPoint> items=null;
        powerpointls = proBasicPowerstationPointService.list().stream().filter(i ->i.getId() != null).collect(Collectors.toList());
        if(powerpointls!=null && !powerpointls.isEmpty()){
            for(int i=0;i<powerpointls.size();i++){

                if(pjmap.containsKey(powerpointls.get(i).getWindpowerstationId()))
                {
                    ProBasicPowerstationPoint point=powerpointls.get(i);
                    if(pjPointmap.containsKey(point.getWindpowerstationId())){
                        items=pjPointmap.get(point.getWindpowerstationId());
                        items.put(point.getUniformCode(), point);
                    }
                    else{
                        items=new HashMap<String,ProBasicPowerstationPoint>();
                        pjPointmap.put(point.getWindpowerstationId(), items);
                        items.put(point.getUniformCode(), point);
                    }
                }else if(lnmap.containsKey(powerpointls.get(i).getWindpowerstationId()))
                {
                    ProBasicPowerstationPoint point=powerpointls.get(i);
                    if(lnPointmap.containsKey(point.getWindpowerstationId())){
                        items=lnPointmap.get(point.getWindpowerstationId());
                        items.put(point.getUniformCode(), point);
                    }
                    else{
                        items=new HashMap<String,ProBasicPowerstationPoint>();
                        lnPointmap.put(point.getWindpowerstationId(), items);
                        items.put(point.getUniformCode(), point);
                    }
                }else
                {
                    ProBasicPowerstationPoint point = powerpointls.get(i);
                    if(pointwpmap.containsKey(point.getWindpowerstationId())){
                        items=pointwpmap.get(point.getWindpowerstationId());
                        items.put(point.getUniformCode(), point);
                    }
                    else{
                        items=new HashMap<String,ProBasicPowerstationPoint>();
                        pointwpmap.put(point.getWindpowerstationId(), items);
                        items.put(point.getUniformCode(), point);
                    }
                }
            }
        }




        String llglString = redisService.get("ZLLGL");
        theoreticalPowerMap = JSONObject.parseObject(llglString, new TypeReference<Map<String, Map<Double,ProBasicModelPowerRd>>>() {
        });

        llglString = redisService.get("ZLLGLLS");
        theoreticalPowerList=  JSONObject.parseObject(llglString, new TypeReference<List<ProBasicModelPowerRd>>() {
        });

        String sszzt = redisService.get("SSZZT");
        statusMap = JSONObject.parseObject(sszzt, new TypeReference<Map<String,List<ProBasicStatusPoint>>>() {
        });



        logger.info("缓存结束------------------------------------------------------------");
    }
}