4dkankan-center-user/src/main/java/com/fdkankan/ucenter/service/impl/ScenePlusServiceImpl.java

package com.fdkankan.ucenter.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSON;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.common.constant.CommonStatus;
import com.fdkankan.common.constant.ErrorCode;
import com.fdkankan.common.util.FileUtils;
import com.fdkankan.fyun.face.FYunFileServiceInterface;
import com.fdkankan.image.MatrixToImageWriterUtil;
import com.fdkankan.model.utils.CreateObjUtil;
import com.fdkankan.ucenter.common.OssPath;
import com.fdkankan.ucenter.common.PageInfo;
import com.fdkankan.ucenter.common.Result;
import com.fdkankan.ucenter.common.constants.ConstantFilePath;
import com.fdkankan.ucenter.common.constants.NacosProperty;
import com.fdkankan.ucenter.common.constants.UploadFilePath;
import com.fdkankan.redis.constant.RedisKey;
import com.fdkankan.redis.util.RedisUtil;
import com.fdkankan.ucenter.bean.SceneJsonBean;
import com.fdkankan.ucenter.entity.*;
import com.fdkankan.ucenter.httpClient.service.LaserService;
import com.fdkankan.ucenter.mapper.IScenePlusMapper;
import com.fdkankan.ucenter.service.*;

import java.io.File;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.concurrent.CompletableFuture;
import java.util.stream.Collectors;

import com.fdkankan.ucenter.util.RoamingPointUtil;
import com.fdkankan.ucenter.vo.ResponseScene;
import com.fdkankan.ucenter.vo.SceneEditControlsVO;
import com.fdkankan.ucenter.vo.request.RequestScene;
import com.fdkankan.ucenter.vo.response.SceneVo;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;

/**
 * <p>
 * 场景主表 服务实现类
 * </p>
 *
 * @author 
 * @since 2022-07-04
 */
@Service
@Slf4j
public class ScenePlusServiceImpl extends ServiceImpl<IScenePlusMapper, ScenePlus> implements IScenePlusService {

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

    @Autowired
    private IScenePlusExtService scenePlusExtService;
    @Autowired
    private ISceneEditInfoService sceneEditInfoService;
    @Autowired
    private ISceneEditInfoExtService sceneEditInfoExtService;
    @Autowired
    private ISceneEditControlsService sceneEditControlsService;
    @Autowired
    private ICameraDetailService cameraDetailService;
    @Autowired
    private ISurveillanceService surveillanceService;
    @Autowired
    private ISceneProService sceneProService;
    @Autowired
    FYunFileServiceInterface fYunFileServiceInterface;
    @Autowired
    RedisUtil redisUtil;
    @Autowired
    LaserService laserService;
    @Autowired
    ISceneCopyLogService sceneCopyLogService;
    @Autowired
    private IUserService userService;


    @Override
    public Long getCountByUserId(Long userId, List<?> sceneSourceList) {
        LambdaQueryWrapper<ScenePlus> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ScenePlus::getUserId, userId);
        wrapper.in(ScenePlus::getSceneSource, sceneSourceList);
        return this.count(wrapper);
    }

    @Override
    public Long getCountByUserId(Long userId, Integer cameraType) {
        return this.getBaseMapper().getCountByUserId(userId,cameraType);
    }


    @Override
    public List<ScenePlus> getListByCameraId(Long cameraId) {
        LambdaQueryWrapper<ScenePlus> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ScenePlus::getCameraId,cameraId);
        return this.list(wrapper);
    }

    @Override
    public void bindOrUnCamera(List<Long> cameraIds, Long userId) {
        if(cameraIds.size() >0){
            LambdaUpdateWrapper<ScenePlus> wrapper = new LambdaUpdateWrapper<>();
            wrapper.set(ScenePlus::getUserId,userId)
                    .in(ScenePlus::getCameraId,cameraIds);
            this.update(wrapper);
        }
    }

    @Override
    public List<ScenePlus> getListByCameraIds(List<Long> cameraIds) {
        if(cameraIds.size() >0){
            LambdaQueryWrapper<ScenePlus> wrapper = new LambdaQueryWrapper<>();
            wrapper.in(ScenePlus::getCameraId,cameraIds);
            return this.list(wrapper);
        }
        return new ArrayList<>();
    }

    @Override
    public List<ScenePlus> getListByNums(List<String> numList) {
        LambdaQueryWrapper<ScenePlus> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(ScenePlus::getNum,numList);
        return this.list(wrapper);
    }

    @Override
    public HashMap<Long, ScenePlus> getMapByIds(List<Long> sceneIds) {
        LambdaQueryWrapper<ScenePlus> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(ScenePlus::getId,sceneIds);
        List<ScenePlus> list = this.list(wrapper);
        HashMap<Long,ScenePlus> map = new HashMap<>();
        list.forEach(entity -> map.put(entity.getId(),entity));
        return map;
    }

    @Override
    public ScenePlus getByNum(String sceneNum) {
        LambdaQueryWrapper<ScenePlus> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ScenePlus::getNum,sceneNum);
        List<ScenePlus> list = this.list(wrapper);
        if(list!=null && list.size() >0){
            return list.get(0);
        }
        return null;
    }

    @Override
    public List<ScenePlus> getByIds(List<Long> plusIds) {
        LambdaQueryWrapper<ScenePlus> wrapper = new LambdaQueryWrapper<>();
        wrapper.in(ScenePlus::getId,plusIds);
        return  this.list(wrapper);
    }

    @Override
    public Long copyV4Scene(ScenePlus scenePlus,String newNum ,CameraDetail cameraDetail,String time) throws Exception {
        String num = scenePlus.getNum();
        Long plusId = scenePlus.getId();
        ScenePlusExt plusExt = scenePlusExtService.getByPlusId(plusId);

        // 拷贝数据
        scenePlus.setNum(newNum);
        scenePlus.setId(null);
        scenePlus.setSceneStatus(0);
        this.save(scenePlus);

        CompletableFuture.runAsync(() -> {
            try {
                // 拷贝场景编辑资源
                String oldEditPath = String.format(UploadFilePath.EDIT_PATH, num);
                String newEditPath = String.format(UploadFilePath.EDIT_PATH, newNum);
                fYunFileServiceInterface.copyFileInBucket(oldEditPath, newEditPath);

                // 拷贝场景展示资源
                String oldViewPath = String.format(UploadFilePath.VIEW_PATH, num);
                String newViewPath = String.format(UploadFilePath.VIEW_PATH, newNum);
                fYunFileServiceInterface.copyFileInBucket(oldViewPath, newViewPath);

                //复制计算结果文件
                String oldResultPath = String.format(UploadFilePath.SCENE_RESULT_DATA_PATH, num);
                String newResultPath = String.format(UploadFilePath.SCENE_RESULT_DATA_PATH, newNum);
                fYunFileServiceInterface.copyFileInBucket(oldResultPath, newResultPath);

                // 拷贝本地资源
                String oldPath = String.format("/mnt/4Dkankan/scene/%s/caches/images", num);
                String newPath = String.format("/mnt/4Dkankan/scene/%s/caches/images", newNum);
                if(new File(oldPath).exists()){
                    FileUtils.copyDirectiory(oldPath, newPath);
                }

                String scenePath = ConstantFilePath.SCENE_V4_PATH + num;
                File file = new File(scenePath);
                if(file.exists()){
                    String newScenePath = ConstantFilePath.SCENE_V4_PATH + newNum;
                    FileUtils.copyDirectiory(scenePath, newScenePath);
                }
                String newVideos = plusExt.getVideos();
                if(StrUtil.isNotEmpty(newVideos)){
                    newVideos = plusExt.getVideos().replaceAll("/data/data" + num, "/scene_view_data/" + newNum + "/data").replaceAll(num, newNum);
                }

                String oldDataSource  = plusExt.getDataSource();
                String newDataSource =  sceneProService.setDataSource(plusExt.getDataSource(),time);

                String buildModelPath = ConstantFilePath.BUILD_MODEL_PATH;
                if(scenePlus.getSceneSource().equals(4)){
                    buildModelPath = ConstantFilePath.BUILD_MODEL_LASER_PATH;
                }
                sceneProService.copyFdage(oldDataSource,newDataSource,buildModelPath,time);

                plusExt.setId(null);
                plusExt.setPlusId(scenePlus.getId());
                plusExt.setDataSource(newDataSource);
                plusExt.setWebSite(plusExt.getWebSite().replace(num, newNum));
                plusExt.setThumb(plusExt.getThumb().replace(num, newNum));
                plusExt.setVideos(newVideos);
                plusExt.setViewCount(0);
                scenePlusExtService.save(plusExt);

                SceneEditInfo sceneEditInfo = sceneEditInfoService.getByScenePlusId(plusId);
                Long sceneEditInfoId = sceneEditInfo.getId();

                sceneEditInfo.setId(null);
                sceneEditInfo.setScenePlusId(scenePlus.getId());
                sceneEditInfo.setSceneProId(null);
                sceneEditInfo.setTitle(scenePlus.getTitle());
                sceneEditInfoService.save(sceneEditInfo);

                SceneEditInfoExt sceneEditInfoExt = sceneEditInfoExtService.getByEditInfoId(sceneEditInfoId);
                sceneEditInfoExt.setId(null);
                sceneEditInfoExt.setEditInfoId(sceneEditInfo.getId());
                sceneEditInfoExt.setScenePlusId(scenePlus.getId());
                sceneEditInfoExt.setSceneProId(null);
                sceneEditInfoExtService.save(sceneEditInfoExt);

                SceneEditControls sceneEditControls = sceneEditControlsService.getBySceneEditId(sceneEditInfoId);
                sceneEditControls.setId(null);
                sceneEditControls.setEditInfoId(sceneEditInfo.getId());
                sceneEditControlsService.save(sceneEditControls);

                if(scenePlus.getSceneSource() == 4){  //深时复制
                    laserService.copy(num,scenePlus.getCameraId(),scenePlus.getCreateTime(),newNum,0,null,
                            sceneEditInfo.getScenePassword(),scenePlus.getTitle(),scenePlus.getUserId(),"V4",plusExt.getIsObj());
                }

                List<Surveillance> list = surveillanceService.list(new LambdaQueryWrapper<Surveillance>().eq(Surveillance::getNum, num));
                if (!Objects.isNull(list)) {
                    list.stream().forEach(item -> {
                        item.setNum(newNum);
                        item.setId(null);
                        surveillanceService.save(item);
                    });
                }

                //复制马赛克数据
                String key = String.format(RedisKey.SCENE_MOSAIC_DATA, num);
                Map<String, String> map = redisUtil.hmget(key);
                redisUtil.hmset(String.format(RedisKey.SCENE_MOSAIC_DATA, newNum), map);

                // 生成scene.json
                SceneJsonBean sceneJson = new SceneJsonBean();
                BeanUtil.copyProperties(sceneEditInfoExt, sceneJson);
                BeanUtil.copyProperties(sceneEditInfo, sceneJson);
                SceneEditControlsVO sceneEditControlsVO = BeanUtil.copyProperties(sceneEditControls, SceneEditControlsVO.class);
                sceneJson.setControls(sceneEditControlsVO);
                sceneJson.setNum(newNum);
                sceneJson.setCreateTime(scenePlus.getCreateTime());

                sceneJson.setSceneResolution(plusExt.getSceneResolution());
                sceneJson.setSceneFrom(plusExt.getSceneFrom());
                sceneJson.setSceneKind(plusExt.getSceneKind());
                sceneJson.setModelKind(plusExt.getModelKind());
                if(StrUtil.isNotEmpty(plusExt.getVideos())){
                    sceneJson.setVideos(plusExt.getVideos());
                }
                sceneJson.setMosaicList(sceneEditInfoService.getMosaicList(num));

                log.info("开始生成本地json文件……");
                String sceneJsonLocalPath = ConstantFilePath.SCENE_PATH + "data" + File.separator + "data" + newNum + File.separator + "scene.json";
                FileUtils.writeFile(sceneJsonLocalPath, JSON.toJSONString(sceneJson));

                String sceneJsonPath = String.format(UploadFilePath.DATA_VIEW_PATH+"scene.json", newNum);
                fYunFileServiceInterface.uploadFile(JSON.toJSONBytes(sceneJson), sceneJsonPath);

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

                // 生成二维码
                String outPathZh = ConstantFilePath.BASE_PATH + File.separator + "sceneQRcode/" + newNum + ".png";
                String outPathEn = ConstantFilePath.BASE_PATH + File.separator + "sceneQRcode/" + newNum + "_en.png";
                MatrixToImageWriterUtil.createQRCode(plusExt.getWebSite(), outPathZh, false,null);
                MatrixToImageWriterUtil.createQRCode(plusExt.getWebSite() + "&lang=en", outPathEn, false, null);
                fYunFileServiceInterface.uploadFile(outPathZh, String.format(UploadFilePath.DOWNLOADS_QRCODE, newNum) + newNum + ".png");
                fYunFileServiceInterface.uploadFile(outPathEn, String.format(UploadFilePath.DOWNLOADS_QRCODE, newNum) + newNum + "_en.png");
                scenePlus.setSceneStatus(-2);
                this.updateById(scenePlus);

                cameraDetail.setUsedSpace(cameraDetail.getUsedSpace() + plusExt.getSpace());
                cameraDetailService.updateById(cameraDetail);

                if(scenePlus.getPayStatus() == -2){
                    sceneProService.updateOssStatus(String.format(OssPath.v4_statusPath,scenePlus.getNum()),-2);
                    sceneProService.updateOssStatus(String.format(OssPath.v4_scenePath,scenePlus.getNum()),-2);
                }

                log.info("复制场景结束-{}", new Date());
                if(scenePlus.getSceneSource() == 4){  //深时复制
                    String laserPath = laserService.copyDataSource(oldDataSource,plusExt.getDataSource());
                    laserService.copy(num,scenePlus.getCameraId(),scenePlus.getCreateTime(),newNum,2,laserPath,
                            sceneEditInfo.getScenePassword(),scenePlus.getTitle(),scenePlus.getUserId(),"V4",plusExt.getIsObj());
                } else if(!"aws".equals(NacosProperty.uploadType)){
                    laserService.cloudPointBuild(num,newNum);
                }
                sceneCopyLogService.saveByNum(num,newNum,scenePlus.getUserId());

            }catch (Exception e){
                this.removeById(scenePlus.getId());
                log.error("复制场景异常", e);
            }
        }).join();
        return scenePlus.getId();
    }

    @Override
    public Result pageSceneWithHouseType(RequestScene param, String token) {
        User ssoUser = userService.getByToken(token);
        Page<ScenePlus> page = this.page(new Page<>(param.getPageNum(), param.getPageSize()),
                new LambdaQueryWrapper<ScenePlus>().eq(ScenePlus::getUserId, ssoUser.getId()).eq(ScenePlus::getHouseType, CommonStatus.YES.code().intValue()));
        List<SceneVo> records = null;
        if(page.getRecords().size() > 0){
            records = page.getRecords().parallelStream().map(plus -> {
                return SceneVo.builder().createTime(plus.getCreateTime())
                        .id(plus.getId()).roamingPointUrl(this.createRoamingPoint(plus.getNum())).sceneName(plus.getTitle())
                        .num(plus.getNum()).updateTime(plus.getUpdateTime()).userId(plus.getUserId()).build();
            }).collect(Collectors.toList());
        }

        PageInfo pageInfo = PageInfo.PageInfo(page);
        pageInfo.setList(records);

        return Result.success(pageInfo);
    }

    @Override
    public Result getArPathByNum(String num) {
        ScenePro scenePro = sceneProService.getByNum(num);
        if(Objects.nonNull(scenePro)){
            return Result.success("成功", String.format("images/images%s/ar", num));
        }
        ScenePlus scenePlus = this.getByNum(num);
        if(Objects.nonNull(scenePlus)){
            return Result.success("成功", String.format(UploadFilePath.IMG_VIEW_PATH, num) + "ar");
        }

        return Result.failure(ErrorCode.FAILURE_CODE_5005.code(), ErrorCode.FAILURE_CODE_5005.message());
    }

    private String createRoamingPoint(String num){
        String roamingPointOssPath = String.format(UploadFilePath.DATA_VIEW_PATH, num) + "roamingPoint.json";
        String url = null;
        try {
            if(!fYunFileServiceInterface.fileExist(roamingPointOssPath)){
                String visionModeldataPath = ConstantFilePath.SCENE_V4_PATH + num + File.separator + "vision.modeldata";
                String visionModeldataOssPath = String.format(UploadFilePath.IMG_VIEW_PATH, num) + "vision.modeldata";
                fYunFileServiceInterface.downloadFile(visionModeldataOssPath, visionModeldataPath);
                String visionTxtLocalPath = ConstantFilePath.SCENE_V4_PATH + num + File.separator + "vision.txt";
                CreateObjUtil.convertVisionmodeldataToTxt(visionModeldataPath, visionTxtLocalPath);
                String roamingPoint = RoamingPointUtil.createRoamingPoint(num, visionTxtLocalPath);
                if (StrUtil.isNotEmpty(roamingPoint)) {
                    fYunFileServiceInterface.uploadFile(roamingPoint.getBytes(StandardCharsets.UTF_8), roamingPointOssPath);
                    url = fyunHost + roamingPointOssPath;
                }
            }else{
                url = fyunHost + roamingPointOssPath;
            }
        }catch (Exception e){
            log.warn("生成roamingPointJson出错，num:" + num, e);
        }

        return url;
    }



}