4dkankan-parent/4dkankan-center-scene/src/main/java/com/fdkankan/scene/service/impl/SceneServiceImpl.java

package com.fdkankan.scene.service.impl;

import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.common.constant.*;
import com.fdkankan.common.exception.BusinessException;
import com.fdkankan.common.response.ResultData;
import com.fdkankan.common.util.ConvertUtils;
import com.fdkankan.common.util.DateExtUtil;
import com.fdkankan.common.util.FileUtils;
import com.fdkankan.fyun.oss.UploadToOssUtil;
import com.fdkankan.fyun.qiniu.QiniuUpload;
import com.fdkankan.platform.api.feign.PlatformUserClient;
import com.fdkankan.redis.constant.RedisKey;
import com.fdkankan.redis.constant.RedisLockKey;
import com.fdkankan.redis.util.RedisLockUtil;
import com.fdkankan.redis.util.RedisUtil;
import com.fdkankan.scene.entity.*;
import com.fdkankan.scene.mapper.ISceneMapper;
import com.fdkankan.scene.mapper.ISceneProMapper;
import com.fdkankan.scene.service.ISceneExtService;
import com.fdkankan.scene.service.ISceneProExtService;
import com.fdkankan.scene.service.ISceneProService;
import com.fdkankan.scene.service.ISceneService;
import com.fdkankan.scene.vo.SceneEditParamVO;
import com.fdkankan.scene.vo.SceneParamVO;
import com.fdkankan.scene.vo.SceneVO;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.joda.time.DateTime;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.multipart.MultipartFile;

import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * <p>
 * 场景表 服务实现类
 * </p>
 *
 * @author dengsixing
 * @since 2021-12-23
 */
@Slf4j
@Service
public class SceneServiceImpl extends ServiceImpl<ISceneMapper, Scene> implements ISceneService {

    @Value("${oss.type}")
    private String type;

    @Value("${oss.prefix.ali}")
    private String prefixAli;

    @Resource
    ISceneProMapper sceneProMapper;
    @Autowired
    ISceneProService sceneProService;
    @Autowired
    ISceneExtService sceneExtService;
    @Autowired
    @Qualifier("uploadToOssUtil")
    UploadToOssUtil uploadToOssUtil;
    @Autowired
    RedisUtil redisUtil;
    @Autowired
    RedisLockUtil redisLockUtil;
    @Autowired
    ISceneProExtService sceneProExtService;
    @Autowired
    PlatformUserClient platformUserClient;
    @Autowired
    ISceneService sceneService;

    @Override
    public void updateUserIdByCameraId(Long userId, Long cameraId) {
        this.update(new LambdaUpdateWrapper<Scene>().eq(Scene::getCameraId, cameraId).set(Scene::getUserId, userId));
    }

    @Override
//    @SystemServiceLog(description = "上传场景的热点媒体文件")
    public void uploadHotMedia(String sceneNum, MultipartFile file) throws IOException {
        if(StrUtil.isEmpty(sceneNum)){
            throw new BusinessException(ErrorCode.FAILURE_CODE_3001);
        }

        ScenePO scene = findBySceneNum(sceneNum);
        if(scene == null){
            throw new BusinessException(ErrorCode.FAILURE_CODE_5005);
        }

        if (!file.isEmpty()){

            String path = ConstantFilePath.SCENE_PATH + "images" + File.separator + "images" + scene.getSceneCode() + "hot";
            File targetFile = new File(path);
            if (!targetFile.exists()){
                targetFile.mkdirs();
            }

            String fileName = file.getOriginalFilename();
            targetFile = new File(path + File.separator + fileName);
            if (targetFile.exists()){
                FileUtils.deleteFile(path + File.separator + fileName);
            }
            file.transferTo(targetFile);
        }
    }

    @Override
//    @SystemServiceLog(description = "上传场景的导览图片")
    public void uploadGuidePic(String sceneId, MultipartFile file) throws IOException {
        Scene scene = this.getValidById(Long.valueOf(sceneId));
        if (scene != null && !file.isEmpty()){

            String path = ConstantFilePath.SCENE_PATH + "images" + File.separator + "images" + scene.getSceneCode()
                    + File.separator + ConstantFileName.GUIDE_MEDIA_FOLDER;
            File targetFile = new File(path);
            if (!targetFile.exists()){
                targetFile.mkdirs();
            }

            String fileName = file.getOriginalFilename();
            targetFile = new File(path + File.separator + fileName);
            int count = 1;
            while (targetFile.exists()){
                targetFile = new File(path + File.separator + fileName.substring(0, fileName.lastIndexOf("."))+"("+count+")"+fileName.substring(fileName.lastIndexOf(".")));
                ++count;
            }
            file.transferTo(targetFile);
        }
    }

    @Override
//    @SystemServiceLog(description = "保存热点的导览信息")
    public ResultData saveGuideInfo(SceneParamVO base) throws Exception {
        ResultData result = null;
        Scene scene = getValidById(base.getSceneId());
        if (scene != null){
            String path = ConstantFilePath.SCENE_PATH + "data" + File.separator + "data" + scene.getSceneCode()
                    + File.separator + ConstantFileName.GUIDE_DATAFILE;

            File file = new File(path);
            String guideData = null;
            if(file.exists()) {
                guideData = FileUtils.readFile(path);
            }
            if (StrUtil.isEmpty(guideData)){
                result = ResultData.error(ErrorCode.FAILURE_CODE_5001);
            }else{
                JSONObject guideJo = JSONObject.parseObject(guideData);
                if ("1".equals(base.getType())) {
                    if (StrUtil.isEmpty(base.getOrder())) {
                        result = ResultData.error(ErrorCode.FAILURE_CODE_5002);
                    }else{
                        if(!StrUtil.isEmpty(base.getItem())) {
                            JSONObject jo = new JSONObject();
                            JSONArray jy = guideJo.getJSONArray("images");
                            jy.add(JSONObject.parse(base.getItem()));
                        }
                        guideJo.put("imagesOrder", JSONArray.parse(base.getOrder()));
                    }
                } else if ("2".equals(base.getType())) {
                    if (StrUtil.isEmpty(base.getOrder()) || StrUtil.isEmpty(base.getGuideSid())) {
                        result = ResultData.error(ErrorCode.FAILURE_CODE_5003);
                    }else{
                        JSONArray jy = guideJo.getJSONArray("images");
                        for (int i = 0; i < jy.size(); ++i) {
                            JSONObject itemData = jy.getJSONObject(i);
                            if (itemData.getString("sid").equals(base.getGuideSid())) {
                                jy.remove(i);
                                break;
                            }
                        }
                        guideJo.put("imagesOrder", JSONArray.parse(base.getOrder()));
                    }
                } else if ("3".equals(base.getType())) {
                    if (StrUtil.isEmpty(base.getOrder())) {
                        result = ResultData.error(ErrorCode.FAILURE_CODE_5002);
                    } else {
                        guideJo.put("imagesOrder", JSONArray.parse(base.getOrder()));
                    }
                } else if ("4".equals(base.getType())) {
                    if (StrUtil.isEmpty(base.getGuideName()) || StrUtil.isEmpty(base.getGuideSid())) {
                        result = ResultData.error(ErrorCode.FAILURE_CODE_5004);
                    }else{
                        JSONArray jy = guideJo.getJSONArray("images");
                        for (int i = 0; i < jy.size(); ++i) {
                            JSONObject itemData = jy.getJSONObject(i);
                            if (itemData.getString("sid").equals(base.getGuideSid())) {
                                itemData.put("name", base.getGuideName());
                                break;
                            }
                        }
                    }
                }
                FileUtils.deleteFile(path);
                FileUtils.writeFileContent(path, guideJo.toString());
                result = ResultData.ok();
            }
        }else{
            result = ResultData.error(ErrorCode.FAILURE_CODE_5005);
        }
        return result;
    }

    @Override
//    @SystemServiceLog(description = "恢复场景的户型图")
    public ResultData recoveryFloor(SceneParamVO base) throws Exception {
        ResultData result = null;
        Scene scene = this.getValidById(base.getSceneId());
        if (scene != null) {
            String unicode = scene.getDataSource();
            if (StrUtil.isNotEmpty(unicode)) {
                unicode = unicode.substring(0, unicode.lastIndexOf("/"));
                unicode = unicode.replace(ConstantUrl.DEFAULT_PREFIX_QINIU_PIC, "");
                String path = ConstantFilePath.BUILD_MODEL_PATH + unicode + File.separator + "tex" + File.separator + "floor.json";
                FileUtils.copyFile(path, ConstantFilePath.SCENE_PATH + "data" + File.separator + "data" + scene.getSceneCode() + File.separator + "floor.json", true);
            }
            result = ResultData.ok();
        } else {
            result = ResultData.error(ErrorCode.FAILURE_CODE_5005);
        }
        return result;
    }

    @Override
//    @SystemServiceLog(description = "保存场景编辑信息")
    public ResultData saveEditInfo(SceneParamVO base) throws Exception {
        ResultData result = ResultData.ok();
        Scene scene = this.getValidById(base.getSceneId());
        if (scene != null) {
            JSONObject json = new JSONObject();
            json.put("sceneName", base.getSceneName());
            json.put("sceneDec", base.getSceneDec());
            json.put("sceneType", base.getSceneType());
            json.put("scenePsd", base.getSceneKey());
            json.put("version", base.getVersion());
            json.put("thumbImg", base.getThumbImg());
            json.put("currentPanoId", base.getCurrentPanoId());
            json.put("floorLogo", base.getFloorLogo());
            json.put("floorLogoSize", base.getFloorLogoSize());
            json.put("entry", base.getEntry());
            json.put("index", base.getIndex());
            json.put("sceneIndex", base.getSceneIndex());

            JSONObject json2 = new JSONObject();
            json2.put("geoData", base.getGeoData());
            json2.put("center", base.getCenter());
            json2.put("zoom", base.getZoom());
            json2.put("realScale", base.getRealScale());

            StringBuffer imagesBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH)
                    .append("images").append(File.separator)
                    .append("images").append(base.getIndex());

            StringBuffer dataBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH)
                    .append("data").append(File.separator)
                    .append("data").append(base.getIndex());

            File imagesFile = new File(imagesBuffer.toString());
            if(!imagesFile.exists() || !imagesFile.isDirectory()) {
                imagesFile.mkdirs();
            }

            File dataFile = new File(dataBuffer.toString());
            if(!dataFile.exists() || !dataFile.isDirectory()) {
                dataFile.mkdirs();
            }

            if (StrUtil.isNotEmpty(base.getThumbFishBigImg()) && !"undefined".equals(base.getThumbFishBigImg())){
                StringBuffer sb = new StringBuffer(imagesBuffer);
                String thumbFishBigImgPath = sb.append(File.separator).append("thumbFishBigImg.jpg").toString();
                FileUtils.deleteFile(thumbFishBigImgPath);
                FileUtils.uploadImg(thumbFishBigImgPath, base.getThumbFishBigImg());
            }

            if (StrUtil.isNotEmpty(base.getThumbBigImg()) && !"undefined".equals(base.getThumbBigImg())) {
                StringBuffer sb = new StringBuffer(imagesBuffer);
                String thumbBigImgPath = sb.append(File.separator).append("thumbBigImg.jpg").toString();
                FileUtils.deleteFile(thumbBigImgPath);
                FileUtils.uploadImg(thumbBigImgPath, base.getThumbBigImg());
            }

            if (StrUtil.isNotEmpty(base.getThumbSmallImg()) && !"undefined".equals(base.getThumbSmallImg())) {
                StringBuffer sb = new StringBuffer(imagesBuffer);
                String thumbSmallImgPath = sb.append(File.separator).append("thumbSmallImg.jpg").toString();
                FileUtils.deleteFile(thumbSmallImgPath);
                FileUtils.uploadImg(thumbSmallImgPath, base.getThumbSmallImg());
            }

            if (StrUtil.isNotEmpty(base.getFloorLogoImg()) && !"undefined".equals(base.getFloorLogoImg())) {
                StringBuffer sb = new StringBuffer(imagesBuffer);
                String floorLogoImgPath = sb.append(File.separator).append("floorLogoImg.png").toString();
                FileUtils.deleteFile(floorLogoImgPath);
                FileUtils.uploadImg(floorLogoImgPath, base.getFloorLogoImg());
            }

            if (StrUtil.isNotEmpty(base.getImgData()) && !"undefined".equals(base.getImgData())) {
                StringBuffer sb = new StringBuffer(imagesBuffer);
                String floorPlanPath = sb.append(File.separator).append("floorplan.png").toString();
                FileUtils.deleteFile(floorPlanPath);
                FileUtils.uploadImg(floorPlanPath, base.getImgData());

                if (base.getFloorPlaneInfo() != null) {

                    String floorPath = dataBuffer.append(File.separator).append("floor.json").toString();
                    FileUtils.deleteFile(floorPath);

                    JSONObject info = JSONObject.parseObject(base.getFloorPlaneInfo());
                    if (info.containsKey("height")) {
                        json2.put("height", info.getString("height"));
                    }
                    if (info.containsKey("width")) {
                        json2.put("width", info.getString("width"));
                    }
                    if (info.containsKey("position")) {
                        json2.put("position", info.getJSONObject("position"));
                    }
                    FileUtils.writeFileContent(floorPath, json2.toString());
                }
            }
            String floorFilepath = imagesBuffer.append(File.separator).append("scene.json").toString();
            FileUtils.writeFileContent(floorFilepath, json.toString());
        } else {
            result = ResultData.error(ErrorCode.FAILURE_CODE_5005);
        }
        return result;
    }

    @Override
//    @SystemServiceLog(description = "发布场景")
    public ResultData publishScene(SceneParamVO base) throws Exception {
        ResultData result = ResultData.ok();
        Scene scene = this.getValidById(base.getSceneId());
        if (scene != null) {
            SceneExt sceneExt = sceneExtService.getBySceneId(scene.getId());
            StringBuffer dataBuf = new StringBuffer()
                    .append("data").append(File.separator)
                    .append("data").append(scene.getSceneCode())
                    .append(File.separator);

            StringBuffer imagesBuf = new StringBuffer()
                    .append("images").append(File.separator)
                    .append("images").append(scene.getSceneCode())
                    .append(File.separator);

            StringBuffer dataBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH).append(dataBuf.toString());
            StringBuffer imagesBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH).append(imagesBuf.toString());

            String str = FileUtils.readFile(dataBuffer.append("scene.json").toString());
            JSONObject json = JSONObject.parseObject(str);

            String sceneIndex = json.getString("sceneIndex") == null ? "0" : json.getString("sceneIndex");
            String index = json.getString("index");
            if(json.containsKey("entry")) {
                String entry = json.getString("entry");
                sceneExt.setEntry(entry);
            }

            String sceneType = json.getString("sceneType");
            int type = sceneType != null ? Integer.valueOf(sceneType) : 0;

            scene.setSceneCode(index);
            scene.setSceneName(json.getString("sceneName"));
            scene.setSceneDec(json.getString("sceneDec"));
            scene.setSceneType(type);
            scene.setSceneKey(json.getString("scenePsd"));
            scene.setVersion(json.getInteger("version")+1);
            scene.setThumbStatus(json.getInteger("thumbImg"));
            scene.setFloorLogo(json.getString("floorLogo"));
            scene.setFloorLogoSize(json.getInteger("floorLogoSize"));
            
            sceneExt.setStyle(Integer.valueOf(sceneIndex));

            if (scene.getThumbStatus() == 1) {

                scene.setThumb(ConstantUrl.PREFIX_QINIU + imagesBuf.append("thumbSmallImg.jpg").toString());
            } else {
                scene.setThumb(ConstantUrl.PREFIX_QINIU + "loading/pc.jpg");
            }

            //上传文件到七牛云
            QiniuUpload.setFilesToBucket(imagesBuf.toString(), imagesBuffer.toString());
            QiniuUpload.setFilesToBucket(dataBuf.toString(), dataBuffer.toString());
            
            scene.setUpdateTime(Calendar.getInstance().getTime());
            this.updateById(scene);
            
            sceneExt.setUpdateTime(Calendar.getInstance().getTime());
            sceneExtService.updateById(sceneExt);
            
        } else {
            result = ResultData.error(ErrorCode.FAILURE_CODE_5005);
        }
        return result;
    }

    @Override
//    @SystemServiceLog(description = "删除场景热点")
    public ResultData deleteHot(SceneParamVO base) throws Exception {
        ResultData result = ResultData.ok();
        Scene scene = getValidById(base.getSceneId());
        if (scene != null && StrUtil.isNotEmpty(base.getIndex())) {

            SceneExt sceneExt = sceneExtService.getBySceneId(scene.getId());

            StringBuffer dataBuf = new StringBuffer()
                    .append("data").append(File.separator)
                    .append("data").append(scene.getSceneCode())
                    .append(File.separator);
            StringBuffer imagesBuf = new StringBuffer()
                    .append("images").append(File.separator)
                    .append("images").append(scene.getSceneCode())
                    .append(File.separator);

            StringBuffer imagesBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH).append(imagesBuf.toString());
            StringBuffer dataBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH).append(dataBuf.toString()).append("hot.json");

            String str = FileUtils.readFile(dataBuffer.toString());
            JSONArray jsonhots = null;
            if (StrUtil.isNotEmpty(str)){
                jsonhots = JSONArray.parseArray(str);
                for (int i = 0; i < jsonhots.size(); ++i) {
                    JSONObject ele = jsonhots.getJSONObject(i);
                    if (ele.getString("sid").equals(base.getIndex())) {
                        jsonhots.remove(i);
                        break;
                    }
                }
            }
            String sPath = null;
            File file = new File(imagesBuffer.toString());
            if (file.isDirectory()){
                String[] strs = file.list();
                if (strs != null) {
                    for (int i = 0; i < strs.length; ++i) {
                        if (strs[i].contains("hot" + base.getIndex())) {
                            sPath = imagesBuffer.toString() + strs[i];
                            break;
                        }
                    }
                }
            }
            if (sPath != null){
                FileUtils.deleteFile(sPath);
            }
            FileUtils.deleteFile(dataBuffer.toString());
            if (jsonhots != null){
                FileUtils.writeFileContent(dataBuffer.toString(), jsonhots.toString());
            }

            String hotsIds = sceneExt.getHotsIds();
            if (StrUtil.isNotEmpty(hotsIds)) {
                String updateHotsIds = "";
                String[] sids = hotsIds.split(",");
                boolean flag = false;
                for (int i = 0; i < sids.length; ++i) {
                    String s = sids[i];
                    if (s.equals(base.getIndex())) {
                        flag = true;
                    } else {
                        updateHotsIds += s + ",";
                    }
                }
                if (!flag) {
                    scene.setVersion(scene.getVersion() + 1);
                    scene.setUpdateTime(Calendar.getInstance().getTime());
                    this.updateById(scene);

                    sceneExt.setHotsIds(updateHotsIds);
                    sceneExt.setUpdateTime(Calendar.getInstance().getTime());
                    sceneExtService.updateById(sceneExt);
                }
            }
        } else {
            result = ResultData.error(ErrorCode.FAILURE_CODE_5005);
        }
        return result;
    }

    @Override
//    @SystemServiceLog(description = "保存场景热点")
    public ResultData saveHot(SceneEditParamVO base) throws Exception {
        if(StrUtil.isEmpty(base.getHotData()) || StrUtil.isEmpty(base.getType())){
            throw new BusinessException(ErrorCode.FAILURE_CODE_3001);
        }

        String sid = base.getSid();

        ScenePO scene = findBySceneNum(base.getSceneNum());
        if (scene == null ) {
            return ResultData.error(ErrorCode.FAILURE_CODE_5005);
        }

        JSONObject jsonhot = JSONObject.parseObject(base.getHotData());

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(scene.getSceneCode())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(scene.getSceneCode())
                .append(File.separator);

        StringBuffer imagesBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH).append(imagesBuf.toString());
        StringBuffer dataBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH).append(dataBuf.toString());

        String str = FileUtils.readFile(dataBuffer.append("hot.json").toString());
        JSONArray jsonhots = null;
        if (StrUtil.isNotEmpty(str)) {
            jsonhots = JSONArray.parseArray(str);
        }else {
            File file = new File(dataBuffer.append("hot.json").toString());
            if(!file.getParentFile().exists()){
                file.getParentFile().mkdirs();
            }
            if(!file.exists()){
                file.createNewFile();
            }
        }

        //添加或者修改
        if("1".equals(base.getType())){
            sid = jsonhot.getString("sid");
            if(StrUtil.isEmpty(sid)){
                throw new BusinessException(ErrorCode.FAILURE_CODE_5012);
            }
            jsonhots.add(jsonhot);
        }
        else if("0".equals(base.getType())){
            sid = jsonhot.getString("sid");
            if(StrUtil.isEmpty(sid)){
                throw new BusinessException(ErrorCode.FAILURE_CODE_5012);
            }
        }
        else if("-1".equals(base.getType())){
            if(StrUtil.isEmpty(sid)){
                throw new BusinessException(ErrorCode.FAILURE_CODE_5012);
            }
        }

        for(int i=0;i<jsonhots.size();++i){
            JSONObject ele = jsonhots.getJSONObject(i);
            if(ele.getString("sid").equals(sid)){
                if("-1".equals(base.getType())){
                    jsonhots.remove(i);
                    if(ele.containsKey("media")){
                        String fileType = ele.getString("media");
                        if(fileType.contains("photo"))
                        {
                            FileUtils.deleteFile(imagesBuffer.append("hot").append(sid).append(".jpg").toString());
                        }
                        if(fileType.contains("audio"))
                        {
                            FileUtils.deleteFile(imagesBuffer.append("hot").append(sid).append(".mp3").toString());
                        }
                        if(fileType.contains("video"))
                        {
                            FileUtils.deleteFile(imagesBuffer.append("hot").append(sid).append(".mp4").toString());
                        }
                    }
                }
                else if("0".equals(base.getType())){
                    jsonhots.set(i, jsonhot);
                }
                break;
            }
        }

        FileUtils.deleteFile(dataBuffer.append("hot.json").toString());
        File dataPath = new File(dataBuffer.toString());
        if(!dataPath.exists()){
            dataPath.mkdirs();
        }
        FileUtils.writeFile(dataBuffer.append("hot.json").toString(), jsonhots.toString());

        String strsceneInfos = FileUtils.readFile(dataBuffer.append("scene.json").toString());
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null){
            scenejson = JSONObject.parseObject(strsceneInfos);
        }
        if(jsonhots.size()>0){
            scenejson.put("hots", 1);
        }
        else{
            scenejson.put("hots", 0);
        }
        FileUtils.writeFile(dataBuffer.append("scene.json").toString(), scenejson.toString());
        return ResultData.ok();
    }

    @Override
//    @SystemServiceLog(description = "漫游可行")
    public ResultData saveLinkPano(SceneEditParamVO base) throws Exception {
        if(StrUtil.isEmpty(base.getData()) || StrUtil.isEmpty(base.getSceneNum())){
            throw new BusinessException(ErrorCode.FAILURE_CODE_3001);
        }

        ScenePO scene = baseMapper.findByNum(base.getSceneNum());
        if (scene == null ) {
            return ResultData.error(ErrorCode.FAILURE_CODE_5005);
        }

        JSONArray inputData = JSONObject.parseArray(base.getData());

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(scene.getSceneCode())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(scene.getSceneCode())
                .append(File.separator);

        StringBuffer dataBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH).append(dataBuf.toString());

        File directory = new File(dataBuffer.toString());
        if (!directory.exists()) {
            directory.mkdirs();
        }

        JSONArray inputdata =  JSONArray.parseArray(base.getData());

        String modeldataUrl = prefixAli + imagesBuf.toString() + "vision.modeldata?t=" + System.currentTimeMillis();
        if("s3".equals(type)){
            modeldataUrl = ConstantUrl.PREFIX_AWS + imagesBuf.toString() + "vision.modeldata?t=" + System.currentTimeMillis();
        }
        FileUtils.downLoadFromUrl(modeldataUrl, "vision.modeldata", dataBuffer.toString());
        File file = new File(dataBuffer.append("vision.modeldata").toString());
        if(file.exists()) {
            return ResultData.error(ErrorCode.FAILURE_CODE_5012);
        }
        ConvertUtils.convertVisionModelDataToTxt(dataBuffer.append("vision.modeldata").toString(), dataBuffer.append("vision.json").toString());

        String str = FileUtils.readFile(dataBuffer.append("vision.json").toString());
        JSONObject json = JSONObject.parseObject(str);
        JSONArray panos = json.getJSONArray("sweepLocations");
        for (int i = 0; i < panos.size(); ++i) {
            JSONObject pano = panos.getJSONObject(i);
            for (int j = 0; j < inputData.size(); ++j) {
                JSONObject jo = inputData.getJSONObject(j);
                String currentPanoId = jo.getString("panoID");
                JSONArray visibles = jo.getJSONArray("visibles");
                JSONArray visibles3 = jo.getJSONArray("visibles3");
                if (pano.getString("uuid").equals(currentPanoId)) {
                    pano.put("visibles", visibles);
                    pano.put("visibles3", visibles3);
                }
            }
        }
        FileUtils.deleteFile(dataBuffer.append("vision.json").toString());
        FileUtils.deleteFile(dataBuffer.toString() + "vision.modeldata");
        FileUtils.writeFileContent(dataBuffer.toString() + "vision.json", json.toString());
        ConvertUtils.convertTxtToVisionModelData(dataBuffer.toString() + "vision.json", dataBuffer.toString() + "vision.modeldata");
        uploadToOssUtil.upload(dataBuffer.toString() + "vision.modeldata", imagesBuf.toString() + "vision.modeldata");
        return ResultData.ok();
    }

    @Override
//    @SystemServiceLog(description = "保存热点可见性的数据")
    public ResultData saveHotVisible(SceneEditParamVO base) throws Exception {
        if(StrUtil.isEmpty(base.getData())){
            throw new BusinessException(ErrorCode.FAILURE_CODE_3001);
        }

//        ScenePO scene = findBySceneNum(base.getSceneNum());
        Scene scene = this.getSceneBySceneCode(base.getSceneNum());
        if (scene == null ) {
            return ResultData.error(ErrorCode.FAILURE_CODE_5005);
        }

        JSONArray visiblePanos = JSONArray.parseArray(base.getData());

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(scene.getSceneCode())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(scene.getSceneCode())
                .append(File.separator);

        StringBuffer imagesBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH).append(imagesBuf.toString());
        StringBuffer dataBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH).append(dataBuf.toString());

        File file = new File(dataBuffer.toString() + "hot.json");
        if (!file.exists()) {
            throw new BusinessException(ErrorCode.FAILURE_CODE_3018);
        }

        String str = FileUtils.readFile(dataBuffer.toString() + "hot.json");
        JSONArray hots = JSONArray.parseArray(str);
        for (int i = 0; i < hots.size(); ++i) {
            JSONObject hot = hots.getJSONObject(i);
            for (int j = 0; j < visiblePanos.size(); ++j) {
                if (hot.getString("sid").equals(((JSONObject) visiblePanos.get(j)).getString("sid"))) {
                    hot.put("visiblePanos", ((JSONObject) visiblePanos.get(j)).getJSONArray("value"));
                }
            }
        }

        scene.setVersion(scene.getVersion() + 1);
        scene.setUpdateTime(Calendar.getInstance().getTime());
        this.updateById(scene);

        FileUtils.deleteFile(dataBuffer.append("hot.json").toString());
        FileUtils.writeFileContent(dataBuffer.append("hot.json").toString(), hots.toString());
        return ResultData.ok();
    }

    @Override
    public IPage<SceneVO> queryByParam(SceneParamVO param) {
        int pageNum = param.getPageNum();
        int pageSize = param.getPageSize();

        Page<SceneVO> page = new Page<>(pageNum, pageSize);

        if(StrUtil.isEmpty(param.getUserIds())){
            param.setUserIds("0");
        }

        if(StrUtil.isEmpty(param.getCameraIds())){
            param.setCameraIds("0");
        }
        List<SceneVO> list = baseMapper.queryByParam(page, param);
        page.setRecords(list);

        return page;
    }

    @Override
    public IPage<SceneVO> queryByParamNew(SceneParamVO param) {
        int pageNum = param.getPageNum();
        int pageSize = param.getPageSize();

        Page<SceneVO> page = new Page<>(pageNum, pageSize);

        if(StrUtil.isEmpty(param.getUserIds())){
            param.setUserIds("0");
        }

        if(StrUtil.isEmpty(param.getCameraIds())){
            param.setCameraIds("0");
        }
        List<SceneVO> list = baseMapper.queryByParamNew(page, param);
        page.setRecords(list);

        return page;
    }

//    @Override
//    public List<SceneVO> findSceneProBySnCode(SceneParamVO param) {
//        return sceneMapper.findSceneProBySnCode(param);
//    }

    @Override
    public Scene getValidById(long id) {
        return this.getOne(new LambdaQueryWrapper<Scene>()
                .eq(Scene::getTbStatus, TbStatus.VALID.code())
                .eq(Scene::getRecStatus, RecStatus.VALID.code())
                .eq(Scene::getId, id));
    }

    @Override
    public List<SceneVO> convert(List<ScenePO> list) {

        List<SceneVO> sceneVOs = list.stream().map(po -> {
            SceneVO sceneVO = new SceneVO();
            BeanUtils.copyProperties(po, sceneVO);
            if (po.getCreateTime() != null) {
                sceneVO.setCreateTime(DateUtil.format(po.getCreateTime(), DateExtUtil.dateStyle4));
                sceneVO.setCreateDate(po.getCreateTime().getTime());
            }
            return sceneVO;
        }).collect(Collectors.toList());
        return sceneVOs;
    }

    @Override
    public List<SceneVO> convertPro(List<SceneProPO> list) {

        List<SceneVO> sceneVOs = list.stream().map(po -> {
            SceneVO sceneVO = new SceneVO();
            BeanUtils.copyProperties(po, sceneVO);
            if (po.getCreateTime() != null) {
                sceneVO.setCreateTime(new DateTime(po.getCreateTime()).toString("yyyy-MM-dd"));
                if ("s3".equals(this.type)) {
                    sceneVO.setCreateTime(new DateTime(DateExtUtil.hoursCalculate(po.getCreateTime(), 8)).toString("yyyy-MM-dd"));
                }
                sceneVO.setCreateDate(po.getCreateTime().getTime());
            }

            sceneVO.setIsFolder(0);
            return sceneVO;
        }).collect(Collectors.toList());

        return sceneVOs;
    }


    @Override
    public List<ScenePO> findAllByYesterday() throws Exception {
        return baseMapper.findAllByYesterday();
    }

    @Override
    public ScenePO findBySceneNum(String sceneNum) {
        return baseMapper.findByNum(sceneNum);
    }

    @Override
    public Scene getSceneBySceneCode(String sceneCode) {

        List<Scene> list = this.list(new LambdaQueryWrapper<Scene>()
                .eq(Scene::getTbStatus, TbStatus.VALID.code())
                .eq(Scene::getRecStatus, RecStatus.VALID.code())
                .eq(Scene::getSceneCode, sceneCode));
        if(CollUtil.isEmpty(list)){
            return null;
        }

        return list.get(0);
    }


    @Override
    public ResultData recover(String sceneNum) throws Exception {
        ScenePO scene = baseMapper.findByNum(sceneNum);
        if (scene == null){
            return ResultData.error(ErrorCode.FAILURE_CODE_5005);
        }
        scene.setPayStatus(1);
        this.update(new LambdaUpdateWrapper<Scene>()
                .eq(Scene::getId, scene.getId())
                .set(Scene::getPayStatus, PayStatus.PAY.code()));

        SceneVO SceneVO = new SceneVO();
        BeanUtils.copyProperties(scene, SceneVO);
        return ResultData.ok(SceneVO);
    }

//    public int getSceneCount(Long cameraId) {
//        return sceneMapper.getSceneCount(cameraId);
//    }

    @Override
    public Scene getSceneStatusByUnicode(String unicode, String recStatus) {
        return this.getOne(new LambdaQueryWrapper<Scene>().eq(Scene::getRecStatus, recStatus).like(Scene::getDataSource, "%"+unicode+"%"));
    }

    public void updateStatus(String sceneNum, int status) {
        this.update(new LambdaUpdateWrapper<Scene>().eq(Scene::getSceneCode, sceneNum).set(Scene::getSceneStatus, status));
    }

    @Override
    public void updateTime(String sceneNum, Long space, int payStatus) {

        List<Scene> sceneList = this.list(new LambdaQueryWrapper<Scene>()
                .select(Scene::getId)
                .eq(Scene::getSceneCode, sceneNum));

        if(CollUtil.isEmpty(sceneList))
            return ;

        this.update(new LambdaUpdateWrapper<Scene>()
                .eq(Scene::getSceneCode, sceneNum)
                .set(Scene::getCreateTime, Calendar.getInstance().getTime())
                .set(Scene::getSceneStatus, SceneStatus.NO_DISPLAY.code()));

        List<Long> sceneIds = sceneList.stream().map(scene -> {
            return scene.getId();
        }).collect(Collectors.toList());

        sceneExtService.update(new LambdaUpdateWrapper<SceneExt>().in(SceneExt::getSceneId, sceneIds).set(SceneExt::getSpace, space));
    }



    @Override
    public ResultData addHotMediaInfo(SceneEditParamVO base) throws Exception{
        if(StrUtil.isEmpty(base.getSceneNum()) || StrUtil.isEmpty(base.getType()) ||
                StrUtil.isEmpty(base.getInfo())){
            throw new BusinessException(ErrorCode.FAILURE_CODE_3001);
        }

        ScenePO scene = findBySceneNum(base.getSceneNum());
        if(scene == null){
            throw new BusinessException(ErrorCode.FAILURE_CODE_5005);
        }
        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(scene.getSceneCode())
                .append(File.separator);

        StringBuffer dataBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH).append(dataBuf.toString());

        String infoData = FileUtils.readFile(dataBuffer.append("mediaInfo.json").toString());
        JSONArray medias =  null;
        if(infoData != null){
            medias= JSONArray.parseArray(infoData);
        }

        if("1".equals(base.getType())){
            JSONObject jo = JSONObject.parseObject(base.getInfo());
            medias.add(jo);
        }else if("1".equals(base.getType())){

            for(int i=0;i<medias.size();++i){
                JSONObject ob = medias.getJSONObject(i);
                if(ob.getString("file").equals(base.getName())){
                    medias.remove(i);
                    break;
                }
            }
        }else{
            throw new BusinessException(ErrorCode.FAILURE_CODE_5012);
        }

        FileUtils.writeFile(dataBuffer.append("mediaInfo.json").toString(), medias.toString());

        return ResultData.ok();
    }

    @Override
    public ResultData saveScreencapFile(SceneEditParamVO base) throws Exception{
        if(StrUtil.isEmpty(base.getSceneNum()) || StrUtil.isEmpty(base.getIndex()) ||
                StrUtil.isEmpty(base.getCamerasData())){
            throw new BusinessException(ErrorCode.FAILURE_CODE_3001);
        }

        ScenePO scene = findBySceneNum(base.getSceneNum());
        if(scene == null){
            throw new BusinessException(ErrorCode.FAILURE_CODE_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(scene.getSceneCode())
                .append(File.separator);

        StringBuffer dataBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH).append(dataBuf.toString());

        if("1".equals(base.getIndex())){
            File file = new File(dataBuffer.append(ConstantFileName.TOURLIST_FOLDER).toString());
            if(file.isDirectory()){
                String[] strs = file.list();
                if(strs!=null){
                    for(int i=0;i<strs.length;++i) {

                        if(strs[i].indexOf(ConstantFileName.SCREEN_CRP_DATAFILE)>-1) {
                            FileUtils.deleteFile(dataBuffer.append(ConstantFileName.TOURLIST_FOLDER).append(File.separator).append(strs[i]).toString());
                        }
                    }
                }
            } else {
                file.mkdirs();
            }

            Map<String, Object> map = new HashMap<>();
            map.put("screencapLen", "0");
            map.put("version", scene.getVersion()+1);
            FileUtils.writeJsonFile(dataBuffer.append("scene.json").toString(), map);
            //sceneService.updateScreencapLen(sceneNum, 0);
        }

        String filePath = dataBuffer.append(ConstantFileName.TOURLIST_FOLDER).append(File.separator).append(ConstantFileName.SCREEN_CRP_DATAFILE).append(base.getIndex()).append("json").toString();
        File file = new File(filePath);
        if(!file.exists())
        {
            file.createNewFile();
        }
        FileUtils.writeFile(filePath, base.getCamerasData());

        return ResultData.ok();
    }


    @Override
    public Page<SceneProPO> findAllScene(SceneParamVO param) {
        Page<SceneProPO> page = new Page<>(param.getPageNum(), param.getPageSize());
        return baseMapper.findAllScene(page, param);
    }


    @Override
    public Page<ScenePO> unionSearchBySceneName(SceneParamVO param) {
        Page<ScenePO> page = new Page<>(param.getPageNum(), param.getPageSize());
        return baseMapper.unionSearchBySceneName(page, param.getSearchKey());
    }

    @Override
    public List<SceneProPO> getOnlySceneList(SceneParamVO param) throws Exception {
        return baseMapper.getOnlySceneList(param);
    }

    @Override
    public ResultData updateViewCount(String sceneNum) {
        String key = String.format(RedisKey.SCENE_VISIT_CNT, sceneNum);
        Object countObject = redisUtil.get(key);
        int count = 0;
        if(countObject == null){
            String lockKey = String.format(RedisLockKey.LOCK_SCENE_VISIT_CNT, sceneNum);
            boolean lock = redisLockUtil.lock(lockKey, RedisKey.EXPIRE_TIME_10_MINUTE);
            try {
                if(!lock){
                    throw new BusinessException(ErrorCode.SYSTEM_BUSY);
                }
                countObject = redisUtil.get(key);
                if(countObject == null){
                    Scene scene = this.getSceneBySceneCode(sceneNum);
                    if(scene == null){
                        ScenePro scenePro = sceneProMapper.findByNum(sceneNum);
                        if(scenePro != null){
                            SceneProExt sceneProExt = sceneProExtService.findBySceneProId(scenePro.getId());
                            count = sceneProExt.getViewCount();
                        }
                    }else {
                        count = scene.getViewCount();
                    }
                    redisUtil.set(key,  String.valueOf(count));
                }
            }finally {
                redisLockUtil.unlockLua(lockKey);
            }
        }
        redisUtil.incr(key, 1);
        return ResultData.ok();
    }

    @Override
    public void updatePv(){

        Boolean lock = redisLockUtil.lock(RedisLockKey.LOCK_SCENE_VISIT_UPDATE, RedisKey.EXPIRE_TIME_2_HOUR);
        if(!lock){
            return;
        }

        try {
            Map<String, Integer> pvMap = redisUtil.hmget(RedisKey.SCENE_VISIT_CNT);
            if(CollUtil.isEmpty(pvMap)){
                return;
            }

            for (Map.Entry<String, Integer> entry : pvMap.entrySet()) {

                Scene scene = this.getSceneBySceneCode(entry.getKey());
                if (Objects.nonNull(scene)){
                    scene.setViewCount(entry.getValue());
                    scene.setUpdateTime(Calendar.getInstance().getTime());
                    this.updateById(scene);
                    continue;
                }

                ScenePro scenePro = sceneProMapper.findByNum(entry.getKey());
                if(scenePro != null){
                    SceneProExt sceneProExt = sceneProExtService.findBySceneProId(scenePro.getId());
                    sceneProExt.setViewCount(entry.getValue());
                    sceneProExt.setUpdateTime(Calendar.getInstance().getTime());
                    sceneProExtService.updateById(sceneProExt);
                }
            }
        }finally {
            redisLockUtil.unlockLua(RedisLockKey.LOCK_SCENE_VISIT_UPDATE);

        }
    }

    @Override
    public Page search(@RequestBody SceneParamVO param) {

        param.setOrderBy("view_count desc");

        Page<ScenePO> scenePOPage = this.unionSearchBySceneName(param);
        if(CollUtil.isEmpty(scenePOPage.getRecords())){
            return scenePOPage;
        }
        List<SceneVO> voList = this.convert(scenePOPage.getRecords());
        for (SceneVO vo : voList){
            if (vo.getUserId() != null){
                ResultData<String> nickNameResult = platformUserClient.getNickNameByUserId(vo.getUserId());
                String nickName = nickNameResult.getData();
                vo.setNickName(nickName);
            }
        }
        Page<SceneVO> result= new Page<>(param.getPageNum(), param.getPageSize());
        result.setTotal(scenePOPage.getTotal());
        result.setRecords(voList);
        return result;
    }

    @Override
    public Page loadScene(SceneParamVO param){
        String orderBy = null;
        if (StringUtils.isEmpty(param.getSceneInterest()) || "1".equals(param.getSceneInterest())){
            orderBy = " recommend desc, create_time  ";
        }else if ("2".equals(param.getSceneInterest())){
            orderBy = " create_time desc ";
        }else if ("3".equals(param.getSceneInterest())){
            orderBy = " view_count desc ";
        }
        param.setOrderBy(orderBy);

        Page<SceneProPO> page = this.findAllScene(param);
        if(CollUtil.isEmpty(page.getRecords())){
            return page;
        }

        List<SceneVO> voList = this.convertPro(page.getRecords());
        for (SceneVO vo : voList){
            ResultData<String> nickNameResult = platformUserClient.getNickNameByUserId(vo.getUserId());
            vo.setNickName(nickNameResult.getData());
        }

        Page<SceneVO> result = new Page<>(param.getPageNum(), param.getPageSize());
        result.setTotal(page.getTotal());
        result.setRecords(voList);
        return result;
    }

    @Override
    public Page loadAllScene2(SceneParamVO param) {
        param.setOrderBy("create_time desc");
        if(param.getSceneScheme()!= null && param.getSceneScheme() == 4){
            Page<ScenePro> page = new Page<>(param.getPageNum(), param.getPageSize());
            Page<ScenePro> sceneProPage = sceneProService.page(page, new LambdaQueryWrapper<ScenePro>()
                    .eq(ScenePro::getRecStatus, RecStatus.VALID.code())
                    .in(ScenePro::getSceneStatus, SceneStatus.SUCCESS.code(), SceneStatus.NO_DISPLAY.code())
                    .and(wrapper -> wrapper.or().like(ScenePro::getSceneName, "%" + param.getSceneKey() + "%")
                            .or().like(ScenePro::getSceneCode, "%" + param.getSceneKey() + "%")).orderByDesc(ScenePro::getId));
            if(CollUtil.isEmpty(sceneProPage.getRecords())){
                return sceneProPage;
            }
            List<SceneVO> sceneList = sceneProService.convert(sceneProPage.getRecords());

            Page<SceneVO> result = new Page<>(param.getPageNum(), param.getPageSize());
            result.setTotal(sceneProPage.getTotal());
            result.setRecords(sceneList);
            return result;
        }


        Page<ScenePO> page = new Page<>(param.getPageNum(), param.getPageSize());
        Page<ScenePO> scenePOPage = baseMapper.selectScenePoByCondition(page, param);
        if(CollUtil.isEmpty(scenePOPage.getRecords())){
            return scenePOPage;
        }
        List<SceneVO> sceneList = sceneService.convert(scenePOPage.getRecords());

        Page<SceneVO> result = new Page<>(param.getPageNum(), param.getPageSize());
        result.setTotal(scenePOPage.getTotal());
        result.setRecords(sceneList);

        return result;
    }



}