package com.fdkankan.scene.service.impl;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.fdkankan.base.aop.SystemServiceLog;
import com.fdkankan.base.constant.LoginConstant;
import com.fdkankan.base.constant.SceneConstant;
import com.fdkankan.base.mapper.base.IBaseMapper;
import com.fdkankan.base.service.impl.BaseServiceImpl;
import com.fdkankan.base.util.ConvertUtils;
import com.fdkankan.base.util.FileMd5Util;
import com.fdkankan.base.util.FileUtil;
import com.fdkankan.common.constant.ConstantFileName;
import com.fdkankan.common.constant.ConstantFilePath;
import com.fdkankan.common.constant.ConstantUrl;
import com.fdkankan.common.exception.BaseRuntimeException;
import com.fdkankan.common.model.Result;
import com.fdkankan.common.util.FileUtils;
import com.fdkankan.common.util.MatrixToImageWriterUtil;
import com.fdkankan.common.util.OkHttpUtils;
import com.fdkankan.common.util.UploadToOssUtil;
import com.fdkankan.common.vo.request.RequestScene;
import com.fdkankan.common.vo.request.RequestSceneEdit;
import com.fdkankan.common.vo.response.ResponseCamera;
import com.fdkankan.common.vo.response.ResponseScene;
import com.fdkankan.scene.entity.*;
import com.fdkankan.scene.mapper.ISceneProEditMapper;
import com.fdkankan.scene.mapper.ISceneProMapper;
import com.fdkankan.scene.service.*;
import com.fdkankan.scene.util.CreateObjUtil;
import com.github.pagehelper.Page;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;
import com.github.pagehelper.util.StringUtil;
import lombok.extern.slf4j.Slf4j;
import net.coobird.thumbnailator.Thumbnails;
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.Value;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.multipart.commons.CommonsMultipartFile;
import tk.mybatis.mapper.entity.Condition;

import java.io.*;
import java.math.BigInteger;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;

/**
 * Created by Hb_zzZ on 2019/7/23.
 */
@Slf4j
@Service("sceneProService")
@Transactional
public class SceneProServiceImpl extends BaseServiceImpl<SceneProEntity, Long> implements ISceneProService {

    @Autowired
    private ISceneProMapper sceneProMapper;

    @Autowired
    private ISceneProEditMapper sceneProEditMapper;

    @Autowired
    private UploadToOssUtil uploadToOssUtil;

    @Autowired
    private ISceneDataDownloadService sceneDataDownloadService;

    @Autowired
    private ISceneModuleVideoService sceneModuleVideoService;

    @Autowired
    private ISceneService sceneService;



    @Value("${main.url}")
    private String mainUrl;

    @Value("${scene.url}")
    private String sceneUrl;

    @Value("${scene.pro.url}")
    private String sceneProUrl;

    @Value("${scene.pro.new.url}")
    private String sceneProNewUrl;

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

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

    @Value("${hot.domain.list}")
    private String hotDomainList;

    @Value("${hot.delete}")
    private String hotDelete;

    @Override
    public IBaseMapper<SceneProEntity, Long> getBaseMapper() {
        return sceneProMapper;
    }

    @Override
    public List<ResponseScene> convert(List<SceneProEntity> list) throws Exception {
        List<ResponseScene> responseScenes = new ArrayList<>();
        for (SceneProEntity sceneProEntity : list){
            ResponseScene responseScene = new ResponseScene();

            SceneProEditEntity editEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());
            BeanUtils.copyProperties(editEntity, responseScene);
            BeanUtils.copyProperties(sceneProEntity, responseScene);

            responseScene.setCreateTime(new DateTime(sceneProEntity.getCreateTime()).toString("yyyy-MM-dd"));
            responseScene.setCreateDate(sceneProEntity.getCreateTime().getTime());
            responseScenes.add(responseScene);
        }
        return responseScenes;
    }

    @Override
    public int getSceneCount(Long cameraId) {
        return sceneProMapper.getSceneCount(cameraId);
    }

    @Override
    public SceneProEntity findBySceneNum(String sceneNum){
        return sceneProMapper.findByNum(sceneNum);
    }

    @Override
    public SceneProEntity findLikeSceneNum(String sceneNum) throws Exception {
        return sceneProMapper.findLikeNum(sceneNum);
    }

    @Override
    public SceneProEntity findDeleteSceneBySceneNum(String sceneNum) {
        return sceneProMapper.findDeleteSceneBySceneNum(sceneNum);
    }

    @Override
    public SceneProEntity getSceneStatusByUnicode(String unicode, String recStatus) {
        return sceneProMapper.getSceneStatusByUnicode(unicode, recStatus);
    }

    @Override
    public List<SceneProEntity> findByUserId(Long userId, Integer cameraType) {
        return sceneProMapper.findByUserId(userId, cameraType);
    }

    @Override
    public List<SceneProEntity> findBySceneNums(String nums, Integer cameraType) {
        return sceneProMapper.findBySceneNums(nums, cameraType);
    }

    @Override
    public int updateStatus(String sceneNum, int status) {
        return sceneProMapper.updateStatus(sceneNum, status);
    }

    @Override
    public Result resetUploadFloorJson(RequestSceneEdit sceneEdit) throws Exception{
        if(StringUtils.isEmpty(sceneEdit.getSceneNum())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(sceneEdit.getSceneNum());
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);
        StringBuffer dataBuffer = new StringBuffer(ConstantFilePath.SCENE_PATH).append(dataBuf.toString());

        //更新scene.json文件
        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null)
        {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }else {
            new File(dataBuffer.toString() + "scene.json").createNewFile();
        }
        if(!StringUtils.isEmpty(sceneEdit.getSceneData())){
            JSONObject sceneObject = JSONObject.parseObject(sceneEdit.getSceneData());
            Set<String> set =sceneObject.keySet();

            for(String key : set){
                scenejson.put(key, sceneObject.get(key));
            }
        }

        SceneProEditEntity sceneProEditEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());
        //重置将floorEditVer回归floorPublishVer
        sceneProEditEntity.setFloorPublishVer(sceneProEditEntity.getFloorEditVer());
        sceneProEditMapper.updateByPrimaryKeySelective(sceneProEditEntity);

        //更新scene.json文件
        if(strsceneInfos!=null){
            scenejson.put("floorEditVer", sceneProEditEntity.getFloorEditVer());
            scenejson.put("floorPublishVer", sceneProEditEntity.getFloorEditVer());
            scenejson.put("cadInfo", sceneProEditEntity.getCadInfo());
            FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());
            log.info("写入scene.json文件完成——"+sceneEdit.getSceneNum());
        }
        log.info("重置画墙重建模型版本成功");

        return Result.success();
    }

    @Override
    public Result uploadFloorJson(RequestSceneEdit sceneEdit) throws Exception {

        String lock = sceneEdit.getSceneNum().toString().intern();

        synchronized(lock){

            long start = System.currentTimeMillis();
            log.info("画墙重建模型开始时间：" + start);
            if(StringUtils.isEmpty(sceneEdit.getSceneNum())){
                throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
            }

            SceneProEntity sceneProEntity = findBySceneNum(sceneEdit.getSceneNum());
            if(sceneProEntity == null){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
            }

            SceneProEditEntity sceneProEditEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());
            if(sceneProEditEntity == null){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
            }

            //更新scene.json文件
            String strsceneInfos = FileUtils.readFile(ConstantFilePath.SCENE_PATH + "data" + File.separator + "data" + sceneEdit.getSceneNum() + File.separator + "scene.json");
            JSONObject scenejson = new JSONObject();
            if(strsceneInfos!=null)
            {
                scenejson = JSONObject.parseObject(strsceneInfos);
            }else {
                new File(ConstantFilePath.SCENE_PATH + "data" + File.separator + "data" + sceneEdit.getSceneNum() + File.separator + "scene.json").createNewFile();
            }
            if(!StringUtils.isEmpty(sceneEdit.getSceneData())){
                JSONObject sceneObject = JSONObject.parseObject(sceneEdit.getSceneData());
                Set<String> set =sceneObject.keySet();

                for(String key : set){
                    scenejson.put(key, sceneObject.get(key));
                }
            }

            //保存floor.json前端下次进入需要使用
            if(StringUtils.isEmpty(sceneEdit.getWebFloor())){
                sceneEdit.setWebFloor(sceneEdit.getFloor());
            }

            //上传过模型只更新floor.json
//            if(scenejson.containsKey("isUploadObj") && scenejson.getBooleanValue("isUploadObj")){
                FileUtils.writeFile(ConstantFilePath.SCENE_PATH+"data"+File.separator+"data"+sceneEdit.getSceneNum() + File.separator + "floor.json", new String(sceneEdit.getWebFloor().getBytes(), "UTF-8"));

                //更新scene.json文件
                if(strsceneInfos!=null)
                {
                    scenejson.put("floorEditVer", sceneProEditEntity.getFloorEditVer() + 1);
                    scenejson.put("floorPublishVer", sceneProEditEntity.getFloorPublishVer());
                    FileUtils.writeFile(ConstantFilePath.SCENE_PATH+"data"+File.separator+"data"+sceneEdit.getSceneNum()+File.separator+"scene.json", scenejson.toString());
                    log.info("写入scene.json文件完成——"+sceneEdit.getSceneNum());
                }

                //floorEditVer字段增加1
                sceneProEditEntity.setFloorEditVer(sceneProEditEntity.getFloorEditVer() + 1);
                sceneProEditMapper.updateByPrimaryKeySelective(sceneProEditEntity);
//                return Result.success();
//            }

            String path = sceneProEntity.getDataSource();
            if(path != null && !"".equals(path) && path.startsWith("http")){
                path = ConstantFilePath.BUILD_MODEL_PATH + File.separator + path.split("/")[path.split("/").length - 2];
            }
            String target = path + "_edit";
            File editPath = new File(target);
            if(!editPath.exists()){
                editPath.mkdirs();
            }
            //创建文件夹软连接并且复制data.json和project.json
            if(new File(target + File.separator + "capture").exists()){
                new File(target + File.separator + "capture").delete();
            }
            if(new File(target + File.separator + "caches").exists()){
                //删除link
                new File(target + File.separator + "caches" + File.separator + "images").delete();
                //删除所有文件
                FileUtils.delAllFile(target + File.separator + "caches");
            }
            if(new File(target + File.separator + "results").exists()){
                FileUtils.delAllFile(target + File.separator + "results");
            }
            //创建文件夹,并link文件夹
            new File(target + File.separator + "caches").mkdirs();
            CreateObjUtil.createSoftConnection(path + File.separator + "capture", target + File.separator + "capture");
            if(new File(path + File.separator + "caches" + File.separator + "images").exists()){
                CreateObjUtil.createSoftConnection(path + File.separator + "caches" + File.separator + "images", target + File.separator + "caches" + File.separator + "images");
            }

            FileUtils.copyFile(path + File.separator + "data.json", target + File.separator+"data.json", true);
            FileUtils.copyFile(path + File.separator + "project.json", target + File.separator+"project.json", true);

            //data.json增加extras为执行重建算法
            String project = FileUtils.readFile(target + File.separator+"project.json");
            if(project != null){
                JSONObject projectJson = JSONObject.parseObject(project);
                projectJson.put("parent", projectJson.get("uuid"));
                projectJson.put("uuid", UUID.randomUUID().toString());
                projectJson.put("time", System.currentTimeMillis());
                FileUtils.writeFile(path + File.separator + "project.json", projectJson.toString());
            }

            String data = FileUtils.readFile(target + File.separator+"data.json");
            if(data != null){
                JSONObject floorplanJson = new JSONObject();
                floorplanJson.put("has_floorplan_json", true);
                floorplanJson.put("has_vision_txt", true);

                JSONObject dataJson = JSONObject.parseObject(data);
                dataJson.put("extras", floorplanJson);
                //V5表示不需要生成high，low文件
                dataJson.put("skybox_type", "SKYBOX_V5");
                dataJson.put("split_type", "SPLIT_V4");
                FileUtils.writeFile(target + File.separator+"data.json", new String(dataJson.toString().getBytes(), "UTF-8"));
            }

            //文件上传的位置可以自定义
            log.info("画墙重建模型开始");
            File targetFile = new File(target + File.separator + "extras" + File.separator + "floorplan.json");
            if(!targetFile.getParentFile().exists()){
                targetFile.getParentFile().mkdirs();
            }
            if(targetFile.exists()){
                FileUtils.deleteFile(target + File.separator + "extras" + File.separator + "floorplan.json");
            }
            // 保存
            FileUtils.writeFile(target + File.separator + "extras" + File.separator + "floorplan.json", new String(sceneEdit.getFloor().getBytes(), "UTF-8"));

            FileUtils.writeFile(ConstantFilePath.SCENE_PATH+"data"+File.separator+"data"+sceneEdit.getSceneNum() + File.separator + "floor.json", new String(sceneEdit.getWebFloor().getBytes(), "UTF-8"));
            //下载vision.modeldata，解压成vision.txt,并且删除vision.modeldata
            log.info("下载vision.modeldata文件");
            if("s3".equals(type)){
                FileUtils.downLoadFromUrl(ConstantUrl.PREFIX_AWS + "images/images" + sceneEdit.getSceneNum() + "/vision.modeldata" + "?m="+new Date().getTime(),
                        "vision.modeldata", target + File.separator + "extras" + File.separator);
            }
            if("oss".equals(type)){
                FileUtils.downLoadFromUrl(prefixAli + "images/images" + sceneEdit.getSceneNum() + "/vision.modeldata" + "?m="+new Date().getTime(),
                        "vision.modeldata", target + File.separator + "extras" + File.separator);
            }
            CreateObjUtil.convertVisionmodeldataToTxt(target + File.separator + "extras" + File.separator + "vision.modeldata",
                    target + File.separator + "extras" + File.separator + "vision.txt");
            log.info("解压完成，删除vision.modeldata文件");
            FileUtils.deleteFile(target + File.separator + "extras" + File.separator + "vision.modeldata");

//			File visionFile = new File(Message.filePath+"data"+File.separator+"data"+sceneNum+File.separator+"vision.json");
//			if(visionFile.exists()){
//				FileUtil.copyFile(Message.filePath+"data"+File.separator+"data"+sceneNum+File.separator+"vision.json", target + File.separator + "extras" + File.separator + "vision.txt", true);
//			}else {
//				FileUtil.copyFile(path + File.separator + "results" + File.separator + "vision.txt", target + File.separator + "extras" + File.separator + "vision.txt", true);
//			}
            //复制vision2.txt，修改热点可行性不改动vision2.txt
//        FileUtils.copyFile(path + File.separator + "results" + File.separator + "vision2.txt", target + File.separator + "extras" + File.separator + "vision2.txt", true);
            log.info("下载vision2.modeldata文件");
            if("oss".equals(type)){
                FileUtils.downLoadFromUrl(prefixAli + "images/images" + sceneEdit.getSceneNum() + "/vision2.modeldata" + "?m="+new Date().getTime(),
                        "vision2.modeldata", target + File.separator + "extras" + File.separator);
            }
            if("s3".equals(type)){
                FileUtils.downLoadFromUrl(ConstantUrl.PREFIX_AWS + "images/images" + sceneEdit.getSceneNum() + "/vision2.modeldata" + "?m="+new Date().getTime(),
                        "vision2.modeldata", target + File.separator + "extras" + File.separator);
            }
            CreateObjUtil.convertVisionmodeldataToTxt(target + File.separator + "extras" + File.separator + "vision2.modeldata",
                    target + File.separator + "extras" + File.separator + "vision2.txt");
            log.info("解压完成，删除vision2.modeldata文件");
            FileUtils.deleteFile(target + File.separator + "extras" + File.separator + "vision2.modeldata");

            //重新计算算法
            log.info("重新计算大场景：开始建模——"+sceneEdit.getSceneNum());
            //判断V2还是V3
            if("V2".equals(sceneProEntity.getBuildType())){
                CreateObjUtil.build3dModelOld(target , "1");
            }
            if("V3".equals(sceneProEntity.getBuildType())){
                CreateObjUtil.build3dModel(target , "1");
            }
            log.info("重新计算大场景：开始转换成lzma文件——"+sceneEdit.getSceneNum());
            CreateObjUtil.convertTxtToDam( target + File.separator + "results" + File.separator+"tex"+
                    File.separator+"modeldata.txt", target + File.separator + "results" +File.separator+ ConstantFileName.modelUUID+"_50k.dam");
            CreateObjUtil.convertDamToLzma(target + File.separator + "results");
            CreateObjUtil.convertTxtToDam( target + File.separator + "results" +File.separator+"tex"+
                    File.separator+"modeldata.txt", target + File.separator + "results" + File.separator+ConstantFileName.modelUUID+"_50k.dam");
//			createObjService.convertTxtToVisionmodeldata(target + File.separator + "results" +File.separator+
//					"vision.txt",target + File.separator + "results" +File.separator+"vision.modeldata");
            //8目相机有两个vision.txt因此第二个叫vision2.txt
//			if(new File(target + File.separator + "results" +File.separator+"vision2.txt").exists()){
//				createObjService.convertTxtToVisionmodeldata(target + File.separator + "results" +File.separator+
//						"vision2.txt",target + File.separator + "results" +File.separator+"vision2.modeldata");
//			}
            File lzmaFile = new File(target + File.separator + "results" +File.separator+ConstantFileName.modelUUID+"_50k.dam.lzma");
            if(!lzmaFile.exists())
            {
                log.info("lzam文件不存在——"+sceneEdit.getSceneNum());
                Thread.sleep(3000);
            }

            File sceneFile = new File(ConstantFilePath.SCENE_PATH+"images"+File.separator+"images"+sceneEdit.getSceneNum() + File.separator + ConstantFileName.modelUUID + "_50k_texture_jpg_high1");
            if(!sceneFile.exists())
            {
                log.info("high1文件夹不存在——"+sceneEdit.getSceneNum());
                sceneFile.mkdirs();
            }

            //将重新建模的tex里的文件和lzma文件复制到Message.filePath+"images"+File.separator+"images"+sceneNum下。
            List<String> list1 = FileUtils.readfileNamesForDirectory(target+File.separator+ "results" + File.separator +"tex",".jpg");
            if(list1 == null){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
            }
            log.info("新生成的贴图有：——"+list1.size());
            for(int i=0; i<list1.size(); ++i)
            {
                String imgName = list1.get(i);
                FileUtils.copyFile(target+File.separator + "results" + File.separator+"tex"+File.separator+imgName,
                        ConstantFilePath.SCENE_PATH+"images"+File.separator+"images"+sceneEdit.getSceneNum() + File.separator + ConstantFileName.modelUUID + "_50k_texture_jpg_high1"+File.separator+imgName, true);
            }
            FileUtils.copyFile(target+File.separator + "results" + File.separator +ConstantFileName.modelUUID+"_50k.dam",
                    ConstantFilePath.SCENE_PATH+"images"+File.separator+"images"+sceneEdit.getSceneNum() + File.separator + ConstantFileName.modelUUID+"_50k.dam", true);
            log.info("文件复制到本地ecs完成——"+sceneEdit.getSceneNum());


            //更新scene.json文件
            if(strsceneInfos!=null)
            {
                scenejson.put("floorEditVer", sceneProEditEntity.getFloorEditVer() + 1);
                scenejson.put("floorPublishVer", sceneProEditEntity.getFloorPublishVer());
                FileUtils.writeFile(ConstantFilePath.SCENE_PATH+"data"+File.separator+"data"+sceneEdit.getSceneNum()+File.separator+"scene.json", scenejson.toString());
                log.info("写入scene.json文件完成——"+sceneEdit.getSceneNum());
            }

            //floorEditVer字段增加1
            sceneProEditEntity.setFloorEditVer(sceneProEditEntity.getFloorEditVer() + 1);
            sceneProEditMapper.updateByPrimaryKeySelective(sceneProEditEntity);
            log.info("修改数据库完成——"+sceneEdit.getSceneNum());

            log.info("花费时间：" + (System.currentTimeMillis() - start));
        }

//        Thread.sleep(180000);

        return Result.success();
    }

    @Override
    public Result uploadFloorJsonAjk(String sceneNum, String ajkJson, String cameraJson, String floorPlanJson, MultipartFile[] file) throws Exception {
//        log.info("画墙重建模型开始时间：" + start);

        String lock = sceneNum.toString().intern();

        synchronized(lock){
            if(StringUtils.isEmpty(sceneNum)){
                throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
            }

            SceneProEntity sceneProEntity = findBySceneNum(sceneNum);
            if(sceneProEntity == null){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
            }

            SceneProEditEntity sceneProEditEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());
            if(sceneProEditEntity == null){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
            }

            //更新scene.json文件
            String strsceneInfos = FileUtils.readFile(ConstantFilePath.SCENE_PATH + "data" + File.separator + "data" + sceneNum + File.separator + "scene.json");
            JSONObject scenejson = new JSONObject();
            if(strsceneInfos!=null)
            {
                scenejson = JSONObject.parseObject(strsceneInfos);
            }else {
                new File(ConstantFilePath.SCENE_PATH + "data" + File.separator + "data" + sceneNum + File.separator + "scene.json").createNewFile();
            }
//        if(!StringUtils.isEmpty(sceneEdit.getSceneData())){
//            JSONObject sceneObject = JSONObject.parseObject(sceneEdit.getSceneData());
//            Set<String> set =sceneObject.keySet();
//
//            for(String key : set){
//                scenejson.put(key, sceneObject.get(key));
//            }
//        }

            String path = sceneProEntity.getDataSource();
            if(path != null && !"".equals(path) && path.startsWith("http")){
                path = ConstantFilePath.BUILD_MODEL_PATH + File.separator + path.split("/")[path.split("/").length - 2];
            }
            String target = path + "_ajk";
            File editPath = new File(target);
            if(!editPath.exists()){
                editPath.mkdirs();
            }

            //创建文件夹软连接并且复制data.json和project.json
            if(new File(target + File.separator + "capture").exists()){
                new File(target + File.separator + "capture").delete();
            }
            if(new File(target + File.separator + "caches").exists()){
                //删除link
                new File(target + File.separator + "caches" + File.separator + "images").delete();
                //删除所有文件
                FileUtils.delAllFile(target + File.separator + "caches");
            }
            if(new File(target + File.separator + "results").exists()){
                FileUtils.delAllFile(target + File.separator + "results");
            }
            //创建文件夹,并link文件夹
            new File(target + File.separator + "caches").mkdirs();
            CreateObjUtil.createSoftConnection(path + File.separator + "capture", target + File.separator + "capture");
            if(new File(path + File.separator + "caches" + File.separator + "images").exists()){
                CreateObjUtil.createSoftConnection(path + File.separator + "caches" + File.separator + "images", target + File.separator + "caches" + File.separator + "images");
            }

            FileUtils.copyFile(path + File.separator + "data.json", target + File.separator+"data.json", true);
            FileUtils.copyFile(path + File.separator + "project.json", target + File.separator+"project.json", true);

            //data.json增加extras为执行重建算法
            String project = FileUtils.readFile(target + File.separator+"project.json");
            if(project != null){
                JSONObject projectJson = JSONObject.parseObject(project);
                projectJson.put("parent", projectJson.get("uuid"));
                projectJson.put("uuid", UUID.randomUUID().toString());
                projectJson.put("time", System.currentTimeMillis());
                FileUtils.writeFile(path + File.separator + "project.json", projectJson.toString());
            }

            String data = FileUtils.readFile(target + File.separator+"data.json");
            if(data != null){
                JSONObject floorplanJson = new JSONObject();
                floorplanJson.put("has_floor_ajk_json", true);
                floorplanJson.put("has_vision_txt", true);
                floorplanJson.put("has_floorplan_json", true);

                JSONObject dataJson = JSONObject.parseObject(data);
                dataJson.put("extras", floorplanJson);
                //V5表示不需要生成high，low文件
                dataJson.put("skybox_type", "SKYBOX_V8");
                dataJson.put("split_type", "SPLIT_V10");
                FileUtils.writeFile(target + File.separator+"data.json", new String(dataJson.toString().getBytes(), "UTF-8"));
            }

            //文件上传的位置可以自定义
            log.info("画墙重建模型开始");
            File targetFile = new File(target + File.separator + "extras" + File.separator + "floor_ajk.json");
            if(!targetFile.getParentFile().exists()){
                targetFile.getParentFile().mkdirs();
            }
            if(targetFile.exists()){
                FileUtils.deleteFile(target + File.separator + "extras" + File.separator + "floor_ajk.json");
            }
            // 保存
            FileUtils.writeFile(target + File.separator + "extras" + File.separator + "floorplan.json", new String(floorPlanJson.getBytes(), "UTF-8"));

            FileUtils.writeFile(target + File.separator + "extras" + File.separator + "floor_ajk.json", new String(ajkJson.getBytes(), "UTF-8"));
            FileUtils.writeFile(ConstantFilePath.SCENE_PATH+"data"+File.separator+"data"+sceneNum + File.separator + "floor_ajk.json", new String(ajkJson.getBytes(), "UTF-8"));

            FileUtils.writeFile(target + File.separator + "extras" + File.separator + "vision.txt", new String(cameraJson.getBytes(), "UTF-8"));
            FileUtils.writeFile(ConstantFilePath.SCENE_PATH+"data"+File.separator+"data"+sceneNum + File.separator + "camera.json", new String(cameraJson.getBytes(), "UTF-8"));

            for(int i = 0; i < file.length; i ++){

                File cadImg = new File(target + File.separator + "extras" + File.separator + "Floorplans/" + file[i].getOriginalFilename());
                if(!cadImg.getParentFile().exists()){
                    cadImg.getParentFile().mkdirs();
                }
                if(cadImg.exists())
                {
                    cadImg.delete();
                }

                file[i].transferTo(cadImg);
            }
            //下载封面图
            FileUtils.downLoadFromUrl(sceneProEntity.getThumb() + "?t=" + System.currentTimeMillis(),
                    "Cover.png", target + File.separator + "extras" + File.separator + "CoverImage");
            //转换成jpg
            FileUtils.pngToJpg(target + File.separator + "extras" + File.separator + "CoverImage/Cover.png",
                    target + File.separator + "extras" + File.separator + "CoverImage/Cover.jpg");
//        FileUtils.deleteFile(target + File.separator + "extras" + File.separator + "CoverImage/Cover.png");

            //安居客算法运行
            log.info("安居客算法：开始建模——"+sceneNum);

            CreateObjUtil.build3dModel(target , "1");
            if(!new File(target + File.separator + "results" + File.separator + "upload.json").exists()){
                return Result.failure("算法计算失败！");
            }

            String zipPath = target + File.separator + "results/" + sceneNum + ".zip";
            new File(zipPath).delete();

//            FileUtils.zipFile(zipPath, target + File.separator + "results/ajk/");
            String command = "bash /opt/ossutil/gzip.sh " + zipPath.replace(".zip", "") + " " + target + File.separator + "results/ajk/";
            log.info("压缩文件:" + command);
            CreateObjUtil.callshell(command);

            if(!new File(zipPath).exists()){
                return  Result.failure("打包zip失败");
            }
            String fileMD5 = FileMd5Util.getFileMD5(new File(zipPath));

            uploadToOssUtil.upload(zipPath, "data_download/" + sceneNum + ".zip");

            SceneDataDownloadEntity sceneDataDownloadEntity = sceneDataDownloadService.findBySceneNum(sceneNum);
            if(sceneDataDownloadEntity == null){
                sceneDataDownloadEntity = new SceneDataDownloadEntity();
                sceneDataDownloadEntity.setSceneNum(sceneNum);
                sceneDataDownloadEntity.setDownloadPath(prefixAli + "data_download/" + sceneNum + ".zip");
                sceneDataDownloadEntity.setFileMd5(fileMD5);
                sceneDataDownloadService.save(sceneDataDownloadEntity);
                return Result.success();
            }

            sceneDataDownloadEntity.setFileMd5(fileMD5);
            sceneDataDownloadEntity.setUpdateTime(new Date());
            sceneDataDownloadService.update(sceneDataDownloadEntity);
        }

        return Result.success();
    }

    @Override
    public Result addHotMediaInfo(RequestSceneEdit base) throws Exception{
        if(StringUtils.isEmpty(base.getSceneNum()) || StringUtils.isEmpty(base.getType()) ||
                StringUtils.isEmpty(base.getInfo())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }
        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String infoData = FileUtils.readFile(dataBuffer.toString() + "mediaInfo.json");
        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 BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
        }

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

        return Result.success();
    }

    @Override
    public Result saveScreencapFile(RequestSceneEdit base) throws Exception{
        if(StringUtils.isEmpty(base.getSceneNum()) || StringUtils.isEmpty(base.getIndex()) ||
                StringUtils.isEmpty(base.getCamerasData())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

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

        if("1".equals(base.getIndex())){
            File file = new File(dataBuffer.toString() + ConstantFileName.TOURLIST_FOLDER);
            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.toString() + ConstantFileName.TOURLIST_FOLDER + File.separator + strs[i]);
                        }
                    }
                }
            } else {
                file.mkdirs();
            }

            String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
            JSONObject scenejson = new JSONObject();
            if(strsceneInfos!=null) {
                scenejson = JSONObject.parseObject(strsceneInfos);
            }
            Map<String, Object> map = new HashMap<>();
            map.put("screencapLen", "0");
            map.put("version", scenejson.getIntValue("version")+1);
            FileUtils.writeJsonFile(dataBuffer.toString() + "scene.json", map);
            //sceneService.updateScreencapLen(sceneNum, 0);
        }

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

        return Result.success();
    }

    @Override
    public Result saveSceneKey(RequestSceneEdit base) throws Exception{
        if(StringUtils.isEmpty(base.getSceneNum()) || StringUtils.isEmpty(base.getSceneKey())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        SceneProEditEntity sceneProEditEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());
        sceneProEditEntity.setSceneKey(base.getSceneKey());
        sceneProEditEntity.setNeedKey(0);
        sceneProEditEntity.setVersion(sceneProEditEntity.getVersion() + 1);
        sceneProEditMapper.updateByPrimaryKeySelective(sceneProEditEntity);
        return Result.success();
    }

    @Override
    public Result saveFloorLogo(RequestSceneEdit base) throws Exception{
        if(StringUtils.isEmpty(base.getSceneNum()) || StringUtils.isEmpty(base.getSize()) ||
                StringUtil.isEmpty(base.getLogoType())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String strsceneInfos = FileUtils.readFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneProEntity.getNum() + File.separator + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }
        Map map = new HashMap();
        map.put("floorLogo", base.getLogoType());
        map.put("floorLogoSize", base.getSize());
        map.put("version", scenejson.getIntValue("version")+1);

        FileUtils.writeJsonFile(dataBuffer.toString() + "scene.json", map);
        return Result.success();
    }

    @Override
    public Result saveBackgroundMusic(RequestSceneEdit base) throws Exception{
        if(StringUtils.isEmpty(base.getSceneNum()) || StringUtils.isEmpty(base.getMusicName())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String strsceneInfos = FileUtils.readFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneProEntity.getNum() + File.separator + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }
        Map map = new HashMap();
        map.put("bgMusic", base.getMusicName());
        map.put("version", scenejson.getIntValue("version")+1);

        FileUtils.writeJsonFile(dataBuffer.toString() + "scene.json", map);
        return Result.success();
    }

    @Override
    public Result saveInitialPage(RequestSceneEdit base) throws Exception{
        if(StringUtils.isEmpty(base.getSceneNum()) || StringUtils.isEmpty(base.getInitialPoint())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String path1 = imagesBuffer.toString() + "thumbBigImg.jpg";
        String path2 = imagesBuffer.toString() + "thumbSmallImg.jpg";

        //生成缩略图
        //按指定大小把图片进行缩和放（会遵循原图高宽比例）
        //此处把图片压成1024×512的缩略图
        Thumbnails.of(path1).size(1024,512).toFile(path2);//变为1024×512

        String strsceneInfos = FileUtils.readFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneProEntity.getNum() + File.separator + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }
        Map map = new HashMap();
        map.put("entry", JSONObject.parseObject(base.getInitialPoint()));
        map.put("thumbImg", 1);
        map.put("version", scenejson.getIntValue("version")+1);
        FileUtils.writeJsonFile(dataBuffer.toString() + "scene.json", map);

        return Result.success();
    }

    @Override
    public Result getScreencapVoice(RequestSceneEdit base) throws Exception{
        if(StringUtils.isEmpty(base.getSceneNum())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String sceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(sceneInfos!=null)
        {
            scenejson = JSONObject.parseObject(sceneInfos);
        }
        JSONObject result = new JSONObject();
        String screencapVoiceFileName = "";
        if(scenejson.containsKey("screencapVoiceFileName"))
        {
            screencapVoiceFileName = scenejson.getString("screencapVoiceFileName");
        }
        String screencapVoiceSrc = "";
        if(scenejson.containsKey("screencapVoiceSrc"))
        {
            screencapVoiceSrc = scenejson.getString("screencapVoiceSrc");
        }
        if(!screencapVoiceFileName.trim().equals("")&&!screencapVoiceSrc.trim().equals("")&&screencapVoiceFileName.indexOf(".")>-1)
        {
            result.put("screencapVoiceFileName", screencapVoiceFileName);
            result.put("screencapVoiceSrc1", screencapVoiceSrc);
            result.put("screencapVoiceSrc2", "voice/voice"+base.getSceneNum()+"/201810" +screencapVoiceFileName.substring(screencapVoiceFileName.lastIndexOf(".")));
        }

        return Result.success();
    }

    @Override
    public Result uploadScreencapVoiceNew(String sceneNum, String type, String fileName, MultipartFile file, String length, String replace) throws Exception{
        if(StringUtils.isEmpty(sceneNum)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        if (!file.isEmpty()&& file.getSize() <= 0) {
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
        }
        //文件上传的位置可以自定义
        String path = ConstantFilePath.SCENE_PATH+"voice"+File.separator+"voice"+sceneNum;
        File targetFile = new File(path);
        if (!targetFile.exists()) {
            targetFile.mkdirs();
        }

        //获取文件名去掉后缀
        String originalFileName = file.getOriginalFilename().substring(0,
                file.getOriginalFilename().indexOf(".") > 0 ? file.getOriginalFilename().indexOf(".") : file.getOriginalFilename().length());
        log.info("上传的音频文件名：" + file.getOriginalFilename());
        String soundFileName = "sound201810.wav";

        String strsceneInfos = FileUtils.readFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }
        if("soundsync".equals(type) && !"1".equals(replace)){
            synchronized(this){
                if(scenejson.containsKey("screencapVoiceSoundsync") && !StringUtils.isEmpty(scenejson.getString("screencapVoiceSoundsync"))){
                    String target = ConstantFilePath.SCENE_PATH + scenejson.getString("screencapVoiceSoundsync").substring(
                            scenejson.getString("screencapVoiceSoundsync").indexOf("voice"));

                    if(new File(target).exists()){
                        targetFile = new File(path + File.separator +soundFileName);
                        if(targetFile.exists())
                        {
                            FileUtils.deleteFile(path + File.separator + soundFileName);
                        }
                        file.transferTo(targetFile);
                        FileUtils.changeVoiceToMp3(path + File.separator + soundFileName, path + File.separator + "newSound201810.mp3");

                        //目标文件改名
                        new File(target).renameTo(new File(path + File.separator + "oldSound201810.mp3"));

                        //判断音频时长，不够拼接空白音效
                        double total = Double.parseDouble(length);
                        double now = (FileUtils.getAudioPlayTime(new File(path + File.separator + "oldSound201810.mp3")) +
                                FileUtils.getAudioPlayTime(new File(path + File.separator + "newSound201810.mp3"))) / 1000.0;
                        if(total - now > 0.5){
                            CreateObjUtil.createMuteViode(total - now, path + File.separator + "muteSound.mp3");
                            if(new File(path + File.separator + "muteSound.mp3").exists()){
                                //需要将旧的音频改名
                                new File(path + File.separator + "oldSound201810.mp3").renameTo(new File(path + File.separator + "oldMuteSound201810.mp3"));
                                log.info("生成新的静音音频和旧的音频合并");
                                CreateObjUtil.mergeVideo(path + File.separator + "oldMuteSound201810.mp3", path + File.separator + "muteSound.mp3",
                                        path + File.separator + "oldSound201810.mp3");
                            }
                        }

                        //app端和pc端名字不一致，统一文件名字
                        target = path + File.separator + originalFileName + ".mp3";
                        CreateObjUtil.mergeVideo(path + File.separator + "oldSound201810.mp3", path + File.separator + "newSound201810.mp3", target);
                        //删除改名后的文件
//                    new File(path + File.separator + "oldSound201810.mp3").delete();

                        Map map = new HashMap();
                        map.put("screencapVoiceSoundsyncFileName", originalFileName + ".mp3");
                        String proVideo = "voice/voice"+sceneNum+"/"+originalFileName  + ".mp3";
                        map.put("screencapVoiceSoundsync", proVideo);
                        map.put("uploadVoiceSoundsync", 1);
                        map.put("screencapVoiceType", type);
                        map.put("version", scenejson.getIntValue("version")+1);
                        FileUtils.writeJsonFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json", map);
                        return Result.success("voice/voice"+sceneNum+"/"+originalFileName + ".mp3");
                    }

                }else {
                    targetFile = new File(path + File.separator +soundFileName);
                    if(targetFile.exists())
                    {
                        FileUtils.deleteFile(path + File.separator + soundFileName);
                    }
                    file.transferTo(targetFile);
                    //判断音频时长，不够拼接空白音效
                    FileUtils.changeVoiceToMp3(path + File.separator + soundFileName, path + File.separator + "newSound201810.mp3");
                    double total = Double.parseDouble(length);
                    double now = (FileUtils.getAudioPlayTime(new File(path + File.separator + "newSound201810.mp3"))) / 1000.0;
                    log.info("前端传的时长：" + total);
                    log.info("获取文件的时长：" + now);

                    //同步录音前一段没空白，直接生成文件
                    if(total - now < 0.5){
                        FileUtils.changeVoiceToMp3(path + File.separator + soundFileName, path + File.separator + originalFileName + ".mp3");
                        Map map = new HashMap();
                        map.put("screencapVoiceSoundsyncFileName", originalFileName + ".mp3");
                        String proVideo = "voice/voice"+sceneNum+"/"+originalFileName  + ".mp3";
                        map.put("screencapVoiceSoundsync", proVideo);
                        map.put("uploadVoiceSoundsync", 1);
                        map.put("screencapVoiceType", type);
                        map.put("version", scenejson.getIntValue("version")+1);

                        FileUtils.writeJsonFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json", map);
                        //uploadToQiniuForScene3DService.upload(path + File.separator +fileName, "voice/voice"+sceneNum+"/"+CONSTANTFILENAME.VOICENAME +fileName.substring(fileName.lastIndexOf(".")));
                        //sceneService.updateScreencapMusic(sceneNum, voiceSrc);
                        return Result.success(proVideo);
                    }

                    ////同步录音前一段有空白，生成一段静音后拼接文件
                    CreateObjUtil.createMuteViode(total - now, path + File.separator + "muteSound.mp3");

                    //app端和pc端名字不一致，统一文件名字
                    String target = path + File.separator + originalFileName + ".mp3";
                    CreateObjUtil.mergeVideo(path + File.separator + "muteSound.mp3", path + File.separator + "newSound201810.mp3", target);

                    Map map = new HashMap();
                    map.put("screencapVoiceSoundsyncFileName", originalFileName + ".mp3");
                    String proVideo = "voice/voice"+sceneNum+"/"+originalFileName  + ".mp3";
                    map.put("screencapVoiceSoundsync", proVideo);
                    map.put("uploadVoiceSoundsync", 1);
                    map.put("screencapVoiceType", type);
                    map.put("version", scenejson.getIntValue("version")+1);
                    FileUtils.writeJsonFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json", map);
                    return Result.success("voice/voice"+sceneNum+"/"+originalFileName + ".mp3");
                }

            }
        }

        String name = "201810.wav";
        targetFile = new File(path + File.separator +name);
        // 保存
        synchronized(this){
            if(targetFile.exists())
            {
                FileUtils.deleteFile(path + File.separator + name);
            }
            file.transferTo(targetFile);
        }
        Map map = new HashMap();

        if("soundsync".equals(type)){
            FileUtils.changeVoiceToMp3(path + File.separator + name, path + File.separator + originalFileName + ".mp3");
            map.put("screencapVoiceSoundsyncFileName", originalFileName + ".mp3");
            String proVideo = "voice/voice"+sceneNum+"/"+originalFileName  + ".mp3";
            map.put("screencapVoiceSoundsync", proVideo);
            map.put("uploadVoiceSoundsync", 1);
            map.put("version", scenejson.getIntValue("version")+1);
            map.put("screencapVoiceType", type);
            FileUtils.writeJsonFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json", map);
            return Result.success(proVideo);
        }

        if("sound".equals(type)){
            FileUtils.changeVoiceToMp3(path + File.separator + name, path + File.separator + originalFileName + ".mp3");
            map.put("screencapVoiceSoundFileName", originalFileName + ".mp3");
            String proVideo = "voice/voice"+sceneNum+"/"+originalFileName  + ".mp3";
            map.put("screencapVoiceSound", proVideo);
            map.put("uploadVoiceSound", 1);
            map.put("version", scenejson.getIntValue("version")+1);
            map.put("screencapVoiceType", type);
            FileUtils.writeJsonFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json", map);
            return Result.success(proVideo);
        }

        FileUtils.changeVoiceToMp3(path + File.separator + name, path + File.separator +"201810.mp3");
        if(StringUtils.isEmpty(fileName)){
            map.put("screencapVoiceFileName", originalFileName + ".mp3");
        }else {
            map.put("screencapVoiceFileName", fileName);
        }
        String voiceSrc = "voice/voice"+sceneNum+"/"+"201810.mp3";
        map.put("screencapVoiceSrc", voiceSrc);
        map.put("uploadVoiceSrc", 1);
        map.put("version", scenejson.getIntValue("version")+1);
        map.put("screencapVoiceType", type);
        FileUtils.writeJsonFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json", map);
        //uploadToQiniuForScene3DService.upload(path + File.separator +fileName, "voice/voice"+sceneNum+"/"+CONSTANTFILENAME.VOICENAME +fileName.substring(fileName.lastIndexOf(".")));
        //sceneService.updateScreencapMusic(sceneNum, voiceSrc);
        return Result.success(voiceSrc);
    }

    @Override
    public Result uploadScreencapVoiceNewV3(String sceneNum, String type, String fileName, MultipartFile file, String length, String replace, String times, String index) throws Exception{
        if(StringUtils.isEmpty(sceneNum)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        if (!file.isEmpty()&& file.getSize() <= 0) {
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
        }
        //文件上传的位置可以自定义
        String path = ConstantFilePath.SCENE_PATH+"voice"+File.separator+"voice"+sceneNum;
        File targetFile = new File(path);
        if (!targetFile.exists()) {
            targetFile.mkdirs();
        }

        String originalFileName = "sound201810.mp3";

        String strsceneInfos = FileUtils.readFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }
        if("soundsync".equals(type) && !"1".equals(replace)){
            //判断分房间模块文件夹是否存在
            String partPath = path + File.separator + "part";
            File partFile = new File(partPath);
            if(!partFile.exists()){
                partFile.mkdirs();
            }

            synchronized(this){
                targetFile = new File(partPath + File.separator + fileName);
                if(targetFile.exists())
                {
                    FileUtils.deleteFile(partPath + File.separator + fileName);
                }
                file.transferTo(targetFile);
            }

            //获取总音频多少段，每段时长
            String[] time = times.split(",");
            //遍历判断音频是否存在，不存在生成空白音效
            for(int i = 0, len = time.length; i < len; i++){
                if(!new File(partPath + File.separator + i + ".mp3").exists()){
                    //某部分文件不存在，直接生成一段静音后拼接文件
                    CreateObjUtil.createMuteViode(Double.valueOf(time[i]), partPath + File.separator + i + ".mp3");
                }
            }

            //拼接所有音频文件
            if(time.length > 2){
                //若是多部分，两个两个合并，最后合成最终文件
                for(int i = 1, len = time.length; i < len; i++){
                    if(i == 1){
//                        FileUtils.deleteFile(partPath + File.separator + i + "muteSound.mp3");

                        CreateObjUtil.mergeVideo(partPath + File.separator + (i - 1) + ".mp3", partPath + File.separator + i + ".mp3",
                                partPath + File.separator + i + "muteSound.mp3");
                    }else if(i == len - 1){
                        CreateObjUtil.mergeVideo(partPath + File.separator + (i - 1) + "muteSound.mp3", partPath + File.separator + i + ".mp3",
                                path + File.separator + originalFileName);
                    }else {
                        CreateObjUtil.mergeVideo(partPath + File.separator + (i - 1) + "muteSound.mp3", partPath + File.separator + i + ".mp3",
                                partPath + File.separator + i + "muteSound.mp3");
                    }
                }
            }else {
                //若只有两部分，直接合并成最终文件
                CreateObjUtil.mergeVideo(partPath + File.separator + "0.mp3", partPath + File.separator + "1.mp3", path + File.separator + originalFileName);
            }

            Map map = new HashMap();
            map.put("screencapVoiceSoundsyncFileName", originalFileName);
            String proVideo = "voice/voice"+sceneNum+"/"+originalFileName;
            map.put("screencapVoiceSoundsync", proVideo);
            map.put("uploadVoiceSoundsync", 1);
            map.put("screencapVoiceType", type);
            map.put("version", scenejson.getIntValue("version")+1);
            FileUtils.writeJsonFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json", map);
            return Result.success("voice/voice"+sceneNum+"/"+originalFileName);
        }

        String name = "201810.wav";
        targetFile = new File(path + File.separator +name);
        // 保存
        synchronized(this){
            if(targetFile.exists())
            {
                FileUtils.deleteFile(path + File.separator + name);
            }
            file.transferTo(targetFile);
        }
        Map map = new HashMap();

        if("soundsync".equals(type)){
            FileUtils.delAllFile(path + File.separator + "part");
            //判断分房间模块文件夹是否存在
            String partPath = path + File.separator + "part";
            File partFile = new File(partPath);
            if(!partFile.exists()){
                partFile.mkdirs();
            }

            //保存0.mp3文件到part
            FileUtils.copyFile(path + File.separator +name, partPath + File.separator + fileName, true);

            FileUtils.changeVoiceToMp3(path + File.separator + name, path + File.separator + originalFileName);
            map.put("screencapVoiceSoundsyncFileName", originalFileName);
            String proVideo = "voice/voice"+sceneNum+"/"+originalFileName;
            map.put("screencapVoiceSoundsync", proVideo);
            map.put("uploadVoiceSoundsync", 1);
            map.put("version", scenejson.getIntValue("version")+1);
            map.put("screencapVoiceType", type);
            FileUtils.writeJsonFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json", map);
            return Result.success(proVideo);
        }

//        if("sound".equals(type)){
//            FileUtils.changeVoiceToMp3(path + File.separator + name, path + File.separator + originalFileName);
//            map.put("screencapVoiceSoundFileName", originalFileName);
//            String proVideo = "voice/voice"+sceneNum+"/"+originalFileName;
//            map.put("screencapVoiceSound", proVideo);
//            map.put("uploadVoiceSound", 1);
//            map.put("version", scenejson.getIntValue("version")+1);
//            map.put("screencapVoiceType", type);
//            FileUtils.writeJsonFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json", map);
//            return Result.success(proVideo);
//        }

        FileUtils.changeVoiceToMp3(path + File.separator + name, path + File.separator +"201810.mp3");
        map.put("screencapVoiceFileName", file.getOriginalFilename());
        String voiceSrc = "voice/voice"+sceneNum+"/"+"201810.mp3";
        map.put("screencapVoiceSrc", voiceSrc);
        map.put("uploadVoiceSrc", 1);
        map.put("version", scenejson.getIntValue("version")+1);
        map.put("screencapVoiceType", type);
        FileUtils.writeJsonFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json", map);
        return Result.success(voiceSrc);
    }

    @Override
    public Result deleteScreencapVoicePart(String sceneNum, String fileName, String times, String index) throws Exception {
        if(StringUtils.isEmpty(sceneNum)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        //文件上传的位置可以自定义
        String path = ConstantFilePath.SCENE_PATH+"voice"+File.separator+"voice"+sceneNum;
        File targetFile = new File(path);
        if (!targetFile.exists()) {
            targetFile.mkdirs();
        }

        String originalFileName = "sound201810.mp3";
        log.info("上传的音频文件名：" + originalFileName);

        String strsceneInfos = FileUtils.readFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }
        //判断分房间模块文件夹是否存在
        String partPath = path + File.separator + "part";
        File partFile = new File(partPath);
        if(!partFile.exists()){
            partFile.mkdirs();
        }

        //删除指定部分音频文件
        FileUtils.deleteFile(partPath + File.separator + index + ".mp3");

        //获取总音频多少段，每段时长
        String[] time = times.split(",");
        //修改删除的部分视频后面部分音频名字，如删除1.MP3，则将2.mp3修改成1.mp3，往后以此类推
        if(Integer.parseInt(index) < time.length) {
            for(int i = 0, len = time.length - Integer.parseInt(index); i < len; i++){
                if(new File(partPath + File.separator + (Integer.parseInt(index) + 1 + i) + ".mp3").exists()){
                    FileUtils.copyFile(partPath + File.separator + (Integer.parseInt(index) + 1 + i) + ".mp3",
                            partPath + File.separator + (Integer.parseInt(index) + i) + ".mp3", true);
                }
            }
        }

        //遍历判断音频是否存在，不存在生成空白音效
        for(int i = 0, len = time.length; i < len; i++){
            if(!new File(partPath + File.separator + i + ".mp3").exists()){
                //某部分文件不存在，直接生成一段静音后拼接文件
                CreateObjUtil.createMuteViode(Double.valueOf(time[i]), partPath + File.separator + i + ".mp3");
            }
        }

        //拼接所有音频文件
        if(time.length > 2){
            //若是多部分，两个两个合并，最后合成最终文件
            for(int i = 1, len = time.length; i < len; i++){
                if(i == 1){
//                    FileUtils.deleteFile(partPath + File.separator + i + "muteSound.mp3");

                    CreateObjUtil.mergeVideo(partPath + File.separator + (i - 1) + ".mp3", partPath + File.separator + i + ".mp3",
                            partPath + File.separator + i + "muteSound.mp3");
                }else if(i == len - 1){
                    CreateObjUtil.mergeVideo(partPath + File.separator + (i - 1) + "muteSound.mp3", partPath + File.separator + i + ".mp3",
                            path + File.separator + originalFileName);
                }else {
                    CreateObjUtil.mergeVideo(partPath + File.separator + (i - 1) + "muteSound.mp3", partPath + File.separator + i + ".mp3",
                            partPath + File.separator + i + "muteSound.mp3");
                }
            }
        }else if(time.length == 2){
            //若只有两部分，直接合并成最终文件
            CreateObjUtil.mergeVideo(partPath + File.separator + "0.mp3", partPath + File.separator + "1.mp3", path + File.separator + originalFileName);
        }else {
            FileUtils.copyFile(partPath + File.separator + "0.mp3", path + File.separator + originalFileName, true);
        }

        Map map = new HashMap();
        map.put("screencapVoiceSoundsyncFileName", originalFileName);
        String proVideo = "voice/voice"+sceneNum+"/"+originalFileName;
        map.put("screencapVoiceSoundsync", proVideo);
        map.put("uploadVoiceSoundsync", 1);
        map.put("screencapVoiceType", "soundsync");
        map.put("version", scenejson.getIntValue("version")+1);
        FileUtils.writeJsonFile(ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + File.separator + "scene.json", map);
        return Result.success("voice/voice"+sceneNum+"/"+originalFileName);
    }

    @Override
    public Result deleteScreencapVoice(RequestSceneEdit base) throws Exception{
        if(StringUtils.isEmpty(base.getSceneNum())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        String scenePath = ConstantFilePath.SCENE_PATH+ "data" + File.separator+"data"+base.getSceneNum()+File.separator+"scene.json";
        String str = FileUtils.readFile(scenePath);
        JSONObject json = new JSONObject();
        if(str!=null){
            json = JSONObject.parseObject(str);
        }
        else{
            File file = new File(scenePath);
            if(!file.getParentFile().exists())
            {
                file.getParentFile().mkdirs();
            }
            if(!file.exists())
            {
                file.createNewFile();
            }
        }
        log.info("type:" + base.getType());
        if("soundsync".equals(base.getType())){
            FileUtils.deleteFile(ConstantFilePath.SCENE_PATH+json.getString("screencapVoiceSoundsync"));
            json.put("screencapVoiceSoundsyncFileName", "");
            json.put("screencapVoiceSoundsync", "");
            json.put("version", json.getIntValue("version")+1);
            FileUtils.deleteFile(scenePath);
            FileUtils.writeFile(scenePath, json.toString());
            return Result.success();
        }

        if("sound".equals(base.getType())){
            FileUtils.deleteFile(ConstantFilePath.SCENE_PATH+json.getString("screencapVoiceSound"));
            json.put("screencapVoiceSoundFileName", "");
            json.put("screencapVoiceSound", "");
            json.put("version", json.getIntValue("version")+1);
            FileUtils.deleteFile(scenePath);
            FileUtils.writeFile(scenePath, json.toString());
            return Result.success();
        }

        String path = ConstantFilePath.SCENE_PATH+json.getString("screencapVoiceSrc");
        log.info("path:" + ConstantFilePath.SCENE_PATH+json.getString("screencapVoiceSrc"));
        FileUtils.deleteFile(path);

        json.put("screencapVoiceFileName", "");
        json.put("screencapVoiceSrc", "");
        json.put("version", json.getIntValue("version")+1);
        log.info("scenePath:" + scenePath);
        FileUtils.deleteFile(scenePath);
        FileUtils.writeFile(scenePath, json.toString());
        return Result.success();
    }

    @Override
    public Result deleteScreencap(RequestSceneEdit base) throws Exception{
        if(StringUtils.isEmpty(base.getSceneNum())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String capPath = dataBuffer.toString() + ConstantFileName.TOURLIST_FOLDER;
        File file1 = new File(capPath);
        String[] strs = file1.list();
        //删除screenCap对应的json数据
        if(strs!=null) {
            for(int i=0;i<strs.length;++i) {
                if(strs[i].indexOf(ConstantFileName.SCREEN_CRP_DATAFILE)>-1) {
                    FileUtils.deleteFile(capPath+File.separator+strs[i]);
                }
            }
        }

        String imgPath = imagesBuffer.toString() + ConstantFileName.TOURLIST_FOLDER;

        String tourListPath = dataBuffer.toString() + ConstantFileName.TOUR_LIST;
        String tourList = FileUtils.readFile(tourListPath);
        JSONArray tourJsons = new JSONArray();
        if(tourList!=null) {
            tourJsons = JSONArray.parseArray(tourList);
        }
        for(int i=0;i<tourJsons.size();++i) {
            String filePath = imgPath + File.separator +"guide"+i+".jpg";
            FileUtils.deleteFile(filePath);
        }
        FileUtils.deleteFile(tourListPath);

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }
        Map<String, Object> map = new HashMap<>();
        map.put("screencapLen", 0);
        map.put("uploadTourList", 1);
        map.put("version", scenejson.getIntValue("version") + 1);
        FileUtils.writeJsonFile(dataBuffer.toString() + "scene.json", map);

        return Result.success();
    }

    @Override
    public Result saveTourList(RequestSceneEdit base) throws Exception{
        if(StringUtils.isEmpty(base.getSceneNum()) || StringUtils.isEmpty(base.getTourList()) ||
                StringUtils.isEmpty(base.getScreencapLen())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }
        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

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

        log.info("editScene/saveTourList：生成tourList.json文件");
        String tourListPath = dataBuffer.toString() + ConstantFileName.TOUR_LIST;
        FileUtils.writeFile(tourListPath, base.getTourList());

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        Map<String, Object> map = new HashMap<>();
        map.put("screencapLen", String.valueOf(base.getScreencapLen()));
//			map.put("tourList", tourList);
        map.put("uploadTourList", 1);
        map.put("version", scenejson.getIntValue("version")+1);
        FileUtils.writeJsonFile(dataBuffer.toString() + "scene.json", map);

        return Result.success();
    }

    @Override
    public Result saveSceneInfo(RequestSceneEdit base) throws Exception{
        if(StringUtils.isEmpty(base.getSceneNum())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .append(File.separator);

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

        int type = Integer.valueOf(base.getSceneType());

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        //上传七牛
        Map<String,String> map = new HashMap<String,String>();

        SceneProEditEntity sceneProEditEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());

        if(!StringUtils.isEmpty(base.getTourList())){
            if(scenejson.containsKey("uploadTourList") && scenejson.getIntValue("uploadTourList") == 1){
                int screencapLen = 0;
                File file = new File(dataBuffer.toString() + ConstantFileName.TOURLIST_FOLDER);
                String[] strs = file.list();
                if(strs!=null) {
                    for(int i=0;i<strs.length;++i) {
                        if(strs[i].indexOf(ConstantFileName.SCREEN_CRP_DATAFILE)>-1)
                        {
                            ++screencapLen;
                            map.put(dataBuffer.toString() + ConstantFileName.TOURLIST_FOLDER+File.separator+strs[i],
                                    "data/data"+base.getSceneNum()+"/tour/"+strs[i]);
                        }
                    }
                }
                scenejson.put("screencapLen", screencapLen);
//                sceneProEditEntity.setScreencapLen(screencapLen);

                String path = imagesBuffer.toString() + ConstantFileName.TOURLIST_FOLDER;
                JSONArray tourJsons = JSONArray.parseArray(base.getTourList());
                for(int i=0;i<tourJsons.size();++i) {
                    String fileName = path + File.separator +"guide"+i+".jpg";
                    map.put(fileName,"images/images"+base.getSceneNum()+"/tour/guide"+i+".jpg");
                }

                scenejson.put("uploadTourList", 0);
            }

            String tourListPath = dataBuffer.toString() + ConstantFileName.TOUR_LIST;
            FileUtils.deleteFile(tourListPath);
            FileUtils.writeFile(tourListPath, base.getTourList());
            map.put(tourListPath, dataBuffer.toString() + ConstantFileName.TOUR_LIST);
        }
        else{
            if(scenejson.containsKey("uploadTourList") && scenejson.getIntValue("uploadTourList") == 1){
                scenejson.put("uploadTourList", 0);
            }
            scenejson.put("screencapLen", 0);
//            sceneProEditEntity.setScreencapLen(0);
        }

        //判断scene.json是否有uploadVoiceSrc上传普通版音频
        if(scenejson.containsKey("uploadVoiceSrc") && scenejson.getIntValue("uploadVoiceSrc") == 1) {
            String screencapVoiceFileName = "";
            if(scenejson.containsKey("screencapVoiceFileName")) {
                screencapVoiceFileName = scenejson.getString("screencapVoiceFileName");
            }
            String screencapVoiceSrc = "";
            if(scenejson.containsKey("screencapVoiceSrc")) {
                screencapVoiceSrc = scenejson.getString("screencapVoiceSrc");
            }

            if(screencapVoiceFileName.indexOf(".")>-1) {
                String fileName = "201810" + screencapVoiceFileName.substring(screencapVoiceFileName.lastIndexOf("."));
                String path = ConstantFilePath.SCENE_PATH + "voice" + File.separator+"voice"+base.getSceneNum()+File.separator+fileName;
                map.put(path, "voice/voice"+base.getSceneNum()+"/201810" +screencapVoiceFileName.substring(screencapVoiceFileName.lastIndexOf(".")));
            }
            sceneProEditEntity.setScreencapVoiceSrc(screencapVoiceSrc);
        }

        //判断scene.json是否有uploadVoiceSound上传专业版音频
        if(scenejson.containsKey("uploadVoiceSound") && scenejson.getIntValue("uploadVoiceSound") == 1){
            if(!StringUtils.isEmpty(scenejson.getString("screencapVoiceSound"))){
                map.put(ConstantFilePath.SCENE_PATH + scenejson.getString("screencapVoiceSound"), scenejson.getString("screencapVoiceSound"));
            }
            sceneProEditEntity.setScreencapVoiceSound(scenejson.getString("screencapVoiceSound"));
        }

        if(scenejson.containsKey("uploadVoiceSoundsync") && scenejson.getIntValue("uploadVoiceSoundsync") == 1){
            if(!StringUtils.isEmpty(scenejson.getString("screencapVoiceSoundsync"))){
                map.put(ConstantFilePath.SCENE_PATH + scenejson.getString("screencapVoiceSoundsync"), scenejson.getString("screencapVoiceSoundsync"));
            }
            sceneProEditEntity.setScreencapVoiceSoundsync(scenejson.getString("screencapVoiceSoundsync"));
        }

        if(base.getScreencapVoiceType() != null){
            scenejson.put("screencapVoiceType", base.getScreencapVoiceType());
            sceneProEditEntity.setScreencapVoiceType(base.getScreencapVoiceType());
        }

        if(!StringUtils.isEmpty(base.getCapData())){
            FileUtils.writeFile(dataBuffer.toString() + "capData.json", new String(base.getCapData().getBytes(), "UTF-8"));
            scenejson.put("capData", dataBuf.toString() + "capData.json");
        }

        if(!StringUtils.isEmpty(base.getFrameData())){
            FileUtils.writeFile(dataBuffer.toString() + "frameData.json", new String(base.getFrameData().getBytes(), "UTF-8"));
            scenejson.put("frameData", dataBuf.toString() + "frameData.json");
        }

        if(!StringUtils.isEmpty(base.getPlayData())){
            FileUtils.writeFile(dataBuffer.toString() + "playData.json", new String(base.getPlayData().getBytes(), "UTF-8"));
            scenejson.put("playData", dataBuf.toString() + "playData.json");
            sceneProEditEntity.setPlayData(dataBuf.toString() + "playData.json");
            map.put(dataBuffer.toString() + "playData.json", dataBuf.toString() + "playData.json");
        }

        if(!StringUtils.isEmpty(base.getScreencapThumb())){
            FileUtils.writeFile(dataBuffer.toString() + "screencapThumb.json", new String(base.getScreencapThumb().getBytes(), "UTF-8"));
            scenejson.put("screencapThumb", dataBuf.toString() + "screencapThumb.json");
            sceneProEditEntity.setScreencapThumb(dataBuf.toString() + "screencapThumb.json");
            map.put(dataBuffer.toString() + "screencapThumb.json", dataBuf.toString() + "screencapThumb.json");
        }

        if(!StringUtils.isEmpty(base.getRecordType())){
            scenejson.put("recordType", base.getRecordType());
        }

        if(!StringUtils.isEmpty(base.getMapVisi())){
            scenejson.put("mapVisi", Integer.parseInt(base.getMapVisi()));
            sceneProEditEntity.setMapVisi(Integer.parseInt(base.getMapVisi()));
        }

        if(!StringUtils.isEmpty(base.getTourVisi())){
            scenejson.put("tourVisi", Integer.parseInt(base.getTourVisi()));
            sceneProEditEntity.setTourVisi(Integer.parseInt(base.getTourVisi()));
        }
        if(!StringUtils.isEmpty(base.getVrVisi())){
            scenejson.put("vrVisi", Integer.parseInt(base.getVrVisi()));
            sceneProEditEntity.setVrVisi(Integer.parseInt(base.getVrVisi()));
        }

        if(!StringUtils.isEmpty(base.getRulerVisi())){
            scenejson.put("rulerVisi", Integer.parseInt(base.getRulerVisi()));
            sceneProEditEntity.setRulerVisi(Integer.parseInt(base.getRulerVisi()));
        }
        if(!StringUtils.isEmpty(base.getCadImgVisi())){
            scenejson.put("cadImgVisi", Integer.parseInt(base.getCadImgVisi()));
            sceneProEditEntity.setCadImgVisi(Integer.parseInt(base.getCadImgVisi()));
        }

        if(!StringUtils.isEmpty(base.getPanoVisi())){
            scenejson.put("panoVisi", Integer.parseInt(base.getPanoVisi()));
            sceneProEditEntity.setPanoVisi(Integer.parseInt(base.getPanoVisi()));
        }

        if(!StringUtils.isEmpty(base.getM2dVisi())){
            scenejson.put("m2dVisi", Integer.parseInt(base.getM2dVisi()));
            sceneProEditEntity.setM2dVisi(Integer.parseInt(base.getM2dVisi()));
        }
        if(!StringUtils.isEmpty(base.getM3dVisi())){
            scenejson.put("m3dVisi", Integer.parseInt(base.getM3dVisi()));
            sceneProEditEntity.setM3dVisi(Integer.parseInt(base.getM3dVisi()));
        }
        if(!StringUtils.isEmpty(base.getMeasureVisi())){
            scenejson.put("measureVisi", Integer.parseInt(base.getMeasureVisi()));
            sceneProEditEntity.setMeasureVisi(Integer.parseInt(base.getMeasureVisi()));
        }

        if(!StringUtils.isEmpty(base.getFloorPlanAngle())){
            scenejson.put("floorPlanAngle", base.getFloorPlanAngle());
            sceneProEditEntity.setFloorPlanAngle(base.getFloorPlanAngle());
        }

        if(scenejson.containsKey("uploadFloorPlanPng") && scenejson.getIntValue("uploadFloorPlanPng") == 1){
            JSONArray floorPlanPngStr = new JSONArray();
            JSONArray floorPlanPng = scenejson.getJSONArray("floorPlanPng");

            scenejson.put("uploadFloorPlanPng", 0);
            for(int i = 0, len = floorPlanPng.size(); i < len; i++){
                map.put(ConstantFilePath.SCENE_PATH+floorPlanPng.getString(i), floorPlanPng.getString(i));
                floorPlanPngStr.add(floorPlanPng.getString(i) + "?t=" + System.currentTimeMillis());
            }
            sceneProEditEntity.setFloorPlanPng(floorPlanPngStr.toJSONString());
        }

        if(scenejson.containsKey("uploadFloorJson") && scenejson.getIntValue("uploadFloorJson") == 1){
            map.put(dataBuffer.toString() + "floor.json", dataBuf.toString() + "floor.json");
            scenejson.put("uploadFloorJson", 0);
        }

        if(StringUtil.isNotEmpty(base.getEntry())) {
            //上传七牛
            map.put(imagesBuffer.toString() + "thumbBigImg.jpg", imagesBuf.toString() + "thumbBigImg.jpg");
            map.put(imagesBuffer.toString() + "thumbFishBigImg.jpg",imagesBuf.toString() + "thumbFishBigImg.jpg");
            map.put(imagesBuffer.toString() + "thumbSmallImg.jpg", imagesBuf.toString() + "thumbSmallImg.jpg");
            map.put(imagesBuffer.toString() + "smallPic.jpg", imagesBuf.toString() + "smallPic.jpg");
            sceneProEditEntity.setEntry(base.getEntry());

            scenejson.put("entry", base.getEntry());

            if(scenejson.containsKey("thumbImg"))
            {
                sceneProEditEntity.setThumbStatus(scenejson.getIntValue("thumbImg"));
            }

            if(sceneProEditEntity.getThumbStatus() == 1)
            {
                sceneProEntity.setThumb(prefixAli + imagesBuf.toString() + "thumbSmallImg.jpg");
                if("s3".equals(this.type)){
                    sceneProEntity.setThumb(ConstantUrl.PREFIX_AWS + imagesBuf.toString() + "thumbSmallImg.jpg");
                }
            }

        }

        if(base.getHotFlag() != null && "1".equals(base.getHotFlag())) {
            String str = FileUtils.readFile(dataBuffer.toString() + "hot.json");
            JSONArray jsonhots = new JSONArray();

            if(str != null&&!str.trim().equals("")) {
                jsonhots = JSONArray.parseArray(str);
            }
            String hotsids = "";
            for(int i=0;i<jsonhots.size();++i) {
                JSONObject ele = jsonhots.getJSONObject(i);
                String index = ele.getString("sid");
                hotsids+=index+",";
                if(ele.containsKey("media"))
                {
                    String fileType = ele.getString("media");
                    if(fileType.contains("photo"))
                    {
                        map.put(imagesBuffer.toString() + "hot"+index+".jpg",
                                imagesBuf.toString() + "hot"+index+".jpg");
                    }
                    if(fileType.contains("audio") || fileType.contains("voice"))
                    {
                        map.put(imagesBuffer.toString() + "hot"+index+".mp3",
                                imagesBuf.toString() + "hot"+index+".mp3");
                    }
                    if(fileType.contains("video"))
                    {
                        map.put(imagesBuffer.toString() + "hot"+index+".mp4",
                                imagesBuf.toString() + "hot"+index+".mp4");
                        map.put(imagesBuffer.toString() + "hot"+index+"-cut.jpg",
                                imagesBuf.toString() + "hot"+index+"-cut.jpg");
                    }
                }

            }
//            File hotdic = new File(ConstantFilePath.SCENE_PATH+"images"+File.separator+"images"+base.getSceneNum());
//            if(!hotdic.exists()) {
//                hotdic.mkdirs();
//            }
//            String[] fileNames = hotdic.list();
//            for(int i=0;i<fileNames.length;++i) {
//                if(fileNames[i].contains("hot")&&!hotsids.contains(fileNames[i].substring(0, fileNames[i].lastIndexOf(".")).replace("hot", ""))) {
//                    FileUtils.deleteFile(imagesBuffer.toString() + fileNames[i]);
//                }
//            }
            map.put(dataBuffer.toString() + "hot.json",dataBuf.toString() + "hot.json");
            //sceneService.updateHots(sceneNum,hotsids);
            sceneProEditEntity.setHotsIds(hotsids);
        }

        if(StringUtil.isNotEmpty(base.getFloorLogoType())) {
            sceneProEditEntity.setFloorLogo(base.getFloorLogoType());
            scenejson.put("floorLogo", base.getFloorLogoType());
            if(base.getFloorLogoType().trim().equals("1")||base.getFloorLogoType().trim().equals("user")) {
                map.put(imagesBuffer.toString() + "floorLogoImg.png", imagesBuf.toString() + "floorLogoImg.png");
            }
        }

        if(StringUtil.isNotEmpty(base.getFloorLogoSize())) {
            sceneProEditEntity.setFloorLogoSize(Integer.valueOf(base.getFloorLogoSize()));
            scenejson.put("floorLogoSize", base.getFloorLogoSize());
        }

        if(base.getBgMusic() != null) {
            sceneProEditEntity.setBgMusic(base.getBgMusic());
            scenejson.put("bgMusic", base.getBgMusic());
        }

        if(base.getSceneName() != null) {
            sceneProEntity.setSceneName(base.getSceneName());
            scenejson.put("sceneName", base.getSceneName());
        }

        if(StringUtil.isNotEmpty(base.getSceneType())) {
            if(sceneProEntity.getSceneType() == 99){
                scenejson.put("sceneType", sceneProEntity.getSceneType());
            }else {
                sceneProEntity.setSceneType(type);
                scenejson.put("sceneType", base.getSceneType());
            }
        }

        if(base.getSceneDec() != null) {
            sceneProEntity.setSceneDec(base.getSceneDec());
            scenejson.put("sceneDec", base.getSceneDec());
        }

//        if(StringUtil.isNotEmpty(base.getSceneIndex())) {
//            sceneProEntity.setStyle(Integer.valueOf(base.getSceneIndex()));
//            scenejson.put("sceneIndex", base.getSceneIndex());
//        }

        if(!StringUtils.isEmpty(base.getSceneKey())) {
            sceneProEditEntity.setSceneKey(base.getSceneKey());
            sceneProEditEntity.setNeedKey(1);
            scenejson.put("sceneKey", base.getSceneKey());
            scenejson.put("needKey", 1);
        }else {
            sceneProEditEntity.setSceneKey("");
            sceneProEditEntity.setNeedKey(0);
            scenejson.put("sceneKey", "");
            scenejson.put("needKey", 0);
        }

        if(!scenejson.containsKey("version")) {
            scenejson.put("version", 0);
        }
        scenejson.put("version", scenejson.getIntValue("version")+1);
        map.put(dataBuffer.toString() + "scene.json", dataBuf.toString() + "scene.json");

        sceneProEditEntity.setCadInfo(scenejson.getString("cadInfo"));
        sceneProEditEntity.setVersion(scenejson.getIntValue("version"));
        sceneProEditMapper.updateByPrimaryKeySelective(sceneProEditEntity);

        //重建上传资源到oss
        if(sceneProEditEntity.getFloorEditVer() != sceneProEditEntity.getFloorPublishVer()){
            //上传过模型，只更新floor.json
            if(scenejson.containsKey("isUploadObj") && scenejson.getBooleanValue("isUploadObj")){
                map.put(dataBuffer.toString() + "floor.json", dataBuf.toString() + "floor.json");
                //发布重新建模场景，将floorPublishVer设为floorEditVer的值
                sceneProEditEntity.setFloorPublishVer(sceneProEditEntity.getFloorEditVer());

                scenejson.put("floorEditVer", sceneProEditEntity.getFloorEditVer());
                scenejson.put("floorPublishVer", sceneProEditEntity.getFloorEditVer());
            }else {

                String path = sceneProEntity.getDataSource();
                if(path != null && !"".equals(path) && path.startsWith("http")){
                    path = ConstantFilePath.BUILD_MODEL_PATH + path.split("/")[path.split("/").length - 2];
                }
                path = path + "_edit";
                String projectNum = base.getSceneNum();

                //读取upload文件，检验需要上传的文件是否存在
                String uploadData = FileUtils.readFile(path + File.separator + "results" +File.separator+"upload.json");
                JSONObject uploadJson = null;
                JSONArray array = null;
                if(uploadData!=null) {
                    uploadJson = JSONObject.parseObject(uploadData);
                    array = uploadJson.getJSONArray("upload");
                }
                if(array != null){
                    JSONObject fileJson = null;
                    String fileName = "";
                    for(int i = 0, len = array.size(); i < len; i++){
                        fileJson = array.getJSONObject(i);
                        fileName = fileJson.getString("file");
                        //文件不存在抛出异常
                        if(!new File(path + File.separator + "results" +File.separator + fileName).exists()){
                            throw new Exception(path + File.separator + "results" +File.separator + fileName+"文件不存在");
                        }

                        //tex文件夹
                        if(fileJson.getIntValue("clazz") == 2 && !fileJson.containsKey("pack-file")){
                            map.put(path + File.separator + "results" +File.separator+ fileName,"images/images"+
                                    projectNum+"/"+ConstantFileName.modelUUID+"_50k_texture_jpg_high1/"+fileName.replace("tex/", ""));
                        }

                        //2048的模型和贴图
                        if(fileJson.getIntValue("clazz") == 16){
                            map.put(path + File.separator + "results" + File.separator+ fileName,"data/data"+
                                    projectNum+ File.separator + fileName);
                        }
                    }

                    map.put(path + File.separator + "results" +File.separator+ConstantFileName.modelUUID+"_50k.dam.lzma", "images/images"+projectNum+"/"+ConstantFileName.modelUUID+"_50k.dam.lzma");
                    map.put(path + File.separator + "results" +File.separator+ConstantFileName.modelUUID+"_50k.dam", "images/images"+projectNum+"/"+ConstantFileName.modelUUID+"_50k.dam");
//        map.put(path + File.separator + "results" +File.separator+"modeldata.js","data/"+projectNum+"/"+"modeldata.js");

//				map.put(path + File.separator + "results" +File.separator+"vision.modeldata", "images/images"+projectNum+"/"+"vision.modeldata");
//				if(new File(path + File.separator + "results" +File.separator+"vision2.modeldata").exists()){
//					map.put(path + File.separator + "results" +File.separator+"vision2.modeldata", "images/images"+projectNum+"/"+"vision2.modeldata");
//				}
//				List<String> list1 = FileUtil.readfileNamesForDirectory(path + File.separator + "results" +File.separator+"tex",".jpg");
//				for(int i=0;i<list1.size();++i)
//				{
//					String imgName = list1.get(i);
//					map.put(path + File.separator + "results" +File.separator+"tex"+File.separator+imgName,"images/images"+projectNum+"/"+Constant.modelUUID+"_50k_texture_jpg_high1/"+imgName);
//				}

                    File file = new File(ConstantFilePath.SCENE_PATH+"data"+File.separator+"data"+projectNum);
                    if(!file.exists())
                    {
                        file.mkdir();
                    }
                    log.info("计算大场景：开始上传大场景文件到阿里——"+projectNum);
                    //上传修改后的本地的缩略图
                    map.put(dataBuffer.toString() + "floor.json", dataBuf.toString() + "floor.json");

                    //发布重新建模场景，将floorPublishVer设为floorEditVer的值
                    sceneProEditEntity.setFloorPublishVer(sceneProEditEntity.getFloorEditVer());

                    scenejson.put("floorEditVer", sceneProEditEntity.getFloorEditVer());
                    scenejson.put("floorPublishVer", sceneProEditEntity.getFloorEditVer());
                }
            }

        }

        //重算全景图并上传oss或oss
        if(scenejson.containsKey("buildImages") && scenejson.getIntValue("buildImages") == 1){
            String path = sceneProEntity.getDataSource();

            if(path != null && !"".equals(path) && path.startsWith("http")){
                path = ConstantFilePath.BUILD_MODEL_PATH + File.separator + path.split("/")[path.split("/").length - 2];
            }
            String target = path + "_images";

            File images = new File(target + File.separator + "extras/images");
            File video = new File(target + File.separator + "extras/video");

            log.info("下载vision.modeldata文件");
            if("s3".equals(this.type)){
                FileUtils.downLoadFromUrl(ConstantUrl.PREFIX_AWS + "images/images" + sceneProEntity.getNum() + "/vision.modeldata" + "?m="+new Date().getTime(),
                        "vision.modeldata", target + File.separator + "extras" + File.separator);
            }
            if("oss".equals(this.type)){
                FileUtils.downLoadFromUrl(prefixAli + "images/images" + sceneProEntity.getNum() + "/vision.modeldata" + "?m="+new Date().getTime(),
                        "vision.modeldata", target + File.separator + "extras" + File.separator);
            }
            CreateObjUtil.convertVisionmodeldataToTxt(target + File.separator + "extras" + File.separator + "vision.modeldata",
                    target + File.separator + "extras" + File.separator + "vision.txt");

            if(images.exists() && images.listFiles() != null && images.listFiles().length > 0){

                FileUtils.copyFile(path + File.separator + "data.json", target + File.separator+"data.json", true);
                FileUtils.copyFile(path + File.separator + "project.json", target + File.separator+"project.json", true);

                //data.json增加extras为执行重建算法
                String data = FileUtils.readFile(target + File.separator+"data.json");
                if(data != null){
                    JSONObject floorplanJson = new JSONObject();
                    floorplanJson.put("has_source_images", true);
                    floorplanJson.put("has_vision_txt", true);

                    JSONObject dataJson = JSONObject.parseObject(data);
                    dataJson.put("extras", floorplanJson);
                    //V5表示不需要生成high，low文件
                    dataJson.put("skybox_type", "SKYBOX_V6");
                    if(sceneProEntity.getSceneScheme() == 11){
                        dataJson.put("skybox_type", "SKYBOX_V7");
                    }
                    dataJson.put("split_type", "SPLIT_V8");
                    //sceneScheme为3切成瓦片图
                    if(sceneProEntity.getSceneScheme() == 3){
                        dataJson.put("skybox_type", "SKYBOX_V4");
                    }
                    FileUtils.writeFile(target + File.separator+"data.json", new String(dataJson.toString().getBytes(), "UTF-8"));
                }

                //创建文件夹软连接并且复制data.json和project.json
                if(new File(target + File.separator + "capture").exists()){
                    new File(target + File.separator + "capture").delete();
                }
                if(new File(target + File.separator + "results").exists()){
                    FileUtils.delAllFile(target + File.separator + "results");
                }
                //下载data.fdage
                if("s3".equals(this.type)){
                    //亚马逊保持旧方式，超链接capture
                    CreateObjUtil.createSoftConnection(path + File.separator + "capture", target + File.separator + "capture");
                }
                CreateObjUtil.ossUtilCpWithZfbBucket(ConstantFilePath.OSS_PREFIX + path.replace(ConstantFilePath.BUILD_MODEL_PATH, "") + "/data.fdage", target + File.separator + "capture/");

                CreateObjUtil.build3dModel(target , "1");

                //读取upload文件，检验需要上传的文件是否存在
//                Thread.sleep(20000L);

                String uploadPath = target + File.separator + "results" +File.separator+"upload.json";

                long timeStamp = System.currentTimeMillis();
                Integer time = 0;
                boolean isExsts = true;
                while (isExsts){
                    File f = new File(uploadPath);
                    long diff = System.currentTimeMillis() - timeStamp;
                    log.info("文件生产时间倒计时 -- " + diff/1000);
                    if (f.exists()) {
                        isExsts = false;
                    }else{
                        if(diff/1000 > 30){
                            isExsts = false;
                        }
                    }
                }

//                String pathW = "/mnt/data/02613f6e8/812690850248130560/7ca7b00e9a90_202102200957308970_images/results/upload.json";
                String uploadData = FileUtils.readFile(target + File.separator + "results" +File.separator+"upload.json");

                JSONObject uploadJson = null;
                JSONArray array = null;
                if(uploadData!=null) {
                    uploadJson = JSONObject.parseObject(uploadData);
                    array = uploadJson.getJSONArray("upload");
                }

                log.info("uploadData" + array);

                if(array == null){
                    throw new Exception("upload.json数据出错");
                }
                JSONObject fileJson = null;
                String fileName = "";
                for(int i = 0, len = array.size(); i < len; i++){
                    fileJson = array.getJSONObject(i);
                    fileName = fileJson.getString("file");
                    //文件不存在抛出异常
                    if(!new File(target + File.separator + "results" +File.separator + fileName).exists()){
                        throw new Exception(target + File.separator + "results" +File.separator + fileName+"文件不存在");
                    }

                    //high文件夹
                    if(fileJson.getIntValue("clazz") == 3){
                        map.put(target + File.separator + "results" +File.separator+ fileName,"images/images"+
                                sceneProEntity.getNum()+"/pan/high/"+ fileName.replace("high/", ""));
                        continue;
                    }
                    //low文件夹
                    if(fileJson.getIntValue("clazz") == 4){
                        map.put(target + File.separator + "results" +File.separator+ fileName,"images/images"+
                                sceneProEntity.getNum()+"/pan/low/"+ fileName.replace("low/", ""));
                        continue;
                    }

                    //tiles文件夹,亚马逊没有裁剪图片api，不需要上传4k图
                    if(fileJson.getIntValue("clazz") == 5){
                        map.put(target + File.separator + "results" + File.separator+ fileName,"images/images"+
                                sceneProEntity.getNum()+ File.separator + fileName);
                        continue;
                    }

                    //tiles文件夹,亚马逊瓦片图
                    if(fileJson.getIntValue("clazz") == 7 ){
                        map.put(target + File.separator + "results" + File.separator+ fileName,"images/images"+
                                sceneProEntity.getNum()+ File.separator + fileName);
                        continue;
                    }
                }

                for(String imagesName : images.list()){
                    //覆盖原始图片资源
                    FileUtils.copyFile(target + File.separator + "extras/images/" + imagesName,
                            path + File.separator + "caches/images/" + imagesName, true);
                    FileUtils.deleteFile(target + File.separator + "extras/images/" + imagesName);
                }
            }

            if(video.exists() && video.listFiles() != null && video.listFiles().length > 0){
                for(String videoName : video.list()){
                    uploadToOssUtil.upload(target + File.separator + "extras/video/" + videoName,"video/video"+
                            sceneProEntity.getNum()+ File.separator + videoName);

                    CreateObjUtil.mp4ToFlv(target + File.separator + "extras/video/" + videoName,
                            target + File.separator + "extras/video/" + videoName.replace("mp4", "flv"));

                    uploadToOssUtil.upload(target + File.separator + "extras/video/" + videoName.replace("mp4", "flv"),"video/video"+
                            sceneProEntity.getNum()+ File.separator + videoName.replace("mp4", "flv"));

                    //覆盖原始视频资源
                    FileUtils.copyFile(target + File.separator + "extras/video/" + videoName,
                            path + File.separator + "caches/videos/" + videoName, true);

                }
                FileUtils.deleteDirectory(target + File.separator + "extras/video/");
            }

            scenejson.put("imagesVersion", sceneProEditEntity.getImagesVersion() + 1);
            scenejson.put("buildImages", 0);
            sceneProEditEntity.setImagesVersion(sceneProEditEntity.getImagesVersion() + 1);
        }

        if(scenejson.containsKey("uploadBgMusic") && scenejson.getIntValue("uploadBgMusic") == 1){
            if(StringUtil.isNotEmpty(scenejson.getString("bgMusicName"))){
                map.put(imagesBuffer.toString() + scenejson.getString("bgMusicName"), imagesBuf.toString() + scenejson.getString("bgMusicName"));
            }

            scenejson.put("uploadBgMusic", 0);
            sceneProEditEntity.setBgMusicName(scenejson.getString("bgMusicName"));
        }

        if(scenejson.containsKey("uploadPanoramaImg") && scenejson.getIntValue("uploadPanoramaImg") == 1){
            String targetPath = ConstantFilePath.SCENE_PATH + "images/images" + base.getSceneNum() + "/panorama";
            for(File targetFile : new File(targetPath).listFiles()){
                if(targetFile.isDirectory()){
                    String target = targetFile.getAbsolutePath();
                    String sid = target.substring(target.lastIndexOf(File.separator) + 1);
                    //读取upload文件，检验需要上传的文件是否存在
                    String uploadData = FileUtils.readFile(target + File.separator + "results" +File.separator+"upload.json");
                    JSONObject uploadJson = null;
                    JSONArray array = null;
                    if(uploadData!=null) {
                        uploadJson = JSONObject.parseObject(uploadData);
                        array = uploadJson.getJSONArray("upload");
                    }
                    if(array == null){
                        continue;
                    }
                    JSONObject fileJson = null;
                    String fileName = "";
                    for(int i = 0, len = array.size(); i < len; i++){
                        fileJson = array.getJSONObject(i);
                        fileName = fileJson.getString("file");
                        //文件不存在抛出异常
                        if(!new File(target + File.separator + "results" +File.separator + fileName).exists()){
                            throw new Exception(target + File.separator + "results" +File.separator + fileName+"文件不存在");
                        }

                        //high文件夹
                        if(fileJson.getIntValue("clazz") == 3){
                            map.put(target + File.separator + "results" +File.separator+ fileName,"images/images"+
                                    sceneProEntity.getNum()+"/panorama/" + sid + "/pan/high/"+ fileName.replace("high/", ""));
                            continue;
                        }
                        //low文件夹
                        if(fileJson.getIntValue("clazz") == 4){
                            map.put(target + File.separator + "results" +File.separator+ fileName,"images/images"+
                                    sceneProEntity.getNum()+"/panorama/" + sid + "/pan/low/"+ fileName.replace("low/", ""));
                            continue;
                        }

                        //tiles文件夹,亚马逊没有裁剪图片api，不需要上传4k图
                        if(fileJson.getIntValue("clazz") == 5){
                            map.put(target + File.separator + "results" + File.separator+ fileName,"images/images"+
                                    sceneProEntity.getNum()+ "/panorama/" + sid + File.separator + fileName);

//                            uploadToOssUtil.delete("images/images"+ sceneProEntity.getNum()+
//                                    "/panorama_edit/" + sid + File.separator + fileName);
                            continue;
                        }

                        //tiles文件夹,亚马逊瓦片图
                        if(fileJson.getIntValue("clazz") == 7 ){
                            map.put(target + File.separator + "results" + File.separator+ fileName,"images/images"+
                                    sceneProEntity.getNum()+ File.separator + fileName);
                            continue;
                        }
                    }
                }
            }

            scenejson.put("uploadPanoramaImg", 0);
        }

        if(scenejson.containsKey("uploadPanoramaJson") && scenejson.getIntValue("uploadPanoramaJson") == 1){
            scenejson.put("uploadPanoramaJson", 0);

            map.put(dataBuffer.toString() + "link-scene.json", dataBuf.toString() + "link-scene.json");
            sceneProEditEntity.setJumpScene(scenejson.getBooleanValue("jumpScene"));
        }

        log.info("scene.json路径：" + dataBuffer.toString() + "scene.json");
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());

        if(map.size()>0) {
            uploadToOssUtil.uploadMulFiles(map);
        }
        update(sceneProEntity);
        sceneProEditMapper.updateByPrimaryKeySelective(sceneProEditEntity);

        return Result.success();
    }

    @Override
    @SystemServiceLog(description = "上传场景的热点媒体文件")
    public Result uploadHotMedia(String sceneNum, MultipartFile file, String sid) throws Exception {
        if(StringUtils.isEmpty(sceneNum)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        String fileName = "hot" + sid + ".mp4";
        if (!file.isEmpty()){

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

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

            if(targetFile.exists()){
                FileUtils.executeCodecs(path + File.separator + fileName, path, "hot" + sid + "-cut");
            }
        }

        return Result.success(fileName);
    }

    @Override
    @SystemServiceLog(description = "保存场景热点")
    public Result saveHot(RequestSceneEdit base) throws Exception {
        if(StringUtils.isEmpty(base.getType())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        String sid = base.getSid();

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if (sceneProEntity == null ) {
            return Result.failure(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

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

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .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.toString() + "hot.json");
        JSONArray jsonhots = null;
        if (StringUtils.isNotEmpty(str)) {
            jsonhots = JSONArray.parseArray(str);
        }else {
            File file = new File(dataBuffer.toString() + "hot.json");
            if(!file.getParentFile().exists()){
                file.getParentFile().mkdirs();
            }
            if(!file.exists()){
                file.createNewFile();
            }
            jsonhots = new JSONArray();
        }

        //添加或者修改
        if("1".equals(base.getType())){
            sid = jsonhot.getString("sid");
            if(StringUtil.isEmpty(sid)){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
            }
            jsonhots.add(jsonhot);
        }
        else if("0".equals(base.getType())){
            sid = jsonhot.getString("sid");
            if(StringUtil.isEmpty(sid)){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
            }
        }
        else if("-1".equals(base.getType())){
            if(StringUtil.isEmpty(sid)){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
            }
        }
        //判断是否需要删除自定义热点样式
        String[] styles = null;
        if(StringUtil.isNotEmpty(base.getStyleName())){
            styles = base.getStyleName().split(",");
        }

        for(int i=0;i<jsonhots.size();++i){
            JSONObject ele = jsonhots.getJSONObject(i);
            //名字对应上就删除
            if(styles != null){
                for(String style : styles){
                    if(style.equals(ele.getString("styleId"))){
                        jsonhots.getJSONObject(i).put("styleId", null);
                        jsonhots.getJSONObject(i).put("style", "default");
                        jsonhots.getJSONObject(i).put("styleImageURL", null);
                    }
                }
            }
            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.toString() + "hot"+sid+".jpg");
                        }
                        if(fileType.contains("audio") || fileType.contains("voice"))
                        {
                            FileUtils.deleteFile(imagesBuffer.toString() + "hot"+sid+".mp3");
                        }
                        if(fileType.contains("video"))
                        {
                            FileUtils.deleteFile(imagesBuffer.toString() + "hot"+sid+".mp4");
                        }
                    }

                    if(!"s3".equals(this.type)){
                        JSONObject paramData = new JSONObject();
                        paramData.put("hotId", sid);
                        JSONObject hotListJson = JSONObject.parseObject(OkHttpUtils.httpGet(hotDomainList));
                        if(hotListJson != null){
                            JSONArray hotListArray = hotListJson.getJSONArray("data");
                            if(hotListArray != null){
                                for(int l = 0, len = hotListArray.size(); l < len; l++){
                                    OkHttpUtils.httpPostJson(hotListArray.getString(l) + hotDelete + "?hotId=" + sid
                                            , paramData.toJSONString());
                                }

                            }
                        }
                    }

                }
                else if("0".equals(base.getType())){
                    jsonhots.set(i, jsonhot);
                }
            }
        }

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

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

        if(!StringUtils.isEmpty(base.getCapData())){
            FileUtils.writeFile(dataBuffer.toString() + "capData.json", new String(base.getCapData().getBytes(), "UTF-8"));
            scenejson.put("capData", dataBuf.toString() + "capData.json");
        }

        if(!StringUtils.isEmpty(base.getFrameData())){
            FileUtils.writeFile(dataBuffer.toString() + "frameData.json", new String(base.getFrameData().getBytes(), "UTF-8"));
            scenejson.put("frameData", dataBuf.toString() + "frameData.json");
        }

        if(!StringUtils.isEmpty(base.getPlayData())){
            FileUtils.writeFile(dataBuffer.toString() + "playData.json", new String(base.getPlayData().getBytes(), "UTF-8"));
            scenejson.put("playData", dataBuf.toString() + "playData.json");
        }

        if(!StringUtils.isEmpty(base.getScreencapThumb())){
            FileUtils.writeFile(dataBuffer.toString() + "screencapThumb.json", new String(base.getScreencapThumb().getBytes(), "UTF-8"));
            scenejson.put("screencapThumb", dataBuf.toString() + "screencapThumb.json");
        }

        scenejson.put("version", scenejson.getIntValue("version") + 1);
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());
        return Result.success();
    }


    @Override
    @SystemServiceLog(description = "保存场景热点")
    public Result saveShopHot(RequestSceneEdit base) throws Exception {
        if(StringUtils.isEmpty(base.getType())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        String fileName = "shopHot.json";

        String sid = base.getSid();

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if (sceneProEntity == null ) {
            return Result.failure(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

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

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .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.toString() + fileName);

        JSONArray jsonhots = null;
        if (StringUtils.isNotEmpty(str)) {
            jsonhots = JSONArray.parseArray(str);
        }else {
            File file = new File(dataBuffer.toString() + fileName);
            if(!file.getParentFile().exists()){
                file.getParentFile().mkdirs();
            }
            if(!file.exists()){
                file.createNewFile();
            }
            jsonhots = new JSONArray();
        }

        //添加或者修改
        if("1".equals(base.getType())){
            sid = jsonhot.getString("sid");
            if(StringUtil.isEmpty(sid)){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
            }
            jsonhots.add(jsonhot);
        }
        else if("0".equals(base.getType())){
            sid = jsonhot.getString("sid");
            if(StringUtil.isEmpty(sid)){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
            }
        }
        else if("-1".equals(base.getType())){
            if(StringUtil.isEmpty(sid)){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_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.toString() + "hot"+sid+".jpg");
                        }
                        if(fileType.contains("audio") || fileType.contains("voice"))
                        {
                            FileUtils.deleteFile(imagesBuffer.toString() + "hot"+sid+".mp3");
                        }
                        if(fileType.contains("video"))
                        {
                            FileUtils.deleteFile(imagesBuffer.toString() + "hot"+sid+".mp4");
                        }
                    }
                }
                else if("0".equals(base.getType())){
                    jsonhots.set(i, jsonhot);
                }
                break;
            }
        }

        FileUtils.deleteFile(dataBuffer.toString() + fileName);
        File dataPath = new File(dataBuffer.toString());
        if(!dataPath.exists()){
            dataPath.mkdirs();
        }
        FileUtils.writeFile(dataBuffer.toString() + fileName, jsonhots.toString());

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null){
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        scenejson.put("version", scenejson.getIntValue("version") + 1);
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());
        return Result.success();
    }

    @Override
    public Result saveOverlay(RequestSceneEdit base) throws Exception {
        if(StringUtils.isEmpty(base.getType())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        String sid = base.getSid();

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if (sceneProEntity == null ) {
            return Result.failure(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        SceneProEditEntity sceneProEditEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());
        if (sceneProEditEntity == null ) {
            return Result.failure(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        //需要操作的数据
        JSONObject jsonOverlay = JSONObject.parseObject(base.getOverlayData());

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .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 = sceneProEditEntity.getOverlay();
        JSONArray jsonOverlays = null;
        if (StringUtils.isNotEmpty(str)) {
            jsonOverlays = JSONArray.parseArray(str);
        }else {
            jsonOverlays = new JSONArray();
        }

        //添加或者修改
        if("1".equals(base.getType())){
            sid = jsonOverlay.getString("sid");
            if(StringUtil.isEmpty(sid)){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
            }
            jsonOverlays.add(jsonOverlay);
        }
        else if("0".equals(base.getType())){
            sid = jsonOverlay.getString("sid");
            if(StringUtil.isEmpty(sid)){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
            }
        }
        else if("-1".equals(base.getType())){
            if(StringUtil.isEmpty(sid)){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
            }
        }

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

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null){
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        scenejson.put("overlay", jsonOverlays.toString());
        scenejson.put("version", scenejson.getIntValue("version") + 1);
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());

        sceneProEditEntity.setVersion(scenejson.getIntValue("version") + 1);
        sceneProEditEntity.setOverlay(jsonOverlays.toString());
        sceneProEditMapper.updateByPrimaryKey(sceneProEditEntity);

        return Result.success();
    }

    @Override
    public Result uploadOverlayMedia(String sceneNum, MultipartFile file, String sid) throws Exception {
        if(StringUtils.isEmpty(sceneNum)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        String fileName = "overlay" + sid + ".mp4";
        if (!file.isEmpty()){

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

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

            CreateObjUtil.mp4ToFlv(path + File.separator + fileName, path + File.separator + fileName.replace("mp4", "flv"));

            uploadToOssUtil.upload(path + File.separator + fileName, "images"+File.separator+"images"+sceneNum + File.separator + fileName);
            uploadToOssUtil.upload(path + File.separator + fileName.replace("mp4", "flv"), "images"+File.separator+"images"+sceneNum + File.separator + fileName.replace("mp4", "flv"));
//            if(targetFile.exists()){
//                FileUtils.executeCodecs(path + File.separator + fileName, path, "hot" + sid + "-cut");
//            }
        }

        return Result.success(fileName);
    }

    @Override
    @SystemServiceLog(description = "保存场景热点")
    public Result saveScreencapData(RequestSceneEdit base) throws Exception {
        if(StringUtils.isEmpty(base.getSceneNum())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        if(base.getScreencapVoiceType() != null){
            scenejson.put("screencapVoiceType", base.getScreencapVoiceType());
        }

        if(!StringUtils.isEmpty(base.getCapData())){
            FileUtils.writeFile(dataBuffer.toString() + "capData.json", new String(base.getCapData().getBytes(), "UTF-8"));
            scenejson.put("capData", dataBuf.toString() + "capData.json");
        }

        if(!StringUtils.isEmpty(base.getFrameData())){
            FileUtils.writeFile(dataBuffer.toString() + "frameData.json", new String(base.getFrameData().getBytes(), "UTF-8"));
            scenejson.put("frameData", dataBuf.toString() + "frameData.json");
        }

        if(!StringUtils.isEmpty(base.getPlayData())){
            FileUtils.writeFile(dataBuffer.toString() + "playData.json", new String(base.getPlayData().getBytes(), "UTF-8"));
            scenejson.put("playData", dataBuf.toString() + "playData.json");
        }

        if(!StringUtils.isEmpty(base.getScreencapThumb())){
            FileUtils.writeFile(dataBuffer.toString() + "screencapThumb.json", new String(base.getScreencapThumb().getBytes(), "UTF-8"));
            scenejson.put("screencapThumb", dataBuf.toString() + "screencapThumb.json");
        }

        if(!StringUtils.isEmpty(base.getRecordType())){
            scenejson.put("recordType", base.getRecordType());
        }

        scenejson.put("version", scenejson.getIntValue("version") + 1);
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());
        return Result.success();
    }

    @Override
    @SystemServiceLog(description = "漫游可行")
    public Result saveLinkPano(RequestSceneEdit base) throws Exception {
        if(StringUtils.isEmpty(base.getData()) || StringUtils.isEmpty(base.getSceneNum())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if (sceneProEntity == null ) {
            return Result.failure(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

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

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .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.toString() + "vision.modeldata");
        if(!file.exists()) {
            return Result.failure(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
        }
        ConvertUtils.convertVisionModelDataToTxt(dataBuffer.toString() + "vision.modeldata", dataBuffer.toString() + "vision.json");

        String str = FileUtils.readFile(dataBuffer.toString() + "vision.json");
        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.toString() + "vision.json");
        FileUtils.deleteFile(dataBuffer.toString() + "vision.modeldata");
        FileUtils.writeFile(dataBuffer.toString() + "vision.json", json.toString());
        ConvertUtils.convertTxtToVisionModelData(dataBuffer.toString() + "vision.json", dataBuffer.toString() + "vision.modeldata");
//            QiniuUpload.setFileToBucket(dataBuffer.toString() + "vision.modeldata", imagesBuf.toString() + "vision.modeldata");
        uploadToOssUtil.upload(dataBuffer.toString() + "vision.modeldata", imagesBuf.toString() + "vision.modeldata");

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null){
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        scenejson.put("version", scenejson.getIntValue("version") + 1);
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());

        SceneProEditEntity sceneProEditEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());
        if (sceneProEditEntity == null ) {
            return Result.failure(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        sceneProEditEntity.setVersion(scenejson.getIntValue("version") + 1);
        sceneProEditMapper.updateByPrimaryKey(sceneProEditEntity);
        return Result.success();
    }

    @Override
    @SystemServiceLog(description = "保存热点可见性的数据")
    public Result saveHotVisible(RequestSceneEdit base) throws Exception {
        if(StringUtils.isEmpty(base.getData()) || StringUtils.isEmpty(base.getSceneNum())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if (sceneProEntity == null ) {
            return Result.failure(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

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

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .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 BaseRuntimeException(LoginConstant.FAILURE_CODE_3018, LoginConstant.FAILURE_MSG_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"));
                }
            }
        }
        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null){
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        scenejson.put("version", scenejson.getIntValue("version") + 1);
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());

        SceneProEditEntity sceneProEditEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());
        sceneProEditEntity.setVersion(sceneProEditEntity.getVersion() + 1);
        sceneProEditMapper.updateByPrimaryKeySelective(sceneProEditEntity);

        FileUtils.deleteFile(dataBuffer.toString() + "hot.json");
        FileUtils.writeFile(dataBuffer.toString() + "hot.json", hots.toString());
        return Result.success();
    }

    @Override
    public Result uploadShareLogo(RequestSceneEdit base, MultipartFile file) throws Exception {
        if(file == null || StringUtils.isEmpty(base.getSceneNum())){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = findBySceneNum(base.getSceneNum());
        if (sceneProEntity == null ) {
            return Result.failure(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String fileName = "";
        if (!file.isEmpty()&&file.getSize() > 0) {
            //文件上传的位置可以自定义
            System.out.println("上传分享的logo");
            String path = imagesBuffer.toString();
            File targetFile = new File(path);
            if (!targetFile.exists()) {
                targetFile.mkdirs();
            }
            fileName = file.getOriginalFilename();
            targetFile = new File(path + fileName);
            int count = 1;
            // 保存
            synchronized(this)
            {
                file.transferTo(targetFile);
            }

            SceneProEditEntity sceneProEditEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());

            Map<String, Object> map = new HashMap<>();
            map.put("shareLogo", imagesBuf.toString() + fileName);
            map.put("version", sceneProEditEntity.getVersion()+1);
            FileUtils.writeJsonFile(dataBuffer.toString() + "scene.json", map);

            sceneProEditEntity.setShareLogo(imagesBuf.toString() + fileName);
            sceneProEditEntity.setVersion(sceneProEditEntity.getVersion()+1);
            sceneProEditMapper.updateByPrimaryKeySelective(sceneProEditEntity);
            if("V2".equals(sceneProEntity.getBuildType())){
                MatrixToImageWriterUtil.createQRCode(mainUrl + sceneProUrl + sceneProEntity.getNum(), ConstantFilePath.BASE_PATH + File.separator + "sceneQRcode/"+sceneProEntity.getNum()+".png", path + File.separator + fileName);
                MatrixToImageWriterUtil.createQRCode(mainUrl + sceneProUrl + sceneProEntity.getNum() + "&lang=en", ConstantFilePath.BASE_PATH + File.separator + "sceneQRcode/"+sceneProEntity.getNum()+"_en.png", path + File.separator + fileName);
            }
            if("V3".equals(sceneProEntity.getBuildType())){
                MatrixToImageWriterUtil.createQRCode(mainUrl + sceneProNewUrl + sceneProEntity.getNum(), ConstantFilePath.BASE_PATH + File.separator + "sceneQRcode/"+sceneProEntity.getNum()+".png", path + File.separator + fileName);
                MatrixToImageWriterUtil.createQRCode(mainUrl + sceneProNewUrl + sceneProEntity.getNum() + "&lang=en", ConstantFilePath.BASE_PATH + File.separator + "sceneQRcode/"+sceneProEntity.getNum()+"_en.png", path + File.separator + fileName);
            }
        }
        return Result.success(imagesBuf.toString() + fileName);
    }

    @Override
    public Result uploadPic(String sceneNum, String folderName, MultipartFile file, String toOss) throws Exception{
        if(StringUtils.isEmpty(sceneNum)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        if (file.isEmpty() && file.getSize() <= 0) {
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
        }

        //文件上传的位置可以自定义
        String path = ConstantFilePath.SCENE_PATH+"images"+File.separator+"images"+sceneNum;
        if(StringUtil.isNotEmpty(folderName)) {
            path = path+File.separator + folderName;
        }
        File targetFile = new File(path);
        if (!targetFile.exists()) {
            targetFile.mkdirs();
        }
        String fileName = file.getOriginalFilename();
        targetFile = new File(path + File.separator + fileName);
        // 保存
        synchronized(this)
        {
            if(targetFile.exists())
            {
                FileUtils.deleteFile(path + File.separator + fileName);
            }
            file.transferTo(targetFile);
        }

        if(toOss != null && "1".equals(toOss)){
            uploadToOssUtil.upload(path + File.separator + fileName, "images"+File.separator+"images"+sceneNum + File.separator + fileName);
        }

        return Result.success(targetFile.getName());
    }

    @Override
    public Result uploadHotJsonToOss(String sceneNum) throws Exception {
        if(StringUtils.isEmpty(sceneNum)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        String path = ConstantFilePath.SCENE_PATH+"data"+File.separator+"data"+sceneNum;
        uploadToOssUtil.upload(path + File.separator + "hot.json", "data"+File.separator+"data"+sceneNum + File.separator + "hot.json");

        return Result.success();
    }

    @Override
    public Result deleteOss(String filePath) throws Exception {
        uploadToOssUtil.deleteFile(filePath);
        return Result.success();
    }

    @Override
    public Result uploadFloorplanPng(String sceneNum, MultipartFile[] file, String cadInfo) throws Exception{
        if(StringUtils.isEmpty(sceneNum)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        if (file.length <= 0) {
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .append(File.separator);

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


        //文件上传的位置可以自定义
        String path = ConstantFilePath.SCENE_PATH+"images"+File.separator+"images"+sceneNum;
        File targetFile = new File(path);
        if (!targetFile.exists()) {
            targetFile.mkdirs();
        }
        String fileName = "";
        JSONArray floorPlanPngArr = new JSONArray();
        for (MultipartFile multipartFile : file) {
            fileName = multipartFile.getOriginalFilename();
            targetFile = new File(path + File.separator + fileName);
            // 保存
            synchronized(this)
            {
                if(targetFile.exists())
                {
                    FileUtils.deleteFile(path + File.separator + fileName);
                }
                multipartFile.transferTo(targetFile);
            }
            floorPlanPngArr.add("images"+File.separator+"images"+sceneNum + File.separator + fileName);
        }

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        Map<String, Object> map = new HashMap<>();
        map.put("floorPlanPng", floorPlanPngArr);
        map.put("uploadFloorPlanPng", 1);
        map.put("version", scenejson.getIntValue("version")+1);

        if(StringUtil.isNotEmpty(cadInfo)){
            map.put("cadInfo", cadInfo);
        }
        FileUtils.writeJsonFile(dataBuffer.toString() + "scene.json", map);

        return Result.success(floorPlanPngArr);
    }

    @Override
    public int updateTime(String sceneNum, Long space, int payStatus, String videos, long computeTime) {
        return sceneProMapper.updateTime(sceneNum, space, payStatus, videos, computeTime);
    }

    @Override
    public ResponseScene findLatestOneByUserId(Long userId) {
        return sceneProMapper.findLatestOneByUserId(userId);
    }

    @Override
    public void updateUserIdByCameraId(Long userId, Long cameraId) {
        sceneProMapper.updateUserIdByCameraId(userId, cameraId);
    }

    @Override
    public List<SceneProEntity> findByCameraIdPro(Long cameraId) {
        return sceneProMapper.findByCameraIdPro(cameraId);
    }

    @Override
    public void updateCameraIdByCameraIdPro(Long oldCameraId, Long cameraId) {
        sceneProMapper.updateCameraIdByCameraIdPro(oldCameraId, cameraId);
    }

    @Override
    public int updateRecStatus(String unicode) {
        return sceneProMapper.updateRecStatus(unicode);
    }

    @Override
    public SceneProEntity findByFileId(String fileId) {
        return sceneProMapper.findByFileId(fileId);
    }

    @Override
    public List<SceneProEntity> findTempScenes() throws Exception {
        return sceneProMapper.findTempScenes();
    }

    @Override
    public List<String> findByCameraId(Long cameraId) throws Exception {
        return sceneProMapper.findByCameraId(cameraId);
    }

    @Override
    public Result uploadObjAndImg(String sceneNum, MultipartFile file) throws Exception{
        if(StringUtils.isEmpty(sceneNum)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        SceneProEditEntity sceneProEditEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());
        if(sceneProEditEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        if (file == null || file.getSize() <= 0) {
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

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

        //文件上传的位置可以自定义
        String path = sceneProEntity.getDataSource() + "_obj2txt";
        String zipPath = path + "/zip/";
        String filePath =  path + "/extras/";

        FileUtils.delAllFile(path + "/results/");
        File targetFile = new File(filePath);
        if (!targetFile.exists()) {
            targetFile.mkdirs();
        }else {
            FileUtils.delAllFile(filePath);
        }

        targetFile = new File(zipPath);
        if (!targetFile.exists()) {
            targetFile.mkdirs();
        }else {
            FileUtils.delAllFile(zipPath);
        }

        targetFile = new File(zipPath + file.getOriginalFilename());
        if(!targetFile.getParentFile().exists()){
            targetFile.getParentFile().mkdirs();
        }
//        if(file.getOriginalFilename().contains(".obj")){
//            targetFile = new File(filePath + File.separator + "mesh.obj");
//        }else {
//            targetFile = new File(filePath + File.separator + file.getOriginalFilename());
//        }
        // 保存
        synchronized(this)
        {
            if(targetFile.exists())
            {
                FileUtils.deleteFile(zipPath + file.getOriginalFilename());
            }
            file.transferTo(targetFile);
        }

        FileUtils.decompress(zipPath + file.getOriginalFilename(), zipPath + "data/");

        //源文件数据，判断是否有多个文件夹，有多个就提示错误，有一个就将文件夹里数据迁移到extras目录，无直接迁移到extras目录
        boolean flag = false;
        String targetName = "";
        File dataFile = new File(zipPath + "data/");
        for(File data : dataFile.listFiles()){
            if(data.isDirectory() && flag){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5018, SceneConstant.FAILURE_MSG_5018);
            }
            if(data.isDirectory() && !flag){
                flag = true;
                targetName = data.getName();
            }
        }

        boolean objFlag = false;
        boolean mtlFlag = false;
        if(StringUtil.isEmpty(targetName)){
            for(File data : dataFile.listFiles()){
                if(data.getName().endsWith(".obj") && objFlag){
                    throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5019, SceneConstant.FAILURE_MSG_5019);
                }

                if(data.getName().endsWith(".jpg") || data.getName().endsWith(".png")){
                    if(!FileUtils.checkFileSizeIsLimit(data.length(), 1.5, "M")){
                        throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5020, SceneConstant.FAILURE_MSG_5020);
                    }
                }

                if(data.getName().endsWith(".obj") && !objFlag){
                    if(!FileUtils.checkFileSizeIsLimit(data.length(), 20, "M")){
                        throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5020, SceneConstant.FAILURE_MSG_5020);
                    }
                    objFlag = true;
                    FileUtils.copyFile(zipPath + "data/" + data.getName(), filePath + "mesh.obj", true);
                    continue;
                }

                if(data.getName().endsWith(".mtl")){
                    mtlFlag = true;
                }

                FileUtils.copyFile(zipPath + "data/" + data.getName(), filePath + data.getName(), true);
            }
        }else {
            for(File data : new File(zipPath + "data/" + targetName).listFiles()){
                if(data.isDirectory()){
                    throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5018, SceneConstant.FAILURE_MSG_5018);
                }
                if(data.getName().endsWith(".obj") && objFlag){
                    throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5019, SceneConstant.FAILURE_MSG_5019);
                }

                if(data.getName().endsWith(".jpg") || data.getName().endsWith(".png")){
                    if(!FileUtils.checkFileSizeIsLimit(data.length(), 1.5, "M")){
                        throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5020, SceneConstant.FAILURE_MSG_5020);
                    }
                }

                if(data.getName().endsWith(".obj") && !objFlag){
                    if(!FileUtils.checkFileSizeIsLimit(data.length(), 20, "M")){
                        throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5020, SceneConstant.FAILURE_MSG_5020);
                    }

                    objFlag = true;
                    FileUtils.copyFile(zipPath + "data/" + targetName + File.separator + data.getName(), filePath + "mesh.obj", true);
                    continue;
                }

                if(data.getName().endsWith(".mtl")){
                    mtlFlag = true;
                }

                FileUtils.copyFile(zipPath + "data/" + targetName + File.separator + data.getName(), filePath + data.getName(), true);
            }
        }

        if(!mtlFlag && !objFlag){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5019, SceneConstant.FAILURE_MSG_5019);
        }

        //创建data.json
        JSONObject dataJson = new JSONObject();
        dataJson.put("obj2txt", true);
        dataJson.put("split_type", "SPLIT_V6");
        dataJson.put("data_describe", "double spherical");
        dataJson.put("skybox_type", "SKYBOX_V5");
        FileUtils.writeFile(path + "/data.json", dataJson.toString());

        //调用objToTxt算法
        //判断V2还是V3
        if("V2".equals(sceneProEntity.getBuildType())){
            CreateObjUtil.objToTxt(path , "1");
        }
        if("V3".equals(sceneProEntity.getBuildType())){
            CreateObjUtil.build3dModel(path , "1");
        }

        String uploadData = FileUtils.readFile(path + File.separator + "results" +File.separator+"upload.json");
        JSONObject uploadJson = null;
        JSONArray array = null;
        if(uploadData!=null) {
            uploadJson = JSONObject.parseObject(uploadData);
            array = uploadJson.getJSONArray("upload");
        }
        if(array == null){
            log.error("upload.json数据出错");
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5017, SceneConstant.FAILURE_MSG_5017);
        }

        Map<String,String> map = new HashMap<String,String>();
        JSONObject fileJson = null;
        String fileName = "";
        for(int i = 0, len = array.size(); i < len; i++) {
            fileJson = array.getJSONObject(i);
            fileName = fileJson.getString("file");
            //文件不存在抛出异常
            if (!new File(path + File.separator + "results" + File.separator + fileName).exists()) {
                throw new Exception(path + File.separator + "results" + File.separator + fileName + "文件不存在");
            }

            //tex文件夹
            if (fileJson.getIntValue("clazz") == 15) {
//                if(fileName.contains("floor.json")){
//                    map.put(path + File.separator + "results" + File.separator + fileName, "data/data" +
//                            sceneNum + "/floor.json" );
//
//                    FileUtils.copyFile(path + File.separator + "results" + File.separator + fileName,
//                            ConstantFilePath.SCENE_PATH + "data/data" + sceneNum + "/floor.json", true);
//                }
                map.put(path + File.separator + "results" + File.separator + fileName, "images/images" +
                        sceneNum + "/" + ConstantFileName.modelUUID + "_50k_texture_jpg_high1/" + fileName.replace("tex/", ""));

                //复制一份到images本地
                FileUtils.copyFile(path + File.separator + "results" +File.separator + fileName,
                        ConstantFilePath.SCENE_PATH+"images"+File.separator+"images"+sceneNum + File.separator +
                                ConstantFileName.modelUUID + "_50k_texture_jpg_high1/" + fileName.replace("tex/", ""), true);
                continue;
            }
        }

        CreateObjUtil.convertTxtToDam( path + File.separator + "results" +File.separator+"modeldata.txt", path + File.separator + "results" +File.separator+ ConstantFileName.modelUUID+"_50k.dam");
        CreateObjUtil.convertDamToLzma(path + File.separator + "results");
        CreateObjUtil.convertTxtToDam( path + File.separator + "results" +File.separator+"modeldata.txt", path + File.separator + "results" + File.separator+ConstantFileName.modelUUID+"_50k.dam");
        map.put(path + File.separator + "results" +File.separator+ConstantFileName.modelUUID+"_50k.dam.lzma", "images/images"+sceneNum+"/"+ConstantFileName.modelUUID+"_50k.dam.lzma");
        map.put(path + File.separator + "results" +File.separator+ConstantFileName.modelUUID+"_50k.dam", "images/images"+sceneNum+"/"+ConstantFileName.modelUUID+"_50k.dam");

        uploadToOssUtil.uploadMulFiles(map);

        FileUtils.copyFile(path + File.separator + "results" +File.separator+ConstantFileName.modelUUID+"_50k.dam",
                ConstantFilePath.SCENE_PATH+"images"+File.separator+"images"+sceneNum + File.separator + ConstantFileName.modelUUID+"_50k.dam", true);
        FileUtils.copyFile(path + File.separator + "results" +File.separator+ConstantFileName.modelUUID+"_50k.dam.lzma",
                ConstantFilePath.SCENE_PATH+"images"+File.separator+"images"+sceneNum + File.separator + ConstantFileName.modelUUID+"_50k.dam.lzma", true);
        log.info("文件复制到本地ecs完成——"+sceneNum);

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }
        //更新scene.json文件
        if(strsceneInfos!=null)
        {
            scenejson.put("isUploadObj", true);
            scenejson.put("version", sceneProEditEntity.getVersion() + 1);
            scenejson.put("floorEditVer", sceneProEditEntity.getFloorEditVer() + 1);
            scenejson.put("floorPublishVer", sceneProEditEntity.getFloorPublishVer() + 1);
            FileUtils.writeFile(ConstantFilePath.SCENE_PATH+"data"+File.separator+"data"+sceneNum+File.separator+"scene.json", scenejson.toString());
            log.info("写入scene.json文件完成——"+sceneNum);
        }

        //floorEditVer字段增加1
        sceneProEditEntity.setVersion(sceneProEditEntity.getVersion() + 1);
        sceneProEditEntity.setFloorPublishVer(sceneProEditEntity.getFloorPublishVer() + 1);
        sceneProEditEntity.setFloorEditVer(sceneProEditEntity.getFloorEditVer() + 1);
        sceneProEditMapper.updateByPrimaryKeySelective(sceneProEditEntity);
        return Result.success();
    }

    @Override
    public Result uploadLogoBottomStatus(String sceneNum, String status) throws Exception {
        if(StringUtils.isEmpty(sceneNum) || StringUtils.isEmpty(status)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        SceneProEditEntity sceneProEditEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());
        if(sceneProEditEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }


        scenejson.put("showLogoBottom", Integer.valueOf(status));
        scenejson.put("version", scenejson.getIntValue("version") + 1);
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());

        sceneProEditEntity.setVersion(scenejson.getIntValue("version") + 1);
        sceneProEditEntity.setShowLogoBottom(Integer.valueOf(status));
        sceneProEditMapper.updateByPrimaryKey(sceneProEditEntity);
        return Result.success();
    }

    @Override
    public Result saveJsonData(String sceneNum, String fileName, String jsonData) throws Exception {
        if(StringUtils.isEmpty(sceneNum) || StringUtils.isEmpty(fileName) || StringUtils.isEmpty(jsonData)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

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

        FileUtils.writeFile(dataBuffer.toString() + fileName, jsonData.toString());

        return Result.success("scene/" + dataBuf.toString() + fileName);
    }

    @Override
    public String downloadPanoramaOrVideo(String sceneNum, String fileName, String type, String planId) throws Exception {
        if(StringUtils.isEmpty(sceneNum) || StringUtils.isEmpty(fileName) || StringUtils.isEmpty(type)|| StringUtils.isEmpty(planId)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String path = sceneProEntity.getDataSource();

        String url = "";
//        String zipName = "";

        if("image".equals(type)){
            if(!new File(path + "/caches/images/" + fileName).exists()){
                throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3018, LoginConstant.FAILURE_MSG_3018);
            }

            //备份原始数据
            if(!new File(imagesBuffer.toString() + "caches/back-" + fileName).exists()){
                FileUtils.copyFile(path + "/caches/images/" + fileName, imagesBuffer.toString() + "caches/back-" + fileName, false);
            }
            //复制打包数据，并且改名
            FileUtils.copyFile(path + "/caches/images/" + fileName, imagesBuffer.toString() + "caches/" + planId + ".jpg", true);
//            //将图片打成zip包
//            zipName = imagesBuffer.toString() + "caches/" + sceneNum + "-image-" + planId + ".zip";
//            FileUtils.zipFile(zipName, imagesBuffer.toString() + "caches/" + planId + ".jpg");
//
//            url = mainUrl + zipName.replace(ConstantFilePath.BASE_PATH + "/", "");

            url = mainUrl + "scene/" + imagesBuf.toString() + "caches/" + planId + ".jpg";
        }

        if("video".equals(type)){
//            if(!new File(path + "/caches/videos/" + fileName).exists()){
//                throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3018, LoginConstant.FAILURE_MSG_3018);
//            }
//
//            //备份原始数据
//            if(!new File(imagesBuffer.toString() + "caches/back-" + fileName).exists()){
//                FileUtils.copyFile(path + "/caches/videos/" + fileName, imagesBuffer.toString() + "caches/back-" + fileName, false);
//            }
//            //复制打包数据，并且改名
//            FileUtils.copyFile(path + "/caches/videos/" + fileName, imagesBuffer.toString() + "caches/" + planId + ".mp4", true);
////            //将视频打成zip包
////            zipName = imagesBuffer.toString() + "caches/" + sceneNum + "-video-" + planId + ".zip";
////            FileUtils.zipFile(zipName, imagesBuffer.toString() + "caches/" + planId + ".mp4");
////            url = mainUrl + zipName.replace(ConstantFilePath.BASE_PATH + "/", "");
//
//            url = mainUrl + "scene/" + imagesBuf.toString() + "caches/" + planId + ".mp4";

            //使用oss的路径
            url = prefixAli + "video/video" + sceneProEntity.getNum() + "/" + planId + ".mp4";
        }
        return url;
    }

    @Override
    public Result uploadPanoramaOrVideo(String sceneNum, String fileName, String type, MultipartFile file, String planId) throws Exception {
        if(StringUtils.isEmpty(sceneNum) || StringUtils.isEmpty(fileName) || StringUtils.isEmpty(type) || StringUtils.isEmpty(planId)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        if(!fileName.endsWith(".jpg") && !fileName.endsWith(".mp4")){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5023, SceneConstant.FAILURE_MSG_5023);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

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


        String path = sceneProEntity.getDataSource();

        if(path != null && !"".equals(path) && path.startsWith("http")){
            path = ConstantFilePath.BUILD_MODEL_PATH + File.separator + path.split("/")[path.split("/").length - 2];
        }
        String target = path + "_images";

        //文件上传的位置可以自定义
        String filePath = "";
        if("image".equals(type)){
            filePath = target + File.separator + "extras/images" + File.separator + fileName;
        }

        if("video".equals(type)){
            filePath = target + File.separator + "extras/video" + File.separator + fileName;
        }
        File targetFile = new File(filePath);
        if(!targetFile.getParentFile().exists()){
            targetFile.getParentFile().mkdirs();
        }

        //上传文件
        file.transferTo(targetFile);

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        scenejson.put("buildImages", 1);
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());

        return Result.success();
    }

    @Override
    public Result uploadROIVideo(String sceneNum, String fileName, MultipartFile file, String planId, String rect,
                                 String videoDirMatrix, String dir, String hfov, String vfov) throws Exception {
        if(StringUtils.isEmpty(sceneNum) || StringUtils.isEmpty(fileName) ||
                StringUtils.isEmpty(planId) || StringUtil.isEmpty(rect)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

//        if(!fileName.endsWith(".mp4")){
//            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5023, SceneConstant.FAILURE_MSG_5023);
//        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

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


        String path = sceneProEntity.getDataSource();

        if(path != null && !"".equals(path) && path.startsWith("http")){
            path = ConstantFilePath.BUILD_MODEL_PATH + File.separator + path.split("/")[path.split("/").length - 2];
        }
        String target = path + "_roi";

        FileUtils.deleteDirectory(target);

        //文件上传的位置可以自定义
        String filePath = target + File.separator + "extras" + File.separator + fileName;
        File targetFile = new File(filePath);
        if(!targetFile.getParentFile().exists()){
            targetFile.getParentFile().mkdirs();
        }

        if(file == null){
            FileUtils.copyFile(ConstantFilePath.SCENE_PATH + "video/video"+
                    sceneProEntity.getNum() + File.separator + fileName, filePath, true);
        }else {
            //上传文件
            file.transferTo(targetFile);

            FileUtils.copyFile(filePath, ConstantFilePath.SCENE_PATH + "video/video"+
                    sceneProEntity.getNum() + File.separator + fileName, true);
        }

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        JSONArray jsonArray = new JSONArray();
        JSONObject jsonObject = new JSONObject();

        JSONObject rectJson = JSON.parseObject(rect);

        boolean noPanoId = true;
        if(scenejson.containsKey("videosUser")){
            jsonArray = scenejson.getJSONArray("videosUser");
            for(int i = 0, len = jsonArray.size(); i < len; i++){
                jsonObject = jsonArray.getJSONObject(i);
                if(planId.equals(jsonObject.getString("panoId"))){
                    jsonObject.put("rect", rectJson);
                    jsonObject.put("name", fileName.substring(0, fileName.lastIndexOf(".")));
//                    jsonObject.put("videoDirMatrix", JSON.parseArray(videoDirMatrix));
                    jsonObject.put("dir", JSON.parseObject(dir));
                    jsonObject.put("hfov", hfov);
                    jsonObject.put("vfov", vfov);
                    noPanoId = false;
                    break;
                }
            }
        }
        if(noPanoId){
            jsonObject = new JSONObject();
            jsonObject.put("name", fileName.substring(0, fileName.lastIndexOf(".")));
            jsonObject.put("panoId", planId);
            jsonObject.put("rect", rectJson);
//            jsonObject.put("videoDirMatrix", JSON.parseArray(videoDirMatrix));
            jsonObject.put("dir", JSON.parseObject(dir));
            jsonObject.put("hfov", hfov);
            jsonObject.put("vfov", vfov);
            if(!jsonArray.contains(jsonObject)){
                jsonArray.add(jsonObject);
            }
        }
        //保存rect的json数据
        FileUtils.writeFile(target + File.separator + "extras" + File.separator + "video-ROI.json", jsonObject.toJSONString());
        //复制原始图片
        FileUtils.copyFile(path + "/caches/images/" + planId + ".jpg",
                target + File.separator + "extras" + File.separator + planId + ".jpg", true);

        FileUtils.copyFile(path + File.separator + "data.json", target + File.separator+"data.json", true);
        FileUtils.copyFile(path + File.separator + "project.json", target + File.separator+"project.json", true);

        //data.json增加extras为执行重建算法
        String project = FileUtils.readFile(target + File.separator+"project.json");
        if(project != null){
            JSONObject projectJson = JSONObject.parseObject(project);
            projectJson.put("parent", projectJson.get("uuid"));
            projectJson.put("uuid", UUID.randomUUID().toString());
            projectJson.put("time", System.currentTimeMillis());
            FileUtils.writeFile(path + File.separator + "project.json", projectJson.toString());
        }

        String data = FileUtils.readFile(target + File.separator+"data.json");
        if(data != null){
            JSONObject dataJson = JSONObject.parseObject(data);
            //V5表示不需要生成high，low文件
            dataJson.put("skybox_type", "SKYBOX_V5");
            dataJson.put("split_type", "SPLIT_V11");
            FileUtils.writeFile(target + File.separator+"data.json", new String(dataJson.toString().getBytes(), "UTF-8"));
        }

        //进行计算
        log.info("绿幕抠图视频：开始建模——" + sceneProEntity.getNum());
        CreateObjUtil.build3dModel2(target , "1");

        //读取upload文件，检验需要上传的文件是否存在
        String uploadData = FileUtils.readFile(target + File.separator + "results" +File.separator+"upload.json");
        JSONObject uploadJson = null;
        JSONArray array = null;
        if(uploadData!=null) {
            uploadJson = JSONObject.parseObject(uploadData);
            array = uploadJson.getJSONArray("upload");
        }
        if(array == null){
            throw new Exception("upload.json数据出错");
        }

        Map<String, String> map = new HashMap<>();
        JSONObject fileJson = null;
        for(int i = 0, len = array.size(); i < len; i++){
            fileJson = array.getJSONObject(i);
            fileName = fileJson.getString("file");
            //文件不存在抛出异常
            if(!new File(target + File.separator + "results" +File.separator + fileName).exists()){
                throw new Exception(target + File.separator + "results" +File.separator + fileName+"文件不存在");
            }

            if(fileJson.getIntValue("clazz") == 19 ){
                map.put(target + File.separator + "results" + File.separator+ fileName,"video/video"+
                        sceneProEntity.getNum() + File.separator + fileName.replace("videos/", ""));
            }

        }

        uploadToOssUtil.uploadMulFiles(map);

        scenejson.put("videosUser", jsonArray.toJSONString());
        scenejson.put("imagesVersion", scenejson.getIntValue("imagesVersion") + 1);

        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());

        SceneProEditEntity sceneProEditEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());
        if(sceneProEditEntity != null){
            sceneProEditEntity.setVideosUser(jsonArray.toJSONString());
            sceneProEditEntity.setImagesVersion(sceneProEditEntity.getImagesVersion() + 1);
            sceneProEditMapper.updateByPrimaryKey(sceneProEditEntity);
        }

        return Result.success();
    }

    @Override
    public Result deleteROIVideo(String sceneNum, String fileName, String planId) throws Exception {
        if(StringUtils.isEmpty(sceneNum) || StringUtils.isEmpty(fileName) || StringUtils.isEmpty(planId)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        JSONArray newArray = new JSONArray();
        JSONArray jsonArray = new JSONArray();
        JSONObject jsonObject = new JSONObject();

        if(scenejson.containsKey("videosUser")){
            jsonArray = JSON.parseArray(scenejson.getString("videosUser"));
            for(int i = 0, len = jsonArray.size(); i < len; i++){
                jsonObject = jsonArray.getJSONObject(i);
                if(planId.equals(jsonObject.getString("panoId"))){
                    continue;
                }
                if(!newArray.contains(jsonObject)){
                    newArray.add(jsonObject);
                }
            }
        }

        scenejson.put("videosUser", newArray.toJSONString());
        scenejson.put("imagesVersion", scenejson.getIntValue("imagesVersion") + 1);

        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());

        SceneProEditEntity sceneProEditEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());
        if(sceneProEditEntity != null){
            sceneProEditEntity.setVideosUser(newArray.toJSONString());
            sceneProEditEntity.setImagesVersion(sceneProEditEntity.getImagesVersion() + 1);
            sceneProEditMapper.updateByPrimaryKey(sceneProEditEntity);
        }

        uploadToOssUtil.delete("video/video"+ sceneProEntity.getNum() + File.separator +
                fileName.substring(0, fileName.lastIndexOf(".")) + ".mp4");
        uploadToOssUtil.delete("video/video"+ sceneProEntity.getNum() + File.separator +
                fileName.substring(0, fileName.lastIndexOf(".")) + ".flv");

        FileUtils.deleteFile(ConstantFilePath.SCENE_PATH + "video/video"+ sceneProEntity.getNum() + File.separator + fileName);
        return Result.success();
    }

    @Override
    public Result uploadBgMusic(String sceneNum, String fileName, MultipartFile file) throws Exception {
        if(StringUtils.isEmpty(sceneNum) || StringUtils.isEmpty(fileName)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .append(File.separator);

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

        File buMusicFile = new File(imagesBuffer.toString() + fileName);
        if(!buMusicFile.getParentFile().exists()){
            buMusicFile.getParentFile().mkdirs();
        }

        //上传文件
        file.transferTo(buMusicFile);

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        scenejson.put("bgMusicName", fileName);
        scenejson.put("uploadBgMusic", 1);
        scenejson.put("version", scenejson.getIntValue("version") + 1);
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());

        return Result.success();
    }

    @Override
    public Result deleteUploadBgMusic(String sceneNum) throws Exception {
        if(StringUtils.isEmpty(sceneNum)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        scenejson.put("bgMusicName", "");
        scenejson.put("uploadBgMusic", 1);
        scenejson.put("version", scenejson.getIntValue("version") + 1);
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());

        return Result.success();
    }

    @Override
    public Result savePanorama(String sceneNum, String sid, MultipartFile file, String imagesName) throws Exception {
        if(StringUtils.isEmpty(sceneNum) || StringUtils.isEmpty(sid)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String path = sceneProEntity.getDataSource();
        String target = imagesBuffer.toString() + "panorama/" + sid;
        FileUtils.deleteDirectory(target);

        //文件上传的位置可以自定义
        String filePath = target + File.separator + "extras/images" + File.separator + imagesName;

        File targetFile = new File(filePath);
        if(!targetFile.getParentFile().exists()){
            targetFile.getParentFile().mkdirs();
        }

        //上传文件
        file.transferTo(targetFile);

        //调用算法切全景图
        FileUtils.copyFile(path + File.separator + "data.json", target + File.separator+"data.json", true);
        FileUtils.copyFile(path + File.separator + "project.json", target + File.separator+"project.json", true);

        JSONObject visionJson = new JSONObject();
        JSONArray visionArray = new JSONArray();
        visionJson.put("uuid", imagesName.substring(0, imagesName.lastIndexOf(".")));
        visionJson.put("group", 1);
        visionJson.put("subgroup", 0);
        visionArray.add(visionJson);

        JSONObject vision = new JSONObject();
        vision.put("sweepLocations", visionArray);
        FileUtils.writeFile(target + "/extras" + File.separator + "vision.txt", new String(vision.toString().getBytes(), "UTF-8"));

        //data.json增加extras为执行重建算法
        String data = FileUtils.readFile(target + File.separator + "data.json");
        if(data != null){
            JSONObject floorplanJson = new JSONObject();
            floorplanJson.put("has_source_images", true);
            floorplanJson.put("has_vision_txt", true);

            JSONObject dataJson = JSONObject.parseObject(data);
            dataJson.put("extras", floorplanJson);
            //V5表示不需要生成high，low文件
            dataJson.put("skybox_type", "SKYBOX_V6");
            if(sceneProEntity.getSceneScheme() == 11){
                dataJson.put("skybox_type", "SKYBOX_V7");
            }
            dataJson.put("split_type", "SPLIT_V8");
            if(sceneProEntity.getSceneScheme() == 3){
                dataJson.put("skybox_type", "SKYBOX_V4");
            }
            FileUtils.writeFile(target + File.separator+"data.json", new String(dataJson.toString().getBytes(), "UTF-8"));
        }

        //创建文件夹软连接并且复制data.json和project.json
        if(new File(target + File.separator + "capture").exists()){
            new File(target + File.separator + "capture").delete();
        }
        if(new File(target + File.separator + "results").exists()){
            FileUtils.delAllFile(target + File.separator + "results");
        }
        //下载data.fdage
        if("s3".equals(this.type)){
            //亚马逊保持旧方式，超链接capture
            CreateObjUtil.createSoftConnection(path + File.separator + "capture", target + File.separator + "capture");
        }
        CreateObjUtil.ossUtilCpWithZfbBucket(ConstantFilePath.OSS_PREFIX + path.replace(ConstantFilePath.BUILD_MODEL_PATH, "") + "/data.fdage", target + File.separator + "capture/");

        CreateObjUtil.build3dModel(target , "1");
//        CreateObjUtil.build3dModel2(target , "1");
        //读取upload文件，检验需要上传的文件是否存在
//        Thread.sleep(20000L);

        String uploadPath = target + File.separator + "results" +File.separator+"upload.json";
        long timeStamp = System.currentTimeMillis();
        Integer time = 0;
        boolean isExsts = true;
        while (isExsts){
            File f = new File(uploadPath);
            long diff = System.currentTimeMillis() - timeStamp;
            log.info("文件生产时间倒计时 -- " + diff/1000);
            if (f.exists()) {
                isExsts = false;
            }else{
                if(diff/1000 > 30){
                    isExsts = false;
                }
            }
        }

        String uploadData = FileUtils.readFile(target + File.separator + "results" +File.separator+"upload.json");
        JSONObject uploadJson = null;
        JSONArray array = null;
        if(uploadData!=null) {
            uploadJson = JSONObject.parseObject(uploadData);
            array = uploadJson.getJSONArray("upload");
        }
        if(array == null){
            log.info("计算全景图失败，没有upload.json");
        }
        Map<String, String> map = new HashMap<>();
        JSONObject fileJson = null;
        String fileName = "";
        String img = "";
        for(int i = 0, len = array.size(); i < len; i++){
            fileJson = array.getJSONObject(i);
            fileName = fileJson.getString("file");
            //文件不存在抛出异常
            if(!new File(target + File.separator + "results" +File.separator + fileName).exists()){
                throw new Exception(target + File.separator + "results" +File.separator + fileName+"文件不存在");
            }

            //high文件夹
//            if(fileJson.getIntValue("clazz") == 3){
//                map.put(target + File.separator + "results" +File.separator+ fileName,"images/images"+
//                        sceneProEntity.getNum()+"/pan/high/"+ fileName.replace("high/", ""));
//                continue;
//            }
            //low文件夹
            if(fileJson.getIntValue("clazz") == 4){
                img = "/results" + File.separator + fileName;

                map.put(target + File.separator + "results" +File.separator+ fileName,"images/images"+
                        sceneProEntity.getNum()+"/pan/low/"+ fileName.replace("low/", ""));
                continue;
            }

            //tiles文件夹,亚马逊没有裁剪图片api，不需要上传4k图
            if(fileJson.getIntValue("clazz") == 5){
                map.put(target + File.separator + "results" + File.separator+ fileName,"images/images"+
                        sceneProEntity.getNum()+ "/panorama_edit/" + sid + File.separator + fileName);
            }

            //tiles文件夹,亚马逊瓦片图
            if(fileJson.getIntValue("clazz") == 7 ){
                map.put(target + File.separator + "results" + File.separator+ fileName,"images/images"+
                        sceneProEntity.getNum()+ File.separator + fileName);
            }

        }

        //上传全景图
        map.put(filePath, "images/images"+ sceneProEntity.getNum()+ File.separator + "pan/high/" + imagesName);

        uploadToOssUtil.uploadMulFiles(map);

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        scenejson.put("uploadPanoramaImg", 1);
        scenejson.put("version", scenejson.getIntValue("version") + 1);
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());

        Map<String, String> result = new HashMap<>();
        result.put("type", sceneProEntity.getSceneScheme() == 11? "2k" : "4k");
        result.put("img", "scene/" + imagesBuf.toString() + "panorama/" + sid + img);
        result.put("path", "images/images"+ sceneProEntity.getNum()+ "/panorama_edit/" + sid);
        return Result.success(result);
    }

    @Override
    public Result savePanoramaJson(String sceneNum, String fileData, String fileName, String sid) throws Exception {
        if(StringUtils.isEmpty(sceneNum) || StringUtils.isEmpty(fileName)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

        SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }

        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .append(File.separator);

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

        FileUtils.writeFile(dataBuffer.toString() + fileName, fileData);

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        scenejson.put("uploadPanoramaJson", 1);
        scenejson.put("version", scenejson.getIntValue("version") + 1);
        if(StringUtils.isNotEmpty(fileData)){
            scenejson.put("jumpScene", true);
        }else {
            scenejson.put("jumpScene", false);
        }
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toString());

        if(StringUtils.isNotEmpty(sid)){
            String target = imagesBuffer.toString() + "panorama/" + sid;
            FileUtils.deleteDirectory(target);
//            uploadToOssUtil.deleteFile(imagesBuf.toString() + "panorama/" + sid);
            uploadToOssUtil.deleteFile(imagesBuf.toString() + "panorama_edit/" + sid);
        }

        return Result.success();
    }

    @Override
    public Result copyAndUpdateFloorJson(String sceneNum, String floorJsonData) throws Exception{
        if(StringUtils.isEmpty(sceneNum) ){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

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

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

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        if(StringUtils.isEmpty(floorJsonData)){
            SceneProEntity sceneProEntity = sceneProMapper.findByNum(sceneNum);
            if(sceneProEntity == null){
                throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
            }

            FileUtils.copyFile(sceneProEntity.getDataSource() + "/results/floor.json", dataBuffer.toString() + "houst_floor.json", true);
            uploadToOssUtil.upload(dataBuffer.toString() + "houst_floor.json", dataBuf.toString() + "houst_floor.json");

            String result = FileUtils.readFile(dataBuffer.toString() + "houst_floor.json");
            return Result.success((Object) result);
        }

        FileUtils.writeFile(dataBuffer.toString() + "houst_floor.json", floorJsonData);
        uploadToOssUtil.upload(dataBuffer.toString() + "houst_floor.json", dataBuf.toString() + "houst_floor.json");
        return Result.success((Object) floorJsonData);
    }

    @Override
    public Result updateFloorJson(String sceneNum, String floorJsonData) throws Exception{
        if(StringUtils.isEmpty(sceneNum) || StringUtils.isEmpty(floorJsonData)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }

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

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

        String strsceneInfos = FileUtils.readFile(dataBuffer.toString() + "scene.json");
        JSONObject scenejson = new JSONObject();
        if(strsceneInfos!=null) {
            scenejson = JSONObject.parseObject(strsceneInfos);
        }

        scenejson.put("uploadFloorJson", 1);
        scenejson.put("version", scenejson.getIntValue("version") + 1);
        FileUtils.writeFile(dataBuffer.toString() + "floor.json", floorJsonData);
        FileUtils.writeFile(dataBuffer.toString() + "scene.json", scenejson.toJSONString());
//        uploadToOssUtil.upload(dataBuffer.toString() + "houst_floor.json", dataBuf.toString() + "houst_floor.json");
        return Result.success((Object) floorJsonData);
    }

    @Override
    public PageInfo<ResponseScene> queryCompanySceneListByParams(RequestScene param) {
        int pageNum = param.getPageNum();
        int pageSize = param.getPageSize();
        Page page = PageHelper.startPage(pageNum, pageSize, true);
        PageHelper.orderBy(" a.create_time desc");

        List<ResponseScene> result = sceneProMapper.queryCompanySceneListByParams(param);

        Page<ResponseScene> a = new Page<ResponseScene>(param.getPageNum(), param.getPageSize());
        a.setTotal(page.getTotal());
        PageInfo<ResponseScene> pageInfo = a.toPageInfo();
        pageInfo.setList(result);

        return pageInfo;
    }

    @Override
    public PageInfo<ResponseScene> getAppAllSceneByPage(Long cameraId, Long userId, int cameraType, int pageNum, Integer pageSize, String orderBy, Integer sceneType, String nums, String sceneName) {
        Page page = PageHelper.startPage(pageNum, pageSize, true);
        if(StringUtil.isEmpty(orderBy)){
            PageHelper.orderBy(" create_time desc");
        }else {
            PageHelper.orderBy(orderBy);
        }

        if(StringUtil.isEmpty(nums)){
            nums = null;
        }

        List<ResponseScene> result = sceneProMapper.getAppAllSceneByPage(cameraId, userId, cameraType, sceneType, nums, sceneName);

        Page<ResponseScene> a = new Page<ResponseScene>(pageNum, pageSize);
        a.setTotal(page.getTotal());
        PageInfo<ResponseScene> pageInfo = a.toPageInfo();
        pageInfo.setList(result);

        return pageInfo;
    }

    @Override
    public Integer findSceneNumByCameraId(Long cameraId) {
        return sceneProMapper.findSceneNumByCameraId(cameraId);
    }

    @Override
    public SceneProEntity findLastSceneByCameraId(Long cameraId) {
        return sceneProMapper.findLastSceneByCameraId(cameraId);
    }

    @Override
    public BigInteger findTotalSpaceByCameraId(Long cmaeraId) {
        return sceneProMapper.findTotalSpaceByCameraId(cmaeraId);
    }

    @Override
    public void updatePayStatusByCameraId(Integer payStatus, Long cameraId) {
        sceneProMapper.updatePayStatusByCameraId(payStatus, cameraId);
    }



    @Override
    public Result downloadVisionData(String sceneNum) throws Exception {
        if(StringUtils.isEmpty(sceneNum)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }
        SceneProEntity sceneProEntity = findBySceneNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }
        StringBuffer dataBuf = new StringBuffer()
                .append("data").append(File.separator)
                .append("data").append(sceneProEntity.getNum())
                .append(File.separator);

        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .append(File.separator);

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


        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.toString() + "vision.modeldata");
        if(!file.exists()) {
            return Result.failure(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
        }
        ConvertUtils.convertVisionModelDataToTxt(dataBuffer.toString() + "vision.modeldata", dataBuffer.toString() + "vision.json");

        uploadToOssUtil.upload(dataBuffer.toString() + "vision.json", dataBuf.toString() + "vision.json");
        return Result.success(prefixAli + dataBuf.toString() + "vision.json?t=" + System.currentTimeMillis());
    }

    @Override
    public Result downloadPanoramaData(String sceneNum) throws Exception {
        if(StringUtils.isEmpty(sceneNum)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }
        SceneProEntity sceneProEntity = findBySceneNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }
        StringBuffer imagesBuf = new StringBuffer()
                .append("images").append(File.separator)
                .append("images").append(sceneProEntity.getNum())
                .append(File.separator);

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

        String highPath = sceneProEntity.getDataSource() + "/results/high";
        if(!new File(highPath).exists()){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5012, SceneConstant.FAILURE_MSG_5012);
        }

        FileUtils.zipFile(imagesBuffer.toString() + sceneNum + "-high.zip", highPath);
        uploadToOssUtil.upload(imagesBuffer.toString() + sceneNum + "-high.zip", imagesBuf.toString() + sceneNum + "-high.zip");
        return Result.success(prefixAli + imagesBuf.toString() + sceneNum + "-high.zip?t=" + System.currentTimeMillis());

    }

    @Override
    public Result getInfo(String sceneNum) throws Exception {
        if(StringUtils.isEmpty(sceneNum)){
            throw new BaseRuntimeException(LoginConstant.FAILURE_CODE_3001, LoginConstant.FAILURE_MSG_3001);
        }
        SceneProEntity sceneProEntity = findBySceneNum(sceneNum);
        if(sceneProEntity == null){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }
        if(sceneProEntity.getPayStatus() != 1){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }
        if(sceneProEntity.getStatus() != 1 && sceneProEntity.getStatus() != -2){
            throw new BaseRuntimeException(SceneConstant.FAILURE_CODE_5005, SceneConstant.FAILURE_MSG_5005);
        }
        ResponseScene responseScene = new ResponseScene();
        SceneProEditEntity editEntity = sceneProEditMapper.findByProId(sceneProEntity.getId());
        BeanUtils.copyProperties(editEntity, responseScene);
        BeanUtils.copyProperties(sceneProEntity, responseScene);
        if(StringUtil.isNotEmpty(editEntity.getEntry())){
            responseScene.setEntry(JSONObject.parseObject(editEntity.getEntry()).toJSONString());
        }

        if(StringUtil.isNotEmpty(sceneProEntity.getGps())){
            responseScene.setGps(JSONObject.parseObject(sceneProEntity.getGps()).toJSONString());
        }

        responseScene.setCreateTime(new DateTime(sceneProEntity.getCreateTime()).toString("yyyy-MM-dd"));
        responseScene.setCreateDate(sceneProEntity.getCreateTime().getTime());
        if(StringUtil.isEmpty(editEntity.getSceneKey())){
            responseScene.setIsPublic(0);
        }else {
            responseScene.setIsPublic(1);
        }

        //不返回场景访问密码
        responseScene.setSceneKey("");

        //查询是否有随心装场景
        if(sceneNum.indexOf("vr-")!=-1){
            SceneProEntity vrSceneProEntity = findLikeSceneNum(sceneNum);
            if(vrSceneProEntity != null){
                responseScene.setVrNum(vrSceneProEntity.getNum());
                responseScene.setVideosUser(null);
                responseScene.setBgMusicName(null);
                responseScene.setBgMusic(null);
            }
        }
        

        //更新访问数量
        sceneService.updateViewCount(sceneNum);
        return Result.success(responseScene);
    }

    @Override
    public Integer findFolderIdScence(Long folderId, Long userId) {
        return sceneProMapper.findFolderIdScence(folderId,userId);
    }

    @Override
    public void updatePayStatus(Long id, Integer status) {
        sceneProMapper.updatePayStatus(id,status);
    }

    @Override
    public SceneProEntity getById(Long id) {
        return sceneProMapper.getById(id);
    }

    public static void main(String[] args) {
        try {
            Thumbnails.of("C:\\Users\\hisun\\Downloads\\100m.jpg").size(1024,512).toFile("C:\\Users\\hisun\\Downloads\\100m-T.jpg");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}