4dkankan-center-modeling-control/src/main/java/com/fdkankan/contro/service/impl/CommonServiceImpl.java

package com.fdkankan.contro.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.collection.CollUtil;
import cn.hutool.core.io.FileUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.ZipUtil;
import cn.hutool.http.HttpUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.fdkankan.common.constant.*;
import com.fdkankan.common.util.FileUtils;
import com.fdkankan.contro.bean.SceneJsonBean;
import com.fdkankan.contro.constant.DetectType;
import com.fdkankan.contro.entity.*;
import com.fdkankan.contro.factory.UserEditData.UserEditDataHandler;
import com.fdkankan.contro.factory.UserEditData.UserEditDataHandlerFactory;
import com.fdkankan.contro.service.*;
import com.fdkankan.contro.vo.SceneEditControlsVO;
import com.fdkankan.fyun.config.FYunFileConfig;
import com.fdkankan.fyun.face.FYunFileServiceInterface;
import com.fdkankan.model.constants.ConstantFileName;
import com.fdkankan.model.constants.ConstantFilePath;
import com.fdkankan.model.constants.UploadFilePath;
import com.fdkankan.model.utils.CreateObjUtil;
import com.fdkankan.model.utils.FloorPlanUserUtil;
import com.fdkankan.model.utils.SceneUtil;
import com.fdkankan.rabbitmq.bean.BuildSceneCallMessage;
import com.fdkankan.rabbitmq.bean.BuildSceneResultMqMessage;
import com.fdkankan.rabbitmq.util.RabbitMqProducer;
import com.fdkankan.redis.constant.RedisKey;
import com.fdkankan.redis.util.RedisUtil;
import com.fdkankan.sms.SendMailAcceUtils;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.io.File;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.GeneralSecurityException;
import java.util.*;
import java.util.stream.Collectors;

@Slf4j
@Service
@RefreshScope
public class CommonServiceImpl implements ICommonService {

    @Value("${main.laserUrl:#{null}}")
    private String laserUrl;

    @Value("${env:gn}")
    private String env;

    @Value("${helpLink.zh-cn:https://docs.4dkankan.com/#/product/4dkk/zh-cn/README}")
    private String helpLinkZh;

    @Value("${helpLink.en-us:https://docs.4dkankan.com/#/product/4dkk/en-us/README}")
    private String helpLinkEn;

    @Value("#{'${camType.laser:}'.split(',')}")
    private List<Integer> laserCamTypeList;

    @Value("${model.modelKind:3dtiles}")
    private String modelKind;

    @Value("#{'${model.3dtiles.sceneSource:}'.split(',')}")
    private List<Integer> sdTilesSceneSourceList;

    @Autowired
    private ISceneAsynOperLogService sceneAsynOperLogService;
    @Resource
    private FYunFileServiceInterface fYunFileServiceInterface;
    @Autowired
    private IScenePlusService scenePlusService;
    @Autowired
    private IScenePlusExtService scenePlusExtService;
    @Autowired
    private IMailTemplateService mailTemplateService;
    @Autowired
    private IUserService userService;
    @Autowired
    private ISceneProService sceneProService;
    @Autowired
    private ICameraDetailService cameraDetailService;
    @Autowired
    private IUserIncrementService userIncrementService;
    @Autowired
    private IIncrementTypeService incrementTypeService;
    @Autowired
    private ICameraService cameraService;
    @Autowired
    private FYunFileConfig fYunFileConfig;
    @Autowired
    private ISceneEditInfoService sceneEditInfoService;
    @Autowired
    private ISceneEditControlsService sceneEditControlsService;
    @Autowired
    private ISceneEditInfoExtService sceneEditInfoExtService;
    @Autowired
    private RedisUtil redisUtil;
    @Autowired
    private IMqSendLogService mqSendLogService;
    @Autowired
    private RabbitMqProducer rabbitMqProducer;
    @Autowired
    private ISceneInfoSyncMqConfigService sceneInfoSyncMqConfigService;
    @Resource
    private FYunFileServiceInterface fYunFileService;
    @Autowired
    private ISceneMarkShapeService sceneMarkShapeService;

    @Override
    public void uploadBuildResultData(String num, String dataSource, String version) {

        Map<String, String> uploadMap = new HashMap<>();

        String ossResultPath = String.format(UploadFilePath.scene_result_data_path, num);

        //删除旧的文件目录
        fYunFileServiceInterface.deleteFolder(ossResultPath);

        //上传caches/images
        String localCachesImagePath = dataSource + "/caches/images/";
        String ossCachesImagePath = ossResultPath + "caches/images/";
        //先清除旧的全景图
        if(FileUtil.exist(localCachesImagePath)){
            fYunFileServiceInterface.uploadFileByCommand(localCachesImagePath, ossCachesImagePath);
        }

        //上传project.json
        String localProjectJsonPath = dataSource + "/project.json";
        String ossProjectJsonPath = ossResultPath + "project.json";
        if(FileUtil.exist(localProjectJsonPath)){
            uploadMap.put(localProjectJsonPath, ossProjectJsonPath);
        }

        //上传data.json
        String localDataJsonPath = dataSource + "/data.json";
        String ossDataJsonPath = ossResultPath + "data.json";
        if(FileUtil.exist(localDataJsonPath)){
            uploadMap.put(localDataJsonPath, ossDataJsonPath);
        }

        //户型图上传
        String floorplanCadPath = ossResultPath + "floorplan_cad";
        String cadPicPathFormat = floorplanCadPath + "/floor-cad-%s.%s";
        String floorCadPath = dataSource + "/results/floorplan_cad";
        //清除原有旧的cad图
        fYunFileServiceInterface.deleteFolder(floorplanCadPath);
        List<String> floorCadList = FileUtils.getFileList(floorCadPath);
        if(CollUtil.isNotEmpty(floorCadList)){
            floorCadList.stream().forEach(str->{
                String substring = str.substring(str.lastIndexOf(File.separator) + 1);
                String[] arr = substring.split("floor");
                String[] arr2 = arr[1].split("\\.");
                //上传到用户编辑目录
                uploadMap.put(str, String.format(cadPicPathFormat, arr2[0], arr2[1]));
            });
        }

        //上传深时场景生成obj需要的文件
        String localReconstruction = dataSource + "/caches/reconstruction/";
        String ossReconstruction = ossResultPath + "caches/reconstruction/";
        if(FileUtil.exist(localReconstruction)){
            fYunFileServiceInterface.uploadFileByCommand(localReconstruction, ossReconstruction);
        }
        String localDepthmap = dataSource + "/caches/depthmap/";
        String ossDepthmap = ossResultPath + "caches/depthmap/";
        if(FileUtil.exist(localDepthmap)){
            fYunFileServiceInterface.uploadFileByCommand(localDepthmap, ossDepthmap);
        }
        String localDepthmapAsc = dataSource + "/caches/depthmap_csc/";
        String ossDepthmapAsc = ossResultPath + "caches/depthmap_csc/";
        if(FileUtil.exist(localDepthmapAsc)){
            fYunFileServiceInterface.uploadFileByCommand(localDepthmapAsc, ossDepthmapAsc);
        }
        String localPanoramaJson =  dataSource + "/caches/panorama.json";
        String ossPanoramaJson =  ossResultPath + "caches/panorama.json";
        if(FileUtil.exist(localPanoramaJson)){
            fYunFileServiceInterface.uploadFile(localPanoramaJson, ossPanoramaJson);
        }
//        String localLaserPly = dataSource + "/results/laserData/laser.ply";
//        String ossLaserPly =  ossResultPath + "results/laserData/laser.ply";
//        if(FileUtil.exist(localLaserPly)){
//            fYunFileServiceInterface.uploadFile(localLaserPly, ossLaserPly);
//        }
        String localFloorGroupFixJson = dataSource + "/caches/floor_group_fix.json";
        String ossFloorGroupFixJson = ossResultPath + "caches/floor_group_fix.json";
        if(FileUtil.exist(localFloorGroupFixJson)){
            fYunFileServiceInterface.uploadFile(localFloorGroupFixJson, ossFloorGroupFixJson);
        }

        String localDepthmapVis = dataSource + "/caches/depthmap_vis";
        String ossDepthmapVis = ossResultPath + "caches/depthmap_vis";
        if(FileUtil.exist(localDepthmapVis)){
            fYunFileServiceInterface.uploadFileByCommand(localDepthmapVis, ossDepthmapVis);
        }

        String localIntensity = dataSource + "/caches/intensity";
        String ossIntensity = ossResultPath + "caches/intensity";
        if(FileUtil.exist(localIntensity)){
            fYunFileServiceInterface.uploadFileByCommand(localIntensity, ossIntensity);
        }

        //上传点位校准相关文件
        String localExtras = dataSource + "/extras";
        String ossExtras = ossResultPath + "extras";
        if(FileUtil.exist(localExtras)){
            fYunFileServiceInterface.uploadFileByCommand(localExtras, ossExtras);
        }

        //上传post文件，用于深巡全景图重定位计算
        String localPose = dataSource + "/results/pose";
        String ossPose = ossResultPath + "pose";
        if(FileUtil.exist(localPose)){
            fYunFileServiceInterface.uploadFileByCommand(localPose, ossPose);
        }

        //开始上传
        fYunFileServiceInterface.uploadMulFiles(uploadMap);
    }

    @Override
    public void uploadFloorplanJson(String num, String dataSource) throws Exception{
        String floorPlanCardFilePath = dataSource + File.separator + "results/floorplan_cad.json";
        if (!new File(floorPlanCardFilePath).exists()) {
            log.warn("floorplan_cad.json 文件不存在，文件路径：{}", floorPlanCardFilePath);
            return;
        }
        JSONObject json = FloorPlanUserUtil.createFloorPlanUserJson(floorPlanCardFilePath);
        if(Objects.isNull(json)){
            log.warn("生成floorplan.json失败,cadPath:{}", floorPlanCardFilePath);
            return;
        }
        String floorplanJsonPath = String.format(UploadFilePath.DATA_VIEW_PATH, num) + "floorplan.json";
        fYunFileServiceInterface.uploadFile(json.toJSONString().getBytes(), floorplanJsonPath);
    }

    @Override
    public void initUserEditData(String num, Set<String> bizs, Map<String, Map<String ,Object>> params) throws Exception {
        if(StrUtil.isEmpty(num) || CollUtil.isEmpty(bizs)){
            return;
        }
        for (String biz : bizs) {
            UserEditDataHandler handler = UserEditDataHandlerFactory.getHandler(biz);
            handler.init(num, CollUtil.isEmpty(params) ? null : params.get(biz));
        }
    }

    @Override
    public void sendEmail(String num, String type) {
        try {
            Long userId = null;
            String websize = "";
            String title = "";
            Integer sceneSource = null;
            ScenePlus scenePlus = scenePlusService.getScenePlusByNum(num);
            if(Objects.isNull(scenePlus)){
                ScenePro scenePro = sceneProService.getByNum(num);
                if(Objects.isNull(scenePro)){
                    return;
                }
                userId = scenePro.getUserId();
                websize = scenePro.getWebSite();
                title = scenePro.getSceneName();
                sceneSource = scenePro.getSceneSource();
            }else{
                userId = scenePlus.getUserId();
                ScenePlusExt scenePlusExt = scenePlusExtService.getScenePlusExtByPlusId(scenePlus.getId());
                websize = scenePlusExt.getWebSite();
                title = scenePlus.getTitle();
                sceneSource = scenePlus.getSceneSource();
            }

            if(Objects.isNull(userId)){
                return;
            }
            User user = userService.getById(userId);
            if(Objects.isNull(user) || StrUtil.isEmpty(user.getUserName())){
                return;
            }
            String toEmail = user.getUserName();
            String helpLink = helpLinkEn;
            String lang = "en";
            if("gn".equals(env)){
                lang = "zh";
                helpLink = helpLinkZh;
            }
            websize += "&lang=" + lang;
            if(("standar".equals(type))
                    && (sceneSource == SceneSource.JG.code() || sceneSource == SceneSource.SG.code())){
                websize = String.format(laserUrl, num, lang);
            }

            MailTemplate mailTemplate = mailTemplateService.getOne(new LambdaQueryWrapper<MailTemplate>().eq(MailTemplate::getRemark, "计算完成").eq(MailTemplate::getLang, lang));
            String content = mailTemplate.getMsg().replaceAll("scene_name", title).replaceAll("scene_link", websize).replaceAll("help_link", helpLink);
            SendMailAcceUtils.sendMail(mailTemplate.getSendMail(), mailTemplate.getSendPassword(), mailTemplate.getSendHost(), toEmail, mailTemplate.getSubject(), content, null);
        }catch (Exception e){
            log.error("发送邮件失败,num:" + num, e);
        }
    }

    public static void main(String[] args) throws GeneralSecurityException {
        String content  = "<p>Dear Valued Customer,&nbsp;</p>\n" +
                "<p>&nbsp;</p>\n" +
                "<p>The scene \"scene_name\" has been successfully calculated, please review the following:&nbsp;<a href=\"scene_link\" target=\"_blank\" rel=\"noopener\">scene_link</a>&nbsp;</p>\n" +
                "<p>&nbsp;</p>\n" +
                "<p>If you need to edit the scene, the User Manual can provide instructions: <a href=\"help_link\" target=\"_blank\" rel=\"noopener\">help_link</a>&nbsp;</p>\n" +
                "<p>&nbsp;</p>\n" +
                "<p>Sincerely,&nbsp;</p>\n" +
                "<p>4Dage Support Team</p>\n" +
                "<p>&nbsp;</p>\n" +
                "<p>------------------</p>\n" +
                "<p><img src=\"http://4dkk.4dage.com/ucenter/image/4dkankan_en.png\" /></p>\n" +
                "<p><br /><strong><em>Web：</em></strong><a href=\"http://eur.4dkankan.com/\" target=\"_blank\" rel=\"noopener\">eur.4dkankan.com</a></p>";
        SendMailAcceUtils.sendMail("4Dkankan@4dage.com", "6996790AAaa", "smtp.exmail.qq.com", "qinyongcheng@cgaii.com", "The Scene Calculation is Now Complete.", content, null);
    }

    public String getOssOrignPath(String path) {
        String ossPath = ConstantFilePath.OSS_PREFIX
                + path.replace(ConstantFilePath.BUILD_MODEL_PATH, "")
                .replace(ConstantFilePath.BUILD_MODEL_LASER_PATH, "");
        if (!ossPath.endsWith("/")) {
            ossPath = ossPath.concat("/");
        }
        return ossPath;
    }

    @Override
    public int getPayStatus(Long cameraId, Long space, JSONObject dataFdageJson){
        //查询权益统计容量的方式
//        String unit = SpaceType.GB.code();
//        CameraDetail cameraDetail = cameraDetailService.getByCameraId(cameraId);
//        if(StrUtil.isNotEmpty(cameraDetail.getUnit())){
//            unit = cameraDetail.getUnit();
//        }
//        Long limit = this.getSpaceLimit(cameraDetail);
//
//        if(SpaceType.SP.code().equals(unit)){//如果按空间方式统计，则space置为1
//            space = 1L;
//        }
//
//        //更新相机使用用量，非激光相机或者是空间个数计算方式的，需要叠加相机容量
//        cameraDetailService.updateCameraDetailByCameraIdAndSpace(cameraId, space);
//
//        //无限容量或者激光相机或者文保vr，直接返回已支付
//        if(limit == -1
//                || ("gn".equals(env) && CollUtil.isNotEmpty(laserCamTypeList) && laserCamTypeList.contains(cameraDetail.getType()))
//                || this.checkIsSpVr(dataFdageJson, cameraDetail)){
//            return PayStatus.PAY.code();
//        }
//
//        Long usedSpace = cameraService.getUsedSpace(cameraId, unit);
//        if(usedSpace + space > limit){
//            return PayStatus.NO_CAPACITY.code();
//        }

        return PayStatus.PAY.code();
    }

    @Override
    public void uploadStatusJson(String num, Integer sceneStatus, String webSite, String thumb, Integer payStatus, String uploadPath) {
        String localDataPath = String.format(ConstantFilePath.DATABUFFER_FORMAT, num);
        JSONObject statusJson = new JSONObject();
        statusJson.put("status", sceneStatus);
        statusJson.put("webSite", webSite);
        statusJson.put("sceneNum", num);
        statusJson.put("thumb", thumb);
        statusJson.put("payStatus", PayStatus.NOT_PAY.code());
        statusJson.put("recStatus", 'A');
        FileUtils.writeFile(localDataPath + "status.json", statusJson.toString());
        fYunFileServiceInterface.uploadFile(localDataPath + "status.json", uploadPath + "status.json");
    }

    @Override
    public Long getSpaceLimit(CameraDetail cameraDetail){
        Long limit = cameraDetail.getTotalSpace();
        UserIncrement userIncrement = userIncrementService.getByCameraId(cameraDetail.getCameraId());
        if(Objects.nonNull(userIncrement) && userIncrement.getIsExpired() == CommonStatus.NO.code().intValue()){
            IncrementType incrementType = incrementTypeService.getById(userIncrement.getIncrementTypeId());
            switch (SpaceType.get(cameraDetail.getUnit())){
                case GB:
                    limit = incrementType.getCameraCapacity();
                    if(limit != -1){
                        limit = limit * 1024 * 1024 * 1024;
                    }
                    break;
                case SP:
                    limit = incrementType.getCameraSpace();
                    break;
            }
        }
        return limit;
    }

    @Override
    public Long getSpace(String num){
        Long space = fYunFileServiceInterface.getSpace(fYunFileConfig.getBucket(), String.format(UploadFilePath.DATA_VIEW_PATH, num));
        space += fYunFileServiceInterface.getSpace(fYunFileConfig.getBucket(), String.format(UploadFilePath.IMG_VIEW_PATH, num));
        space += fYunFileServiceInterface.getSpace(fYunFileConfig.getBucket(), String.format(UploadFilePath.VIDEOS_VIEW_PATH, num));
        space += fYunFileServiceInterface.getSpace(fYunFileConfig.getBucket(), String.format(UploadFilePath.VOICE_VIEW_PATH, num));
        space += fYunFileServiceInterface.getSpace(fYunFileConfig.getBucket(), String.format(UploadFilePath.scene_result_data_path, num).concat("caches"));
        return  space;
    }

    public Object[] updateEditInfo(ScenePlus scenePlus){
        SceneEditInfo sceneEditInfo = sceneEditInfoService.getByScenePlusId(scenePlus.getId());
        SceneEditControls sceneEditControls = null;
        SceneEditInfoExt sceneEditInfoExt = null;
        if(sceneEditInfo == null){
            sceneEditInfo = new SceneEditInfo();
            sceneEditInfo.setScenePlusId(scenePlus.getId());
            sceneEditInfo.setDescription(scenePlus.getDescription());
            sceneEditInfo.setTitle(scenePlus.getTitle());
            sceneEditInfoService.save(sceneEditInfo);
        }else{

            int version = 0;
            int imgVersion = 0;
            int linkVersion = 0;
            //获取展示页的版本号
            String sceneJsonStr = null;
            String sceneJsonKey = String.format(UploadFilePath.DATA_VIEW_PATH, scenePlus.getNum()) + "scene.json";
            if(fYunFileService.fileExist(sceneJsonKey)){
                sceneJsonStr = fYunFileServiceInterface.getFileContent(sceneJsonKey);
            }
            if(StrUtil.isNotEmpty(sceneJsonStr)){
                JSONObject sceneJson = JSON.parseObject(sceneJsonStr);
                version = sceneJson.getIntValue("version");
                imgVersion = sceneJson.getIntValue("imgVersion");
                linkVersion =  sceneJson.getIntValue("linkVersion");
            }

            if(version < sceneEditInfo.getVersion()){
                version = sceneEditInfo.getVersion();
            }
            if(imgVersion < sceneEditInfo.getImgVersion()){
                imgVersion = sceneEditInfo.getImgVersion();
            }
            if(linkVersion < sceneEditInfo.getLinkVersion()){
                linkVersion = sceneEditInfo.getLinkVersion();
            }

            sceneEditControls = sceneEditControlsService.getBySceneEditId(sceneEditInfo.getId());
            sceneEditInfoExt = sceneEditInfoExtService.getByEditInfoId(sceneEditInfo.getId());
            sceneEditInfo.setVersion(version + 1);
            sceneEditInfo.setImgVersion(imgVersion + 1);
            sceneEditInfo.setLinkVersion(linkVersion + 1);
            sceneEditInfo.setIsUploadObj(CommonStatus.NO.code());
            sceneEditInfoService.updateById(sceneEditInfo);
        }
        if(sceneEditControls == null){
            sceneEditControls = new SceneEditControls();
            sceneEditControls.setEditInfoId(sceneEditInfo.getId());
            sceneEditControlsService.save(sceneEditControls);
        }
        if(sceneEditInfoExt == null){
            sceneEditInfoExt = new SceneEditInfoExt();
            sceneEditInfoExt.setScenePlusId(scenePlus.getId());
            sceneEditInfoExt.setEditInfoId(sceneEditInfo.getId());
            sceneEditInfoExtService.save(sceneEditInfoExt);
        }
        return new Object[]{sceneEditInfo, sceneEditInfoExt, sceneEditControls};
    }

    public void writeSceneJson(String num, SceneEditInfo sceneEditInfo, SceneEditInfoExt sceneEditInfoExt,
                                SceneEditControls sceneEditControls, ScenePlus scenePlus, ScenePlusExt scenePlusExt,Company company){
        String dataViewPath = String.format(UploadFilePath.DATA_VIEW_PATH, num);

        String sceneJsonKey = dataViewPath + "scene.json";
        String oldSceneJson = null;
        if(fYunFileService.fileExist(sceneJsonKey)){
            oldSceneJson = fYunFileServiceInterface.getFileContent(sceneJsonKey);
        }

        SceneJsonBean sceneJson = new SceneJsonBean();
        BeanUtil.copyProperties(sceneEditInfoExt, sceneJson, "started");
        BeanUtil.copyProperties(sceneEditInfo, sceneJson);
        SceneEditControlsVO sceneEditControlsVO = BeanUtil.copyProperties(sceneEditControls, SceneEditControlsVO.class);
        sceneJson.setControls(sceneEditControlsVO);
        sceneJson.setNum(num);
        sceneJson.setCreateTime(scenePlus.getCreateTime());
        sceneJson.setSceneResolution(scenePlusExt.getSceneResolution());
        sceneJson.setVersion(sceneEditInfo.getVersion());
        sceneJson.setImgVersion(sceneEditInfo.getImgVersion());
        sceneJson.setSceneFrom(scenePlusExt.getSceneFrom());
        sceneJson.setSceneKind(scenePlusExt.getSceneKind());
        sceneJson.setModelKind(scenePlusExt.getModelKind());
        sceneJson.setVideos(scenePlusExt.getVideos());
        sceneJson.setPayStatus(scenePlus.getPayStatus());
        sceneJson.setHasRecognition(scenePlusExt.getHasRecognition());
        sceneJson.setHasFloorplanAi(scenePlus.getHasFloorplanAi());
        if(StrUtil.isNotEmpty(oldSceneJson)){
            SceneJsonBean oldSceneJsonBean = JSON.parseObject(oldSceneJson, SceneJsonBean.class);
            List<JSONObject> mosaicList = JSON.parseObject(oldSceneJson, SceneJsonBean.class).getMosaicList();
            sceneJson.setMosaicList(mosaicList);
            sceneJson.setFloorLogo(oldSceneJsonBean.getFloorLogo());
            sceneJson.setFloorLogoFile(oldSceneJsonBean.getFloorLogoFile());
            sceneJson.setBoxModels(oldSceneJsonBean.getBoxModels());
            sceneJson.setBoxVideos(oldSceneJsonBean.getBoxVideos());
            sceneJson.setBoxPhotos(oldSceneJsonBean.getBoxPhotos());
        }
        if(StrUtil.isNotEmpty(sceneEditInfoExt.getStarted())){
            sceneJson.setStarted(JSON.parseObject(sceneEditInfoExt.getStarted()));
        }

        if(!ObjectUtils.isEmpty(company)){
            String userViewPath = String.format(UploadFilePath.USER_VIEW_PATH, num);
            String userEditPath = String.format(UploadFilePath.USER_EDIT_PATH, num);
            String localLogoPath = null;
            if (StrUtil.isNotEmpty(company.getTopLogo())) {
                localLogoPath = ConstantFilePath.AGENT_PATH + company.getTopLogo().substring(company.getTopLogo().lastIndexOf("//") + 1);
                HttpUtil.downloadFile(company.getTopLogo(), localLogoPath);
                fYunFileServiceInterface.uploadFile(localLogoPath, userViewPath + "loadingLogo-user.png");
                fYunFileServiceInterface.uploadFile(localLogoPath, userEditPath + "loadingLogo-user.png");
                sceneJson.setLoadingLogo("user");
                sceneJson.setLoadingLogoFile("loadingLogo-user.png");
                sceneEditInfo.setLoadingLogo("user");
                sceneEditInfo.setLoadingLogoFile("loadingLogo-user.png");
            }
            if (StrUtil.isNotEmpty(company.getFloorLogo())) {
                localLogoPath = ConstantFilePath.AGENT_PATH + company.getFloorLogo().substring(company.getFloorLogo().lastIndexOf("//") + 1);
                HttpUtil.downloadFile(company.getFloorLogo(), localLogoPath);
                fYunFileServiceInterface.uploadFile(localLogoPath, userViewPath + "floorLogo-user.png");
                fYunFileServiceInterface.uploadFile(localLogoPath, userEditPath + "floorLogo-user.png");
                sceneJson.setFloorLogo("user");
                sceneJson.setFloorLogoFile("floorLogo-user.png");

                sceneEditInfo.setFloorLogo("user");
                sceneEditInfo.setFloorLogoFile("floorLogo-user.png");
            }
            if(!ObjectUtils.isEmpty(localLogoPath)){
                sceneEditInfoService.updateById(sceneEditInfo);
                FileUtils.deleteFile(localLogoPath);
            }
        }
        String sceneJsonStr = JSON.toJSONString(sceneJson);
        //上传sceneJson文件
        fYunFileServiceInterface.uploadFile(sceneJsonStr.getBytes(), dataViewPath + "scene.json");
        //scenejson写入缓存
        redisUtil.set(String.format(RedisKey.SCENE_JSON, num), sceneJsonStr);
    }

    @Override
    public void saveMqSendLog(String num, BuildSceneCallMessage message, Integer status) {
        MqSendLog mqSendLog = null;
        if(status != null || status != -1){//-1代表未进入到计算前置处理器，计算调度器不能进行调度
            mqSendLog = mqSendLogService.getOne(new LambdaQueryWrapper<MqSendLog>().eq(MqSendLog::getNum, num).eq(MqSendLog::getStatus, -1));
        }
        if(mqSendLog == null){
            mqSendLog = new MqSendLog();
        }

        mqSendLog.setNum(num);
        mqSendLog.setContent(JSON.toJSONString(message));
        mqSendLog.setStatus(status);
        mqSendLogService.saveOrUpdate(mqSendLog);
    }

    @Override
    public void sendUpdateSceneStatusMqToQueues(Map<String, Object> content) {
        List<SceneInfoSyncMqConfig> configs = sceneInfoSyncMqConfigService.listByInfoType("update_scene_status");
        if(CollUtil.isEmpty(configs)){
            return;
        }
        for (SceneInfoSyncMqConfig config : configs) {
            rabbitMqProducer.sendByWorkQueue(config.getQueueName(), content);
        }
    }

    @Override
    public void removeSceneAsynOperLog(String num) {
        List<SceneAsynOperLog> list = sceneAsynOperLogService.list(new LambdaQueryWrapper<SceneAsynOperLog>().eq(SceneAsynOperLog::getNum, num));
        if(CollUtil.isEmpty(list)){
            return;
        }
        //删除数据库记录
        List<Long> deleteIdList = list.parallelStream().map(item -> item.getId()).collect(Collectors.toList());
        sceneAsynOperLogService.removeByIds(deleteIdList);

        list.parallelStream().forEach(item -> {
            if(StrUtil.isNotEmpty(item.getUrl())){
                try {
                    fYunFileServiceInterface.deleteFile(item.getUrl());
                } catch (IOException e) {
                    log.warn("删除oss全景图下载压缩包失败，key:{}", item.getUrl());
                }
            }
        });
    }

    public JSONObject getVideosJson(String path, Integer videoVersion, String projectNum, int cameraType){
        //读取videos_hdr_param.json, 保存点位视频的value
        Map<String, Object> videoMap = new HashMap<>();
        String videosHdr = FileUtils.readFile(path + File.separator + "results/videos/videos_hdr_param.json");
        JSONArray videoArray = null;
        if(StringUtils.isNotEmpty(videosHdr)){
            videoArray = JSONObject.parseObject(videosHdr).getJSONArray("hdr_param");
        }
        if(videoArray != null){
            for(int i = 0, len = videoArray.size(); i < len; i++) {
                videoMap.put(videoArray.getJSONObject(i).getString("name"), videoArray.getJSONObject(i).getString("value"));
                if(videoArray.getJSONObject(i).containsKey("fov")){
                    videoMap.put(videoArray.getJSONObject(i).getString("name") + "_fov", videoArray.getJSONObject(i).getString("fov"));
                }
            }
        }

        //获取upload中的video视频名称
        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");
        }
        JSONObject fileJson = null;
        String fileName = "";

        //计算ts文件的大小，并拼接成json格式
        JSONArray jsonArray = new JSONArray();
        JSONObject videoJson = null;
        JSONObject videosJson = new JSONObject();
        long videoSize = 0L;
        for(int i = 0, len = array.size(); i < len; i++) {
            fileJson = array.getJSONObject(i);
            fileName = fileJson.getString("file");
            if(fileJson.getIntValue("clazz") == 11 && fileName.contains(".mp4") && !fileName.contains("-ios.mp4")){
                videoJson = new JSONObject();
                videoJson.put("id", fileName.substring(
                        0, fileName.lastIndexOf(".")).replace("videos/", ""));

                //如果ts文件存在，就计算ts大小
                if(new File(path + File.separator + "results" +File.separator+ fileName.replace(".mp4", ".ts")).exists()){
                    videoSize = new File(path + File.separator + "results" +File.separator+ fileName.replace(".mp4", ".ts")).length();
                    videoJson.put("tsSize", videoSize);
                }
                if(videoMap.containsKey(videoJson.get("id"))){
                    videoJson.put("value", videoMap.get(videoJson.get("id")));
                }
                if(videoMap.containsKey(videoJson.get("id") + "_fov")){
                    videoJson.put("blend_fov", videoMap.get(videoJson.get("id") + "_fov"));
                }else {
                    videoJson.put("blend_fov", 7);
                }
                jsonArray.add(videoJson);
            }
        }

        videosJson.put("data", jsonArray);
        if(Objects.nonNull(videoVersion) && videoVersion >= 4){
            videosJson.put("version", 3);
            videosJson.put("upPath", fYunFileConfig.getHost() + String.format(UploadFilePath.DATA_VIEW_PATH, projectNum) + "Up.xml");
            if(cameraType == 13 || cameraType == 14){
                //转台相机
                videosJson.put("upPath", videosJson.getString("upPath").replace(".xml", ".txt"));
            }
        }else {
            videosJson.put("version", 1);
            videosJson.put("upPath", fYunFileConfig.getHost() + String.format(UploadFilePath.DATA_VIEW_PATH, projectNum) + "Up2.xml");
            if(cameraType == 13 || cameraType == 14){
                //转台相机
                videosJson.put("upPath", videosJson.getString("upPath").replace(".xml", ".txt"));
            }
        }

        if(cameraType == 5 || cameraType == 6){
            videosJson.put("version", 1);
            videosJson.put("upPath", fYunFileConfig.getHost() + String.format(UploadFilePath.DATA_VIEW_PATH, projectNum) + "stitch_params.txt");
        }

        return videosJson;
    }

    @Override
    public JSONObject getFdageData(String dataFdagePath) {
        log.info("dataFdagePath 文件路径 ：{}", dataFdagePath);
        String data = FileUtils.readFile(dataFdagePath);
        //获取data.fdage的内容
        JSONObject dataJson = new JSONObject();
        if(data!=null){
            dataJson = JSONObject.parseObject(data);
        }
        return dataJson;
    }

    @Override
    public Map<String, String> getUploadFiles(ScenePlus scenePlus,String path,Integer cameraType,JSONObject fdageData) throws Exception {
        return this.getUploadFiles(scenePlus,path,cameraType,fdageData,null);

    }

    @Override
    public Map<String, String> getUploadFiles(ScenePlus scenePlus,String path,Integer cameraType,JSONObject fdageData, BuildSceneResultMqMessage brMsg) throws Exception {
        if (ObjectUtils.isEmpty(scenePlus)) {
            throw new Exception("未找到场景信息：" + path);
        }

        String projectNum = scenePlus.getNum();

        String dataViewPath = String.format(UploadFilePath.DATA_VIEW_PATH, projectNum);
        String imagesPath = String.format(UploadFilePath.IMG_VIEW_PATH, projectNum);
        String videoPath = String.format(UploadFilePath.VIDEOS_VIEW_PATH, projectNum);
        String resultsPath = path + File.separator + "results" + File.separator;

        String uploadData = FileUtils.readFile(resultsPath + "upload.json");
        JSONArray array = JSONObject.parseObject(uploadData).getJSONArray("upload");

        JSONObject fileJson = null;
        String fileName = "";

        Map<String, String> map = new HashMap();

        for (int i = 0; i < array.size(); ++i) {
            fileJson = array.getJSONObject(i);
            fileName = fileJson.getString("file");
            String filePath = resultsPath + fileName;

            if (!(new File(filePath)).exists()) {
                throw new Exception(filePath + "文件不存在");
            }

            if ("vision2.txt".equals(fileName)) {
                CreateObjUtil.convertTxtToVisionmodeldata(resultsPath + "vision2.txt", resultsPath + "vision2.modeldata");
                map.put(resultsPath + "vision2.modeldata", imagesPath + "vision2.modeldata");
                map.put(resultsPath + "vision2.txt", imagesPath + "vision2.txt");
            }

            if (fileJson.getIntValue("clazz") == 2) {
                map.put(filePath, imagesPath + ConstantFileName.modelUUID + "_50k_texture_jpg_high1/" + fileName.replace("tex/", ""));
            } else if (fileJson.getIntValue("clazz") == 3) {
                map.put(filePath, imagesPath + "pan/high/" + fileName.replace("high/", ""));
            } else if (fileJson.getIntValue("clazz") == 4) {
                map.put(filePath, imagesPath + "pan/low/" + fileName.replace("low/", ""));
            } else if (fileJson.getIntValue("clazz") == 5) {
                map.put(filePath, imagesPath + fileName);
            } else if (fileJson.getIntValue("clazz") == 7) {
                map.put(filePath, imagesPath + fileName);
            } else if (fileJson.getIntValue("clazz") == 10) {
                String updown = FileUtils.readFile(filePath);
                JSONObject updownJson = JSONObject.parseObject(updown);
                String mappingOssPath = String.format("scene_edit_data/%s/data/", projectNum) + fileName.replace("updown", "mapping");
                map.put(filePath, mappingOssPath);
            } else {
                if (fileJson.getIntValue("clazz") == 11 || fileJson.getIntValue("clazz") == 12) {
                    map.put(filePath, videoPath + fileName.replace("videos/", ""));
                    if (fileName.contains(".mp4")) {
                        map.put(resultsPath + fileName.replace("mp4", "flv"), videoPath + fileName.replace("videos/", "").replace("mp4", "flv"));
                    }
                }

                if (fileJson.getIntValue("clazz") == 16) {
                    map.put(filePath, dataViewPath + fileName);
                }

                if (fileJson.getIntValue("clazz") == 18) {
                    map.put(filePath, imagesPath + fileName);
                }
            }
        }

        String splitType = null;
        if(brMsg != null){
            splitType = (String) brMsg.getExt().get("splitType");
        }

        //exportMeshObj这个是字段由app写入的
        boolean genModel = true;//是否生成模型 默认生成，深时场景要根据 exportMeshObj判断是否生成
        if(!ObjectUtils.isEmpty(cameraType)
                && cameraType == 14
                && (!fdageData.containsKey("exportMeshObj") || fdageData.getIntValue("exportMeshObj") != 1)){
            genModel = false;
        }
        boolean gen3dTiles = true;//是否生成3dtiles模型 默认生成
        if(!ModelKind.THREE_D_TILE.code().equals(modelKind)
                || CollUtil.isEmpty(sdTilesSceneSourceList)
                || !sdTilesSceneSourceList.contains(scenePlus.getSceneSource())){
            gen3dTiles = false;
        }
        //算法部又偷偷改了东西了，SPLIT_V3以前是生成obj模型的，现在生成了3dtiles
        if(splitType != null && splitType.equals("SPLIT_V3")){
            gen3dTiles = true;
        }

        if(genModel){
            if (!gen3dTiles) {
                String damPath = path + File.separator + "results" + File.separator + ConstantFileName.modelUUID + "_50k.dam";
                CreateObjUtil.convertTxtToDam(path + File.separator + "results" + File.separator + "tex" + File.separator + "modeldata.txt", damPath);
                FileUtil.writeBytes(ZipUtil.gzip(new File(damPath)), damPath);
                map.put(damPath, imagesPath + ConstantFileName.modelUUID + "_50k.dam");
            }else{
                List<String> list = FileUtils.list(new File(path + File.separator + "results" + File.separator + ModelKind.THREE_D_TILE.code()));
                if(CollUtil.isEmpty(list)){
                    log.error("3dtiles目录异常，3dtiles地址：{}", new File(path + File.separator + "results" + File.separator + ModelKind.THREE_D_TILE.code()));
                    throw new Exception("3dtiles目录异常");
                }
                list.stream().forEach(str->{
                    map.put(str, str.replace(path + File.separator + "results" + File.separator, imagesPath));
                });
            }
        }

        CreateObjUtil.convertTxtToVisionmodeldata(resultsPath + "vision.txt", resultsPath + "vision.modeldata");
        map.put(resultsPath + "vision.txt", imagesPath + "vision.txt");
        map.put(resultsPath + "vision.modeldata", imagesPath + "vision.modeldata");

        log.info("数据转换完成：" + projectNum);
        if(!new File("/mnt/4Dkankan/scene/data" + File.separator + "data" + projectNum).exists()){
            FileUtil.mkdir("/mnt/4Dkankan/scene/data" + File.separator + "data" + projectNum);
        }
//        map.put(resultsPath + "floorplan.json", dataViewPath + "floor.json");
        map.put(resultsPath + "floorplan_cad.json", dataViewPath + "floorplan_cad.json");
        map.put(path + File.separator + "capture/stitch_params.txt", dataViewPath + "stitch_params.txt");
        map.put(path + File.separator + "capture/Up.xml", dataViewPath + "Up.xml");
        map.put(path + File.separator + "capture/Up2.xml", dataViewPath + "Up2.xml");
        map.put(path + File.separator + "capture/Up.txt", dataViewPath + "Up.txt");
        map.put(path + File.separator + "capture/Up2.txt", dataViewPath + "Up2.txt");
        return map;

    }

    @Override
    public boolean checkIsSpVr(JSONObject dataFdageJson, CameraDetail cameraDetail) {
        if(Objects.isNull(cameraDetail)
                || Objects.isNull(cameraDetail.getCompanyId())
                || Objects.isNull(dataFdageJson)
                || Objects.isNull(dataFdageJson.getInteger("location"))){
            return false;
        }
        Integer location = dataFdageJson.getInteger("location");
        Long companyId = cameraDetail.getCompanyId();
        if(companyId == 26 && location == 7){
            return true;
        }
        return false;
    }

    @Override
    public Integer getShootCount(String num) {

        ScenePlus scenePlus = scenePlusService.getScenePlusByNum(num);
        ScenePlusExt scenePlusExt = scenePlusExtService.getScenePlusExtByPlusId(scenePlus.getId());

        Integer shootCount = null;
        String homePath = SceneUtil.getHomePath(scenePlusExt.getDataSource());
        JSONObject dataFdageObj = JSON.parseObject(fYunFileService.getFileContent(homePath.concat("data.fdage")));
        if(Objects.nonNull(dataFdageObj)){
            JSONArray points = dataFdageObj.getJSONArray("points");
            if(CollUtil.isNotEmpty(points)){
                shootCount = points.size();
            }
        }

        return shootCount;
    }

    @Override
    public Integer getSlamCount(String num) {

        ScenePlus scenePlus = scenePlusService.getScenePlusByNum(num);
        ScenePlusExt scenePlusExt = scenePlusExtService.getScenePlusExtByPlusId(scenePlus.getId());

        Integer slamCount = null;
        String homePath = SceneUtil.getHomePath(scenePlusExt.getDataSource());
        if(Objects.nonNull(scenePlusExt.getLocation()) && (scenePlusExt.getLocation() == 6 || scenePlusExt.getLocation() == 8)){
            String slamDataStr = fYunFileService.getFileContent(homePath.concat("slam_data.json"));
            JSONObject slamDataObj = JSON.parseObject(slamDataStr);
            if(Objects.nonNull(slamDataObj)){
                JSONArray viewsInfo = slamDataObj.getJSONArray("views_info");
                if(CollUtil.isNotEmpty(viewsInfo)){
                    slamCount = viewsInfo.stream().mapToInt(info -> {
                        return  ((JSONObject) info).getJSONArray("list_pose").size();
                    }).sum();
                }
            }
        }

        return slamCount;
    }

    @Override
    public void uploadFloorplanAi(String num, String path) throws IOException {
        String floorplanPath = path + "/results/floorplan/";
        List<File> files = FileUtil.loopFiles(floorplanPath);
        String ossPath = String.format(UploadFilePath.DATA_VIEW_PATH, num) + "floorplan/";
        if(CollUtil.isNotEmpty(files)){
            for (File file : files) {
                fYunFileService.uploadFile(file.getAbsolutePath(), file.getAbsolutePath().replace(floorplanPath, ossPath));
            }
        }
    }

    @Override
    public boolean detFloorPlanAi(String num, String path, LinkedHashMap<Integer, Boolean> detFloorplan) throws IOException {

        try {
            String aiJsonKey = String.format(UploadFilePath.DATA_VIEW_PATH, num) + "floorplan/ai.json";
            String aiEntireJsonKey = String.format(UploadFilePath.DATA_VIEW_PATH, num) + "floorplan/ai-entire.json";
            //先清空历史数据,因为数据格式改动很多个版本，已经无法按照规律进行过滤删除，所以这里先删除历史数据，而后再根据算法生成去插入数据
            sceneMarkShapeService.remove(new LambdaQueryWrapper<SceneMarkShape>().eq(SceneMarkShape::getNum, num).eq(SceneMarkShape::getType, DetectType.PLAN.getCode()));
            if(fYunFileService.fileExist(aiJsonKey)){
                fYunFileService.deleteFile(aiJsonKey);
            }
            if(CollUtil.isEmpty(detFloorplan)){
                return false;
            }
            boolean hasFloorplanAi = false;
            String workDir = path + "/detFloorplan/";
            for (Integer subgroup : detFloorplan.keySet()) {
                Boolean yes = detFloorplan.get(subgroup);
                SceneMarkShape sceneMarkShape = null;
                if(yes){
                    String detectPath = workDir + subgroup + "/detect.json";
                    sceneMarkShape = sceneMarkShapeService.readDetectJson(detectPath);
                }
                if (Objects.isNull(sceneMarkShape)){
                    sceneMarkShape = new SceneMarkShape();
                    String infoJsonPath = path + "/results/floorplan/info.json";
                    JSONObject infoObj = JSON.parseObject(FileUtil.readUtf8String(infoJsonPath));
                    JSONArray floors = infoObj.getJSONArray("floors");
                    for (Object floor : floors) {
                        JSONObject floorObj = (JSONObject)floor;
                        Integer group = floorObj.getInteger("subgroup");
                        if(!subgroup.equals(group)){
                            continue;
                        }
                        JSONObject resolution = floorObj.getJSONObject("resolution");
                        sceneMarkShape.setImageWidth(resolution.getInteger("width"));
                        sceneMarkShape.setImageHeight(resolution.getInteger("height"));
                    }
                }
                if(Objects.isNull(sceneMarkShape.getShapes())){
                    sceneMarkShape.setShapes(new ArrayList<>());
                }
                sceneMarkShape.setNum(num);
                sceneMarkShape.setCreateTime(new Date());
                sceneMarkShape.setType(DetectType.PLAN.getCode());
                sceneMarkShapeService.save(sceneMarkShape);
                if(CollUtil.isNotEmpty(sceneMarkShape.getShapes())){
                    hasFloorplanAi = true;
                }
            }

            List<SceneMarkShape> sceneMarkShapes = sceneMarkShapeService.findByNumAndType(num, DetectType.PLAN.getCode());
            for (SceneMarkShape ms : sceneMarkShapes) {
                if (ObjectUtil.isNotEmpty(ms.getShapes())){
                    for (JSONObject s : ms.getShapes()) {
                        String category = s.getString("category");
                        if (category.contains("Tag_")){
                            s.put("category","Tag");
                        }
                    }
                }
            }
            //先上传一份带门窗的，完整的，绘图功能要用
            fYunFileService.uploadFile(JSON.toJSONString(sceneMarkShapes).getBytes(StandardCharsets.UTF_8), aiEntireJsonKey);

            //上传一份过滤掉门窗的，徐总要求过滤
            for (SceneMarkShape sceneMarkShape : sceneMarkShapes) {
                //徐总要求去掉门窗（因为门窗不属于家具）
                List<JSONObject> shapes = sceneMarkShape.getShapes().stream().filter(v -> {
                    String category = v.getString("category");
                    if (StrUtil.isNotEmpty(category) && (category.contains("Door") || category.contains("Window"))) {
                        return false;
                    }
                    return true;
                }).collect(Collectors.toList());
                sceneMarkShape.setShapes(shapes);
            }
            fYunFileService.uploadFile(JSON.toJSONString(sceneMarkShapes).getBytes(StandardCharsets.UTF_8), aiJsonKey);

            return hasFloorplanAi;
        }catch (Exception e){
            log.error("平面图ai识别处理报错", e);
            return false;
        }finally {
//            FileUtil.del(workDir);
        }
    }


}