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

package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.business.*;
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.model.request.StringRequest;
import cn.cslg.pas.common.utils.CacheUtils;
import cn.cslg.pas.common.utils.LoginUtils;
import cn.cslg.pas.common.vo.PatentWithIdVO;
import cn.cslg.pas.common.vo.business.*;
import cn.cslg.pas.domain.business.*;
import cn.cslg.pas.domain.es.EsProjectTask;
import cn.cslg.pas.domain.es.Patent;
import cn.cslg.pas.domain.es.PatentJoin;
import cn.cslg.pas.exception.UnLoginException;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.factorys.businessFactory.Business;
import cn.cslg.pas.mapper.ProjectTaskMapper;
import cn.cslg.pas.service.AssoTaskFieldService;
import cn.cslg.pas.service.MailSendService;
import cn.cslg.pas.service.business.es.EsPatentService;
import cn.cslg.pas.service.business.es.EsService;
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.annotation.TableField;
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.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 任务模块
 *
 * @Author xiexiang
 * @Date 2023/11/21
 */
@Service
public class ProjectTaskService extends ServiceImpl<ProjectTaskMapper, ProjectTask> implements Business {

    @Autowired
    private CacheUtils cacheUtils;

    @Autowired
    private LoginUtils loginUtils;

    @Autowired
    private PatentDigProjectService patentDigProjectService;

    @Autowired
    private PatentDigProjectFilesService patentDigProjectFilesService;

    @Autowired
    private FormatQueryService formatQueryService;

    @Autowired
    private ProjectTaskMapper projectTaskMapper;

    @Autowired
    private PermissionService permissionService;

    @Autowired
    private AssoTaskFileService assoTaskFileService;

    @Autowired
    private TaskHandleResultService taskHandleResultService;

    @Autowired
    private AssoHandleResultFileService assoHandleResultFileService;

    @Autowired
    private FileManagerService fileManagerService;

    @Autowired
    private ProjectService projectService;

    @Autowired
    private AssoTaskPersonService assoTaskPersonService;

    @Autowired
    private TortCompareRecordService tortCompareRecordService;

    @Autowired
    private ReportProjectService reportProjectService;

    @Autowired
    private EsPatentService esPatentService;

    @Autowired
    private CompareLiteratureService compareLiteratureService;

    @Autowired
    private EsService esService;

    @Autowired
    private CustomFieldService customFieldService;

    @Autowired
    private AssoTaskFieldService assoTaskFieldService;

    @Autowired
    private FTOCompareRecordService ftoCompareRecordService;

    @Autowired
    private TaskCodeService taskCodeService;

    @Autowired
    private MailSendService mailSendService;

    /**
     * 挖掘项目开卷审核任务
     *
     * @param patentDigProjectTaskDTO
     * @return
     */
    public Object addProjectOpenAuditTask(PatentDigProjectTaskDTO patentDigProjectTaskDTO) {
        PatentDigProjectDTO patentDigProjectDTO = patentDigProjectTaskDTO.getPatentDigProjectDTO();
        ProjectTaskDTO projectTaskDTO = patentDigProjectTaskDTO.getProjectTaskDTO();
        //如果专利挖掘项目DTO不为空，则需要先建立专利挖掘项目
        if (patentDigProjectDTO != null) {
            Integer projectId = (Integer) patentDigProjectService.addMessage(patentDigProjectDTO);
            if (projectId != null) {
                projectTaskDTO.setProjectId(projectId);
                Integer projectTaskId = this.addTask(projectTaskDTO);
                if (projectTaskId != null) {
                    //将专利挖掘项目状态置为开卷审核
                    LambdaQueryWrapper<PatentDigProject> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.eq(PatentDigProject::getProjectId, projectId);
                    List<PatentDigProject> patentDigProjects = patentDigProjectService.list(queryWrapper);
                    if (!patentDigProjects.isEmpty()) {
                        PatentDigProject patentDigProject = patentDigProjects.get(0);
                        patentDigProject.setState(0);
                        patentDigProject.updateById();
                    }
                }
                return projectTaskId;
            } else {
                throw new XiaoShiException("专利挖掘项目新增失败");
            }
        } else {
            throw new XiaoShiException("挖掘项目数据不能为空！");
        }
    }

    /**
     * 新建任务
     *
     * @param projectTaskDTO
     * @return
     */
    public Integer addTask(ProjectTaskDTO projectTaskDTO) {
        //判断专题库id不为空
        if (projectTaskDTO.getProjectId() == null) {
            throw new XiaoShiException("专题库id不能为空!");
        }
        //判断任务类型不为空
        if (projectTaskDTO.getType() == null) {
            throw new XiaoShiException("任务类型不能为空!");
        }
        //判断任务名称不为空
        projectTaskDTO.setName(projectTaskDTO.getName().trim());
        String name = projectTaskDTO.getName();
        if (name == null || name.equals("")) {
            throw new XiaoShiException("任务名称不能为空!");
        }
        //根据assoTaskId查询processId
        if (projectTaskDTO.getAssoTaskId() != null) {
            LambdaQueryWrapper<ProjectTask> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ProjectTask::getId, projectTaskDTO.getAssoTaskId());
            List<ProjectTask> projectTasks = this.list(queryWrapper);
            if (projectTasks != null && projectTasks.size() != 0) {
                ProjectTask projectTask = projectTasks.get(0);
                projectTaskDTO.setProcessId(projectTask.getProcessId());
            }
        }
        ProjectTask projectTask = new ProjectTask();
        BeanUtils.copyProperties(projectTaskDTO, projectTask);
        //任务状态置为处理中
        projectTask.setStatus(2);
        //获取登录人信息
        PersonnelVO personnelVO = new PersonnelVO();
        try {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }
        //设置任务的发起人
        projectTask.setCreateId(personnelVO.getId());
        projectTask.insert();
        //如果assoTaskId为空，就设置
        if (projectTask.getAssoTaskId() == null) {
            if (projectTask.getType() == 1 || projectTask.getType() == 6 || projectTask.getType() == 7) {
                projectTask.setAssoTaskId(projectTask.getId());
                projectTask.updateById();
            }
        }
        //新增任务可能会上传附件，如果附件不为空，则添加任务与附件关联
        if (projectTaskDTO.getFileGuids() != null) {
            AssoTaskFileDTO assoTaskFileDTO = new AssoTaskFileDTO();
            assoTaskFileDTO.setTaskId(projectTask.getId());
            assoTaskFileDTO.setFileGuids(projectTaskDTO.getFileGuids());
            assoTaskFileService.addTaskFile(assoTaskFileDTO);
        }
        //根据新增的审核任务的lastTaskId，将上一级任务状态改为审核中
        if (projectTask.getLastTaskId() != null && projectTask.getType().equals(5)) {
            LambdaQueryWrapper<ProjectTask> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(ProjectTask::getId, projectTask.getLastTaskId());
            List<ProjectTask> projectTasks = this.list(queryWrapper);
            if (projectTasks != null && projectTasks.size() != 0) {
                ProjectTask projectTask1 = projectTasks.get(0);
                projectTask1.setStatus(1);
                projectTask1.updateById();
            }
        }
        return projectTask.getId();
    }

    /**
     * 查询任务
     *
     * @param queryRequest
     * @return
     * @throws Exception
     */
    @Override
    public Object queryMessage(QueryRequest queryRequest) throws Exception {
        List<String> sqls = formatQueryService.reSqls(queryRequest, "projectTask");
        sqls=this.loadSearchSql(sqls);
        //根据sql查询任务信息
        List<ProjectTaskVO> projectTaskVOS = projectTaskMapper.getProjectTask(sqls.get(0), sqls.get(1), sqls.get(2));
        //查询总数
        Long total = projectTaskMapper.getProjectTaskCount(sqls.get(0));
        //装载事件信息
        this.loadProjectTask(projectTaskVOS);
        Records records = new Records();
        records.setCurrent(queryRequest.getCurrent());
        records.setSize(queryRequest.getSize());
        records.setData(projectTaskVOS);
        records.setTotal(total);
        return records;
    }

    /**
     * 装载任务
     *
     * @param projectTaskVOS
     * @throws IOException
     */
    public void loadProjectTask(List<ProjectTaskVO> projectTaskVOS) throws IOException {
        List<String> createIds = new ArrayList<>();
        List<String> handlerIds = new ArrayList<>();
        List<Integer> projectIds = new ArrayList<>();
        projectTaskVOS.forEach(
                item -> {
                    if (item.getCreateId() != null) {
                        createIds.add(item.getCreateId());
                    }
                    if (item.getHandler() != null && item.getHandlerType() != null && item.getHandlerType().equals(0)) {
                        handlerIds.add(item.getHandler());
                    }
                    if (item.getProjectId() != null) {
                        projectIds.add(item.getProjectId());
                    }
                }
        );
        List<Personnel> personnels = new ArrayList<>();
        List<Personnel> personnels2 = new ArrayList<>();
        //查询发起人名称
        if (createIds.size() != 0) {
            String res = permissionService.getPersonnelByIdsFromPCS(createIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }
        //查询负责人名称
        if (handlerIds.size() != 0) {
            String res = permissionService.getPersonnelByIdsFromPCS(handlerIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels2 = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }
        //根据报告ids查询项目信息
        List<Project> projects = new ArrayList<>();
        if (!projectIds.isEmpty()) {
            projects = this.getProjectInfo(projectIds);
        }
        //装载信息
        for (ProjectTaskVO projectTaskVO : projectTaskVOS) {
            Integer handlerType = projectTaskVO.getHandlerType();
            //装载人员信息
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(projectTaskVO.getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                projectTaskVO.setCreateName(personnel.getPersonnelName());
            }

            if (handlerType != null && handlerType.equals(0)) {
                Personnel personnel2 = personnels2.stream().filter(item -> item.getId().equals(projectTaskVO.getHandler())).findFirst().orElse(null);
                if (personnel2 != null) {
                    projectTaskVO.setHandlerName(personnel2.getPersonnelName());
                }
            } else {
                projectTaskVO.setHandlerName(projectTaskVO.getHandler());
            }


            String name = patentDigProjectFilesService.getProcessName(projectTaskVO.getProcessId());
            projectTaskVO.setProcessName(name);
            Project project = projects.stream().filter(item -> item.getId().equals(projectTaskVO.getProjectId())).findFirst().orElse(null);
            if (project != null) {
                projectTaskVO.setProjectName(project.getName());
                projectTaskVO.setProjectType(project.getType());
                if (project.getType().equals(2)) {//报告
                    LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.eq(ReportProject::getProjectId, projectTaskVO.getProjectId());
                    ReportProject reportProject = reportProjectService.getOne(queryWrapper, false);
                    if (reportProject != null) {
                        projectTaskVO.setReportType(reportProject.getReportType());
                    }
                }
            }
        }
    }


    /**
     * 根据任务id查询任务详情以及处理结果以及审核历史
     *
     * @param taskId
     * @return
     */
    public TaskDetailsVO getAuditHistory(Integer taskId) throws IOException {
        //新建返回VO类
        TaskDetailsVO taskDetailsVO = new TaskDetailsVO();
        List<HandleResultFileVO> handleResultFileVOS = new ArrayList<>();
        List<AuditHistoryVO> auditHistoryVOS = new ArrayList<>();
        //根据taskId查询此条任务详情
        ProjectTask currentTask = this.getById(taskId);
        //根据此条任务详情获取assoTaskId
        //使用Optional避免空指针异常：使用Optional来处理可能为空的变量，例如currentTask和assoTask。
        Optional<ProjectTask> currentTaskOptional = Optional.ofNullable(currentTask);
        Integer assoTaskId = currentTaskOptional.map(ProjectTask::getAssoTaskId).orElse(null);
        List<ProjectTask> allProjectTasks = new ArrayList<>();
        if (assoTaskId != null) {
            //根据assoTaskId获取最初任务的详情
            LambdaQueryWrapper<ProjectTask> assoTaskWrapper = new LambdaQueryWrapper<>();
            assoTaskWrapper.eq(ProjectTask::getId, assoTaskId);
            ProjectTaskVO projectTaskVO = new ProjectTaskVO();
            ProjectTask assoTask = this.list(assoTaskWrapper).get(0);
            if (assoTask != null) {
                //装载最初任务详情
                BeanUtils.copyProperties(assoTask, projectTaskVO);
                taskDetailsVO.setProjectTaskVO(projectTaskVO);
                if (assoTask.getType() == 7) {
                    //专利挖掘文件任务
                    LambdaQueryWrapper<PatentDigProjectFiles> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.eq(PatentDigProjectFiles::getTaskId, assoTask.getId());
                    List<PatentDigProjectFiles> patentDigProjectFiles = patentDigProjectFilesService.list(queryWrapper);
                    List<String> fileGuids = new ArrayList<>();
                    List<SystemFile> systemFiles = new ArrayList<>();
                    if (!patentDigProjectFiles.isEmpty()) {
                        fileGuids = patentDigProjectFiles.stream().map(PatentDigProjectFiles::getFileGuid).collect(Collectors.toList());
                    }
                    //调用文件系统查询文件信息接口
                    if (!fileGuids.isEmpty()) {
                        String res = fileManagerService.getSystemFileFromFMS(fileGuids);
                        systemFiles = JSONObject.parseArray(res, SystemFile.class);
                    }
                    if (!systemFiles.isEmpty()) {
                        for (PatentDigProjectFiles patentDigProjectFiles1 : patentDigProjectFiles) {
                            HandleResultFileVO handleResultFileVO = new HandleResultFileVO();
                            //装载文件信息
                            SystemFile systemFile = systemFiles.stream().filter(item -> item.getGuid().equals(patentDigProjectFiles1.getFileGuid())).findFirst().orElse(null);
                            if (systemFile != null) {
                                BeanUtils.copyProperties(patentDigProjectFiles1, handleResultFileVO);
                                handleResultFileVO.setGuid(patentDigProjectFiles1.getFileGuid());
                                handleResultFileVO.setType(systemFile.getType());
                                handleResultFileVO.setOriginalName(systemFile.getOriginalName());
                            }
                            handleResultFileVOS.add(handleResultFileVO);
                        }
                    }
                }
                //根据assoTaskId查询所有任务的id
                LambdaQueryWrapper<ProjectTask> allTaskWrapper = new LambdaQueryWrapper<>();
                allTaskWrapper.eq(ProjectTask::getAssoTaskId, assoTaskId);
                allProjectTasks = this.list(allTaskWrapper);
            }
        }
        //审核历史返回VO以及集合
        if (allProjectTasks != null) {
            auditHistoryVOS = allProjectTasks.stream()
                    //过滤筛选掉分配任务的信息
                    .filter(item -> item.getId() != item.getAssoTaskId())
                    .map(item -> {
                        //新建VO
                        AuditHistoryVO auditHistoryVO = new AuditHistoryVO();
                        ProjectTaskVO auditHistoryTaskVO = new ProjectTaskVO();
                        BeanUtils.copyProperties(item, auditHistoryTaskVO);
                        //处理结果VO
                        TaskHandleResultVO taskHandleResultVO = new TaskHandleResultVO();
                        LambdaQueryWrapper<TaskHandleResult> queryWrapper = new LambdaQueryWrapper<>();
                        queryWrapper.eq(TaskHandleResult::getTaskId, item.getId());
                        List<TaskHandleResult> taskHandleResults = taskHandleResultService.list(queryWrapper);
                        if (taskHandleResults.size() != 0) {
                            TaskHandleResult taskHandleResult = taskHandleResults.get(0);
                            if (taskHandleResult != null) {
                                BeanUtils.copyProperties(taskHandleResult, taskHandleResultVO);
                                auditHistoryVO.setProjectTaskVO(auditHistoryTaskVO);
                                auditHistoryVO.setTaskHandleResultVO(taskHandleResultVO);
                                return auditHistoryVO;
                            }
                        }
                        return null;//返回空值不装到列表中
                    })
                    //过滤掉空对象
                    .filter(Objects::nonNull)
                    .sorted(Comparator.comparing(
                            a -> a.getTaskHandleResultVO(),
                            Comparator.nullsLast(Comparator.comparing(TaskHandleResultVO::getCreateTime, Comparator.reverseOrder()))))
                    .collect(Collectors.toList());

            taskDetailsVO.setAuditHistoryVOS(auditHistoryVOS);
        }
        //全部的文件信息(获取所有的任务的id，查出所有的结果id)
        List<Integer> allTaskIds = allProjectTasks.stream().map(ProjectTask::getId).collect(Collectors.toList());
        LambdaQueryWrapper<TaskHandleResult> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(TaskHandleResult::getTaskId, allTaskIds);
        List<TaskHandleResult> taskHandleResults = taskHandleResultService.list(queryWrapper);

        List<Integer> resultIds = new ArrayList<>();
        if (taskHandleResults != null && !taskHandleResults.isEmpty()) {
            resultIds = taskHandleResults.stream().map(TaskHandleResult::getId).collect(Collectors.toList());
        }
        //根据所有的结果ids查询所有fileGuids
        if (resultIds != null && !resultIds.isEmpty()) {
            LambdaQueryWrapper<AssoHandleResultFile> allGuidsWrapper = new LambdaQueryWrapper<>();
            allGuidsWrapper.in(AssoHandleResultFile::getTaskHandleResultId, resultIds);
            List<AssoHandleResultFile> assoHandleResultFiles = assoHandleResultFileService.list(allGuidsWrapper);
            List<String> fileGuids = new ArrayList<>();
            List<SystemFile> systemFiles = new ArrayList<>();
            if (!assoHandleResultFiles.isEmpty()) {
                fileGuids = assoHandleResultFiles.stream().map(AssoHandleResultFile::getFileGuid).collect(Collectors.toList());
            }
            //调用文件系统查询文件信息接口
            if (!fileGuids.isEmpty()) {
                String res = fileManagerService.getSystemFileFromFMS(fileGuids);
                systemFiles = JSONObject.parseArray(res, SystemFile.class);
            }
            if (!systemFiles.isEmpty()) {
                for (AssoHandleResultFile assoHandleResultFile : assoHandleResultFiles) {
                    HandleResultFileVO handleResultFileVO = new HandleResultFileVO();
                    //装载文件信息
                    SystemFile systemFile = systemFiles.stream().filter(item -> item.getGuid().equals(assoHandleResultFile.getFileGuid())).findFirst().orElse(null);
                    if (systemFile != null) {
                        BeanUtils.copyProperties(assoHandleResultFile, handleResultFileVO);
                        handleResultFileVO.setGuid(assoHandleResultFile.getFileGuid());
                        handleResultFileVO.setType(systemFile.getType());
                        handleResultFileVO.setOriginalName(systemFile.getOriginalName());
                    }
                    handleResultFileVOS.add(handleResultFileVO);
                }
            }
        }
        taskDetailsVO.setSystemFileList(handleResultFileVOS.stream()
                .sorted(Comparator.comparing(HandleResultFileVO::getCreateTime).reversed())
                .collect(Collectors.toList()));
        //装载名称
        this.loadTaskDetails(taskDetailsVO);
        return taskDetailsVO;
    }

    /**
     * 装载任务详情的集合
     *
     * @param taskDetailsVO
     * @throws IOException
     */
    public void loadTaskDetails(TaskDetailsVO taskDetailsVO) throws IOException {
        //装载项目名称
        Integer projectId = null;
        if (taskDetailsVO.getProjectTaskVO() != null) {
            projectId = taskDetailsVO.getProjectTaskVO().getProjectId();
        }
        if (projectId != null) {
            //根据项目id查询项目名称并装载
            LambdaQueryWrapper<PatentDigProject> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(PatentDigProject::getProjectId, projectId);
            List<PatentDigProject> patentDigProjects = patentDigProjectService.list(queryWrapper);
            if (patentDigProjects != null && patentDigProjects.size() != 0) {
                PatentDigProject patentDigProject = patentDigProjects.get(0);
                String projectName = patentDigProject.getName();
                taskDetailsVO.getProjectTaskVO().setProjectName(projectName);
            }
        }
        //新建人员id集合
        List<String> createIds = new ArrayList<>();
        //添加分配任务的创建人id
        if (taskDetailsVO.getProjectTaskVO().getCreateId() != null) {
            createIds.add(taskDetailsVO.getProjectTaskVO().getCreateId());
        }
        //添加分配任务的负责人id
        if (taskDetailsVO.getProjectTaskVO().getHandler() != null) {
            createIds.add(taskDetailsVO.getProjectTaskVO().getHandler());
        }
        //添加文件上传人的id
        taskDetailsVO.getSystemFileList().forEach(
                item -> {
                    if (item.getCreateId() != null) {
                        createIds.add(item.getCreateId());
                    }
                }
        );
        //添加审查历史中的人员id
        taskDetailsVO.getAuditHistoryVOS().forEach(
                item -> {
                    if (item.getProjectTaskVO() != null) {
                        if (item.getProjectTaskVO().getCreateId() != null) {
                            createIds.add(item.getProjectTaskVO().getCreateId());
                        }
                        if (item.getProjectTaskVO().getHandler() != null) {
                            createIds.add(item.getProjectTaskVO().getHandler());
                        }
                    }
                    if (item.getTaskHandleResultVO() != null) {
                        if (item.getTaskHandleResultVO().getCreateId() != null) {
                            createIds.add(item.getTaskHandleResultVO().getCreateId());
                        }
                    }
                }
        );
        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);
        }
        //装载人员信息
        //分配任务的创建人name
        if (taskDetailsVO.getProjectTaskVO() != null) {
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(taskDetailsVO.getProjectTaskVO().getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                taskDetailsVO.getProjectTaskVO().setCreateName(personnel.getPersonnelName());
            } else {
                throw new XiaoShiException("未获取到分配任务的创建人id信息");
            }
            //分配任务的负责人name
            Personnel personnel1 = personnels.stream().filter(item -> item.getId().equals(taskDetailsVO.getProjectTaskVO().getHandler())).findFirst().orElse(null);
            if (personnel1 != null) {
                taskDetailsVO.getProjectTaskVO().setHandlerName(personnel1.getPersonnelName());
            } else {
                throw new XiaoShiException("未获取到分配任务的负责人id信息");
            }
        }
        //装载所有文件的上传人name
        for (HandleResultFileVO handleResultFileVO : taskDetailsVO.getSystemFileList()) {
            if (handleResultFileVO != null) {
                Personnel personnel2 = personnels.stream().filter(item -> item.getId().equals(handleResultFileVO.getCreateId())).findFirst().orElse(null);
                if (personnel2 != null) {
                    handleResultFileVO.setCreateName(personnel2.getPersonnelName());
                } else {
                    throw new XiaoShiException("未获取到所有文件上传人id信息");
                }
            }
        }
        //装载所有审查历史中的人员name
        for (AuditHistoryVO auditHistoryVO : taskDetailsVO.getAuditHistoryVOS()) {
            if (auditHistoryVO.getProjectTaskVO() != null) {
                Personnel personnel3 = personnels.stream().filter(item -> item.getId().equals(auditHistoryVO.getProjectTaskVO().getCreateId())).findFirst().orElse(null);
                if (personnel3 != null) {
                    auditHistoryVO.getProjectTaskVO().setCreateName(personnel3.getPersonnelName());
                } else {
                    throw new XiaoShiException("未获取到分配任务的负责人id信息");
                }
                Personnel personnel4 = personnels.stream().filter(item -> item.getId().equals(auditHistoryVO.getProjectTaskVO().getHandler())).findFirst().orElse(null);
                if (personnel4 != null) {
                    auditHistoryVO.getProjectTaskVO().setHandlerName(personnel4.getPersonnelName());
                } else {
                    throw new XiaoShiException("未获取到分配任务的负责人id信息");
                }
            }
            if (auditHistoryVO.getTaskHandleResultVO() != null) {
                Personnel personnel5 = personnels.stream().filter(item -> item.getId().equals(auditHistoryVO.getTaskHandleResultVO().getCreateId())).findFirst().orElse(null);
                if (personnel5 != null) {
                    auditHistoryVO.getTaskHandleResultVO().setCreateName(personnel5.getPersonnelName());
                } else {
                    throw new XiaoShiException("未获取到分配任务的负责人id信息");
                }
            }
        }

    }

    /**
     * 取消/完成任务
     *
     * @param taskId
     * @param type
     */
    public void finishTask(Integer taskId, Integer type) {
        //处理人直接完成任务
        LambdaQueryWrapper<ProjectTask> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ProjectTask::getId, taskId);
        ProjectTask projectTask = this.getOne(queryWrapper, false);
        if (projectTask != null) {
            //查询出当前任务的类型
            //如果是分配任务/或者协同任务
            if (projectTask.getType() == 6) {
                //类型为0，需要完成任务
                if (type == 0) {
                    //完成需要判断不为审核中
                    if (projectTask.getStatus() != 1) {
                        projectTask.setStatus(3);
                        projectTask.updateById();
                    } else {
                        throw new XiaoShiException("任务状态为审核中，不可以完成");
                    }
                } else if (type == 1) {
                    //类型为1，取消任务
                    projectTask.setStatus(5);
                    projectTask.updateById();
                    //所关联的审核任务的状态为处理中的设置为取消
                    //根据assoTaskId查询出所有任务，过滤状态为处理中的
                    Integer assoTaskId = projectTask.getAssoTaskId();
                    if (assoTaskId != null) {
                        LambdaQueryWrapper<ProjectTask> queryWrapper1 = new LambdaQueryWrapper<>();
                        queryWrapper1.eq(ProjectTask::getAssoTaskId, assoTaskId).eq(ProjectTask::getStatus, 2);
                        List<ProjectTask> projectTasks1 = this.list(queryWrapper1);
                        if (!projectTasks1.isEmpty()) {
                            projectTasks1.forEach(item -> {
                                item.setStatus(5);
                            });
                            this.updateBatchById(projectTasks1);
                        }
                    }
                }
                //开卷审核项目(判断是报告还是挖掘项目)
            } else if (projectTask.getType() == 1) {
                Integer projectId = projectTask.getProjectId();
                //根据projectId查询类型
                LambdaQueryWrapper<Project> getType = new LambdaQueryWrapper<>();
                getType.eq(Project::getId, projectId);
                Project project = projectService.getOne(getType, false);
                Integer projectType = project.getType();
                //挖掘项目
                if (projectType != null && projectType.equals(3)) {
                    LambdaQueryWrapper<PatentDigProject> queryWrapper1 = new LambdaQueryWrapper<>();
                    queryWrapper1.eq(PatentDigProject::getProjectId, projectId);
                    PatentDigProject patentDigProject = patentDigProjectService.getOne(queryWrapper1, false);
                    if (patentDigProject != null) {
                        if (type == 0) {
                            //直接同意
                            projectTask.setStatus(3);
                            projectTask.updateById();
                            patentDigProject.setState(2);
                            patentDigProject.updateById();
                        } else if (type == 1) {
                            //取消
                            projectTask.setStatus(5);
                            projectTask.updateById();
                            patentDigProject.setState(4);
                            patentDigProject.updateById();
                        } else if (type == 2) {
                            //缺少资料
                            projectTask.setStatus(4);
                            projectTask.updateById();
                            patentDigProject.setState(5);
                            patentDigProject.updateById();
                        }
                    } else {
                        throw new XiaoShiException("未查询到专利挖掘项目");
                    }
                } else if (projectType != null && projectType.equals(2)) {//报告
                    LambdaQueryWrapper<ReportProject> queryWrapper1 = new LambdaQueryWrapper<>();
                    queryWrapper1.eq(ReportProject::getProjectId, projectId);
                    ReportProject reportProject = reportProjectService.getOne(queryWrapper1, false);
                    if (reportProject != null) {
                        if (type == 0) {
                            //直接同意
                            projectTask.setStatus(3);
                            projectTask.updateById();
                            reportProject.setStatus(2);
                            reportProject.updateById();
                        } else if (type == 1) {
                            //取消
                            projectTask.setStatus(5);
                            projectTask.updateById();
                            reportProject.setStatus(4);
                            reportProject.updateById();
                        } else if (type == 2) {
                            //缺少资料
                            projectTask.setStatus(4);
                            projectTask.updateById();
                            reportProject.setStatus(5);
                            reportProject.updateById();
                        }
                    } else {
                        throw new XiaoShiException("未查询到报告");
                    }
                }
            }
            //处理协同任务完成
            else if (projectTask.getType() == 4) {
                //获得请求人
                PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
                if (type == 0) {
                    //判断请求人是否为创建人
                    if (personnelVO.getId() != null && personnelVO.getId().equals(projectTask.getCreateId())) {
                        projectTask.setStatus(3);
                        projectTask.updateById();
                    } else {
                        projectTask.setStatus(6);
                        projectTask.updateById();
                    }
                } else if (type == 1) {
                    projectTask.setStatus(5);
                    projectTask.updateById();
                }

            } else {
                if (type.equals(1)) {
                    projectTask.setStatus(5);
                    projectTask.updateById();
                }
            }
        } else {
            throw new XiaoShiException("该任务不存在");
        }
    }

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

    @Override
    public Object deleteMessage(List<Integer> ids) throws IOException {
        return null;
    }

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

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

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

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

    public List<Project> getProjectInfo(List<Integer> projectIds) {
        LambdaQueryWrapper<Project> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(Project::getId, projectIds);
        List<Project> projects = projectService.list(queryWrapper);
        if (!projects.isEmpty()) {
            projects.forEach(item -> {
                Integer type = item.getType();
                if (type == 3) {
                    //挖掘项目
                    LambdaQueryWrapper<PatentDigProject> queryWrapper1 = new LambdaQueryWrapper<>();
                    queryWrapper1.eq(PatentDigProject::getProjectId, item.getId());
                    PatentDigProject patentDigProject = patentDigProjectService.getOne(queryWrapper1, false);
                    item.setName(patentDigProject.getName());
                }
            });
        }
        return projects;
    }

    /**
     * 添加侵权分析协同任务
     */
    public Integer addTortTask(TortTaskDTO tortTaskDTO) {
        //1.保存任务信息 project_task表
        if (tortTaskDTO == null) {
            throw new XiaoShiException("入参不能为空！");
        }
        //判断报告id不为空
        if (tortTaskDTO.getProjectId() == null) {
            throw new XiaoShiException("报告id不能为空!");
        }
        //判断协同人员类型不为空
        if (tortTaskDTO.getHandlerType() == null) {
            throw new XiaoShiException("协同人员类型不能为空!");
        }
        //判断任务名称不为空
        tortTaskDTO.setName(tortTaskDTO.getName().trim());
        String name = tortTaskDTO.getName();
        if (name == null || name.equals("")) {
            throw new XiaoShiException("任务名称不能为空!");
        }
        tortTaskDTO.setType(4);
        //获取登录人信息
        PersonnelVO personnelVO = new PersonnelVO();
        try {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }
        ProjectTask projectTask = new ProjectTask();
        BeanUtils.copyProperties(tortTaskDTO, projectTask);
        projectTask.setCreateId(personnelVO.getId());
        projectTask.setStatus(2);
        projectTask.insert();
        Integer taskId = projectTask.getId();
        //2.保存任务和人员关联表信息
        if (taskId != null) {
            List<CCPerson> ccPeople = tortTaskDTO.getCcPeople();
            this.addTaskAndCCPeople(personnelVO.getId(), taskId, ccPeople);
        } else {
            throw new XiaoShiException("创建任务失败，未读取到任务id");
        }
        //3.从侵权分析中获得对比结果，并复制保存
        tortCompareRecordService.copyTortCompareRecords(tortTaskDTO.getProjectId(), taskId, personnelVO.getId());
        //4.发送邮件通知协同人和抄送人
        //TODO
        return projectTask.getId();
    }

    /**
     * 保存任务和人员关联表信息
     *
     * @param taskId
     * @param ccPeople
     */
    public void addTaskAndCCPeople(String createId, Integer taskId, List<CCPerson> ccPeople) {
        if (createId == null && createId.equals("")) {
            throw new XiaoShiException("createId不能为空");
        }
        if (taskId == null) {
            throw new XiaoShiException("taskId不能为空");
        }
        if (ccPeople != null && !ccPeople.isEmpty()) {
            List<AssoTaskPerson> assoTaskPeople = new ArrayList<>();
            ccPeople.forEach(item -> {
                AssoTaskPerson assoTaskPerson = new AssoTaskPerson();
                assoTaskPerson.setPersonId(item.getPersonId());
                assoTaskPerson.setIfInner(item.getIfInner());
                assoTaskPerson.setTaskId(taskId);
                assoTaskPerson.setCreateId(createId);
                assoTaskPeople.add(assoTaskPerson);
            });
            assoTaskPersonService.saveBatch(assoTaskPeople);
        }
    }

    /**
     * 根据任务id查询专利号
     *
     * @param taskId
     * @return
     */
    public String getPatentNoByTaskId(Integer taskId) {
        //根据任务id查询报告id
        if (taskId == null) {
            throw new XiaoShiException("taskId不能为空");
        }
        Integer projectId = tortCompareRecordService.getProjectIdByTaskId(taskId);
        String patentNo = this.getPatentNoByProjectId(projectId);
        return patentNo;
    }

    /**
     * 根据projectId查询专利号
     *
     * @param projectId
     * @return
     */
    public String getPatentNoByProjectId(Integer projectId) {
        //根据报告id查询专利号
        LambdaQueryWrapper<ReportProject> queryWrapper1 = new LambdaQueryWrapper<>();
        queryWrapper1.eq(ReportProject::getProjectId, projectId);
        ReportProject reportProject = reportProjectService.getOne(queryWrapper1, false);
        if (reportProject != null) {
            String patentNo = reportProject.getSignPatentNo();
            return patentNo;
        } else {
            throw new XiaoShiException("报告为空");
        }
    }

    /**
     * 侵权分析报告开卷审核任务
     *
     * @param reportAuditTaskDTO
     * @return
     */
    public Object addReportOpenAuditTask(ReportAuditTaskDTO reportAuditTaskDTO) {
        ReportProjectDTO reportProjectDTO = reportAuditTaskDTO.getReportProjectDTO();
        ProjectTaskDTO projectTaskDTO = reportAuditTaskDTO.getProjectTaskDTO();
        //如果报告DTO不为空，则需要先建立报告
        if (reportProjectDTO != null) {
            Integer projectId = (Integer) reportProjectService.addMessage(reportProjectDTO);
            if (projectId != null) {
                projectTaskDTO.setProjectId(projectId);
                Integer projectTaskId = this.addTask(projectTaskDTO);
                if (projectTaskId != null) {
                    //将侵权分析报告置为开卷审核
                    LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
                    queryWrapper.eq(ReportProject::getProjectId, projectId);
                    ReportProject reportProject = reportProjectService.getOne(queryWrapper, false);
                    reportProject.setStatus(0);
                    reportProject.updateById();
                }
                return projectTaskId;
            } else {
                throw new XiaoShiException("侵权分析报告新增失败");
            }
        } else {
            throw new XiaoShiException("侵权分析报告数据不能为空！");
        }
    }

    @Transactional(rollbackFor = Exception.class)
    public List<Integer> addMarkTask(MarkTaskDTO markTaskDTO) throws Exception {
        Integer projectId = markTaskDTO.getProjectId();
        List<MarkTaskDTO.MarkedField> markedFields = markTaskDTO.getMarkedFields();
        //获取人员专利
        List<PersonAssignedDTO> personAssignedDTOList = markTaskDTO.getPersonAssignedDTOList();
        //获取任务类型
        Integer taskType = markTaskDTO.getTaskType();
        //获取任务名称
        String taskName = markTaskDTO.getName();
        //获得截止时间
        Date deadLineTime = markTaskDTO.getDeadLineTime();
        List<Integer> ids = new ArrayList<>();
        StringRequest stringRequest = markTaskDTO.getStringRequest();
        //过滤出已经添加的专利
        PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        //添加任务批次
        TaskBatch taskBatch = new TaskBatch();
        taskBatch.setCreateId(personnelVO.getId());
        taskBatch.insert();

        Integer taskBatchId = taskBatch.getId();

        List<String> patentNos = new ArrayList<>();
        List<Integer> nums = new ArrayList<>();
        personAssignedDTOList.forEach(item -> {
            if (item.getPatentNos() != null && item.getPatentNos().size() != 0) {
                patentNos.addAll(item.getPatentNos());
            } else {
                if (item.getPatentNum() != null) {
                    nums.add(item.getPatentNum());
                }
            }
        });


        Integer current = 0;
        for (PersonAssignedDTO item : personAssignedDTOList) {
            List<String> addPatentNos = new ArrayList<>();
            //创建任务
            ProjectTaskDTO projectTaskDTO = new ProjectTaskDTO();
            projectTaskDTO.setType(taskType);
            projectTaskDTO.setName(taskName);
            projectTaskDTO.setDeadLineTime(deadLineTime);
            projectTaskDTO.setHandler(item.getPersonId());
            projectTaskDTO.setHandlerType(0);
            projectTaskDTO.setProjectId(projectId);
            Integer taskId = this.addTask(projectTaskDTO);
            ids.add(taskId);
            //添加任务和标引关联
            this.addAssoTaskField(markedFields, taskId, taskBatchId, projectId);
            //根据检索式和已经添加的专利以及位置获得专利
            if (item.getPatentNos() == null || item.getPatentNos().size() == 0) {
                if (nums.size() > 0) {
                    Integer num = nums.remove(0);
                    stringRequest.setCurrent(Long.parseLong(current.toString()));
                    stringRequest.setSize(Long.parseLong(num.toString()));
                    stringRequest.setProjectId(projectId);
                    current += num;
                    List<Patent> patentList = esPatentService.getPatentsWithNotNo(stringRequest, patentNos);
                    addPatentNos = patentList.stream().map(Patent::getPatentNo).collect(Collectors.toList());
                }
            } else {
                addPatentNos = item.getPatentNos();
            }
            //添加专利
            this.addCompareLiteratureByNosToEs(addPatentNos, taskId, projectId);
        }
        return ids;
    }

    //添加对比文献和专利号关联
    private void addCompareLiteratureByNos(List<String> patentNos, Integer taskId, Integer projectId) {
        List<CompareLiterature> compareLiteratures = new ArrayList<>();
        if (patentNos == null || patentNos.size() == 0) {
            return;
        } else {
            patentNos.forEach(item -> {
                CompareLiterature compareLiterature = new CompareLiterature();
                compareLiterature.setLiteratureNo(item);
                compareLiterature.setProjectId(projectId);
                compareLiterature.setName(item);
                compareLiteratures.add(compareLiterature);
            });
        }
        compareLiteratureService.saveBatch(compareLiteratures);
    }


    /**
     * 添加FTO协同任务
     *
     * @param tortTaskDTO
     * @return
     */
    public Integer addFTOAssitTask(TortTaskDTO tortTaskDTO) {
        //1.保存任务信息 project_task表
        if (tortTaskDTO == null) {
            throw new XiaoShiException("入参不能为空！");
        }
        //判断报告id不为空
        Integer projectId = tortTaskDTO.getProjectId();
        if (projectId == null) {
            throw new XiaoShiException("报告id不能为空!");
        }
        //判断协同人员类型不为空
        if (tortTaskDTO.getHandlerType() == null) {
            throw new XiaoShiException("协同人员类型不能为空!");
        }
        //判断任务名称不为空
        tortTaskDTO.setName(tortTaskDTO.getName().trim());
        String name = tortTaskDTO.getName();
        if (name == null || name.equals("")) {
            throw new XiaoShiException("任务名称不能为空!");
        }
        tortTaskDTO.setType(4);
        //获取登录人信息
        PersonnelVO personnelVO = new PersonnelVO();
        try {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }
        ProjectTask projectTask = new ProjectTask();
        BeanUtils.copyProperties(tortTaskDTO, projectTask);
        projectTask.setCreateId(personnelVO.getId());
        projectTask.setStatus(2);
        projectTask.insert();
        Integer taskId = projectTask.getId();
        //2.compareLiterature入库
        List<String> patentNos = tortTaskDTO.getPatentNos();
        if (!patentNos.isEmpty()) {
            try {
                this.addCompareLiteratureByNosToEs(patentNos, taskId, projectId);
                //3.从侵权分析中获得对比结果，并复制保存
                //taskId是协同任务id
                ftoCompareRecordService.copyFTOCompareRecords(tortTaskDTO.getProjectId(), taskId, personnelVO.getId(), patentNos);
            } catch (Exception e) {
                throw new XiaoShiException(e.toString());
            }
        }
        //4.保存任务和人员关联表信息
        if (taskId != null) {
            List<CCPerson> ccPeople = tortTaskDTO.getCcPeople();
            this.addTaskAndCCPeople(personnelVO.getId(), taskId, ccPeople);
            //发送给抄送人
            for (CCPerson item : ccPeople) {
                mailSendService.sentToCCMail(item.getPersonId(), item.getIfInner(), personnelVO.getId());
            }
        } else {
            throw new XiaoShiException("创建任务失败，未读取到任务id");
        }
        //5.发送邮件通知协同人
        //获取code码
        String code = taskCodeService.addTaskCode(taskId);
        Boolean ifInner = true;
        if (tortTaskDTO.getHandlerType() == 0) {
            ifInner = true;
        } else {
            ifInner = false;
        }
        LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ReportProject::getProjectId, projectId);
        ReportProject reportProject = reportProjectService.getOne(queryWrapper, false);
        Integer reportType = null;
        if (reportProject != null) {
            reportType = reportProject.getReportType();
        }
        mailSendService.sendSynery(projectTask.getHandler(), ifInner, projectId, taskId, reportType, code);
        return projectTask.getId();
    }

    /**
     * 添加任务与专利关联到ES
     *
     * @param patentNos
     * @param taskId
     * @param projectId
     * @throws Exception
     */
    private void addCompareLiteratureByNosToEs(List<String> patentNos, Integer taskId, Integer projectId) throws Exception {
        if (patentNos == null || patentNos.size() == 0) {
            return;
        } else {
            patentNos.forEach(item -> {
                //根据专利号查询专利
                PatentWithIdVO patentWithIdVO = null;
                try {
                    patentWithIdVO = esService.getIdByPatentNo(item);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                if (patentWithIdVO != null) {
                    String id = patentWithIdVO.getId();
                    if (id != null || !id.trim().equals("")) {
                        Patent patent = new Patent();
                        EsProjectTask esProjectTask = new EsProjectTask();
                        esProjectTask.setProjectId(projectId);
                        esProjectTask.setTaskId(taskId);
                        PatentJoin patentJoin = new PatentJoin();
                        patentJoin.setParent(id);
                        patentJoin.setName("task");
                        patent.setPatentJoin(patentJoin);
                        patent.setProjectTask(esProjectTask);
                        try {
                            esService.addChildPatent(patent, id);
                        } catch (Exception e) {
                        }
                    }
                }
            });
        }
    }


    private void addAssoTaskField(List<MarkTaskDTO.MarkedField> markedFields, Integer taskId, Integer batchId, Integer projectId) {
        List<AssoTaskField> assoTaskFields = new ArrayList<>();
        if (markedFields == null || markedFields.size() == 0) {
            //根据projectId 查询所有标引栏位
            List<AllCustomFieldVO> customFieldVOS = customFieldService.getAllProjectCustomField(projectId);
            if (customFieldVOS != null && customFieldVOS.size() > 0) {
                customFieldVOS.forEach(item -> {
                    AssoTaskField assoTaskField = new AssoTaskField();
                    assoTaskField.setFieldId(item.getId());
                    assoTaskField.setFieldType(item.getType());
                    assoTaskField.setTaskId(taskId);
                    assoTaskField.setProjectId(batchId);
                    assoTaskField.setProjectId(projectId);
                    assoTaskFields.add(assoTaskField);
                });
            }
        } else {
            markedFields.forEach(item -> {
                AssoTaskField assoTaskField = new AssoTaskField();
                assoTaskField.setFieldId(item.getFieldId());
                assoTaskField.setFieldType(item.getFieldType());
                assoTaskField.setTaskId(taskId);
                assoTaskField.setProjectId(batchId);
                assoTaskField.setProjectId(projectId);
                assoTaskFields.add(assoTaskField);
            });

        }
        assoTaskFieldService.saveBatch(assoTaskFields);
    }

    public Optional<ProjectTask> getByIdOpt(Integer id) {
        ProjectTask projectTask = projectTaskMapper.selectById(id);
        return Optional.ofNullable(projectTask);
    }

    /**
     *
     */
    public void getPatent(String patentNo, Integer taskId) {


    }

    /**
     * 更新任务
     * @param updateProjectTaskDTO
     * @return
     */
    public Integer updateTask(UpdateProjectTaskDTO updateProjectTaskDTO){
        if (updateProjectTaskDTO == null) {
            throw new XiaoShiException("入参为空");
        }
        Integer id = updateProjectTaskDTO.getId();
        ProjectTask projectTask = this.getById(id);
        if (projectTask != null) {
            BeanUtils.copyProperties(updateProjectTaskDTO, projectTask);
            projectTask.updateById();
        }
        return projectTask.getId();
    }
    //装载查询语句
    private List<String> loadSearchSql(List<String> sqls){
        PersonnelVO personnelVO =cacheUtils.getLoginUser(loginUtils.getId());
        String id =personnelVO.getId();
        String rootSql ="(create_id ="+id+" or handler="+id+")";
        if(sqls.get(0)!=null&&!sqls.get(0).equals(""))
        {
            sqls.set(0,rootSql+" and"+"("+sqls.get(0)+")");

        }
        else {
            sqls.set(0,rootSql);
        }

        return sqls;

    }
}