FMS2/src/main/java/com/example/fms/service/FileVersionService.java

package com.example.fms.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.LambdaUpdateWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.example.fms.common.model.dto.*;
import com.example.fms.common.model.vo.FileVersionInfoVO;
import com.example.fms.common.model.vo.ForceSaveVO;
import com.example.fms.common.model.vo.QueryFileVersionHistoryVO;
import com.example.fms.common.model.vo.WebSocketMessageVO;
import com.example.fms.common.utils.FileUtils;
import com.example.fms.common.utils.JWTUtils;
import com.example.fms.common.utils.RandomUtil;
import com.example.fms.domain.FileOperateRecord;
import com.example.fms.domain.FileVersion;
import com.example.fms.domain.Personnel;
import com.example.fms.mapper.FileOperateRecordMapper;
import com.example.fms.mapper.FileVersionMapper;
import com.example.fms.service.permissions.MessageService;
import com.example.fms.service.permissions.PermissionService;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.compress.utils.IOUtils;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
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.util.CollectionUtils;
import org.springframework.web.multipart.MultipartFile;

import java.io.*;
import java.util.*;

@RequiredArgsConstructor
@Slf4j
@Service
public class FileVersionService {

    @Autowired
    private MessageService messageService;

    @Autowired
    private PermissionService permissionService;

    @Autowired
    private FileMangerService fileMangerService;

    @Autowired
    private FileVersionMapper fileVersionMapper;

    @Autowired
    private FileOperateRecordMapper fileOperateRecordMapper;

    /**
     * onlyoffice回调函数(文件保存)
     *
     * @param params
     * @param guid
     * @param fileName
     * @param user
     * @param previousVersion
     * @return
     * @throws IOException
     */
    public Integer callback(Map<String, Object> params, String guid, String fileName,
                            String user, String previousVersion) throws Exception {
        boolean flag = true;
        if (!CollectionUtils.isEmpty(params)) {
            int status = Integer.parseInt(params.get("status").toString());
            if (status != 2 && status != 6) {
                return 0;
            }
            String url = "";
            if (ObjectUtils.isNotEmpty(params.get("url"))) {
                url = params.get("url").toString();
            }
            String changesUrl = "";
            if (ObjectUtils.isNotEmpty(params.get("changesurl"))) {
                changesUrl = params.get("changesurl").toString();
            }
            if (status == 6 && StringUtils.isNotEmpty(url)) {
                MultipartFile multipartFile = FileUtils.urlToMultipartFile(url, fileName);
                String replaceFile = fileMangerService.replaceFile(multipartFile, guid, 6);
                if (StringUtils.isEmpty(replaceFile)) {
                    flag = false;
                }
                WebSocketMessageVO messageVO = new WebSocketMessageVO();
                messageVO.setMessage("版本文件已保存");
                messageVO.setCode(702);
                messageService.sendMessage(messageVO);
            }
            if (status == 2) {
                if (StringUtils.isNotEmpty(url)) {
                    MultipartFile multipartFile = FileUtils.urlToMultipartFile(url, fileName);
                    List<String> list = fileMangerService.uploadFile(Collections.singletonList(multipartFile), 6);
                    if (!CollectionUtils.isEmpty(list)) {
                        url = list.get(0);
                    } else {
                        url = "";
                    }
                }
                if (StringUtils.isNotEmpty(changesUrl)) {
                    MultipartFile multipartFile1 = FileUtils.urlToMultipartFile(changesUrl, fileName);
                    List<String> list1 = fileMangerService.uploadFile(Collections.singletonList(multipartFile1), 6);
                    if (!CollectionUtils.isEmpty(list1)) {
                        changesUrl = list1.get(0);
                    } else {
                        changesUrl = "";
                    }
                }
                if (StringUtils.equals(fileName, "undefined")) {
                    fileName = "";
                }
                if (StringUtils.equals(user, "undefined")) {
                    user = "";
                }
                if (StringUtils.equals(previousVersion, "undefined")) {
                    previousVersion = "";
                }
                this.addFileVersion(params, guid, fileName, user, previousVersion, url, changesUrl);
            }
        }
        if (flag) {
            return 0;
        } else {
            return 1;
        }
    }

    public void addFileVersion(Map<String, Object> params, String guid, String fileName,
                               String user, String previousVersion, String url,
                               String changesUrl) throws IOException {
        String fileType = "";
        if (ObjectUtils.isNotEmpty(params.get("filetype"))) {
            fileType = params.get("filetype").toString();
        }
        String changes = "";
        String serverVersion = "";
        String history = "";
        if (ObjectUtils.isNotEmpty(params.get("history"))) {
            history = params.get("history").toString();
        }
        if (StringUtils.isNotEmpty(history)) {
            String strip = StringUtils.strip(history, "{}");
            int i = strip.indexOf(",");
            String s1 = strip.substring(0, i);
            serverVersion = s1.trim().substring(s1.indexOf("=") + 1);
            String s2 = strip.substring(i + 1);
            changes = s2.trim().substring(s2.indexOf("=") + 1);
        }
        int version = 1;
        String originalFile = guid;
        FileVersion fileVersion = fileVersionMapper.queryFileVersionByGuid(originalFile);
        if (ObjectUtils.isNotEmpty(fileVersion)) {
            version = fileVersion.getVersion();
            originalFile = fileVersion.getOriginalFile();
        } else {
            FileVersion fileVersion1 = new FileVersion();
            fileVersion1.setFileName(fileName);
            fileVersion1.setFileType(fileType);
            fileVersion1.setFileKey(RandomUtil.generateInvitationCode());
            fileVersion1.setUrl(guid);
            fileVersion1.setVersion(version);
            fileVersion1.setOriginalFile(guid);
            fileVersion1.setUser(user);
            fileVersion1.insert();
            previousVersion = "1";
        }
        version += 1;
        //添加新版本数据
        FileVersion version1 = new FileVersion();
        version1.setFileName(fileName);
        version1.setFileType(fileType);
        version1.setFileKey(RandomUtil.generateInvitationCode());
        version1.setUrl(url);
        version1.setChangesUrl(changesUrl);
        version1.setVersion(version);
        version1.setOriginalFile(originalFile);
        version1.setChanges(changes);
        version1.setServerVersion(serverVersion);
        if (StringUtils.isNotEmpty(previousVersion)) {
            version1.setPreviousVersion(Integer.valueOf(previousVersion));
        }
        version1.setUser(user);
        version1.insert();

        //查询编辑人
        List<Personnel> personnels = new ArrayList<>();
        if (StringUtils.isNotEmpty(user)) {
            String res = permissionService.getPersonnelByIdsFromPCS(Collections.singletonList(user));
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }
        //添加当前操作版本
        FileOperateRecord operateRecord = new FileOperateRecord();
        operateRecord.setUserId(user);
        Personnel personnel = personnels.stream().filter(i -> i.getId().toString().equals(user)).findFirst().orElse(null);
        if (ObjectUtils.isNotEmpty(personnel)) {
            operateRecord.setUserName(personnel.getPersonnelName());
        }
        operateRecord.setCurrentVersion(version);
        if (StringUtils.isNotEmpty(previousVersion)) {
            operateRecord.setPreviousVersion(Integer.valueOf(previousVersion));
        }
        operateRecord.setOperate("2");
        operateRecord.setOriginalFile(originalFile);
        operateRecord.insert();
    }

    /**
     * onlyoffice版本恢复
     * @param vo
     */
    public void restoreFileVersion(RestoreFileVersionDTO vo) {
        Integer currentVersion = vo.getRestoreVersion();
        Integer previousVersion = vo.getPreviousVersion();
        String guid = vo.getGuid();
        String userId = vo.getUserId();
        String userName = vo.getUserName();
        //新增操作记录
        FileOperateRecord record = new FileOperateRecord();
        record.setPreviousVersion(previousVersion);
        record.setCurrentVersion(currentVersion);
        record.setOriginalFile(guid);
        record.setUserId(userId);
        record.setUserName(userName);
        record.setOperate("1");
        record.insert();
        //更新版本
        String key = RandomUtil.generateInvitationCode();
        LambdaUpdateWrapper<FileVersion> wrapper = new UpdateWrapper<FileVersion>()
                .lambda()
                .set(FileVersion::getFileKey, key)
                .eq(FileVersion::getVersion, currentVersion)
                .eq(FileVersion::getOriginalFile, guid);
        fileVersionMapper.update(null, wrapper);
        //发送websocket
        WebSocketMessageVO messageVO = new WebSocketMessageVO();
        messageVO.setMessage("版本文件已恢复");
        messageVO.setCode(703);
        messageService.sendMessage(messageVO);
    }

    /**
     * onlyoffice强制保存
     * @param vo
     * @return
     */
    public ForceSaveVO forceSave(ForceSaveDTO vo) throws IOException {
        Map<Integer, String> map = new HashMap<>();
        map.put(0,"没有错误");
        map.put(1,"文档密钥丢失或找不到具有该密钥的文档");
        map.put(2,"回调地址不正确");
        map.put(3,"内部服务器错误");
        map.put(4,"没有对文档进行任何更改");
        map.put(5,"key不正确");
        map.put(6,"令牌无效");
        String officeInfo = permissionService.getOnlyOfficeInfo(vo);
        int result = 1;
        ForceSaveVO saveVO = new ForceSaveVO();
        if (StringUtils.isNotEmpty(officeInfo)) {
            JSONObject object = JSON.parseObject(officeInfo);
            int error = Integer.parseInt(object.get("error").toString());
            saveVO.setMessage(map.get(error));
            if (error == 4) {
                result = 1;
            } else {
                if (error == 0){
                    result = 2;
                } else {
                    return saveVO;
                }
            }
        }
        saveVO.setNum(result);
        return saveVO;
    }

    /**
     * 获取当前显示版本数据
     *
     * @param vo
     * @return
     */
    public FileVersionInfoVO getCurrentVersionData(QueryFileVersionDTO vo) {
        FileVersion fileVersion = fileVersionMapper.queryCurrentFileVersionInfo(vo.getGuid());
        FileVersionInfoVO infoVO = new FileVersionInfoVO();
        if (ObjectUtils.isNotEmpty(fileVersion)) {
            BeanUtils.copyProperties(fileVersion, infoVO);
            infoVO.setFileVersionId(fileVersion.getId());
            infoVO.setKey(fileVersion.getFileKey());
        }
        return infoVO;
    }

    /**
     * onlyoffice查询文件版本历史
     * @param vo
     * @return
     */
    public QueryFileVersionHistoryVO queryFileVersionHistory(QueryFileVersionDTO vo) {
        QueryFileVersionHistoryVO historyVO = new QueryFileVersionHistoryVO();
        List<FileVersion> versions = fileVersionMapper.selectList(new LambdaQueryWrapper<FileVersion>()
                .eq(FileVersion::getOriginalFile, vo.getGuid())
                .orderByDesc(FileVersion::getVersion));
        if (!CollectionUtils.isEmpty(versions)) {
            List<FileVersionInfoVO> fileVersionInfoVOS = new ArrayList<>();
            versions.forEach(i -> {
                FileVersionInfoVO infoVO = new FileVersionInfoVO();
                BeanUtils.copyProperties(i, infoVO);
                infoVO.setFileVersionId(i.getId());
                infoVO.setKey(i.getFileKey());
                fileVersionInfoVOS.add(infoVO);
            });
            historyVO.setHistory(fileVersionInfoVOS);
        }
        FileOperateRecord operateRecord = fileVersionMapper.queryFileOperateRecord(vo.getGuid());
        if (ObjectUtils.isNotEmpty(operateRecord)) {
            historyVO.setCurrentVersion(operateRecord.getCurrentVersion());
        }
        return historyVO;
    }
}