4dkankan-fusion/src/main/java/com/fdkankan/fusion/service/impl/CommonUploadServiceImpl.java

package com.fdkankan.fusion.service.impl;


import cn.dev33.satoken.stp.StpUtil;
import cn.hutool.core.io.FileUtil;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.fdkankan.fusion.common.OssPath;
import com.fdkankan.fusion.common.ResultCode;
import com.fdkankan.fusion.common.ResultData;
import com.fdkankan.fusion.common.enums.FileTypeEnum;
import com.fdkankan.fusion.common.util.*;
import com.fdkankan.fusion.config.CacheUtil;
import com.fdkankan.fusion.entity.CommonUpload;
import com.fdkankan.fusion.entity.Dict;
import com.fdkankan.fusion.entity.DictFile;
import com.fdkankan.fusion.exception.BusinessException;
import com.fdkankan.fusion.mapper.ICommonUploadMapper;
import com.fdkankan.fusion.mq.consumer.OsgbToB3dmConsumer;
import com.fdkankan.fusion.service.ICommonUploadService;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.fdkankan.fusion.service.IDictFileService;
import com.fdkankan.fusion.service.IDictService;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.File;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.UUID;

/**
 * <p>
 *  服务实现类
 * </p>
 *
 * @author 
 * @since 2024-12-06
 */
@Service
@Slf4j
public class CommonUploadServiceImpl extends ServiceImpl<ICommonUploadMapper, CommonUpload> implements ICommonUploadService {


    @Autowired
    ICommonUploadService commonUploadService;
    @Autowired
    IDictFileService dictFileService;

    @Autowired
    private UploadToOssUtil uploadToOssUtil;

    @Value("${upload.query-path}")
    private String ossUrlPrefix;

    @Autowired
    IDictService dictService;

    @Override
    public ResultData uploadFileNew( Integer dictId,MultipartFile file) {
        if(file == null || file.isEmpty() ){
            throw new BusinessException(ResultCode.UPLOAD_ERROR);
        }
        File  tempFile = null;
        try {
            String uuid = UUID.randomUUID().toString().replace("-","");
            String originalFilename = file.getOriginalFilename();
            String extName = originalFilename.substring(originalFilename.lastIndexOf(".")).toLowerCase();

            if(dictId != null){
                Dict dict = dictService.getById(dictId);
                if(dict == null ){
                    throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
                }
                if("animation".equals(dict.getUseType()) && !(extName.equalsIgnoreCase(".zip") || extName.equalsIgnoreCase(".glb"))){
                    throw new BusinessException(ResultCode.FILE_TYPE_ERROR2);
                }

            }

            String ossPath = String.format(OssPath.MANAGE_MODEL_FILE_PATH, uuid + extName);

            tempFile = new File(OssPath.localPath + ossPath);
            if(!tempFile.getParentFile().exists()){
                tempFile.getParentFile().mkdirs();
            }
            file.transferTo(tempFile);
            if(extName.equals(".zip")){
                return uploadModelZip(originalFilename.replace(extName, ""),tempFile,dictId);
            }
            ShellUtil.yunUpload(tempFile.getPath(),ossPath);

            String url = this.ossUrlPrefix + ossPath;

            FileTypeEnum fileTypeEnum = FileTypeEnum.getByType(extName.replace(".", ""));
            if(fileTypeEnum == null){
                throw new BusinessException(ResultCode.FILE_TYPE_ERROR2);
            }
            String format = extName.replace(".", "");
            CommonUpload commonUpload = commonUploadService.add(originalFilename.replace(extName, ""), url, String.valueOf(file.getSize()), uuid, fileTypeEnum, format,format,1,null,dictId);
            tempFile.delete();
            return ResultData.ok(commonUpload);
        }catch ( BusinessException e){
            log.info("upload-file-error:{}",e);
            throw e;
        }catch (Exception e){
            log.info("upload-file-error:{}",e);
            throw new BusinessException(ResultCode.UPLOAD_ERROR);
        }
    }

    private ResultData uploadModelZip(String oldName,File file,Integer dictId) {

        String ossZipPath = String.format(OssPath.MANAGE_MODEL_FILE_PATH, UUID.randomUUID().toString().replace("-", ""));
        String unzipPath = CacheUtil.basePath  + ossZipPath;
        ShellUtil.unZip(file.getPath(),unzipPath);
        try {
            Thread.sleep(1000L);
            FileUtil.del(file.getPath());
        }catch (Exception e){
            log.info("删除文件失败:{}",e);
        }

        //FileUtil.copyContent(file,new File(unzipPath),true);
        File unZipFile = new File(unzipPath);

        if(!unZipFile.exists() || !unZipFile.isDirectory() ){
            throw new BusinessException(ResultCode.UNZIP_ERROR);
        }
        List<File> fileList = new ArrayList<>();
        FileWriterUtil.getCanRunList(fileList,unZipFile);
        if(fileList.size() <=0){
            throw new BusinessException(ResultCode.UPLOAD_FILE_ERROR);
        }
        File modelFile = fileList.get(0);
        String modelFileFormat = modelFile.getName().split("\\.")[1].toLowerCase();

        FileTypeEnum fileTypeEnum = FileTypeEnum.getByType(modelFileFormat);
        if(fileTypeEnum == null){
            throw new BusinessException(ResultCode.FILE_TYPE_ERROR2);
        }

        if(dictId != null){
            Dict dict = dictService.getById(dictId);
            if(dict == null ){
                throw new BusinessException(ResultCode.MISSING_REQUIRED_PARAMETERS);
            }
            if("animation".equals(dict.getUseType()) && !(modelFileFormat.equals("glb") || modelFileFormat.equals("obj"))){
                throw new BusinessException(ResultCode.FILE_TYPE_ERROR2);
            }

        }

        if(FileWriterUtil.isChinese(modelFile.getName())){
            throw new BusinessException(ResultCode.FILE_TYPE_ERROR23);
        }
        if(FileWriterUtil.isChinese(modelFile.getPath())){
            throw new BusinessException(ResultCode.FILE_TYPE_ERROR23);
        }
        String url = null;
        String resultFormat = modelFileFormat;
        switch (modelFileFormat){
            case "obj" :  resultFormat = "obj";
                url = uploadObjOss(unzipPath,modelFile);break;
            case "glb" :   url = uploadOss(unzipPath,modelFile);break;
            case "laz" :    url = uploadLazOss(unzipPath,modelFile); break;
            case "shp" :   url = uploadOss(unzipPath,modelFile); break;
            case "b3dm" :  url = uploadB3dm(unzipPath,modelFile); break;
            case "las" :
            case "ply" :  url = uploadLasOrPly(unzipPath,modelFile);break;
            case "osgb":
                    resultFormat = "b3dm";
                   break;
            default: break;
        }

        Integer status = StringUtils.isNotBlank(url) ?1:-1;
        url = StringUtils.isNotBlank(url) ?ossUrlPrefix + url:null;
        CommonUpload commonUpload = commonUploadService.add(oldName,url, String.valueOf(getDirectorySize(unZipFile)),
                null, fileTypeEnum, modelFileFormat,resultFormat,status,unZipFile.getPath(),dictId);
        if("osgb".equals(modelFileFormat)){
            //commonUploadService.updateStatus(commonUpload.getId(),0);
            uploadOsgb(commonUpload.getId()) ;
        }
        return ResultData.ok(commonUpload);
    }

    private String uploadObjOss(String unzipPath, File modelFile) {
        OBJToGLBUtil.checkObj(modelFile.getPath());
        String localGlbPath = modelFile.getPath().replace(".obj",".glb");
        OBJToGLBUtil.objToGlb2(modelFile.getPath(),localGlbPath);
        String ossPath = unzipPath.replace(OssPath.localPath,"");
        ShellUtil.yunUpload(unzipPath,ossPath);
        if(!uploadToOssUtil.fileExist(localGlbPath.replace(OssPath.localPath,""))){
            throw new BusinessException(ResultCode.UPLOAD_FILE_ERROR);
        }
        FileUtil.del(unzipPath);
        return  ossUrlPrefix +  localGlbPath.replace(OssPath.localPath,"");
    }

    private String uploadB3dm(String unzipPath, File modelFile) {
        String b3dmJsonPath = FileWriterUtil.checkB3dmTileset(new File(unzipPath));
        if(b3dmJsonPath == null){
            throw new BusinessException(ResultCode.UPLOAD_FILE_OBJ_ERROR);
        }
        String ossPath = b3dmJsonPath.replace(OssPath.localPath, "");
        uploadOss(unzipPath,modelFile);
        if(!uploadToOssUtil.fileExist(ossPath)){
            throw new BusinessException(ResultCode.UPLOAD_FILE_ERROR);
        }
        FileUtil.del(unzipPath);
        return   ossPath;
    }

    @Autowired
    OsgbToB3dmConsumer osgbToB3dmConsumer;

    private void uploadOsgb(Integer uploadId) {
         osgbToB3dmConsumer.consumerQueue(uploadId);
    }

    private String uploadLazOss(String unzipPath,File modelFile) {
        String ossPath = unzipPath.replace(OssPath.localPath,"");
        String modelOssPath = modelFile.getPath().replace(OssPath.localPath, "");
        ShellUtil.yunUpload(unzipPath,ossPath);
        if(!uploadToOssUtil.fileExist(modelOssPath)){
            throw new BusinessException(ResultCode.UPLOAD_FILE_ERROR);
        }
        FileUtil.del(unzipPath);
        return   ossPath;
    }

    private String uploadOss(String unzipPath,File modelFile) {
        String ossPath = unzipPath.replace(OssPath.localPath,"");
        String modelOssPath = modelFile.getPath().replace(OssPath.localPath, "");
        ShellUtil.yunUpload(unzipPath,ossPath);
        if(!uploadToOssUtil.existKey(modelOssPath)){
            throw new BusinessException(ResultCode.UPLOAD_FILE_ERROR);
        }
        FileUtil.del(unzipPath);
        return   modelOssPath;
    }

    private String uploadLasOrPly(String unzipPath ,File modelFile) {
        File mntFile = OBJToGLBUtil.lasOrPlyToBin(modelFile);
        String ossPath = mntFile.getPath().replace(OssPath.localPath,"");
        ShellUtil.yunUpload(mntFile.getPath(),ossPath);
        if(!uploadToOssUtil.existKey(ossPath+"/webcloud/cloud.js")){
            throw new BusinessException(-1,"缺少cloud.js文件");
        }
        FileUtil.del(unzipPath);
        return   ossPath + "/webcloud";
    }



    @Override
    public CommonUpload add(String fileName, String url, String fileSize, String uuid, FileTypeEnum fileTypeEnum, String resultFormat,String replace1, Integer status, String unzipPath, Integer dictId) {
        CommonUpload upload = new CommonUpload();
        upload.setFileName(fileName);
        upload.setFileUrl(url);
        upload.setFileSize(fileSize);
        upload.setNewFileName(uuid);
        upload.setFileType(fileTypeEnum.getCode());
        upload.setFileTypeStr(fileTypeEnum.getMsg());
        upload.setFileFormat(resultFormat);
        upload.setResultFileFormat(replace1);
        upload.setStatus(status);
        upload.setUnzipPath(unzipPath);
        this.save(upload);

        DictFile dictFile = new DictFile();
        dictFile.setName(fileName);
        dictFile.setTypeKey("media-library");
        dictFile.setUploadId(upload.getId());
        dictFile.setDictId(dictId);
        dictFile.setSysUserId((String) StpUtil.getLoginId());
        dictFileService.saveOrUpdate(dictFile);

        return upload;
    }

    @Override
    public void updateByPath(Integer uploadId, String url) {
        LambdaUpdateWrapper<CommonUpload> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(CommonUpload::getId,uploadId);
        wrapper.set(CommonUpload::getStatus,1);
        wrapper.set(CommonUpload::getFileUrl,url);
        this.update(wrapper);
    }

    @Override
    public void updateStatus(Integer uploadId,Integer status) {
        LambdaUpdateWrapper<CommonUpload> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(CommonUpload::getId,uploadId);
        wrapper.set(CommonUpload::getStatus,status);
        this.update(wrapper);
    }

    @Override
    public void updateByPath(Integer uploadId, String url,String wgs84 ,String gcj02) {
        LambdaUpdateWrapper<CommonUpload> wrapper = new LambdaUpdateWrapper<>();
        wrapper.eq(CommonUpload::getId,uploadId);
        wrapper.set(CommonUpload::getStatus,1);
        wrapper.set(CommonUpload::getFileUrl,url);
        wrapper.set(CommonUpload::getWgs84,wgs84);
        wrapper.set(CommonUpload::getGcj02,gcj02);
        this.update(wrapper);
    }


    public static long getDirectorySize(File directory) {
        long size = 0;
        try {
            File[] files = directory.listFiles();
            if (files != null) {
                for (File file : files) {
                    if (file.isFile()) {
                        size += file.length();
                    } else if (file.isDirectory()) {
                        size += getDirectorySize(file);
                    }
                }
            }
        }catch (Exception e){
        }
        return size;
    }

    @Override
    public List<CommonUpload> getDelData() {
        return this.getBaseMapper().getDelData();
    }

    @Override
    public void delByIds(List<Integer> ids) {
         this.getBaseMapper().delByIds(ids);
    }
}