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

package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.ClientDTO;
import cn.cslg.pas.common.dto.business.PatentDigProjectDTO;
import cn.cslg.pas.common.dto.business.PatentDigProjectUpdateDTO;
import cn.cslg.pas.common.dto.business.ProjectEventDTO;
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.StringGroupRequest;
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.RdProjectVO;
import cn.cslg.pas.common.vo.business.PatentDigProjectVO;
import cn.cslg.pas.common.vo.business.PatentProjectVO;
import cn.cslg.pas.common.vo.business.SimplePersonVO;
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.PatentDigProjectMapper;
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 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.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

@Service
public class PatentDigProjectService extends ServiceImpl<PatentDigProjectMapper, PatentDigProject> implements Business {
    @Autowired
    private RdProjectService rdProjectService;

    @Autowired
    private AssoProjectFileService assoProjectFileService;

    @Autowired
    private ProjectService projectService;

    @Autowired
    private FormatQueryService formatQueryService;

    @Autowired
    private PatentDigProjectMapper patentDigProjectMapper;

    @Autowired
    private FileManagerService fileManagerService;

    @Autowired
    private PermissionService permissionService;

    @Autowired
    private CacheUtils cacheUtils;

    @Autowired
    private LoginUtils loginUtils;

    @Autowired
    private AssoProjectEventService assoProjectEventService;

    @Autowired
    private EventService eventService;

    @Autowired
    private AssoProjectPersonService assoProjectPersonService;

    @Autowired
    private MatterService matterService;

    @Autowired
    private ScenarioService scenarioService;

    @Autowired
    private QueryGroupFactory queryGroupFactory;

    @Autowired
    private  SystemDictService systemDictService;

    @Override
    public Object queryMessage(QueryRequest queryRequest) throws Exception {
        List<String> sqls = formatQueryService.reSqls(queryRequest, "patentDigProject");
        //根据sql查询专题库信息
       sqls = this.loadSearchSql(sqls);
        List<PatentDigProjectVO> patentProjectVOS = patentDigProjectMapper.getPatentDigProject(sqls.get(0), sqls.get(1), sqls.get(2));
        Long total = patentDigProjectMapper.getPatentDigCount(sqls.get(0));
        //装载专利数据库信息
        this.loadPatentDigProject(patentProjectVOS);
        Records records = new Records();
        records.setCurrent(queryRequest.getCurrent());
        records.setSize(queryRequest.getSize());
        records.setData(patentProjectVOS);
        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 == null || ids.size() == 0) {
            throw new XiaoShiException("ids不能为空");
        }
        //根据projectId 删除专利挖掘项目
        LambdaQueryWrapper<PatentDigProject> digProjectQueryWrapper = new LambdaQueryWrapper<>();
        digProjectQueryWrapper.in(PatentDigProject::getProjectId, ids);
        this.remove(digProjectQueryWrapper);

        //根据projectId 删除相关文件
        LambdaQueryWrapper<AssoProjectFile> deleteFileWrapper = new LambdaQueryWrapper<>();
        deleteFileWrapper.in(AssoProjectFile::getProjectId, ids);
        assoProjectFileService.remove(deleteFileWrapper);

        //TODO 删除流程文件

        //根据专利挖掘项目删除项目
        projectService.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 {
        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_dig_project as dp left join project as p on dp.project_id =p.id left join rd_project rp on dp.rd_project_id =rp.id ";
        tableName+=  "left join (select * from asso_project_event where scenario_id is not null ) as asps on p.id = asps.project_id " +
                "left join (select * from asso_project_event where event_id is not null ) as aspe on p.id = aspe.project_id " +
                "left join (select * from asso_project_event where matter_id is not null ) as aspm on p.id = aspm.project_id";
        //返回分组数据
        QueryGroupImp queryGroupImp = queryGroupFactory.getClass(groupConfig.getGroupClass());
        String countFiled="distinct p.id";
        ReGroupDataVO reGroupDataVO = queryGroupImp.getGroup(sqls, tableName, groupConfig.getSqlField(),countFiled);

        //装载数据
        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;
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object addMessage(Object object) {
        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());

        String userId = personnelVO.getId();
        PatentDigProjectDTO patentDigProjectDTO = (PatentDigProjectDTO) object;
        PatentDigProject patentDigProject = new PatentDigProject();
        BeanUtils.copyProperties(patentDigProjectDTO, patentDigProject);
        Project project = new Project();
        project.setTenantId(personnelVO.getTenantId());
        project.setType(3);
        project.setHeadId(patentDigProjectDTO.getHeadId());
        project.setCreateId(personnelVO.getId());
        project.setDescription(patentDigProjectDTO.getDescription());

        //TODO 当委托方id或者委托方名称不为空时，
        if (patentDigProjectDTO.getEntrustId() != null || patentDigProjectDTO.getEntrustName() != null) {
            //根据创建人的租户类型设置project的委托类型
            if (personnelVO.getTenantType().equals("1")) {
                project.setEntrustType(1);

                //当委托方id不为空时
                if (patentDigProjectDTO.getEntrustId() != null) {
                    project.setEntrustId(patentDigProjectDTO.getEntrustId());
                }
                //若且租户类型为代理机构，并且委托方id为空，委托方名称不为空时，新增委托方
                else {
                    if (patentDigProjectDTO.getEntrustName() != null && patentDigProjectDTO.getEntrustName().trim() != "") {
                        ClientDTO clientDTO = new ClientDTO();
                        clientDTO.setName(patentDigProjectDTO.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());
                            project.setEntrustType(1);
                        } catch (Exception e) {
                            throw new XiaoShiException("网络异常");
                        }
                    }
                }
            } else {
                if (patentDigProjectDTO.getEntrustId() != null) {
                    project.setEntrustType(0);
                    project.setEntrustId(patentDigProjectDTO.getEntrustId());
                }
            }
        }


        project.insert();
        patentDigProject.setProjectId(project.getId());


        RdProject rdProject = new RdProject();
        List<RdProject> rdProjects = new ArrayList<>();

        if (patentDigProjectDTO.getRdnumber() != null) {
            //根据研发项目编号查询研发项目
            LambdaQueryWrapper<RdProject> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(RdProject::getNumber, patentDigProjectDTO.getRdnumber());
            rdProjects = rdProjectService.list(queryWrapper);
        }
        else if (patentDigProjectDTO.getRdName() != null && rdProjects.size() == 0) {
            //根据研发项目编号查询研发项目
            LambdaQueryWrapper<RdProject> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(RdProject::getName, patentDigProjectDTO.getRdName());
            rdProjects = rdProjectService.list(queryWrapper);

        }

        if (rdProjects.size() != 0) {
            rdProject = rdProjects.get(0);
            rdProject.setProductPhase(patentDigProjectDTO.getProductPhase());
            rdProject.setProduct(patentDigProjectDTO.getProduct());
            rdProject.updateById();

        } else {
            if (patentDigProjectDTO.getRdName() != null || patentDigProjectDTO.getRdnumber() != null || patentDigProjectDTO.getProduct() != null || patentDigProjectDTO.getProductPhase() != null) {
                rdProject.setName(patentDigProjectDTO.getRdName());
                rdProject.setCreateId(userId);
                rdProject.setTenantId(personnelVO.getTenantId());
                rdProject.setNumber(patentDigProjectDTO.getRdnumber());
                rdProject.setProductPhase(patentDigProjectDTO.getProductPhase());
                rdProject.setProduct(patentDigProjectDTO.getProduct());
                rdProject.insert();
            }
        }
        if (rdProject.getId()!=null) {
            patentDigProject.setRdProjectId(rdProject.getId());
        }
        patentDigProject.setState(2);
        patentDigProject.setProcess("0");
        patentDigProject.setTenantId(personnelVO.getTenantId());
        patentDigProject.insert();

        /**
         * 装载和附件关联
         */
        List<AssoProjectFile> assoProjectFiles = new ArrayList<>();
        List<String> fileGuids = patentDigProjectDTO.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);
            }
        }

        /**
         * 装载事件与project关联
         */
        List<ProjectEventDTO> events = patentDigProjectDTO.getEvents();
        if (events != null && events.size() != 0) {
            //遍历传入的事件集合
            if (events != null && events.size() != 0) {
                assoProjectEventService.addAssoEventProject(events,project.getId(),2);
            }
        }


        /**
         *装载参与人
         */

        if (patentDigProjectDTO.getInvolvedPersonIds() != null && patentDigProjectDTO.getInvolvedPersonIds().size() != 0) {
            List<AssoProjectPerson> assoProjectPersonList = new ArrayList<>();
            patentDigProjectDTO.getInvolvedPersonIds().forEach(item -> {
                AssoProjectPerson assoProjectPerson = new AssoProjectPerson();
                assoProjectPerson.setPersonId(item);
                assoProjectPerson.setRole(1);
                assoProjectPerson.setProjectId(project.getId());
                assoProjectPerson.setCreateId(userId);
                assoProjectPersonList.add(assoProjectPerson);
            });
            assoProjectPersonService.saveBatch(assoProjectPersonList);
        }

        return patentDigProject.getProjectId();
    }

    @Override
    @Transactional(rollbackFor = Exception.class)
    public Object updateMessage(Object object) {
        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        String userId = personnelVO.getId();
        PatentDigProjectUpdateDTO projectUpdateDTO = (PatentDigProjectUpdateDTO) object;
        PatentDigProject patentDigProject = new PatentDigProject();
        Project project = projectService.getById(projectUpdateDTO.getId());
        project.setHeadId(projectUpdateDTO.getHeadId());
        project.setDescription(projectUpdateDTO.getDescription());

        //当委托方id不为空时
        if (projectUpdateDTO.getEntrustId() != null) {
            project.setEntrustId(projectUpdateDTO.getEntrustId());
        }
        else {//若且租户类型为代理机构，并且委托方id为空，委托方名称不为空时，新增委托方
            if (projectUpdateDTO.getEntrustName() != null && projectUpdateDTO.getEntrustName().trim() != "") {
                ClientDTO clientDTO = new ClientDTO();
                clientDTO.setName(projectUpdateDTO.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();


        //根据projectId查询专利挖掘项目
        LambdaQueryWrapper<PatentDigProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PatentDigProject::getProjectId, project.getId());
        List<PatentDigProject> patentDigProjects = this.list(queryWrapper);

        if (patentDigProjects.size() != 0) {
            //装载专利挖掘项目基本信息
            patentDigProject = patentDigProjects.get(0);
            patentDigProject.setName(projectUpdateDTO.getName());
            patentDigProject.setIfSearch(projectUpdateDTO.getIfSearch());
            patentDigProject.setOutput(projectUpdateDTO.getOutput());
            patentDigProject.setTechnicalDirection(projectUpdateDTO.getTechnicalDirection());
            patentDigProject.setRelatedCompetitors(projectUpdateDTO.getRelatedCompetitors());
            patentDigProject.setTechnicalKeyword(projectUpdateDTO.getTechnicalKeyword());
            if (projectUpdateDTO.getProcess() != null) {
                patentDigProject.setProcess(projectUpdateDTO.getProcess());

            }
        }

            RdProject rdProject = new RdProject();
            List<RdProject> rdProjects = new ArrayList<>();
            if (projectUpdateDTO.getRdnumber() != null) {
                //根据研发项目编号查询研发项目
                LambdaQueryWrapper<RdProject> queryWrappera = new LambdaQueryWrapper<>();
                queryWrappera.eq(RdProject::getNumber, projectUpdateDTO.getRdnumber());
                rdProjects = rdProjectService.list(queryWrappera);
            } else if (projectUpdateDTO.getRdName() != null && rdProjects.size() == 0) {
                //根据研发项目编号查询研发项目
                LambdaQueryWrapper<RdProject> queryWrappera = new LambdaQueryWrapper<>();
                queryWrappera.eq(RdProject::getName, projectUpdateDTO.getRdName());
                rdProjects = rdProjectService.list(queryWrappera);

            }

            if (rdProjects.size() != 0) {
                rdProject = rdProjects.get(0);
                rdProject.setProductPhase(projectUpdateDTO.getProductPhase());
                rdProject.setProduct(projectUpdateDTO.getProduct());
                rdProject.updateById();

            } else {
                if (projectUpdateDTO.getRdName() != null || projectUpdateDTO.getRdnumber() != null || projectUpdateDTO.getProduct() != null || projectUpdateDTO.getProductPhase() != null) {
                    rdProject.setName(projectUpdateDTO.getRdName());
                    rdProject.setCreateId(userId);
                    rdProject.setTenantId(personnelVO.getTenantId());
                    rdProject.setNumber(projectUpdateDTO.getRdnumber());
                    rdProject.setProductPhase(projectUpdateDTO.getProductPhase());
                    rdProject.setProduct(projectUpdateDTO.getProduct());
                    rdProject.insert();
                }
            }
            if (rdProject.getId() != null) {
                patentDigProject.setRdProjectId(rdProject.getId());
            }


            //更新专利挖掘项目
        patentDigProject.updateById();
            //移除和附件关联
            LambdaQueryWrapper<AssoProjectFile> assoQueryWrapper = new LambdaQueryWrapper<>();
            assoQueryWrapper.eq(AssoProjectFile::getProjectId, projectUpdateDTO.getId());
            assoProjectFileService.remove(assoQueryWrapper);

            /**
             * 装载和附件关联
             */
            List<AssoProjectFile> assoProjectFiles = new ArrayList<>();
            List<String> fileGuids = projectUpdateDTO.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);
                }
            }

            //删除和事件关联
            LambdaQueryWrapper<AssoProjectEvent> assoEventQueryWrapper = new LambdaQueryWrapper<>();
            assoEventQueryWrapper.eq(AssoProjectEvent::getProjectId, projectUpdateDTO.getId());
            assoProjectEventService.remove(assoEventQueryWrapper);
            /**
             * 装载事件与project关联
             */
            List<ProjectEventDTO> events = projectUpdateDTO.getEvents();
                if (events != null && events.size() != 0) {
                    assoProjectEventService.addAssoEventProject(events,project.getId(),2);
                }



            LambdaQueryWrapper<AssoProjectPerson> assoProjectPersonLambdaQueryWrapper = new LambdaQueryWrapper<>();
            assoProjectPersonLambdaQueryWrapper.eq(AssoProjectPerson::getProjectId, projectUpdateDTO.getId());
            assoProjectPersonService.remove(assoProjectPersonLambdaQueryWrapper);

            /**
             *装载参与人
             */
            if (projectUpdateDTO.getInvolvedPersonIds() != null && projectUpdateDTO.getInvolvedPersonIds().size() != 0) {
                List<AssoProjectPerson> assoProjectPersonList = new ArrayList<>();
                projectUpdateDTO.getInvolvedPersonIds().forEach(item -> {
                    AssoProjectPerson assoProjectPerson = new AssoProjectPerson();
                    assoProjectPerson.setPersonId(item);
                    assoProjectPerson.setRole(1);
                    assoProjectPerson.setProjectId(project.getId());
                    assoProjectPerson.setCreateId(userId);
                    assoProjectPersonList.add(assoProjectPerson);
                });
                assoProjectPersonService.saveBatch(assoProjectPersonList);
            }
            return projectUpdateDTO.getId();
        }



    public Records getRdProjectByNumber(@RequestBody StringRequest stringRequest ) {

        List<String> sqls = formatQueryService.reSqls(stringRequest, "rdProject");
        //根据sql查询专题库信息
        List<RdProject> patentProjectVOS = patentDigProjectMapper.getRdProject(sqls.get(0), sqls.get(1), sqls.get(2));
        Long total = patentDigProjectMapper.getRdProjectCount(sqls.get(0));
        //装载专利数据库信息
        Records records = new Records();
        records.setCurrent(stringRequest.getCurrent());
        records.setSize(stringRequest.getSize());
        records.setData(patentProjectVOS);
        records.setTotal(total);
        return records;
    }


    public void loadPatentDigProject(List<PatentDigProjectVO> patentDigProjectVOS) throws IOException {
        List<String> createIds = new ArrayList<>();
        List<AssoProjectFile> assoProjectFiles = new ArrayList<>();
        List<Integer> ids = new ArrayList<>();
        List<String> guids = new ArrayList<>();
        List<SystemFile> systemFiles = new ArrayList<>();
        List<Personnel> personnels = new ArrayList<>();
        List<AssoProjectEvent> assoProjectEvents = new ArrayList<>();
        List<Event> events = new ArrayList<>();
        List<Scenario> scenarios = new ArrayList<>();
        List<Matter> matters = new ArrayList<>();
        List<Client> clients = new ArrayList<>();
        List<String> departmentIds = new ArrayList<>();
        List<Integer> clientIds = new ArrayList<>();
        List<AssoProjectPerson> assoProjectPersonList = new ArrayList<>();
        List<DepartmentVO> departmentVOS = new ArrayList<>();
        List<SystemDict> systemDictList = new ArrayList<>();
        //获得创建人id集合
        patentDigProjectVOS.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.getEntrustType() != null && item.getEntrustType().equals(2)) {
                        departmentIds.add(item.getEntrustId());
                    }

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


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

            //
            LambdaQueryWrapper<SystemDict> systemDictLambdaQueryWrapper = new LambdaQueryWrapper<>();
            systemDictLambdaQueryWrapper.eq(SystemDict::getType, "REPORT_STATE");
            systemDictList = systemDictService.list(systemDictLambdaQueryWrapper);

        }


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

            systemFiles = JSONObject.parseArray(res, SystemFile.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 (departmentIds.size() != 0) {
                String json = permissionService.getDepartmentByIdsFromPCS(departmentIds);
                departmentVOS = JSON.parseArray(json, DepartmentVO.class);

            }

            //查询和参与人关联
            LambdaQueryWrapper<AssoProjectPerson> projectPersonLambdaQueryWrapper = new LambdaQueryWrapper<>();
            projectPersonLambdaQueryWrapper.in(AssoProjectPerson::getProjectId, ids);
            assoProjectPersonList = assoProjectPersonService.list(projectPersonLambdaQueryWrapper);
            List<String> personIds = assoProjectPersonList.stream().map(AssoProjectPerson::getPersonId).collect(Collectors.toList());
            createIds.addAll(personIds);
        }
        //查询创建人名称
        if (createIds.size() != 0) {
            String res = permissionService.getPersonnelByIdsFromPCS(createIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }

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


        //装载信息
        for (PatentDigProjectVO patentDigProjectVO : patentDigProjectVOS) {

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

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


            //装载参与人
            List<SimplePersonVO> simplePersonVOS = new ArrayList<>();
            List<AssoProjectPerson> assoProjectPersonTmps = assoProjectPersonList.stream().filter(item -> item.getProjectId().equals(patentDigProjectVO.getId())).collect(Collectors.toList());
            List<String> personIds = assoProjectPersonTmps.stream().map(AssoProjectPerson::getPersonId).collect(Collectors.toList());
            if (personIds.size() != 0) {
                List<Personnel> personneltmps = personnels.stream().filter(item -> personIds.contains(item.getId())).collect(Collectors.toList());
                personneltmps.forEach(item -> {
                    SimplePersonVO simplePersonVO = new SimplePersonVO();
                    simplePersonVO.setPersonId(item.getId());
                    simplePersonVO.setPersonName(item.getPersonnelName());
                    simplePersonVOS.add(simplePersonVO);
                });
            }
            patentDigProjectVO.setInvolvedPersons(simplePersonVOS);

            //装载文件信息
            List<AssoProjectFile> assoProjectFileTemp = assoProjectFiles.stream().filter(item -> item.getProjectId().equals(patentDigProjectVO.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) {
                        patentDigProjectVO.setSystemFileList(systemFileTemp);
                    }
                }
            }

            //装载事件 应用场景，处理事项
            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(patentDigProjectVO.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());

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


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

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

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

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

            }

            //装载报告状态
            SystemDict systemDictStatus = systemDictList.stream().filter(item -> patentDigProjectVO.getState().equals(Integer.parseInt(item.getValue()))&&item.getType().equals("REPORT_STATE")).findFirst().orElse(null);
            if (systemDictStatus != null) {
                patentDigProjectVO.setStateName(systemDictStatus.getLabel());
            }
        }


    }


    //装载查询语句
    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.tenant_id="+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;

    }
}