changes

liuhaonan

2022-09-23 af4cd17b9851e940dd1dc8a43b3b21fbdd452f76

 ximon-admin/src/main/java/com/sandu/ximon/admin/service/VnnoxService.java

@@ -1,25 +1,32 @@
package com.sandu.ximon.admin.service;

import cn.hutool.core.collection.CollectionUtil;
import com.sandu.common.execption.BusinessException;
import com.sandu.common.util.SpringContextHolder;
import com.sandu.ximon.admin.config.VnnoxConstant;
import com.sandu.ximon.admin.utils.RedisUtils;
import com.sandu.ximon.admin.utils.VnnoxAPIUtil;
import com.sandu.ximon.admin.manager.iot.frame.inner.report.A5AtmosphereHeartbeatReportInnerFrame;
import com.sandu.ximon.admin.security.SecurityUtils;
import com.sandu.ximon.admin.utils.*;
import com.sandu.ximon.admin.utils.request.VnnoxScreenStatusType;
import com.sandu.ximon.admin.utils.response.VnnoxPlayerListResponse;
import com.sandu.ximon.admin.utils.response.VnnoxPlayerResponse;
import com.sandu.ximon.admin.utils.response.VnnoxResult;
import com.sandu.ximon.admin.utils.response.VnnoxResultResponse;
import com.sandu.ximon.admin.vo.NovaAStateInfoVO;
import com.sandu.ximon.admin.vo.NovaPushResultVO;
import com.sandu.ximon.admin.vo.NovaScreenShorUrlVO;
import com.sandu.ximon.admin.vo.NovaWeatherVO;
import com.sandu.ximon.dao.domain.LedPlayerEntity;
import com.sandu.ximon.dao.domain.LedPlayerInfoEntity;
import com.sandu.ximon.dao.domain.LedV2RegisterResultEntity;
import com.sandu.ximon.dao.enums.PoleBindingEnums;
import lombok.AllArgsConstructor;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import java.net.URISyntaxException;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.time.LocalDateTime;
import java.util.*;
import java.util.stream.Collectors;

/**
@@ -31,12 +38,15 @@
@AllArgsConstructor
public class VnnoxService {

    // @Autowired

    private VnnoxAPIUtil vnnoxAPIUtil;
    // @Autowired

    private RedisUtils redisUtils;
    // @Autowired

    private LedPlayerEntityService ledPlayerEntityService;

    private VnnoxProgramAPIUtil vnnoxProgramAPIUtil;
    private CountDownLatchUtil countDownLatchUtil;

    /**
     * 设备校验注册
@@ -98,7 +108,15 @@
     * @param screenStatus
     * @return
     */
    public VnnoxResult screenStatusChange(List<LedPlayerEntity> playerList, Integer screenStatus) {
    public Map<String, Object> screenStatusChange(List<LedPlayerEntity> playerList, Integer screenStatus) {
        playerList.forEach(item -> {
            if (item.getName() == null || item.getPlayerId() == null) {
                throw new BusinessException("playerId或playerName为空");
            }
            if (item.getPlayerId().isEmpty() || item.getName().isEmpty()) {
                throw new BusinessException("playerId或playerName为空");
            }
        });
        VnnoxScreenStatusType type;
        if (screenStatus.equals(0)) {
            type = VnnoxScreenStatusType.CLOSE;
@@ -106,39 +124,121 @@
            type = VnnoxScreenStatusType.OPEN;
        }

        VnnoxResult vnnoxResult = vnnoxAPIUtil.screenStatus(
                playerList.stream().map(item -> item.getPlayerId()).collect(Collectors.toList()),
                type
        );
        VnnoxResult vnnoxResult = vnnoxAPIUtil.screenStatus(playerList.stream().map(item -> item.getPlayerId()).collect(Collectors.toList()), type);


        List<String> success = vnnoxResult.getSuccess();
        List<String> fail = vnnoxResult.getFail();
        //拼接成功失败的结果
        Map<String, Object> result = new HashMap<>();
        List<NovaPushResultVO> successList = new ArrayList<>();
        List<NovaPushResultVO> faileList = new ArrayList<>();
        List<String> finalSuccess = success;
        List<String> finalFail = fail;
        playerList.forEach(n -> {
            if (finalSuccess.contains(n.getPlayerId())) {
                NovaPushResultVO vo = new NovaPushResultVO();
                vo.setName(n.getName());
                vo.setPlayerId(n.getPlayerId());
                successList.add(vo);
            } else if (finalFail.contains(n.getPlayerId())) {
                NovaPushResultVO vo = new NovaPushResultVO();
                vo.setName(n.getName());
                vo.setPlayerId(n.getPlayerId());
                faileList.add(vo);
            }
        });

        result.put("success", successList);
        result.put("fail", faileList);

        //  根据屏幕状态调整REDIS标识位
        for (String playerId : vnnoxResult.getSuccess()) {
            redisUtils.set(VnnoxConstant.REDIS_SCREEN_STATUS + playerId, screenStatus, VnnoxConstant.REDIS_MAX_SAVE_TIME);
            redisUtils.set(VnnoxConstant.REDIS_SCREEN_STATUS + playerId, screenStatus);
        }
        return vnnoxResult;
        return result;
    }

    public VnnoxResult volChange(List<LedPlayerEntity> playerList, Integer vol) {
        VnnoxResult vnnoxResult = vnnoxAPIUtil.volChange(
                playerList.stream().map(item -> item.getPlayerId()).collect(Collectors.toList()),
                vol
        );
    public Map<String, Object> volChange(List<LedPlayerEntity> playerList, Integer vol) {
        playerList.forEach(item -> {
            if (item.getName() == null || item.getPlayerId() == null) {
                throw new BusinessException("playerId或playerName为空");
            }
            if (item.getPlayerId().isEmpty() || item.getName().isEmpty()) {
                throw new BusinessException("playerId或playerName为空");
            }
        });
        VnnoxResult vnnoxResult = vnnoxAPIUtil.volChange(playerList.stream().map(item -> item.getPlayerId()).collect(Collectors.toList()), vol);
        //  根据音量调整REDIS标识位
        for (String playerId : vnnoxResult.getSuccess()) {
            redisUtils.set(VnnoxConstant.REDIS_VOL + playerId, vol, VnnoxConstant.REDIS_MAX_SAVE_TIME);
            redisUtils.set(VnnoxConstant.REDIS_VOL + playerId, vol, VnnoxConstant.STATUS_TIME);
        }
        return vnnoxResult;
        List<String> success = vnnoxResult.getSuccess();
        List<String> fail = vnnoxResult.getFail();
        //拼接成功失败的结果
        Map<String, Object> result = new HashMap<>();
        List<NovaPushResultVO> successList = new ArrayList<>();
        List<NovaPushResultVO> faileList = new ArrayList<>();
        List<String> finalSuccess = success;
        List<String> finalFail = fail;
        playerList.forEach(n -> {
            if (finalSuccess.contains(n.getPlayerId())) {
                NovaPushResultVO vo = new NovaPushResultVO();
                vo.setName(n.getName());
                vo.setPlayerId(n.getPlayerId());
                successList.add(vo);
            } else if (finalFail.contains(n.getPlayerId())) {
                NovaPushResultVO vo = new NovaPushResultVO();
                vo.setName(n.getName());
                vo.setPlayerId(n.getPlayerId());
                faileList.add(vo);
            }
        });

        result.put("success", successList);
        result.put("fail", faileList);
        return result;
    }

    public VnnoxResult brightnessChange(List<LedPlayerEntity> playerList, Integer brightness) {
        VnnoxResult vnnoxResult = vnnoxAPIUtil.brightnessChange(
                playerList.stream().map(item -> item.getPlayerId()).collect(Collectors.toList()),
                brightness
        );
    public Map<String, Object> brightnessChange(List<LedPlayerEntity> playerList, Integer brightness) {
        playerList.forEach(item -> {
            if (item.getName() == null || item.getPlayerId() == null) {
                throw new BusinessException("playerId或playerName为空");
            }
            if (item.getPlayerId().isEmpty() || item.getName().isEmpty()) {
                throw new BusinessException("playerId或playerName为空");
            }
        });
        VnnoxResult vnnoxResult = vnnoxAPIUtil.brightnessChange(playerList.stream().map(item -> item.getPlayerId()).collect(Collectors.toList()), brightness);
        //  根据亮度调整REDIS标识位
        for (String playerId : vnnoxResult.getSuccess()) {
            redisUtils.set(VnnoxConstant.REDIS_BRIGHTNESS + playerId, brightness, VnnoxConstant.REDIS_MAX_SAVE_TIME);
            redisUtils.set(VnnoxConstant.REDIS_BRIGHTNESS + playerId, brightness, VnnoxConstant.STATUS_TIME);
        }
        return vnnoxResult;
        List<String> success = vnnoxResult.getSuccess();
        List<String> fail = vnnoxResult.getFail();
        //拼接成功失败的结果
        Map<String, Object> result = new HashMap<>();
        List<NovaPushResultVO> successList = new ArrayList<>();
        List<NovaPushResultVO> faileList = new ArrayList<>();
        List<String> finalSuccess = success;
        List<String> finalFail = fail;
        playerList.forEach(n -> {
            if (finalSuccess.contains(n.getPlayerId())) {
                NovaPushResultVO vo = new NovaPushResultVO();
                vo.setName(n.getName());
                vo.setPlayerId(n.getPlayerId());
                successList.add(vo);
            } else if (finalFail.contains(n.getPlayerId())) {
                NovaPushResultVO vo = new NovaPushResultVO();
                vo.setName(n.getName());
                vo.setPlayerId(n.getPlayerId());
                faileList.add(vo);
            }
        });

        result.put("success", successList);
        result.put("fail", faileList);
        return result;

    }

@@ -184,69 +284,440 @@
        return map;
    }

    //重启
    public VnnoxResult reboot(List<LedPlayerEntity> playerList) {
        return vnnoxAPIUtil.reboot(
                playerList.stream().map(
                        item -> item.getPlayerId()
                ).collect(Collectors.toList())
        );

    // 批量截屏
    public List<NovaScreenShorUrlVO> getScreenShotUrl(List<NovaPushResultVO> playerIds) throws InterruptedException {
        List<NovaScreenShorUrlVO> screenShorUrlList = new ArrayList<>();

        //从playerIds中获取playerId
        List<String> AllplayerIdsList = playerIds.stream().map(item -> item.getPlayerId()).collect(Collectors.toList());
        List<List<String>> split = CollectionUtil.split(AllplayerIdsList, 100);
        for (List<String> playerIdsList : split) {
            VnnoxResult vnnoxResult = vnnoxAPIUtil.screenShot(playerIdsList);
            LocalDateTime now = LocalDateTime.now();
            NovaScreenShorUrlVO screenShorUrlVO;
            for (String successStrId : vnnoxResult.getSuccess()) {
                screenShorUrlVO = new NovaScreenShorUrlVO();
                String url = null;
                int num = 0;
                while (num < 3) {
                    url = redisUtils.get(VnnoxConstant.REDIS_SCREEN_SHOT + successStrId);
                    if (url != null) {
                        break;
                    } else {
                        num++;
                        Thread.sleep(500);
                    }
                }
                screenShorUrlVO.setShortUrl(url);
                screenShorUrlVO.setPlayerId(successStrId);
                screenShorUrlVO.setTime(now);
                for (NovaPushResultVO bean : playerIds) {
                    if (bean.getPlayerId().equals(successStrId)) {
                        screenShorUrlVO.setName(bean.getName());
                        break;
                    }
                }
                screenShorUrlList.add(screenShorUrlVO);
            }
            for (String failStrId : vnnoxResult.getFail()) {
                screenShorUrlVO = new NovaScreenShorUrlVO();

                String url = null;
                screenShorUrlVO.setShortUrl(url);
                screenShorUrlVO.setPlayerId(failStrId);
                screenShorUrlVO.setTime(now);
                for (NovaPushResultVO bean : playerIds) {
                    if (bean.getPlayerId().equals(failStrId)) {
                        screenShorUrlVO.setName(bean.getName());
                        break;
                    }
                }
                screenShorUrlList.add(screenShorUrlVO);
            }
        }
        return screenShorUrlList;
    }


//    //重启
//    public VnnoxResult reboot(List<LedPlayerEntity> playerList) {
//        return vnnoxAPIUtil.reboot(
//                playerList.stream().map(
//                        item -> item.getPlayerId()
//                ).collect(Collectors.toList())
//        );
//    }

    //重启
    public Map<String, Object> reboot(List<NovaPushResultVO> nova) {
        List<String> playerIds = new ArrayList<>();
        nova.forEach(item -> {
            if (item.getName() == null || item.getPlayerId() == null) {
                throw new BusinessException("playerId或playerName为空");
            }
            if (item.getPlayerId().isEmpty() || item.getName().isEmpty()) {
                throw new BusinessException("playerId或playerName为空");
            }
            playerIds.add(item.getPlayerId());
        });

        VnnoxResult reboot = vnnoxAPIUtil.reboot(playerIds);


        List<String> success = reboot.getSuccess();
        List<String> fail = reboot.getFail();
        //拼接成功失败的结果
        Map<String, Object> result = new HashMap<>();
        List<NovaPushResultVO> successList = new ArrayList<>();
        List<NovaPushResultVO> faileList = new ArrayList<>();
        List<String> finalSuccess = success;
        List<String> finalFail = fail;
        nova.forEach(n -> {
            if (finalSuccess.contains(n.getPlayerId())) {
                successList.add(n);
            } else if (finalFail.contains(n.getPlayerId())) {
                faileList.add(n);
            }
        });

        result.put("success", successList);
        result.put("fail", faileList);
        return result;
    }

    /**
     * 同步播放
     *
     * @param
     * @return
     */
    public Map<String, Object> syncPlay(List<NovaPushResultVO> nova, Integer option) {
        List<String> playerIds = new ArrayList<>();
        nova.forEach(item -> {
            if (item.getName() == null || item.getPlayerId() == null) {
                throw new BusinessException("playerId或playerName为空");
            }
            if (item.getPlayerId().isEmpty() || item.getName().isEmpty()) {
                throw new BusinessException("playerId或playerName为空");
            }
            playerIds.add(item.getPlayerId());
        });
        VnnoxResult vnnoxResult = vnnoxAPIUtil.syncPlay(playerIds, option);

        List<String> success = vnnoxResult.getSuccess();
        List<String> fail = vnnoxResult.getFail();
        //拼接成功失败的结果
        Map<String, Object> result = new HashMap<>();
        List<NovaPushResultVO> successList = new ArrayList<>();
        List<NovaPushResultVO> faileList = new ArrayList<>();
        List<String> finalSuccess = success;
        List<String> finalFail = fail;
        nova.forEach(n -> {
            if (finalSuccess.contains(n.getPlayerId())) {
                successList.add(n);
            } else if (finalFail.contains(n.getPlayerId())) {
                faileList.add(n);
            }
        });

        result.put("success", successList);
        result.put("fail", faileList);
        return result;
    }

    /**
     * 对时
     *
     * @param
     * @return
     */
    public Map<String, Object> ntpSync(List<NovaPushResultVO> nova, boolean enable) {
        List<String> playerIds = new ArrayList<>();
        nova.forEach(item -> {
            if (item.getName() == null || item.getPlayerId() == null) {
                throw new BusinessException("playerId或playerName为空");
            }
            if (item.getPlayerId().isEmpty() || item.getName().isEmpty()) {
                throw new BusinessException("playerId或playerName为空");
            }
            playerIds.add(item.getPlayerId());
        });
        VnnoxResult vnnoxResult = vnnoxAPIUtil.ntpSync(playerIds, enable);

        List<String> success = vnnoxResult.getSuccess();
        List<String> fail = vnnoxResult.getFail();
        //拼接成功失败的结果
        Map<String, Object> result = new HashMap<>();
        List<NovaPushResultVO> successList = new ArrayList<>();
        List<NovaPushResultVO> faileList = new ArrayList<>();
        List<String> finalSuccess = success;
        List<String> finalFail = fail;
        nova.forEach(n -> {
            if (finalSuccess.contains(n.getPlayerId())) {
                successList.add(n);
            } else if (finalFail.contains(n.getPlayerId())) {
                faileList.add(n);
            }
        });

        result.put("success", successList);
        result.put("fail", faileList);
        return result;
    }


    public boolean updateDataName(Long id, String name) {
        LedPlayerEntity byId = ledPlayerEntityService.getById(id);
        if (byId == null) {
            throw new BusinessException("未找到该设备");
        }
        if (SecurityUtils.getClientId() != null) {
            boolean belong = SpringContextHolder.getBean(PoleBindingService.class).isBelong(byId.getSn(), PoleBindingEnums.VONNOX);
            if (!belong) {
                throw new BusinessException("该设备不属于您,不能修改设备信息");
            }
        }
        LedPlayerEntity led = new LedPlayerEntity();
        led.setId(id);
        led.setName(name);
        /**
         * 诺瓦设备编辑 日志记录开始
         */
        List<String> listCode = new ArrayList<>(1);
        listCode.add(byId.getSn());
        String content = "{ 设备id:" + led.getId() + "设备code：" + byId.getSn() + "诺瓦playId:" + led.getPlayerId() + "诺瓦设备原名:" + byId.getName() + "诺瓦设备更改后的名称:" + led.getName() + "}";

        StoreOperationRecordsUtils.storeOperationData(listCode, null, "诺瓦设备编辑", content);
        /**
         * 诺瓦设备编辑 日志记录结束
         */
        return ledPlayerEntityService.updateById(led);
    }

    /**
     * 获取缓存数据
     *
     * @param list
     * @param
     * @return
     */
    public List<LedPlayerEntity> setCacheInfo(List<LedPlayerEntity> list) {
        for (LedPlayerEntity playerEntity : list) {
            String playerId = playerEntity.getPlayerId();
            LedPlayerInfoEntity cache = new LedPlayerInfoEntity();
            //  设置屏幕状态
            String result = redisUtils.get(VnnoxConstant.REDIS_SCREEN_STATUS + playerId);
            Integer screenStatus = 1;
            if (null != result) {
                screenStatus = Integer.parseInt(result);
    public List<LedPlayerEntity> setCacheInfo(List<LedPlayerEntity> ledList) {
        List<String> temp = new ArrayList<>();
        for (LedPlayerEntity item : ledList) {
            String playerId = item.getPlayerId();
            if (redisUtils.get(VnnoxConstant.REDIS_VOL + playerId) == null || redisUtils.get(VnnoxConstant.REDIS_BRIGHTNESS + playerId) == null) {
                temp.add(item.getPlayerId());
            }
            cache.setScreenStatus(screenStatus);
            //  设置屏幕音量
            result = redisUtils.get(VnnoxConstant.REDIS_VOL + playerId);
            Integer vol = 0;
            if (null != result) {
                vol = Integer.parseInt(result);
        }
        if (temp.size() > 0) {
            List<List<String>> split = CollectionUtil.split(temp, 100);
            for (List<String> playIds : split) {
                System.out.println(playIds.size());
                vnnoxAPIUtil.asyncStatus(playIds);
            }
            cache.setVol(vol);
            //  设置屏幕亮度
            result = redisUtils.get(VnnoxConstant.REDIS_BRIGHTNESS + playerId);
            Integer brightness = 0;
            if (null != result) {
                brightness = Integer.parseInt(result);
            }
            cache.setBrightness(brightness);
        }

            //  设置缩略图访问路径
            result = redisUtils.get(VnnoxConstant.REDIS_SCREEN_SHOT + playerId);
            System.out.println(playerId + "的路径结果:-----------------------------" + result);
            if (null != result) {
                playerEntity.setScreenShotUrl(result);
            } else {
                playerEntity.setScreenShotUrl("");
            }
        List<List<LedPlayerEntity>> split = CollectionUtil.split(ledList, 100);
        for (List<LedPlayerEntity> list : split) {
            for (LedPlayerEntity playerEntity : list) {
                String playerId = playerEntity.getPlayerId();
                LedPlayerInfoEntity cache = new LedPlayerInfoEntity();
                //  设置屏幕状态
                String result = redisUtils.get(VnnoxConstant.REDIS_SCREEN_STATUS + playerId);
                Integer screenStatus = 1;
                if (null != result) {
                    screenStatus = Integer.parseInt(result);
                }
                cache.setScreenStatus(screenStatus);
                //  设置屏幕音量
                result = redisUtils.get(VnnoxConstant.REDIS_VOL + playerId);
                Integer vol = 0;
                if (null != result) {
                    vol = Float.valueOf(result).intValue();

            playerEntity.setPlayerInfo(cache);
                }
                cache.setVol(vol);
                //  设置屏幕亮度
                result = redisUtils.get(VnnoxConstant.REDIS_BRIGHTNESS + playerId);
                Integer brightness = 0;
                if (null != result) {
                    brightness = Float.valueOf(result).intValue();
                }
                cache.setBrightness(brightness);

                //  设置缩略图访问路径
                result = redisUtils.get(VnnoxConstant.REDIS_SCREEN_SHOT + playerId);
                if (null != result) {
                    playerEntity.setScreenShotUrl(result);
                } else {
                    playerEntity.setScreenShotUrl("");
                }

                playerEntity.setPlayerInfo(cache);
            }
        }
        return ledList;
    }


    public VnnoxResult WaterData(String playerId, Long duration, A5AtmosphereHeartbeatReportInnerFrame.HeartBeatDataPackage poleSensorEntity) {
        List<String> playerIds = new ArrayList<>();
        playerIds.add(playerId);
        NovaWeatherVO playerProgram = new NovaWeatherVO();
        playerProgram.setPlayerIds(playerIds);

        NovaWeatherVO.AttributeDTO attributeDTO = new NovaWeatherVO.AttributeDTO();
        attributeDTO.setDuration(duration);
        playerProgram.setAttribute(attributeDTO);
        List<NovaWeatherVO.PageDTO.WidgetsDTO> widgets = setWeather(duration, poleSensorEntity);
        NovaWeatherVO.PageDTO page = new NovaWeatherVO.PageDTO();
        page.setWidgets(widgets);
        playerProgram.setPage(page);

        return vnnoxProgramAPIUtil.emergencyProgram(playerProgram).getData();
    }


    private List<NovaWeatherVO.PageDTO.WidgetsDTO> setWeather(Long duration, A5AtmosphereHeartbeatReportInnerFrame.HeartBeatDataPackage poleSensorEntity) {

        List<NovaWeatherVO.PageDTO.WidgetsDTO> widgets = new ArrayList<>();
        List<String> list = new ArrayList<>();
        if (Objects.nonNull(poleSensorEntity)) {
            list.add("环境监测：");
            list.add("温度：" + poleSensorEntity.getTemperature() + "°");
            list.add("湿度：" + poleSensorEntity.getHumidity() + "%");
            list.add("pm25：" + poleSensorEntity.getPm25() + "μg/m³");
            list.add("pm10：" + poleSensorEntity.getPm10() + "μg/m³");
            list.add("甲醛：" + poleSensorEntity.getEch2o() + "μg/m³");
            list.add("CO2：" + poleSensorEntity.getCo2() + "ppm");
        } else {
            list.add("大气设备不在线");
            list.add("目前是固定数据：");
            list.add("环境监测：");
            list.add("温度： 40°");
            list.add("湿度： 60%");
            list.add("pm25：0.58 μg/m³");
            list.add("pm10：0.58 μg/m³");
            list.add("甲醛：99.9 μg/m³");
            list.add("CO2：200 ppm");
        }


        List<NovaWeatherVO.PageDTO.WidgetsDTO.LinesDTO> lines = new ArrayList<>();

        list.forEach(txt -> {
            List<NovaWeatherVO.PageDTO.WidgetsDTO.LinesDTO.TextAttributesDTO> textAttributes = new ArrayList<>();

            NovaWeatherVO.PageDTO.WidgetsDTO.LinesDTO linesDTO = new NovaWeatherVO.PageDTO.WidgetsDTO.LinesDTO();
            NovaWeatherVO.PageDTO.WidgetsDTO.LinesDTO.TextAttributesDTO textAttributesDTO = new NovaWeatherVO.PageDTO.WidgetsDTO.LinesDTO.TextAttributesDTO();
            textAttributesDTO.setContent(txt);
            textAttributes.add(textAttributesDTO);
            System.out.println(txt + "文本内容");
            linesDTO.setTextAttributes(textAttributes);
            lines.add(linesDTO);
        });

        NovaWeatherVO.PageDTO.WidgetsDTO widgetsDTO = new NovaWeatherVO.PageDTO.WidgetsDTO();
        NovaWeatherVO.PageDTO.WidgetsDTO.ScrollAttributeDTO scrollAttribute = new NovaWeatherVO.PageDTO.WidgetsDTO.ScrollAttributeDTO();

        NovaWeatherVO.PageDTO.WidgetsDTO.LayoutDTO layout = new NovaWeatherVO.PageDTO.WidgetsDTO.LayoutDTO();

        widgetsDTO.setScrollAttribute(scrollAttribute);
        widgetsDTO.setLayout(layout);
        widgetsDTO.setLines(lines);

        widgetsDTO.setDuration(duration);
        widgets.add(widgetsDTO);
        System.out.println(lines + "播放内容");

        return widgets;
    }


    /**
     * 更新诺瓦屏幕分辨率
     */
    public void saveInfo() {
        List<LedPlayerEntity> all = ledPlayerEntityService.list();
        List<List<LedPlayerEntity>> split = CollectionUtil.split(all, 100);
        List<LedPlayerEntity> list = new ArrayList<>();
        for (List<LedPlayerEntity> ledList : split) {
            list.addAll(vnnoxAPIUtil.saveCurrentInfo(ledList));
        }
        boolean b = SpringContextHolder.getBean(LedPlayerEntityService.class).updateBatchById(list);
        if (b) {
            LogUtils.error("更新诺瓦屏幕分辨率成功");
        }
    }


    public void asyncStatus(List<String> playerIds) {
        VnnoxResultResponse vnnoxResultResponse = vnnoxAPIUtil.asyncStatus(playerIds);
    }

    /**
     * 获取诺瓦屏幕信息
     *
     * @param stateValue
     * @param playIdList
     * @return
     */
    public List<NovaAStateInfoVO> getInfo(String stateValue, List<String> playIdList) {
        List<NovaAStateInfoVO> list = new ArrayList<>();
        NovaAStateInfoVO novaAStateInfoVO;
        for (String playId : playIdList) {
            String volumeValue = RedisUtils.getBean().get(VnnoxConstant.REDIS_VOL + playId);
            String brightnessValue = RedisUtils.getBean().get(VnnoxConstant.REDIS_BRIGHTNESS + playId);
            String videoSourceValue = RedisUtils.getBean().get(VnnoxConstant.VIDEO_SOURCE_VALUE + playId);
            String timezoneValue = RedisUtils.getBean().get(VnnoxConstant.TIME_VALUE_TIMEZONE + playId);
            String timeValue = RedisUtils.getBean().get(VnnoxConstant.TIME_VALUE_TIME + playId);
            String screenPowerStatus = RedisUtils.getBean().get(VnnoxConstant.REDIS_SCREEN_STATUS + playId);
            String syncPlayStatus = RedisUtils.getBean().get(VnnoxConstant.SYNC_PLAY_STATUS + playId);
            novaAStateInfoVO = new NovaAStateInfoVO();
            novaAStateInfoVO.setPlayerId(playId);
            switch (stateValue) {
                case "all":
                    novaAStateInfoVO.setVolumeValue(volumeValue);
                    novaAStateInfoVO.setBrightnessValue(brightnessValue);
                    novaAStateInfoVO.setVideoSourceValue(videoSourceValue);
                    novaAStateInfoVO.setTimezoneValue(timezoneValue);
                    novaAStateInfoVO.setTimeValue(timeValue);
                    novaAStateInfoVO.setScreenPowerStatus(screenPowerStatus);
                    novaAStateInfoVO.setSyncPlayStatus(syncPlayStatus);
                    break;
                case "volumeValue":
                    novaAStateInfoVO.setVolumeValue(volumeValue);
                    break;
                case "brightnessValue":
                    novaAStateInfoVO.setBrightnessValue(brightnessValue);
                    break;
                case "videoSourceValue":
                    novaAStateInfoVO.setVideoSourceValue(videoSourceValue);
                    break;
                case "timeValue":
                    novaAStateInfoVO.setTimezoneValue(timezoneValue);
                    novaAStateInfoVO.setTimeValue(timeValue);
                    break;
                case "screenPowerStatus":
                    novaAStateInfoVO.setScreenPowerStatus(screenPowerStatus);
                    break;
                case "syncPlayStatus":
                    novaAStateInfoVO.setSyncPlayStatus(syncPlayStatus);
                    break;
                default:
            }
            list.add(novaAStateInfoVO);
        }
        return list;
    }

    public void getAsyncStatus(List<String> playerIdList, String stateValue) {
        List<List<String>> split = CollectionUtil.split(playerIdList, 100);
        split.forEach(
                playerIds -> {
                    vnnoxAPIUtil.getAsyncStatus(playerIdList, stateValue);
                }
        );

    }
}