PAS/src/main/java/cn/cslg/pas/service/business/PatentDigProjectFilesService.java

package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.QueryPatentDigProjectFilesDTO;
import cn.cslg.pas.common.dto.business.PatentDigProjectFilesDTO;
import cn.cslg.pas.common.model.cronModel.Personnel;
import cn.cslg.pas.common.model.cronModel.PersonnelVO;
import cn.cslg.pas.common.model.cronModel.Records;
import cn.cslg.pas.common.model.cronModel.SystemFile;
import cn.cslg.pas.common.model.request.GroupRequest;
import cn.cslg.pas.common.model.request.QueryRequest;
import cn.cslg.pas.common.utils.CacheUtils;
import cn.cslg.pas.common.utils.LoginUtils;
import cn.cslg.pas.common.vo.business.PatentDigProjectFilesVO;
import cn.cslg.pas.domain.business.*;
import cn.cslg.pas.exception.UnLoginException;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.factorys.businessFactory.Business;
import cn.cslg.pas.mapper.PatentDigProjectFilesMapper;
import cn.cslg.pas.service.common.FileManagerService;
import cn.cslg.pas.service.permissions.PermissionService;
import cn.cslg.pas.service.query.FormatQueryService;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 专利挖掘项目文件Service层
 *
 * @Author xiexiang
 * @Date 2023/11/8
 */
@Service
public class PatentDigProjectFilesService extends ServiceImpl<PatentDigProjectFilesMapper, PatentDigProjectFiles> implements Business {

    @Autowired
    private CacheUtils cacheUtils;

    @Autowired
    private LoginUtils loginUtils;

    @Autowired
    private FormatQueryService formatQueryService;

    @Autowired
    private PatentDigProjectFilesMapper patentDigProjectFilesMapper;

    @Autowired
    private PermissionService permissionService;

    @Autowired
    private FileManagerService fileManagerService;

    @Autowired
    @Lazy
    private ProjectTaskService projectTaskService;

    @Autowired
    private AssoTaskFileService assoTaskFileService;

    @Autowired
    private AssoProjectFileService assoProjectFileService;
    @Autowired
    @Lazy
    private TaskHandleResultService taskHandleResultService;
    @Autowired
    private AssoHandleResultFileService assoHandleResultFileService;

    @Override
    public Object queryMessage(QueryRequest queryRequest) throws Exception {
        //根据专题库/报告id查询自定义栏位
        List<String> sqls = formatQueryService.reSqls(queryRequest, "patentDigProjectFiles");
        //根据sql查询自定义栏位信息
        List<PatentDigProjectFilesVO> patentDigProjectFilesVOS = patentDigProjectFilesMapper.getPatentDigProjectFiles(sqls.get(0), sqls.get(1), sqls.get(2));
        //查询总数
        Long total = patentDigProjectFilesMapper.getPatentDigProjectFilesCount(sqls.get(0));
        //装载自定义栏位信息
        this.loadPatentDigProjectFiles(patentDigProjectFilesVOS);
        //装载返回信息
        Records records = new Records();
        records.setCurrent(queryRequest.getCurrent());
        records.setSize(queryRequest.getSize());
        records.setData(patentDigProjectFilesVOS);
        records.setTotal(total);
        return records;
    }

    @Override
    public Object addMessage(Object object, List<MultipartFile> files) {
        return null;
    }

    @Override
    public Object deleteMessage(List<Integer> ids) throws IOException {
        if (!ids.isEmpty()) {
            this.removeBatchByIds(ids);
        }
        return ids;
    }

    @Override
    public Object updateMessage(Object object, List<MultipartFile> files) {
        return null;
    }

    @Override
    public Object getGroup(GroupRequest groupRequest, String tableName) throws Exception {
        return null;
    }

    /**
     * 新增专利挖掘项目文件
     *
     * @param object
     * @return
     */
    @Override
    public Object addMessage(Object object) {
        //object to patentDigProjectFilesDTO
        PatentDigProjectFilesDTO patentDigProjectFilesDTO = (PatentDigProjectFilesDTO) object;
        //判断projectId是否为空
        if (patentDigProjectFilesDTO.getProjectId() == null) {
            throw new XiaoShiException("projectId不能为空");
        }
        //判断processId是否为空
        if (patentDigProjectFilesDTO.getProcessId() == null) {
            throw new XiaoShiException("processId不能为空");
        }
        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();
        try {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }
        List<Integer> ids = new ArrayList<>();

        if (patentDigProjectFilesDTO.getFileGuids() != null && !patentDigProjectFilesDTO.getFileGuids().isEmpty()) {
            List<String> fileGuids = patentDigProjectFilesDTO.getFileGuids();
            List<SystemFile> systemFiles = new ArrayList<>();
            List<PatentDigProjectFiles> patentDigProjectFilesS = new ArrayList<>();
            //调用文件系统查询文件信息接口
            if (fileGuids.size() != 0) {
                try {
                    String res = fileManagerService.getSystemFileFromFMS(fileGuids);
                    systemFiles = JSONObject.parseArray(res, SystemFile.class);
                    if (systemFiles.size() != 0) {
                        for (String item : fileGuids) {
                            SystemFile systemFile = systemFiles.stream().filter(item1 -> item1.getGuid().equals(item)).findFirst().orElse(null);
                            PatentDigProjectFiles patentDigProjectFiles = new PatentDigProjectFiles();
                            BeanUtils.copyProperties(patentDigProjectFilesDTO, patentDigProjectFiles);
                            patentDigProjectFiles.setFileGuid(item);
                            patentDigProjectFiles.setName(systemFile.getOriginalName());
                            patentDigProjectFiles.setCreateId(personnelVO.getId());
                            patentDigProjectFilesS.add(patentDigProjectFiles);
                        }
                        this.saveBatch(patentDigProjectFilesS);
                    }
                } catch (Exception e) {
                    throw new XiaoShiException("查询文件信息错误");
                }
            }

            patentDigProjectFilesS.forEach(item -> {
                ids.add(item.getId());
            });
        }

        return ids;
    }

    @Override
    public Object updateMessage(Object object) {
        return null;
    }

    /**
     * 装载专利挖掘文件列表信息
     *
     * @param patentDigProjectFilesVOS
     */
    private void loadPatentDigProjectFiles(List<PatentDigProjectFilesVO> patentDigProjectFilesVOS) throws IOException {
        List<String> createIds = new ArrayList<>();
        List<String> fileGuids = new ArrayList<>();
        patentDigProjectFilesVOS.forEach(
                item -> {
                    if (item.getCreateId() != null) {
                        createIds.add(item.getCreateId());
                    }
                    if (item.getFileGuid() != null) {
                        fileGuids.add(item.getFileGuid());
                    }
                }
        );
        List<Personnel> personnels = new ArrayList<>();
        //查询创建人名称
        if (createIds.size() != 0) {
            String res = permissionService.getPersonnelByIdsFromPCS(createIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }

        List<SystemFile> systemFiles = new ArrayList<>();
        if (fileGuids.size() != 0) {
            String res = fileManagerService.getSystemFileFromFMS(fileGuids);
            systemFiles = JSONObject.parseArray(res, SystemFile.class);
        }
        for (PatentDigProjectFilesVO patentDigProjectFilesVO : patentDigProjectFilesVOS) {
            //装载人员信息
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(patentDigProjectFilesVO.getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                patentDigProjectFilesVO.setCreateName(personnel.getPersonnelName());
            } else {
                throw new XiaoShiException("未获取到当前登陆人信息");
            }
            SystemFile systemFile = systemFiles.stream().filter(item -> item.getGuid().equals(patentDigProjectFilesVO.getFileGuid())).findFirst().orElse(null);
            patentDigProjectFilesVO.setType(systemFile.getType());
            patentDigProjectFilesVO.setName(systemFile.getOriginalName());
            //调用查询流程名称方法
            String name = this.getProcessName(patentDigProjectFilesVO.getProcessId());
            patentDigProjectFilesVO.setProcessName(name);

            //任务信息
            Integer taskId = patentDigProjectFilesVO.getTaskId();
            if (taskId != null) {
                ProjectTask projectTask = projectTaskService.getById(taskId);
                patentDigProjectFilesVO.setProjectTask(projectTask);
            }
        }
    }

    /**
     * 装载流程名
     *
     * @param processId
     * @return
     */
    public String getProcessName(Integer processId) {
        String name = null;
        Map<Integer, String> processMap = new HashMap<>();
        processMap.put(1, "创新点梳理");
        processMap.put(2, "查新检索");
        processMap.put(3, "保护主题规划");
        processMap.put(4, "独权撰写");
        processMap.put(5, "从权撰写");
        processMap.put(6, "申请文件定稿");
        processMap.put(7, "说明书规划撰写");
        name = processMap.get(processId);
        return name;
    }

    /**
     * 上传专利挖掘项目文件后提交审核，新增专利挖掘文件审核记录
     *
     * @param patentDigProjectFilesDTO
     * @return
     */
    public Integer addPDProjectFilesTask(PatentDigProjectFilesDTO patentDigProjectFilesDTO) {
        //首先调用新增文件接口
        List<Integer> ids = (List<Integer>) this.addMessage(patentDigProjectFilesDTO);
        //其次调用新增任务接口
        patentDigProjectFilesDTO.getProjectTaskDTO().setProjectId(patentDigProjectFilesDTO.getProjectId());
        patentDigProjectFilesDTO.getProjectTaskDTO().setProcessId(patentDigProjectFilesDTO.getProcessId());
        Integer taskType = 7;
        patentDigProjectFilesDTO.getProjectTaskDTO().setType(taskType);
        Integer taskId = projectTaskService.addTask(patentDigProjectFilesDTO.getProjectTaskDTO());
        if (!ids.isEmpty()) {
            LambdaQueryWrapper<PatentDigProjectFiles> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(PatentDigProjectFiles::getId, ids);
            List<PatentDigProjectFiles> patentDigProjectFiles = this.list(queryWrapper);
            if (!patentDigProjectFiles.isEmpty()) {
                patentDigProjectFiles.forEach(item -> {
                    item.setTaskId(taskId);
                });
                this.updateBatchById(patentDigProjectFiles);
            }
        }
        return taskId;
    }

    /**
     * 获取流程信息
     *
     * @param projectId
     * @return
     */
    public Map<Integer, Map<String, Integer>> getProcessInfo(Integer projectId) {
        Map<Integer, Map<String, Integer>> processInfo = new HashMap<>();
        for (int i = 1; i < 8; i++) {
            LambdaQueryWrapper<ProjectTask> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ProjectTask::getProcessId, i).eq(ProjectTask::getProjectId, projectId);
            Integer taskCount = (int) projectTaskService.count(queryWrapper);
            LambdaQueryWrapper<PatentDigProjectFiles> queryWrapper1 = new LambdaQueryWrapper<>();
            queryWrapper1.eq(PatentDigProjectFiles::getProcessId, i).eq(PatentDigProjectFiles::getProjectId, projectId);
            Integer fileCount = (int) this.count(queryWrapper1);
            Integer handleFileCount = assoHandleResultFileService.getBaseMapper().getResultFileNum(projectId, i);
            fileCount += handleFileCount;
            Map<String, Integer> countMap = new HashMap<>();
            countMap.put("taskCount", taskCount);
            countMap.put("fileCount", fileCount);
            processInfo.put(i, countMap);
        }
        return processInfo;
    }

    /**
     * 查询专利挖掘项目所有文件
     * 来源：1 PatentDigProjectFiles
     *      2 AssoHandleResultFile
     *      3 AssoProjectFile
     *      4 AssoTaskFile
     *
     * @param queryPatentDigProjectFilesDTO
     */
    public List<PatentDigProjectFilesVO> getPatentDigProjectFiles(QueryPatentDigProjectFilesDTO queryPatentDigProjectFilesDTO) {
        List<PatentDigProjectFilesVO> patentDigProjectFilesVOS = new ArrayList<>();
        //查询本表
        if (queryPatentDigProjectFilesDTO == null) {
            throw new XiaoShiException("入参为空");
        }
        Integer projectId = queryPatentDigProjectFilesDTO.getProjectId();
        if (projectId == null) {
            throw new XiaoShiException("projectId为空");
        }
        //流程id
        Integer processId = queryPatentDigProjectFilesDTO.getProcessId();
        //任务id
        Integer taskId = queryPatentDigProjectFilesDTO.getTaskId();
        LambdaQueryWrapper<PatentDigProjectFiles> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PatentDigProjectFiles::getProjectId, projectId);
        if (processId != null) {
            queryWrapper.eq(PatentDigProjectFiles::getProcessId, processId);
        }
        if (taskId != null) {
            queryWrapper.eq(PatentDigProjectFiles::getTaskId, taskId);
        }
        List<PatentDigProjectFiles> patentDigProjectFilesList = this.list(queryWrapper);
        if (!patentDigProjectFilesList.isEmpty()) {
            patentDigProjectFilesList.forEach(item -> {
                PatentDigProjectFilesVO patentDigProjectFilesVO = new PatentDigProjectFilesVO();
                BeanUtils.copyProperties(item, patentDigProjectFilesVO);
                patentDigProjectFilesVO.setSource(1);
                patentDigProjectFilesVOS.add(patentDigProjectFilesVO);
            });
        }
        //查询项目下所有任务的文件
        LambdaQueryWrapper<ProjectTask> queryWrapper1 = new LambdaQueryWrapper<>();
        queryWrapper1.eq(ProjectTask::getProjectId, projectId);
        if (processId != null) {
            queryWrapper1.eq(ProjectTask::getProcessId, processId);
        }
        if (taskId != null) {
            queryWrapper1.eq(ProjectTask::getId, taskId);
        }
        List<ProjectTask> projectTasks = projectTaskService.list(queryWrapper1);
        if (!projectTasks.isEmpty()) {
            List<Integer> taskIds = projectTasks.stream().map(ProjectTask::getId).collect(Collectors.toList());
            LambdaQueryWrapper<AssoTaskFile> queryWrapper2 = new LambdaQueryWrapper<>();
            queryWrapper2.in(AssoTaskFile::getTaskId, taskIds);
            List<AssoTaskFile> assoTaskFiles = assoTaskFileService.list(queryWrapper2);
            if (!assoTaskFiles.isEmpty()) {
                assoTaskFiles.forEach(item -> {
                    ProjectTask projectTask = projectTasks.stream().filter(item2 -> item2.getId().equals(item.getTaskId())).findFirst().orElse(null);
                    PatentDigProjectFilesVO patentDigProjectFilesVO = new PatentDigProjectFilesVO();
                    patentDigProjectFilesVO.setProjectId(projectId);
                    patentDigProjectFilesVO.setFileGuid(item.getFileGuid());
                    patentDigProjectFilesVO.setTaskId(item.getTaskId());
                    patentDigProjectFilesVO.setCreateId(item.getCreateId());
                    patentDigProjectFilesVO.setCreateTime(item.getCreateTime());
                    patentDigProjectFilesVO.setDescription(item.getDescription());
                    if (projectTask != null) {
                        patentDigProjectFilesVO.setProcessId(projectTask.getProcessId());
                    }
                    patentDigProjectFilesVO.setSource(4);
                    patentDigProjectFilesVOS.add(patentDigProjectFilesVO);
                });
            }

            //查询审核历史里的文件
            LambdaQueryWrapper<TaskHandleResult> queryWrapper3 = new LambdaQueryWrapper<>();
            queryWrapper3.in(TaskHandleResult::getTaskId, taskIds);
            List<TaskHandleResult> taskHandleResults = taskHandleResultService.list(queryWrapper3);
            if (taskHandleResults != null && taskHandleResults.size() > 0) {
                List<Integer> resultIds = taskHandleResults.stream().map(TaskHandleResult::getId).collect(Collectors.toList());
                LambdaQueryWrapper<AssoHandleResultFile> queryWrapper4 = new LambdaQueryWrapper<>();
                queryWrapper4.in(AssoHandleResultFile::getTaskHandleResultId, resultIds);
                List<AssoHandleResultFile> assoHandleResultFiles = assoHandleResultFileService.list(queryWrapper4);
                assoHandleResultFiles.forEach(item -> {
                    PatentDigProjectFilesVO patentDigProjectFilesVO = new PatentDigProjectFilesVO();
                    patentDigProjectFilesVO.setProjectId(projectId);
                    patentDigProjectFilesVO.setFileGuid(item.getFileGuid());
                    patentDigProjectFilesVO.setCreateId(item.getCreateId());
                    patentDigProjectFilesVO.setProcessId(processId);
                    patentDigProjectFilesVO.setCreateTime(item.getCreateTime());
                    patentDigProjectFilesVO.setSource(2);
                    patentDigProjectFilesVOS.add(patentDigProjectFilesVO);
                });
            }
        }
        //查询项目下的文件
        if (taskId == null) {
            LambdaQueryWrapper<AssoProjectFile> queryWrapper2 = new LambdaQueryWrapper<>();
            queryWrapper2.eq(AssoProjectFile::getProjectId, projectId);
            List<AssoProjectFile> assoProjectFiles = assoProjectFileService.list(queryWrapper2);
            if (!assoProjectFiles.isEmpty()) {
                assoProjectFiles.forEach(item -> {
                    PatentDigProjectFilesVO patentDigProjectFilesVO = new PatentDigProjectFilesVO();
                    patentDigProjectFilesVO.setProjectId(projectId);
                    patentDigProjectFilesVO.setFileGuid(item.getFileGuid());
                    patentDigProjectFilesVO.setCreateId(item.getCreateId());
                    patentDigProjectFilesVO.setCreateTime(item.getCreateTime());
                    patentDigProjectFilesVO.setSource(3);
                    patentDigProjectFilesVOS.add(patentDigProjectFilesVO);
                });
            }
        }
        try {
            this.loadPatentDigProjectFiles(patentDigProjectFilesVOS);
        } catch (Exception e) {
            throw new XiaoShiException("装载信息错误");
        }
        return patentDigProjectFilesVOS;
    }

    /**
     * 删除
     * 来源：1 PatentDigProjectFiles
     *      2 AssoHandleResultFile
     *      3 AssoProjectFile
     *      4 AssoTaskFile
     * @param source
     * @param fileGuid
     */
    public void delete(Integer source, String fileGuid) {
        if (fileGuid != null && !fileGuid.trim().isEmpty()) {
            if (source != null) {
                if (source.equals(1)) {
                    LambdaQueryWrapper<PatentDigProjectFiles> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.eq(PatentDigProjectFiles::getFileGuid, fileGuid);
                    this.remove(queryWrapper);
                } else if (source.equals(2)) {
                    LambdaQueryWrapper<AssoHandleResultFile> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.eq(AssoHandleResultFile::getFileGuid, fileGuid);
                    assoHandleResultFileService.remove(queryWrapper);
                } else if (source.equals(3)) {
                    LambdaQueryWrapper<AssoProjectFile> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.eq(AssoProjectFile::getFileGuid, fileGuid);
                    assoProjectFileService.remove(queryWrapper);
                } else if (source.equals(4)) {
                    LambdaQueryWrapper<AssoTaskFile> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.eq(AssoTaskFile::getFileGuid, fileGuid);
                    assoTaskFileService.remove(queryWrapper);
                }
            }
        }
    }
}