4dkankan-center-job-executor/src/main/java/com/fdkankan/job/service/impl/RepairUpXmlUrlServiceImpl.java

package com.fdkankan.job.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.util.CharUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.fdkankan.fyun.face.FYunFileServiceInterface;
import com.fdkankan.job.entity.ScenePlus;
import com.fdkankan.job.entity.ScenePlusExt;
import com.fdkankan.job.service.IRepairUpXmlUrlService;
import com.fdkankan.job.service.IScenePlusExtService;
import com.fdkankan.job.service.IScenePlusService;
import com.fdkankan.job.service.ISceneProService;
import com.fdkankan.model.constants.UploadFilePath;
import com.fdkankan.redis.constant.RedisKey;
import com.fdkankan.redis.util.RedisUtil;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.stream.Collectors;

import com.xxl.job.core.context.XxlJobHelper;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

/**
 * <p>
 * TODO
 * </p>
 *
 * @author dengsixing
 * @since 2022/12/16
 **/
@Service
public class RepairUpXmlUrlServiceImpl implements IRepairUpXmlUrlService {

    @Value("${fyun.host}")
    private String fyunHost;

    @Autowired
    private ISceneProService sceneProService;
    @Autowired
    private IScenePlusService scenePlusService;
    @Autowired
    private IScenePlusExtService scenePlusExtService;
    @Autowired
    private FYunFileServiceInterface fYunFileServiceInterface;
    @Autowired
    private RedisUtil redisUtil;

    @Override
    public void repairSceneUpXmlUrlOfVideos() {

        List<String> numList = null;
        String nums = XxlJobHelper.getJobParam();
        if(StrUtil.isNotEmpty(nums)){
            numList = Arrays.asList(nums.split(","));
        }

        //查询场景
        LambdaQueryWrapper<ScenePlusExt> scenePlusExtQueryWrapper = new LambdaQueryWrapper<>();
        scenePlusExtQueryWrapper.isNotNull(ScenePlusExt::getVideos);
        if(CollUtil.isNotEmpty(numList)){
            List<ScenePlus> plusList = scenePlusService.list(new LambdaQueryWrapper<ScenePlus>().in(ScenePlus::getNum, numList));
            if(CollUtil.isEmpty(plusList)){
                return;
            }
            List<Long> plusIdList = plusList.stream().map(plus -> plus.getId()).collect(Collectors.toList());
            scenePlusExtQueryWrapper.in(ScenePlusExt::getPlusId, plusIdList);
        }

        int index = 0;
        int size = 200;
        boolean out = false;
        List<ScenePlusExt> plusExtList = new ArrayList<>();
        do {
            scenePlusExtQueryWrapper.last("limit " + index + "," + size);
            List<ScenePlusExt> subList = scenePlusExtService.list(scenePlusExtQueryWrapper);
            if(CollUtil.isNotEmpty(subList)){
                plusExtList.addAll(subList);
                index += size;
            }else{
                out = true;
            }
        }while (!out);

        if(CollUtil.isEmpty(plusExtList)){
            return;
        }
        List<Long> plusIdList = plusExtList.stream().map(ext -> ext.getPlusId()).collect(Collectors.toList());
        List<ScenePlus> plusList = scenePlusService.listByIds(plusIdList);
        if(CollUtil.isEmpty(plusList)){
            return;
        }
        Map<Long, String> idNumMap = new HashMap<>();
        plusList.stream().forEach(plus->{
            idNumMap.put(plus.getId(), plus.getNum());
        });

        List<ScenePlusExt> updateList = plusExtList.stream().filter(ext -> {
            String videos = ext.getVideos();
            String num = idNumMap.get(ext.getPlusId());
            if(StrUtil.isEmpty(num)){
                return false;
            }
            JSONObject videosJson = JSON.parseObject(videos);
            if(Objects.isNull(videosJson)){
                return false;
            }
            String upPath = videosJson.getString("upPath");
            if (StrUtil.isEmpty(upPath)) {
                return false;
            } else
                //判断是否包含
                if (upPath.contains("/data/data") || (upPath.contains("scene_view_data") && !upPath.contains(num))) {
                    String dataViewPath = String.format(UploadFilePath.DATA_VIEW_PATH, num);
                    //修复数据库
                    String fileName = "Up.txt";
                    if(!fYunFileServiceInterface.fileExist(dataViewPath + fileName)){
                        fileName = "Up.xml";
                    }
                    String upXMLUrl = fyunHost + dataViewPath + fileName;
                    videosJson.replace("upPath", upXMLUrl);
                    ext.setVideos(videosJson.toJSONString());

                    //修复scene.json
                    String sceneJsonPath =
                        String.format(UploadFilePath.DATA_VIEW_PATH, num) + "scene.json";
                    String sceneJsonStr = fYunFileServiceInterface.getFileContent(sceneJsonPath);
                    JSONObject sceneJson = JSON.parseObject(sceneJsonStr);
                    sceneJson.replace("videos", ext.getVideos());
                    fYunFileServiceInterface
                        .uploadFile(sceneJson.toJSONString().getBytes(StandardCharsets.UTF_8),
                            sceneJsonPath);

                    //清除缓存
                    redisUtil.del(String.format(RedisKey.SCENE_JSON, num));

                    return true;
                }
            return false;
        }).collect(Collectors.toList());

        if(CollUtil.isNotEmpty(updateList)){
            scenePlusExtService.updateBatchById(updateList);
        }
    }
}