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

package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.ClientDTO;
import cn.cslg.pas.common.dto.business.*;
import cn.cslg.pas.common.model.cronModel.*;
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.DepartmentVO;

import cn.cslg.pas.common.vo.ProductOrCategoryVO;
import cn.cslg.pas.common.vo.business.PatentProjectVO;
import cn.cslg.pas.common.vo.business.ReportCountVO;
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.factorys.reGroupFactory.QueryGroupFactory;
import cn.cslg.pas.factorys.reGroupFactory.QueryGroupImp;
import cn.cslg.pas.mapper.PatentProjectMapper;
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.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.extern.slf4j.Slf4j;
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.multipart.MultipartFile;

import java.io.IOException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;


@Service
@Slf4j
public class PatentProjectService extends ServiceImpl<PatentProjectMapper, PatentProject> implements Business {

    @Autowired
    private PatentProjectMapper patentProjectMapper;

    @Autowired
    private FormatQueryService formatQueryService;

    @Autowired
    private QueryGroupFactory queryGroupFactory;

    @Autowired
    private CacheUtils cacheUtils;

    @Autowired
    private LoginUtils loginUtils;

    @Autowired
    private PermissionService permissionService;

    @Autowired
    private AssoProjectEventService assoProjectEventService;

    @Autowired
    private AssoProjectTreeNodeService assoProjectTreeNodeService;

    @Autowired
    private AssoProjectFileService assoProjectFileService;

    @Autowired
    private FileManagerService fileManagerService;

    @Autowired
    private AssoProjectService assoProjectService;

    @Autowired
    private EventService eventService;

    @Autowired
    private ScenarioService scenarioService;

    @Autowired
    private MatterService matterService;

    @Autowired
    private ProductService productService;

    @Autowired
    private ProductCategoryService productCategoryService;

    @Autowired
    private ProjectService projectService;

    @Autowired
    private AssoProjectScenarioService assoProjectScenarioService;

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object queryMessage(QueryRequest queryRequest) throws Exception {

        List<String> sqls = formatQueryService.reSqls(queryRequest, "patentProject");
        sqls =this.loadSearchSql(sqls);
        //根据sql查询专题库信息
        List<PatentProjectVO> patentProjectVOS = patentProjectMapper.getPatentProject(sqls.get(0), sqls.get(1), sqls.get(2));
        Long total = patentProjectMapper.getPatentProjectCount(sqls.get(0));
        //装载专利数据库信息
        this.loadPatentProject(patentProjectVOS);
        Records records = new Records();
        records.setCurrent(queryRequest.getCurrent());
        records.setSize(queryRequest.getSize());
        records.setData(patentProjectVOS);
        records.setTotal(total);
        return records;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Integer addMessage(Object object, List<MultipartFile> files) {

        return null;
    }

    /**
     * @param object
     * @param files
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object updateMessage(Object object, List<MultipartFile> files) {


        return null;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object deleteMessage(List<Integer> ids) throws IOException {
        //TODO 检查是否有关联报告，如果有则提示不允许删除
        LambdaQueryWrapper<AssoProject> reportExistWrapper = new LambdaQueryWrapper<>();
        reportExistWrapper.in(AssoProject::getProjectId, ids);
        reportExistWrapper.eq(AssoProject::getAssoProjectType, 2);
        List<AssoProject> assoProjects = assoProjectService.list(reportExistWrapper);
        if (assoProjects.size() != 0) {
            throw new XiaoShiException("待删除专题库集合中有关联报告，无法删除！");
        }
        //TODO 根据id删除专利数据库和文件关联表
        LambdaQueryWrapper<AssoProjectFile> deleteFileWrapper = new LambdaQueryWrapper<>();
        deleteFileWrapper.in(AssoProjectFile::getProjectId, ids);
        assoProjectFileService.remove(deleteFileWrapper);
        //TODO 根据id删除专利数据库和事件的关联表
        LambdaQueryWrapper<AssoProjectEvent> deleteEventWrapper = new LambdaQueryWrapper<>();
        deleteEventWrapper.in(AssoProjectEvent::getProjectId, ids);
        assoProjectEventService.remove(deleteEventWrapper);
        //TODO 根据id删除专利数据库的自定义字段的标引（es部分，暂时不做）

        //TODO 根据id删除专利数据库的自定义字段（自定义字段模块未完成，暂时不做)

        //TODO 根据id删除专利数据库和应用场景关联
        LambdaQueryWrapper<AssoProjectScenario> deleteScenarioWrapper = new LambdaQueryWrapper<>();
        deleteScenarioWrapper.in(AssoProjectScenario::getProjectId, ids);
        assoProjectScenarioService.remove(deleteScenarioWrapper);
        //TODO 根据id删除任务信息（任务模块未完成，暂时不做）

        //TODO 根据id删除任专利关联信息（es部分，暂时不做）

        //TODO 根据id删除导入任务信息（导入任务模块未完成，暂时不做）

        //删除专利数据库
        LambdaQueryWrapper<PatentProject> patentProjectLambdaQueryWrapper = new LambdaQueryWrapper<>();
        patentProjectLambdaQueryWrapper.in(PatentProject::getProjectId, ids);
        this.remove(patentProjectLambdaQueryWrapper);
        projectService.removeBatchByIds(ids);

        //
        return ids;
    }

    /**
     * 查询专题库分组信息
     *
     * @param groupRequest
     * @return
     * @throws Exception
     */
    @Transactional(rollbackFor = Exception.class)
    public Object getGroup(GroupRequest groupRequest, String tableName) throws Exception {
        StringRequest stringRequest = new StringRequest();
        BeanUtils.copyProperties(groupRequest, stringRequest);
        List<String> sqls = formatQueryService.reSqls(stringRequest, tableName);
        sqls=this.loadSearchSql(sqls);
        //格式化 分组
        GroupConfig groupConfig = null;
        if (groupRequest.getGroupBy() != null) {
            String json = CommonService.readJsonFile(tableName + ".json");
            List<GroupConfig> groupConfigs = JSON.parseArray(json, GroupConfig.class);
            groupConfig = groupConfigs.stream().filter(item -> groupRequest.getGroupBy().equals(item.getField())).findFirst().orElse(null);
            if (groupConfig == null) {
                throw new XiaoShiException("未找到配置");
            }
        }

        tableName = "patent_project as pp left join project as p on pp.project_id = p.id ";
        //返回分组数据
        QueryGroupImp queryGroupImp = queryGroupFactory.getClass(groupConfig.getGroupClass());
        ReGroupDataVO reGroupDataVO = queryGroupImp.getGroup(sqls, tableName, groupConfig.getSqlField());

        //装载数据
        GroupVO groupVO = new GroupVO();
        groupVO.setField(groupRequest.getGroupBy());
        groupVO.setValues(reGroupDataVO.getValues());

        Records records = new Records();
        records.setCurrent(groupRequest.getCurrent());
        records.setSize(groupRequest.getSize());
        records.setData(groupVO);
        records.setTotal(reGroupDataVO.getTotal());
        return records;
    }

    /**
     * 添加
     *
     * @param object
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object addMessage(Object object) {
        if (object == null) {
            throw new XiaoShiException("参数不能为空");
        }
        //TODO 校验参数
        PatentProjectDTO patentProjectDTO = (PatentProjectDTO) object;
        //判断是否选择更新并且上传了cron表达式
        if (patentProjectDTO.getIfUpdate() != false) {
            if (patentProjectDTO.getCrons() == null && patentProjectDTO.getCrons().equals("")) {
                throw new XiaoShiException("选择更新，则cron表达式不能为空！");
            }
        }
        //校验必传参数是否上传
        if (patentProjectDTO.getHeadId() == null) {
            throw new XiaoShiException("负责人id不能为空");
        }
        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();
        try {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }

        /**
         * 装载project
         */
        Project project = new Project();
        BeanUtils.copyProperties(patentProjectDTO, project);

        //TODO 当委托方id或者委托方名称不为空时，
        if (patentProjectDTO.getEntrustId() != null || patentProjectDTO.getEntrustName() != null) {

            //根据创建人的租户类型设置project的委托类型
            if (personnelVO.getTenantType().equals("1")) {
                project.setEntrustType(1);

                //当委托方id不为空时
                if (patentProjectDTO.getEntrustId() != null) {
                    project.setEntrustId(patentProjectDTO.getEntrustId());
                }
                //若且租户类型为代理机构，并且委托方id为空，委托方名称不为空时，新增委托方
                else {
                    ClientDTO clientDTO = new ClientDTO();
                    clientDTO.setName(patentProjectDTO.getEntrustName());
                    clientDTO.setTenantId(personnelVO.getTenantId());
                    try {
                        String res = permissionService.addClient(clientDTO);
                        JSONObject jsonObject = JSONObject.parseObject(res);
                        Integer clientId = Integer.parseInt(jsonObject.get("data").toString());
                        project.setEntrustId(clientId.toString());
                    } catch (Exception e) {
                        throw new XiaoShiException("网络异常");
                    }
                }
            } else {

                if (patentProjectDTO.getEntrustId() != null) {
                    project.setEntrustType(0);
                    project.setEntrustId(patentProjectDTO.getEntrustId());
                }
            }
        }
        project.setCreateId(personnelVO.getId());
        project.setTenantId(personnelVO.getTenantId());
        project.setType(1);
        project.insert();

        /**
         * 装载patentProject
         */
        PatentProject patentProject = new PatentProject();
        BeanUtils.copyProperties(patentProjectDTO, patentProject);
        patentProject.setProjectId(project.getId());
        patentProject.insert();

        /**
         * 装载事件与project关联
         */
        List<AssoProjectEvent> assoProjectEvents = new ArrayList<>();

        List<ProjectEventDTO> events = patentProjectDTO.getEvents();
        if (events != null && events.size() != 0) {
            //遍历传入的事件集合
            for (ProjectEventDTO projectEventDTO : events) {
                AssoProjectEvent assoProjectEvent = new AssoProjectEvent();
                //事件id和处理事项id
                BeanUtils.copyProperties(projectEventDTO, assoProjectEvent);
                //项目id
                assoProjectEvent.setProjectId(project.getId());
                //创建人
                assoProjectEvent.setCreateId(personnelVO.getId());
                //类型为专题库
                assoProjectEvent.setProjectType(0);
                assoProjectEvents.add(assoProjectEvent);
            }
        }

        //装载应用场景和project关联
        List<Integer> scenarios = patentProjectDTO.getScenarioIds();
        if (scenarios != null && scenarios.size() > 0) {
            for (Integer item : scenarios) {
                AssoProjectEvent assoProjectEvent = new AssoProjectEvent();
                //项目id
                assoProjectEvent.setProjectId(project.getId());
                //创建人
                assoProjectEvent.setCreateId(personnelVO.getId());
                //类型为专题库
                assoProjectEvent.setProjectType(0);
                //装载场景id
                assoProjectEvent.setScenarioId(item);
                assoProjectEvents.add(assoProjectEvent);
            }
        }

        //装载应用场景和project关联
        List<Integer> matter = patentProjectDTO.getMatterIds();
        if (matter != null && matter.size() > 0) {
            for (Integer item : matter) {
                AssoProjectEvent assoProjectEvent = new AssoProjectEvent();
                //项目id
                assoProjectEvent.setProjectId(project.getId());
                //创建人
                assoProjectEvent.setCreateId(personnelVO.getId());
                //类型为专题库
                assoProjectEvent.setProjectType(0);
                //装载处理事项id
                assoProjectEvent.setMatterId(item);
                assoProjectEvents.add(assoProjectEvent);
            }
        }

        //统一进行保存
        if (assoProjectEvents != null && assoProjectEvents.size() != 0) {
            assoProjectEventService.saveBatch(assoProjectEvents);
        }

        /**
         * 装载树结构和project关联
         */
        List<AssoProjectTreeNode> assoProjectTreeNodes = new ArrayList<>();
        List<ProjectTreesDTO> trees = patentProjectDTO.getTrees();
        if (trees != null && trees.size() != 0) {
            //遍历传入的树
            for (ProjectTreesDTO projectTreesDTO : trees) {
                List<Integer> valueIds = projectTreesDTO.getValueIds();
                if(valueIds==null||valueIds.size()==0){
                    valueIds = Arrays.asList(0);
                }
                //遍历值id集合
                for (Integer valueId : valueIds) {
                    AssoProjectTreeNode assoProjectTreeNode = new AssoProjectTreeNode();
                    BeanUtils.copyProperties(projectTreesDTO, assoProjectTreeNode);
                    //专题库、报告id
                    assoProjectTreeNode.setProjectId(project.getId());
                    //值id
                    assoProjectTreeNode.setValueId(valueId);
                    assoProjectTreeNodes.add(assoProjectTreeNode);
                }
            }
            if (assoProjectTreeNodes != null && assoProjectTreeNodes.size() != 0) {
                assoProjectTreeNodeService.saveBatch(assoProjectTreeNodes);
            }
        }

        /**
         * 装载和附件关联
         */
        List<AssoProjectFile> assoProjectFiles = new ArrayList<>();
        List<String> fileGuids = patentProjectDTO.getFileGuids();
        if (fileGuids != null && fileGuids.size() != 0) {
            for (String fileGuid : fileGuids) {
                AssoProjectFile assoProjectFile = new AssoProjectFile();
                assoProjectFile.setProjectId(project.getId());
                assoProjectFile.setFileGuid(fileGuid);
                assoProjectFile.setCreateId(personnelVO.getId());
                assoProjectFiles.add(assoProjectFile);
            }
            if (assoProjectFiles != null && assoProjectFiles.size() != 0) {
                assoProjectFileService.saveBatch(assoProjectFiles);
            }
        }
        return project.getId();
    }

    @Override
    public Object updateMessage(Object object) {
        if (object == null) {
            throw new XiaoShiException("参数不能为空");
        }
        //TODO 校验参数
        UpdatePatentProjectDTO updatePatentProjectDTO = (UpdatePatentProjectDTO) object;
        //判断是否选择更新并且上传了cron表达式
        if (updatePatentProjectDTO.getIfUpdate() != false) {
            if (updatePatentProjectDTO.getCrons() == null && updatePatentProjectDTO.getCrons().equals("")) {
                throw new XiaoShiException("选择更新，则cron表达式不能为空！");
            }
        }
        //校验必传参数是否上传
        if (updatePatentProjectDTO.getHeadId() == null) {
            throw new XiaoShiException("负责人id不能为空");
        }
        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();
        try {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }
        //TODO 更新基本信息
        //根据传入对象id查询project对象
        Project project = projectService.getById(updatePatentProjectDTO.getId());
        BeanUtils.copyProperties(updatePatentProjectDTO, project);
        //当委托方id不为空时
        if (updatePatentProjectDTO.getEntrustId() != null) {
            project.setEntrustId(updatePatentProjectDTO.getEntrustId());
        } else {//若且租户类型为代理机构，并且委托方id为空，委托方名称不为空时，新增委托方
            ClientDTO clientDTO = new ClientDTO();
            clientDTO.setName(updatePatentProjectDTO.getEntrustName());
            clientDTO.setTenantId(personnelVO.getTenantId());
            try {
                String res = permissionService.addClient(clientDTO);
                JSONObject jsonObject = JSONObject.parseObject(res);
                Integer clientId = Integer.parseInt(jsonObject.get("data").toString());
                project.setEntrustId(clientId.toString());
            } catch (Exception e) {
                throw new XiaoShiException("网络异常");
            }

        }
        project.updateById();
        /**
         * 装载patentProject
         */
        //根据projectId查询出patentProject
        LambdaQueryWrapper<PatentProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PatentProject::getProjectId, project.getId());
        PatentProject patentProject = this.list(queryWrapper).get(0);
        //装载数据
        patentProject.setIfUpdate(updatePatentProjectDTO.getIfUpdate());
        patentProject.setStatus(updatePatentProjectDTO.getStatus());
        patentProject.setCrons(updatePatentProjectDTO.getCrons());
        patentProject.updateById();
        //TODO 更新场景

        //TODO 更新事件
        List<AssoProjectEvent> assoProjectEvents = new ArrayList<>();
        LambdaQueryWrapper<AssoProjectEvent> updateEventWrapper = new LambdaQueryWrapper<>();
        updateEventWrapper.eq(AssoProjectEvent::getProjectId, project.getId());
        assoProjectEventService.remove(updateEventWrapper);
        List<ProjectEventDTO> events = updatePatentProjectDTO.getEvents();
        if (events != null && events.size() != 0) {
            //遍历传入的事件集合
            for (ProjectEventDTO projectEventDTO : events) {
                AssoProjectEvent assoProjectEvent = new AssoProjectEvent();
                //事件id和处理事项id
                BeanUtils.copyProperties(projectEventDTO, assoProjectEvent);
                //项目id
                assoProjectEvent.setProjectId(project.getId());
                //创建人
                assoProjectEvent.setCreateId(personnelVO.getId());
                //类型为专题库
                assoProjectEvent.setProjectType(0);
                assoProjectEvents.add(assoProjectEvent);
            }
        }

        //装载应用场景和project关联
        List<Integer> scenarios = updatePatentProjectDTO.getScenarioIds();
        if (scenarios != null && scenarios.size() > 0) {
            for (Integer item : scenarios) {
                AssoProjectEvent assoProjectEvent = new AssoProjectEvent();
                //项目id
                assoProjectEvent.setProjectId(project.getId());
                //创建人
                assoProjectEvent.setCreateId(personnelVO.getId());
                //类型为专题库
                assoProjectEvent.setProjectType(0);
                //装载场景id
                assoProjectEvent.setScenarioId(item);
                assoProjectEvents.add(assoProjectEvent);
            }
        }

        //装载处理事项和project关联
        List<Integer> matter = updatePatentProjectDTO.getMatterIds();
        if (matter != null && matter.size() > 0) {
            for (Integer item : matter) {
                AssoProjectEvent assoProjectEvent = new AssoProjectEvent();
                //项目id
                assoProjectEvent.setProjectId(project.getId());
                //创建人
                assoProjectEvent.setCreateId(personnelVO.getId());
                //类型为专题库
                assoProjectEvent.setProjectType(0);
                //装载处理事项id
                assoProjectEvent.setMatterId(item);
                assoProjectEvents.add(assoProjectEvent);
            }
        }

        //统一进行保存
        if (assoProjectEvents != null && assoProjectEvents.size() != 0) {
            assoProjectEventService.saveBatch(assoProjectEvents);
        }

        /**
         * 装载树结构和project关联
         */
        List<AssoProjectTreeNode> assoProjectTreeNodes = new ArrayList<>();
        LambdaQueryWrapper<AssoProjectTreeNode> updateTreeWrapper = new LambdaQueryWrapper<>();
        updateTreeWrapper.eq(AssoProjectTreeNode::getProjectId, project.getId());
        assoProjectTreeNodeService.remove(updateTreeWrapper);

        List<ProjectTreesDTO> trees = updatePatentProjectDTO.getTrees();
        if (trees != null && trees.size() != 0) {
            //遍历传入的树
            for (ProjectTreesDTO projectTreesDTO : trees) {
                List<Integer> valueIds = projectTreesDTO.getValueIds();
                if(valueIds==null||valueIds.size()==0){
                    valueIds = Arrays.asList(0);
                }
                //遍历值id集合
                for (Integer valueId : valueIds) {
                    AssoProjectTreeNode assoProjectTreeNode = new AssoProjectTreeNode();
                    BeanUtils.copyProperties(projectTreesDTO, assoProjectTreeNode);
                    //专题库、报告id
                    assoProjectTreeNode.setProjectId(project.getId());
                    //值id
                    assoProjectTreeNode.setValueId(valueId);
                    assoProjectTreeNodes.add(assoProjectTreeNode);
                }
            }
            if (assoProjectTreeNodes != null && assoProjectTreeNodes.size() != 0) {
                assoProjectTreeNodeService.saveBatch(assoProjectTreeNodes);
            }
        }
        //TODO 若产品或产品类别技术类别有更新，则删除产品或产品类别技术类别和专利的标引（只需判断，删除部分，待es完成）
        //TODO 更新关联附件
        /**
         * 装载和附件关联
         */
        List<AssoProjectFile> assoProjectFiles = new ArrayList<>();
        LambdaQueryWrapper<AssoProjectFile> updateFileWrapper = new LambdaQueryWrapper<>();
        updateFileWrapper.eq(AssoProjectFile::getProjectId, project.getId());
        assoProjectFileService.remove(updateFileWrapper);
        List<String> fileGuids = updatePatentProjectDTO.getFileGuids();
        if (fileGuids != null && fileGuids.size() != 0) {
            for (String fileGuid : fileGuids) {
                AssoProjectFile assoProjectFile = new AssoProjectFile();
                assoProjectFile.setProjectId(project.getId());
                assoProjectFile.setFileGuid(fileGuid);
                assoProjectFile.setCreateId(personnelVO.getId());
                assoProjectFiles.add(assoProjectFile);
            }
            if (assoProjectFiles != null && assoProjectFiles.size() != 0) {
                assoProjectFileService.saveBatch(assoProjectFiles);
            }
        }
        return project.getId();
    }

    /**
     * @param patentProjectVOS
     * @throws IOException
     */
    private void loadPatentProject(List<PatentProjectVO> patentProjectVOS) throws IOException {
        List<String> createIds = new ArrayList<>();
        List<String> departmentIds = new ArrayList<>();
        List<Integer> clientIds = new ArrayList<>();
        List<Integer> ids = new ArrayList<>();
        List<DepartmentVO> departmentVOS = new ArrayList<>();
        List<ReportCountVO> reportCountVOS = new ArrayList<>();
        List<Client> clients = new ArrayList<>();
        List<AssoProjectEvent> assoProjectEvents = new ArrayList<>();
        List<AssoProjectTreeNode> assoProjectTreeNodes = new ArrayList<>();
        List<Event> events = new ArrayList<>();
        List<Scenario> scenarios = new ArrayList<>();
        List<Matter> matters = new ArrayList<>();
        List<Product> products = new ArrayList<>();
        List<ProductCategory> productCategories = new ArrayList<>();
        //TODO 技术分类
        //获得创建人id集合
        patentProjectVOS.forEach(
                item -> {

                    if (item.getCreateId() != null) {
                        createIds.add(item.getCreateId());
                    }

                    if (item.getHeadId() != null) {
                        createIds.add(item.getHeadId());
                    }

                    if (item.getId() != null) {
                        ids.add(item.getId());
                    }

                    if (item.getDepartmentId() != null) {
                        departmentIds.add(item.getDepartmentId());
                    }

                    if (item.getEntrustType() != null && item.getEntrustType().equals(2)) {
                        departmentIds.add(item.getEntrustId());
                    }

                    if (item.getEntrustType() != null && item.getEntrustType().equals(1)) {
                        clientIds.add(Integer.parseInt(item.getEntrustId()));
                    }
                }
        );

        List<Personnel> personnels = new ArrayList<>();
        List<String> guids = new ArrayList<>();
        List<SystemFile> systemFiles = new ArrayList<>();
        List<AssoProjectFile> assoEventFiles = 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 (departmentIds.size() != 0) {
            String json = permissionService.getDepartmentByIdsFromPCS(departmentIds);
            departmentVOS = JSON.parseArray(json, DepartmentVO.class);

        }


        if (ids.size() != 0) {
            //根据事件id获得专利数据库文件关联表
            LambdaQueryWrapper<AssoProjectFile> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.in(AssoProjectFile::getProjectId, ids);
            assoEventFiles = assoProjectFileService.list(queryWrapper);
            guids = assoEventFiles.stream().map(AssoProjectFile::getFileGuid).collect(Collectors.toList());

            //根据事件id分组查询事件关联专题库或报告数量
            reportCountVOS = assoProjectService.getBaseMapper().getReportCount(ids);
        }


        //查询文件
        if (guids.size() != 0) {
            String res = fileManagerService.getSystemFileFromFMS(guids);

            systemFiles = JSONObject.parseArray(res, SystemFile.class);
        }

        //查询客户名称
        if (clientIds.size() != 0) {
            String res = permissionService.getClientByIdsFromPCS(clientIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            clients = JSONObject.parseArray(jsonObject.getString("data"), Client.class);
        }

        //查询应用场景、调查类型、事件和专题库的关联
        if (ids != null && ids.size() > 0) {
            LambdaQueryWrapper<AssoProjectEvent> assoProjectEventQueryWrapper = new LambdaQueryWrapper<>();
            assoProjectEventQueryWrapper.in(AssoProjectEvent::getProjectId, ids);
            assoProjectEvents = assoProjectEventService.list(assoProjectEventQueryWrapper);

            //查询事件
            if (assoProjectEvents != null && assoProjectEvents.size() != 0) {
                scenarios = scenarioService.list();
                matters = matterService.list();
                List<Integer> eventIds = assoProjectEvents.stream().filter(item -> item.getEventId() != null).map(AssoProjectEvent::getEventId).collect(Collectors.toList());
                if (eventIds.size() != 0) {
                    LambdaQueryWrapper<Event> eventQueryWrapper = new LambdaQueryWrapper<>();
                    eventQueryWrapper.in(Event::getId, eventIds);
                    events = eventService.list(eventQueryWrapper);
                }


            }
        }

        //查询和产品，产品分类，技术分类关联列表
        if (ids != null && ids.size() > 0) {
            LambdaQueryWrapper<AssoProjectTreeNode> assoProjectTreeNodeQueryWrapper = new LambdaQueryWrapper<>();
            assoProjectTreeNodeQueryWrapper.in(AssoProjectTreeNode::getProjectId, ids);
            assoProjectTreeNodes = assoProjectTreeNodeService.list(assoProjectTreeNodeQueryWrapper);
            if (assoProjectTreeNodes != null && assoProjectTreeNodes.size() > 0) {
                List<Integer> productIds = assoProjectTreeNodes.stream().filter(item -> item.getTreeType().equals(2)).map(AssoProjectTreeNode::getFieldId).collect(Collectors.toList());
                if (productIds.size() != 0) {
                    LambdaQueryWrapper<Product> productQueryWrapper = new LambdaQueryWrapper<>();
                    productQueryWrapper.in(Product::getId, productIds);
                    products = productService.list(productQueryWrapper);
                }
                List<Integer> productCategoryIds = assoProjectTreeNodes.stream().filter(item -> item.getTreeType().equals(3)).map(AssoProjectTreeNode::getFieldId).collect(Collectors.toList());
                if (productCategoryIds.size() != 0) {
                    LambdaQueryWrapper<ProductCategory> productCategoryQueryWrapper = new LambdaQueryWrapper<>();
                    productCategoryQueryWrapper.in(ProductCategory::getId, productCategoryIds);
                    productCategories = productCategoryService.list(productCategoryQueryWrapper);
                }

            }

        }

        //装载信息
        for (PatentProjectVO patentProjectVO : patentProjectVOS) {

            //装载人员信息
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(patentProjectVO.getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                patentProjectVO.setCreateName(personnel.getPersonnelName());
            }

            if (patentProjectVO.getHeadId() != null) {
                Personnel headPersonnel = personnels.stream().filter(item -> item.getId().equals(patentProjectVO.getHeadId())).findFirst().orElse(null);
                if (headPersonnel != null) {
                    patentProjectVO.setHeadName(headPersonnel.getPersonnelName());
                }
            }

            //装载文件信息
            List<AssoProjectFile> assoProjectFileTemp = assoEventFiles.stream().filter(item -> item.getProjectId().equals(patentProjectVO.getId())).collect(Collectors.toList());
            if (assoProjectFileTemp.size() != 0) {
                List<String> guidTemp = assoProjectFileTemp.stream().map(AssoProjectFile::getFileGuid).collect(Collectors.toList());
                if (guidTemp.size() != 0) {
                    List<SystemFile> systemFileTemp = systemFiles.stream().filter(item -> guidTemp.contains(item.getGuid())).collect(Collectors.toList());
                    if (systemFileTemp.size() != 0) {
                        patentProjectVO.setSystemFileList(systemFileTemp);
                    }
                }
            }

            //装载报告数量
            if (reportCountVOS.size() != 0) {

                //报告数量
                ReportCountVO reportCountVO = reportCountVOS.stream().filter(item ->
                        item.getProjectId().equals(patentProjectVO.getId())).findFirst().orElse(null);

                //设置报告数量
                if (reportCountVO != null) {
                    patentProjectVO.setReportProjectNum(reportCountVO.getProjectCount());
                } else {
                    patentProjectVO.setReportProjectNum(0);
                }

            } else {
                patentProjectVO.setReportProjectNum(0);
            }

            //装载部门
            if (patentProjectVO.getDepartmentId() != null) {
                DepartmentVO departmentVO = departmentVOS.stream().filter(item -> item.getDepartId().equals(patentProjectVO.getDepartmentId())).findFirst().orElse(null);
                if (departmentVO != null) {
                    patentProjectVO.setDepartmentName(departmentVO.getDepartName());
                }
            }

            //裝載委托方
            if (patentProjectVO.getEntrustType() != null) {
                //当委托方为客户时
                if (patentProjectVO.getEntrustType().equals(1)) {
                    Client client = clients.stream().filter(item -> item.getId().equals(Integer.parseInt(patentProjectVO.getEntrustId()))).findFirst().orElse(null);

                    if (client != null) {
                        patentProjectVO.setEntrustName(client.getName());
                    }

                } else if (patentProjectVO.getEntrustType().equals(2)) {
                    DepartmentVO departmentVO = departmentVOS.stream().filter(item -> item.getDepartId().equals(patentProjectVO.getEntrustId())).findFirst().orElse(null);

                    if (departmentVO != null) {
                        patentProjectVO.setEntrustName(departmentVO.getDepartName());
                    }
                }

            }

            //装载事件 应用场景，处理事项
            List<Integer> eventIds = new ArrayList<>();
            List<Integer> matterIds = new ArrayList<>();
            List<Integer> scenarioIds = new ArrayList<>();
            List<String> eventTmpNames = new ArrayList<>();
            List<String> matterTmpNames = new ArrayList<>();
            List<String> scenarioTmpNames = new ArrayList<>();
            if (assoProjectEvents != null) {
                List<AssoProjectEvent> assoProjectEventTmps = assoProjectEvents.stream().filter(item -> item.getProjectId().equals(patentProjectVO.getId())).collect(Collectors.toList());

                if (assoProjectEventTmps.size() != 0) {
                    //过滤出事件
                    eventIds = assoProjectEventTmps.stream().filter(item -> item.getEventId() != null).map(AssoProjectEvent::getEventId).collect(Collectors.toList());
                    matterIds = assoProjectEventTmps.stream().filter(item -> item.getMatterId() != null).map(AssoProjectEvent::getMatterId).collect(Collectors.toList());
                    scenarioIds = assoProjectEventTmps.stream().filter(item -> item.getScenarioId() != null).map(AssoProjectEvent::getScenarioId).collect(Collectors.toList());

                    List<Integer> eventIdsFilter = eventIds;
                    List<Integer> matterIdsFilter = matterIds;
                    List<Integer> scenarioIdsFilter = scenarioIds;

                    List<Event> eventTmps = events.stream().filter(item -> eventIdsFilter.contains(item.getId())).collect(Collectors.toList());
                    List<Matter> matterTmps = matters.stream().filter(item -> matterIdsFilter.contains(item.getId())).collect(Collectors.toList());
                    List<Scenario> scenarioTmps = scenarios.stream().filter(item -> scenarioIdsFilter.contains(item.getId())).collect(Collectors.toList());
                    eventTmpNames = eventTmps.stream().map(Event::getName).collect(Collectors.toList());
                    eventIds = eventTmps.stream().map(Event::getId).collect(Collectors.toList());
                    matterTmpNames = matterTmps.stream().map(Matter::getName).collect(Collectors.toList());
                    matterIds = matterTmps.stream().map(Matter::getId).collect(Collectors.toList());
                    scenarioTmpNames = scenarioTmps.stream().map(Scenario::getName).collect(Collectors.toList());
                    scenarioIds = scenarioTmps.stream().map(Scenario::getId).collect(Collectors.toList());

                }
            }
            patentProjectVO.setScenarioIds(scenarioIds);
            patentProjectVO.setMatterIds(matterIds);
            patentProjectVO.setEventIds(eventIds);
            patentProjectVO.setScenarioNames(scenarioTmpNames);
            patentProjectVO.setMatterNames(matterTmpNames);
            patentProjectVO.setEventNames(eventTmpNames);

            //装载产品，产品分类，技术分类
            if (assoProjectTreeNodes != null) {
                AssoProjectTreeNode assoProjectTreeNode = assoProjectTreeNodes.stream().filter(item -> item.getProjectId().equals(patentProjectVO.getId()) && (item.getTreeType().equals(2) || item.getTreeType().equals(3))).
                        findFirst().orElse(null);
                if (assoProjectTreeNode != null) {
                    ProductOrCategoryVO productOrCategoryVO = new ProductOrCategoryVO();
                    productOrCategoryVO.setValueIds(Arrays.asList(assoProjectTreeNode.getValueId()));
                    if (assoProjectTreeNode.getTreeType().equals(2)) {
                        Product product = products.stream().filter(item -> item.getId().equals(assoProjectTreeNode.getFieldId())).findFirst().orElse(null);
                        if (product != null) {

                            productOrCategoryVO.setName(product.getName());
                            productOrCategoryVO.setId(product.getId());
                            productOrCategoryVO.setType(2);
                            patentProjectVO.setProductOrCategory(productOrCategoryVO);
                        }
                    } else if (assoProjectTreeNode.getTreeType().equals(3)) {
                        ProductCategory productCategory = productCategories.stream().filter(item -> item.getId().equals(assoProjectTreeNode.getFieldId())).findFirst().orElse(null);
                        if (productCategory != null) {
                            productOrCategoryVO.setName(productCategory.getName());
                            productOrCategoryVO.setId(productCategory.getId());
                            productOrCategoryVO.setType(3);
                            patentProjectVO.setProductOrCategory(productOrCategoryVO);
                        }
                    }
                }
            }
        }

    }
    //装载查询语句
    private List<String> loadSearchSql(List<String> sqls){
        PersonnelVO personnelVO =cacheUtils.getLoginUser(loginUtils.getId());
        String id =personnelVO.getId();
        Integer tenantId= personnelVO.getTenantId();
        Integer roleType = personnelVO.getRoleType();
        String rootSql = "";
        if (roleType == null || roleType.equals(0)) {
           rootSql ="(p.create_id ="+id+" or p.head_id="+id+" or p.id in (select project_id from asso_project_person where person_id ="+id+"))";

        }
        else if(roleType.equals(2))
        {
            rootSql="p.tenantId="+tenantId;
        }

        if (sqls.get(0) != null && !sqls.get(0).equals("") && !rootSql.equals("")) {
            sqls.set(0, rootSql + " and" + "(" + sqls.get(0) + ")");
        } else if ((sqls.get(0) == null || sqls.get(0).equals("")) && !rootSql.equals("")) {
            sqls.set(0, rootSql);
        }

        return sqls;

    }

}