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.importTask.ProjectQuartzQueryDTO;
import cn.cslg.pas.common.importTask.ProjectQuartzSetDTO;
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.patentProject.ProjectQuartzDTO;
import cn.cslg.pas.common.utils.CacheUtils;
import cn.cslg.pas.common.utils.CronUtil;
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.ExceptionEnum;
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.quartzService.JobService;
import cn.cslg.pas.service.quartzService.QrtzTaskDTO;
import cn.cslg.pas.service.quartzService.QuartzVO;
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;

    @Autowired
    private JobService jobService;

    @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删除导入任务信息（导入任务模块未完成，暂时不做）

        //删除专利数据库
        this.removeQuartz(ids);
        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 = "( select p.id as id ,p.create_id as createId,p.tenant_id as tenantId,p.head_id as headId,asps.scenario_id as scenarioId,aspm.matter_id as matterId,p.create_time as createTime,entrust_id as entrustId,entrust_type as entrustType,aspe.event_id as eventId from patent_project as pp left join project as p on pp.project_id = p.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) as t";
        //返回分组数据
        QueryGroupImp queryGroupImp = queryGroupFactory.getClass(groupConfig.getGroupClass());
        String countFiled = "distinct t.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;
    }

    /**
     * 添加
     *
     * @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.getUpdateCycle() == null && patentProjectDTO.getUpdateCycle().equals("")) {
                throw new XiaoShiException("选择更新，则cron表达式不能为空！");
            }
        }
        //校验必传参数是否上传
        if (patentProjectDTO.getHeadId() == null) {
            throw new XiaoShiException("负责人id不能为空");
        }
        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();
        if (patentProjectDTO.getPersonId() == null) {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());

        } else {
            personnelVO.setId(patentProjectDTO.getPersonId());
            personnelVO.setTenantType("1");
            personnelVO.setTenantId(1);
        }

        /**
         * 装载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
         */
        if(patentProjectDTO.getIfUpdate()!=null&&patentProjectDTO.getIfUpdate()){
            ProjectQuartzSetDTO projectQuartzSetDTO =new ProjectQuartzSetDTO();
            projectQuartzSetDTO.setProjectId(project.getId());
            projectQuartzSetDTO.setIfUpdate(patentProjectDTO.getIfUpdate());
            projectQuartzSetDTO.setUpdateCycle(patentProjectDTO.getUpdateCycle());
            this.setProjectQuartz(projectQuartzSetDTO);
        }

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

        List<ProjectEventDTO> events = patentProjectDTO.getEvents();

        if (events != null && events.size() != 0) {
            //遍历传入的事件集合
            if (events != null && events.size() != 0) {
                assoProjectEventService.addAssoEventProject(events, project.getId(), 0);
            }
        }

        //装载应用场景和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.getUpdateCycle() == null && updatePatentProjectDTO.getUpdateCycle().equals("")) {
                throw new XiaoShiException("选择更新，则cron表达式不能为空！");
            }
        }
        //校验必传参数是否上传
        if (updatePatentProjectDTO.getHeadId() == null) {
            throw new XiaoShiException("负责人id不能为空");
        }
        //获取登陆人信息 用于设置创建人
        PersonnelVO personnelVO = new PersonnelVO();

        personnelVO = cacheUtils.getLoginUser(loginUtils.getId());

        //TODO 更新基本信息
        //根据传入对象id查询project对象
        Project project = projectService.getById(updatePatentProjectDTO.getId());
        BeanUtils.copyProperties(updatePatentProjectDTO, project);
        //TODO 当委托方id或者委托方名称不为空时，
        if (updatePatentProjectDTO.getEntrustId() != null || updatePatentProjectDTO.getEntrustName() != null) {

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

                //当委托方id不为空时
                if (updatePatentProjectDTO.getEntrustId() != null) {
                    project.setEntrustId(updatePatentProjectDTO.getEntrustId());
                }
                //若且租户类型为代理机构，并且委托方id为空，委托方名称不为空时，新增委托方
                else {
                    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("网络异常");
                    }
                }
            } else {

                if (updatePatentProjectDTO.getEntrustId() != null) {
                    project.setEntrustType(0);
                    project.setEntrustId(updatePatentProjectDTO.getEntrustId());
                }
            }
        }
        project.updateById();
        /**
         * 装载patentProject
         */
        //根据projectId查询出patentProject
            ProjectQuartzSetDTO projectQuartzSetDTO =new ProjectQuartzSetDTO();
            projectQuartzSetDTO.setProjectId(project.getId());
            projectQuartzSetDTO.setIfUpdate(updatePatentProjectDTO.getIfUpdate());
            projectQuartzSetDTO.setUpdateCycle(updatePatentProjectDTO.getUpdateCycle());
            this.setProjectQuartz(projectQuartzSetDTO);

        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) {
            if (events != null && events.size() != 0) {
                assoProjectEventService.addAssoEventProject(events, project.getId(), 0);
            }
        }

        //装载应用场景和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 (systemFiles == null) {
                systemFiles = new ArrayList<>();
            }
        }

        //查询客户名称
        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 = "(t.createId =" + id + " or t.headId=" + id + " or t.id in (select project_id from asso_project_person where person_id =" + id + "))";

        } else if (roleType.equals(2)) {
            rootSql = "(t.tenantId=" + tenantId + " or t.id in (select project_id from asso_project_person where person_id =" + id + "))";
        }

        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;

    }

    private Boolean IfNameExist(String name) {
        Integer tenantId = 1;
        LambdaQueryWrapper<Project> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(Project::getTenantId, tenantId)
                .eq(Project::getName, name);
        Project project = projectService.getOne(queryWrapper, false);
        if (project != null) {
            return false;
        }

        return true;
    }

    public PatentProjectVO getPatentProjectVOById(Integer projectId) {
        List<String> sqls = new ArrayList<>();
        String sql1 = "p.id =" + projectId;
        sqls.add(sql1);
        sqls.add(null);
        sqls.add(null);
        List<PatentProjectVO> patentProjectVOS = patentProjectMapper.getPatentProject(sqls.get(0), sqls.get(1), sqls.get(2));
        try {
            this.loadPatentProject(patentProjectVOS);
        } catch (Exception e) {
        }
        if (patentProjectVOS != null && patentProjectVOS.size() > 0) {
            return patentProjectVOS.get(0);
        }
        return null;
    }

    /**
     * 设置定时周期
     *
     * @param projectQuartzDTO
     */
    public void setProjectQuartz(ProjectQuartzDTO projectQuartzDTO) {
        Integer projectId = projectQuartzDTO.getProjectId();
        Boolean ifUpdate = projectQuartzDTO.getIfUpdate();
        String crons = projectQuartzDTO.getCrons();
        PatentProject patentProject = this.getProjectQuartz(projectId);
        patentProject.setIfUpdate(ifUpdate);
        patentProject.setCrons(crons);
        patentProject.updateById();
    }

    /**
     * 获取项目定时配置
     *
     * @param projectId
     */
    public PatentProject getProjectQuartz(Integer projectId) {
        LambdaQueryWrapper<PatentProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PatentProject::getProjectId, projectId);
        PatentProject patentProject = this.getOne(queryWrapper);
        return patentProject;
    }

    public PatentProject addProjectQuartz(ProjectQuartzSetDTO projectQuartzSetDTO) {
        Integer projectId = projectQuartzSetDTO.getProjectId();
        String updateCycle = projectQuartzSetDTO.getUpdateCycle();
        Boolean ifUpdate = projectQuartzSetDTO.getIfUpdate();
        PatentProject project = new PatentProject();
        project.setProjectId(projectId);
        project.setIfUpdate(projectQuartzSetDTO.getIfUpdate());
        project.setUpdateCycle(updateCycle);
        if (ifUpdate != null && ifUpdate) {
            String crons = CronUtil.getCron(updateCycle);
            if (crons == null) {
                throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "请输入周期");
            }
            project.setCrons(crons);
            QuartzVO quartzVO = jobService.getPatentProjectVO(projectId);
            QrtzTaskDTO qrtzTaskDTO = new QrtzTaskDTO();
            qrtzTaskDTO.setCron(crons);
            qrtzTaskDTO.setId(projectId);
            qrtzTaskDTO.setQuartzVO(quartzVO);
            qrtzTaskDTO.setJobClass("cn.cslg.pas.service.quartzService.ImportPatentJobService");
            try {
                jobService.addJob(qrtzTaskDTO);
            } catch (Exception e) {
                throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "新建定时任务错误");
            }
            project.insert();
        }
        return project;
    }

    public PatentProject updateProjectQuartz(ProjectQuartzSetDTO projectQuartzSetDTO) {
        Integer projectId = projectQuartzSetDTO.getProjectId();
        String updateCycle = projectQuartzSetDTO.getUpdateCycle();
        Boolean ifUpdate = projectQuartzSetDTO.getIfUpdate();
        PatentProject project = this.getProjectQuartz(projectId);
        String crons = null;
        if (ifUpdate != null && ifUpdate) {
            crons = CronUtil.getCron(updateCycle);
            project.setCrons(crons);
        }

        if (project.getIfUpdate() != null && project.getIfUpdate() && (ifUpdate == null || !ifUpdate)) {
            QuartzVO quartzVO = jobService.getPatentProjectVO(projectId);
            try {
                jobService.deleteJob(quartzVO);
            } catch (Exception e) {
                throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "新建定时任务错误");
            }
        } else if (project.getIfUpdate() != null && project.getIfUpdate() && ifUpdate != null && ifUpdate == true) {
            if (project.getUpdateCycle().equals(updateCycle)) {
                return project;
            }
            QuartzVO quartzVO = jobService.getPatentProjectVO(projectId);
            QrtzTaskDTO qrtzTaskDTO = new QrtzTaskDTO();
            qrtzTaskDTO.setCron(crons);
            qrtzTaskDTO.setQuartzVO(quartzVO);
            qrtzTaskDTO.setId(projectId);
            jobService.updateJob(qrtzTaskDTO);
        } else if ((project.getIfUpdate() == null || !project.getIfUpdate()) && (ifUpdate != null && ifUpdate)) {
            QuartzVO quartzVO = jobService.getPatentProjectVO(projectId);
            QrtzTaskDTO qrtzTaskDTO = new QrtzTaskDTO();
            qrtzTaskDTO.setCron(crons);
            qrtzTaskDTO.setQuartzVO(quartzVO);
            qrtzTaskDTO.setJobClass("cn.cslg.pas.service.quartzService.ImportPatentJobService");
            try {
                jobService.addJob(qrtzTaskDTO);
            } catch (Exception e) {
                throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "新建定时任务错误");
            }
        }
        project.setUpdateCycle(updateCycle);
        project.setIfUpdate(ifUpdate);
        project.updateById();
        return project;
    }

    /**
     * 设置项目定时配置
     *
     * @param projectQuartzSetDTO
     */
    public PatentProject setProjectQuartz(ProjectQuartzSetDTO projectQuartzSetDTO) {
        Integer projectId = projectQuartzSetDTO.getProjectId();
        PatentProject project = this.getProjectQuartz(projectId);
        if (project == null) {
            this.addProjectQuartz(projectQuartzSetDTO);
        } else {
            this.updateProjectQuartz(projectQuartzSetDTO);
        }
        return project;
    }

    public Boolean checkIfHaveQuartz(Integer projectId) {
        PatentProject project = this.getProjectQuartz(projectId);
        return project.getIfUpdate();
    }

    public void removeQuartz(List<Integer> ids) {
        for (Integer id : ids) {
            PatentProject project = this.getProjectQuartz(id);
            if (project.getIfUpdate() != null && project.getIfUpdate()) {
                QuartzVO quartzVO = jobService.getPatentProjectVO(id);
          try {
              jobService.deleteJob(quartzVO);

          }
          catch (Exception e){
              throw  new XiaoShiException(ExceptionEnum.BUSINESS_ERROR,"创建定时任务错误");
          }
            }
        }

    }


    public PatentProject queryProjectQuartz(ProjectQuartzQueryDTO projectQuartzQueryDTO) {
        Integer projectId =projectQuartzQueryDTO.getProjectId();
        LambdaQueryWrapper<PatentProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(PatentProject::getProjectId, projectId);
        PatentProject patentProject = this.getOne(queryWrapper);
        return patentProject;
    }
}