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

package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.business.LiteratureQueryDTO;
import cn.cslg.pas.common.dto.invalidDTO.UpdateBatchLiteratureDTO;
import cn.cslg.pas.common.dto.invalidDTO.UpdateBatchLiteraturesDTO;
import cn.cslg.pas.common.dto.invalidDTO.UpdateLiteratureOrderDTO;
import cn.cslg.pas.common.model.cronModel.PersonnelVO;
import cn.cslg.pas.common.model.cronModel.Records;
import cn.cslg.pas.common.model.cronModel.SystemFile;
import cn.cslg.pas.common.utils.CacheUtils;
import cn.cslg.pas.common.utils.LoginUtils;
import cn.cslg.pas.common.vo.CompareLiteratureVO;
import cn.cslg.pas.common.vo.NoveltyProjectVO.NoveltyCompareRecordVO;
import cn.cslg.pas.common.vo.PatentWithIdVO;
import cn.cslg.pas.common.vo.WebSocketMessageVO;
import cn.cslg.pas.domain.business.CompareLiterature;
import cn.cslg.pas.common.dto.CompareLiteratureDTO;
import cn.cslg.pas.domain.business.ReportProject;
import cn.cslg.pas.domain.business.novelty.NoveltyCompareLiterature;
import cn.cslg.pas.domain.es.Patent;
import cn.cslg.pas.exception.UnLoginException;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.mapper.CompareLiteratureMapper;
import cn.cslg.pas.mapper.novelty.NoveltyCompareLiteratureMapper;
import cn.cslg.pas.service.business.es.EsPatentService;
import cn.cslg.pas.service.business.es.EsScratchWordsService;
import cn.cslg.pas.service.business.es.EsService;
import cn.cslg.pas.service.common.FileManagerService;
import cn.cslg.pas.service.common.MessageService;
import cn.cslg.pas.service.importPatent.ImportSinglePatentService;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.update.UpdateWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
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.Propagation;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.CollectionUtils;
import org.springframework.util.ObjectUtils;

import java.io.IOException;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @Author lrj
 * @Date 2023/12/8
 */
@Slf4j
@Service
public class CompareLiteratureService extends ServiceImpl<CompareLiteratureMapper, CompareLiterature> {
    @Autowired
    private CacheUtils cacheUtils;

    @Autowired
    private LoginUtils loginUtils;

    @Autowired
    private EsPatentService esPatentService;

    @Autowired
    private ReportProjectService reportProjectService;

    @Autowired
    private FileManagerService fileManagerService;

    @Autowired
    private ImportSinglePatentService importSinglePatentService;
    @Autowired
    private EsScratchWordsService esScratchWordsService;
    @Autowired
    private EsService esService;
    @Autowired
    private MessageService messageService;
    @Autowired
    private CompareLiteratureMapper compareLiteratureMapper;
    @Autowired
    private NoveltyCompareLiteratureMapper noveltyCompareLiteratureMapper;

    //添加专利对比文献
    public Integer addPatentCompareLiterature(Patent patent, Integer projectId, String createId) {
        synchronized ("导入任务是否完成") {
            Integer id = null;
            id = this.getHaveAddIdByNos(projectId, patent.getPatentNo());

            //根据专利号和报告id查询是否已经保存
            if (id == null) {
                CompareLiterature compareLiterature = new CompareLiterature();
                compareLiterature.setCreateId(createId);
                //报告id
                compareLiterature.setProjectId(projectId);
                //文档guid
                compareLiterature.setLiteratureNo(patent.getPatentNo());
                //文档名称
                String name = "";

                //作者
                String authorName = "";
                Integer order = 1;
                //根据报告id获得最大序号
                LambdaQueryWrapper<CompareLiterature> queryWrapper = new LambdaQueryWrapper<>();
                queryWrapper.eq(CompareLiterature::getProjectId, projectId).orderByDesc(CompareLiterature::getSysOrder);
                CompareLiterature compareLiteratureBig = this.getOne(queryWrapper, false);
                if (compareLiteratureBig != null && compareLiteratureBig.getSysOrder() != null) {
                    order = compareLiteratureBig.getSysOrder() + 1;
                }
                if (patent != null) {
                    if (patent.getTitle() != null && patent.getTitle().size() != 0) {
                        name = patent.getTitle().get(0).getTextContent();
                    }
                    compareLiterature.setAppDate(patent.getAppDate());
                    compareLiterature.setPublicDate(patent.getPublicDate());
                    if (patent.getRightHolder() != null && patent.getRightHolder().size() != 0) {
                        authorName = patent.getRightHolder().get(0).getName();
                    }
                }
                compareLiterature.setName(name);
                //描述
                //作者
                compareLiterature.setAuthorName(authorName);
                //类型
                compareLiterature.setType(0);
                //装载排序
                compareLiterature.setSysOrder(order);
                compareLiterature.insert();
                return compareLiterature.getId();
            }
            return id;
        }
    }

    //添加非对比文献
    public Integer addNotPatent(CompareLiteratureDTO compareLiteratureDTO) {
        PersonnelVO personnelVO = new PersonnelVO();
        Integer projectId = compareLiteratureDTO.getProjectId();
        try {
            personnelVO = new PersonnelVO();
            personnelVO.setId("1");
//            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }
        Integer order = 1;
        //根据报告id获得最大序号
        LambdaQueryWrapper<CompareLiterature> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CompareLiterature::getProjectId, projectId)
                .orderByDesc(CompareLiterature::getSysOrder);
        CompareLiterature compareLiteratureBig = this.getOne(queryWrapper, false);
        if (compareLiteratureBig != null && compareLiteratureBig.getSysOrder() != null) {
            order = compareLiteratureBig.getSysOrder() + 1;
        }
        CompareLiterature compareLiterature = new CompareLiterature();
        compareLiterature.setCreateId(personnelVO.getId());
        //报告id
        compareLiterature.setProjectId(compareLiteratureDTO.getProjectId());
        //文档guid
        compareLiterature.setLiteratureNo(compareLiteratureDTO.getFileGuid());
        //文档名称
        compareLiterature.setName(compareLiteratureDTO.getName());
        //描述
        compareLiterature.setDescription(compareLiteratureDTO.getDescription());
        //作者
        compareLiterature.setAuthorName(compareLiteratureDTO.getAuthorName());
        //类型
        compareLiterature.setType(1);
        //装载排序
        compareLiterature.setSysOrder(order);
        //装载公开日
        compareLiterature.setPublicDate(compareLiteratureDTO.getPublicDate());
        compareLiterature.insert();

        return compareLiterature.getId();
    }

    //查询对比文献
    public Records queryCompareLiterature(LiteratureQueryDTO literatureQueryDTO) throws Exception {
        Integer projectId = literatureQueryDTO.getProjectId();
        Records records = new Records();
        //根据对比projectId 查询对比文献
        LambdaQueryWrapper<CompareLiterature> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CompareLiterature::getProjectId, projectId)
                .orderByAsc(CompareLiterature::getSysOrder);
        List<CompareLiterature> compareLiteratures = new ArrayList<>();

        if (literatureQueryDTO.getCurrent() != null && literatureQueryDTO.getSize() != null) {
            Page<CompareLiterature> page = this.page(new Page<>(literatureQueryDTO.getCurrent(), literatureQueryDTO.getSize()), queryWrapper);
            compareLiteratures = page.getRecords();
            records.setTotal(page.getTotal());
            records.setSize(Long.parseLong(literatureQueryDTO.getSize().toString()));
            records.setCurrent(Long.parseLong(literatureQueryDTO.getCurrent().toString()));
        } else {
            compareLiteratures = this.list(queryWrapper);
        }

        List<CompareLiteratureVO> compareLiteratureVOS = new ArrayList<>();

        //根据项目id查询标的专利号
        LambdaQueryWrapper<ReportProject> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(ReportProject::getProjectId, projectId);
        ReportProject reportProject = reportProjectService.getOne(wrapper);

        compareLiteratureVOS = this.loadCompareLiterature(compareLiteratures, reportProject);
        //装载查新对比文件和标注
        this.loadCompareLiteratureVOS(compareLiteratureVOS,projectId);

        records.setData(compareLiteratureVOS);

        return records;
    }

    public void loadCompareLiteratureVOS(List<CompareLiteratureVO> compareLiteratureVOS, Integer projectId) throws Exception {
        if (!CollectionUtils.isEmpty(compareLiteratureVOS)) {
            List<Integer> literatureIds = new ArrayList<>();
            compareLiteratureVOS.forEach(item -> {
                literatureIds.add(item.getId());
            });
            List<NoveltyCompareRecordVO> recordVOS = esScratchWordsService.queryNoveltyRecord(projectId, 1);
            List<NoveltyCompareLiterature> noveltyCompareLiteratureList = noveltyCompareLiteratureMapper.selectList(new LambdaQueryWrapper<NoveltyCompareLiterature>()
                    .in(NoveltyCompareLiterature::getCompareLitertureId, literatureIds));
            for (CompareLiteratureVO literatureVO : compareLiteratureVOS) {
                NoveltyCompareLiterature noveltyCompareLiterature = noveltyCompareLiteratureList.stream().filter(i -> literatureVO.getId().equals(i.getCompareLitertureId())).findFirst().orElse(new NoveltyCompareLiterature());
                if (!ObjectUtils.isEmpty(noveltyCompareLiterature)) {
                    literatureVO.setCompareFileId(noveltyCompareLiterature.getId());
                    literatureVO.setRetrieveRecordId(noveltyCompareLiterature.getRetrieveRecordId());
                    literatureVO.setRelevance(noveltyCompareLiterature.getRelevance());
                    literatureVO.setIfEffectinv(noveltyCompareLiterature.getIfEffectinv());
                    literatureVO.setFileRemark(noveltyCompareLiterature.getRemark());
                    literatureVO.setGeneralRemark(noveltyCompareLiterature.getGeneralRemark());
                    literatureVO.setTechnicalPoints(noveltyCompareLiterature.getTechnicalPoints());
                    literatureVO.setExcuteCase(noveltyCompareLiterature.getExcuteCase());
                    literatureVO.setBeneficialEffect(noveltyCompareLiterature.getBeneficialEffect());
                }
                if (!CollectionUtils.isEmpty(recordVOS)) {
                    List<NoveltyCompareRecordVO> collect = recordVOS.stream().filter(i -> i.getPatentNo().equals(literatureVO.getLiteratureNo())).collect(Collectors.toList());
                    if (CollectionUtils.isEmpty(collect)) {
                        collect = new ArrayList<>();
                    }
                    literatureVO.setNoveltyCompareRecordVOS(collect);
                }
            }
        }
    }

    public List<CompareLiteratureVO> loadCompareLiterature(List<CompareLiterature> compareLiteratures, ReportProject reportProject) {
        List<CompareLiteratureVO> compareLiteratureVOS = new ArrayList<>();
        //查询文件
        List<SystemFile> systemFiles = new ArrayList<>();
        //非专利文献列表
        List<String> guids = compareLiteratures.stream().filter(item -> item.getType().equals(1)).map(CompareLiterature::getLiteratureNo).collect(Collectors.toList());
        //查询文件
        if (!CollectionUtils.isEmpty(guids)) {
            try {
                String res = fileManagerService.getSystemFileFromFMS(guids);
                if (res != null && !res.trim().equals("")) {
                    systemFiles = JSONObject.parseArray(res, SystemFile.class);
                }
            } catch (Exception e) {
                throw new XiaoShiException("装载错误");
            }
        }
        if (!ObjectUtils.isEmpty(reportProject)) {
            //查询标的专利号
            String signPatentNo = reportProject.getSignPatentNo();

            //专利文献列表
            List<String> patentNos = compareLiteratures.stream().filter(item -> item.getType().equals(0)).map(CompareLiterature::getLiteratureNo).collect(Collectors.toList());
            List<Patent> patentList = new ArrayList<>();

            if (reportProject.getSignPatentNo() != null) {
                patentNos.add(reportProject.getSignPatentNo());
            }

            if (patentNos.size() > 0) {
                try {
                    patentList = esPatentService.getPatentsByNo(patentNos, false, null, null);
                } catch (Exception e) {
                    throw new XiaoShiException("装载文献信息失败");
                }
            }

            //获得标的专利信息
            Patent signPatent = patentList.stream()
                    .filter(item -> signPatentNo.equals(item.getAppNo())
                            || signPatentNo.equals(item.getPublicNo()) ||
                            signPatentNo.equals(item.getGrantNo())).findFirst().orElse(null);

            for (CompareLiterature compareLiterature : compareLiteratures) {
                String literatureNo = compareLiterature.getLiteratureNo();
                Date publicDate = compareLiterature.getPublicDate();
                CompareLiteratureVO compareLiteratureVO = new CompareLiteratureVO();
                BeanUtils.copyProperties(compareLiterature, compareLiteratureVO);
                //当为专利文献时
                if (compareLiterature.getType().equals(0)) {
                    compareLiteratureVO.setFitType(0);
                    if (patentList.size() > 0) {
                        Patent patent = patentList.stream()
                                .filter(item -> literatureNo.equals(item.getAppNo())
                                        || literatureNo.equals(item.getPublicNo()) ||
                                        literatureNo.equals(item.getGrantNo())).findFirst().orElse(null);
                        if (patent != null) {
                            compareLiteratureVO.setAppNo(patent.getAppNo());
                            compareLiteratureVO.setAppDate(patent.getAppDate());
                            if (patent.getPublicNo() == null) {
                                compareLiteratureVO.setPublicDate(patent.getGrantDate());
                                compareLiteratureVO.setPublicNo(patent.getGrantNo());
                            } else {
                                compareLiteratureVO.setPublicDate(patent.getPublicDate());
                                compareLiteratureVO.setPublicNo(patent.getPublicNo());
                            }
                            compareLiteratureVO.setGrantDate(patent.getGrantDate());
                            compareLiteratureVO.setGrantNo(patent.getGrantNo());
                            compareLiteratureVO.setApplicant(patent.getApplicant());
                            //比较标的专利的申请日和对比专利的公开或者公告日
                            if (signPatent.getAppDate() != null) {
                                //当专利的申请日存在时
                                if (patent.getAppDate() != null) {
                                    if (signPatent.getAppDate().compareTo(patent.getAppDate()) <= 0) {
                                        compareLiteratureVO.setFitType(0);
                                    } else if (patent.getPublicDate() != null) {
                                        if (signPatent.getAppDate().compareTo(patent.getPublicDate()) <= 0)
                                            compareLiteratureVO.setFitType(1);
                                        else if (signPatent.getAppDate().compareTo(patent.getPublicDate()) > 0) {
                                            compareLiteratureVO.setFitType(2);
                                        }
                                    } else if (patent.getGrantDate() != null) {
                                        if (signPatent.getAppDate().compareTo(patent.getGrantDate()) <= 0)
                                            compareLiteratureVO.setFitType(1);
                                        else if (signPatent.getAppDate().compareTo(patent.getGrantDate()) > 0) {
                                            compareLiteratureVO.setFitType(2);
                                        }
                                    }
                                }

                            }
                        }
                    }

                }
                //非专利文献
                else {
                    if (signPatent.getAppDate() != null) {
                        if (publicDate != null) {
                            if (signPatent.getAppDate().compareTo(publicDate) <= 0) {
                                compareLiteratureVO.setFitType(0);
                            } else {
                                compareLiteratureVO.setFitType(2);
                            }
                        }
                    }

                    //装载文件
                    if (literatureNo != null && systemFiles != null && systemFiles.size() != 0) {
                        SystemFile systemFile = systemFiles.stream().filter(item -> item.getGuid().equals(literatureNo)).findFirst().orElse(null);
                        if (systemFile != null) {
                            compareLiteratureVO.setSystemFile(systemFile);
                        }
                    }
                }
                compareLiteratureVOS.add(compareLiteratureVO);
            }
        } else {
            for (CompareLiterature compareLiterature : compareLiteratures) {
                String literatureNo = compareLiterature.getLiteratureNo();
                CompareLiteratureVO compareLiteratureVO = new CompareLiteratureVO();
                BeanUtils.copyProperties(compareLiterature, compareLiteratureVO);
                //当为专利文献时
                if (compareLiterature.getType().equals(0)) {
                    compareLiteratureVO.setFitType(0);
                }
                //非专利文献
                else {
                    compareLiteratureVO.setFitType(2);
                    //装载文件
                    if (literatureNo != null && !CollectionUtils.isEmpty(systemFiles)) {
                        SystemFile systemFile = systemFiles.stream().filter(item -> item.getGuid().equals(literatureNo)).findFirst().orElse(null);
                        if (systemFile != null) {
                            compareLiteratureVO.setSystemFile(systemFile);
                        }
                    }
                }
                compareLiteratureVOS.add(compareLiteratureVO);
            }
        }


        return compareLiteratureVOS;
    }

    //更新对比文献序号
    public Boolean updateLiteratureOrder(List<UpdateLiteratureOrderDTO> dtos) {
        if (dtos != null && dtos.size() < 0) {
            return false;
        }
        dtos.forEach(item -> {
            UpdateWrapper<CompareLiterature> updateWrapper = new UpdateWrapper<>();
            updateWrapper.eq("id", item.getId());
            updateWrapper.set("sys_order", item.getSysOrder());
            this.update(updateWrapper);
        });
        return true;
    }


    //批量添加对比文献

    public void updateCompareLiteratureBatch(UpdateBatchLiteratureDTO updateBatchLiteratureDTO) {
        PersonnelVO personnelVO = new PersonnelVO();
        personnelVO.setId("1");
        if (updateBatchLiteratureDTO == null) {
            return;
        }
        List<UpdateBatchLiteraturesDTO> dtos = updateBatchLiteratureDTO.getUpdateBatchLiteratureDTOs();
        int i = 1;
        for (UpdateBatchLiteraturesDTO item : dtos) {
            if (item.getType().equals(1)) {
                this.saveOrUpdateNotPatent(item);
            } else {
                this.saveOrUpdatePatent(item);
            }
            WebSocketMessageVO webSocketMessageVO = new WebSocketMessageVO();
            webSocketMessageVO.setAllNum(dtos.size());
            webSocketMessageVO.setCurrentNum(i);
            webSocketMessageVO.setCreateId(personnelVO.getId());
            webSocketMessageVO.setState(1);
            messageService.sendMessage(webSocketMessageVO);
            i++;
        }
        WebSocketMessageVO webSocketMessageVO = new WebSocketMessageVO();
        webSocketMessageVO.setAllNum(dtos.size());
        webSocketMessageVO.setCurrentNum(dtos.size());
        webSocketMessageVO.setCreateId(personnelVO.getId());
        webSocketMessageVO.setState(2);
        messageService.sendMessage(webSocketMessageVO);

    }

    /**
     * 添加或更新非专利文献
     */
    public Integer saveOrUpdateNotPatent(UpdateBatchLiteraturesDTO updateBatchLiteratureDTO) {
        PersonnelVO personnelVO = new PersonnelVO();
        Integer projectId = updateBatchLiteratureDTO.getProjectId();
        try {
            personnelVO = new PersonnelVO();
            personnelVO.setId("1");
//            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }

        CompareLiterature compareLiterature = new CompareLiterature();
        compareLiterature.setCreateId(personnelVO.getId());
        //报告id
        compareLiterature.setProjectId(projectId);
        //文档guid
        compareLiterature.setLiteratureNo(updateBatchLiteratureDTO.getLiteratureNo());
        //文档名称
        compareLiterature.setName(updateBatchLiteratureDTO.getName());
        //描述
        compareLiterature.setDescription(updateBatchLiteratureDTO.getDescription());
        //作者
        compareLiterature.setAuthorName(updateBatchLiteratureDTO.getAuthorName());
        //类型
        compareLiterature.setType(1);
        //装载排序
        compareLiterature.setSysOrder(updateBatchLiteratureDTO.getSysOrder());
        //装载公开日
        compareLiterature.setPublicDate(updateBatchLiteratureDTO.getPublicDate());

        //当传id则为更新
        if (updateBatchLiteratureDTO.getId() != null) {

            compareLiterature.setId(updateBatchLiteratureDTO.getId());
            compareLiterature.updateById();

        } else {
            compareLiterature.insert();
        }

        return compareLiterature.getId();

    }


    /**
     * 添加或更新专利文献
     */
    @Transactional(rollbackFor = Exception.class)
    public Integer saveOrUpdatePatent(UpdateBatchLiteraturesDTO updateBatchLiteratureDTO) {
        PersonnelVO personnelVO = new PersonnelVO();
        Integer projectId = updateBatchLiteratureDTO.getProjectId();
        String literatureNo = updateBatchLiteratureDTO.getLiteratureNo();
        Integer id = updateBatchLiteratureDTO.getId();
        try {
            personnelVO = new PersonnelVO();
            personnelVO.setId("1");
//            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }

        Patent patent = new Patent();
        PatentWithIdVO patentWithIdVO = new PatentWithIdVO();
        //判断库里是否存在该专利
        try {
            patentWithIdVO = esService.getIdByPatentNo(literatureNo);
            if (patentWithIdVO == null) {
                // 不存在该专利则从数据库获取著录信息并保存
                patentWithIdVO = importSinglePatentService.addSinglePatent(literatureNo);
                patent = patentWithIdVO.getPatent();
            } else {
                patent = patentWithIdVO.getPatent();
            }
        } catch (Exception e) {

        }
        if(patentWithIdVO==null){
            return  null;
        }
        literatureNo = patent.getPatentNo();
        //判断该专利是否已经作为文献
        Integer lastId = this.getHaveAddIdByNos(projectId, literatureNo);
        if (lastId != null && id == null) {
            id = lastId;
        }

        CompareLiterature compareLiterature = new CompareLiterature();
        compareLiterature.setCreateId(personnelVO.getId());
        //报告id
        compareLiterature.setProjectId(projectId);
        //文档guid
        compareLiterature.setLiteratureNo(patent.getPatentNo());
        //文档名称
        String name = literatureNo;
        if (patent != null) {
            if (patent.getTitle() != null && patent.getTitle().size() != 0) {
                name = patent.getTitle().get(0).getTextContent();
            }
            compareLiterature.setAppDate(patent.getAppDate());
            compareLiterature.setPublicDate(patent.getPublicDate());
        }
        compareLiterature.setName(name);
        //描述
        compareLiterature.setDescription(updateBatchLiteratureDTO.getDescription());
        //作者
        String authorName = "";
        if (patent != null && patent.getRightHolder() != null && patent.getRightHolder().size() > 0) {
            authorName = patent.getRightHolder().get(0).getName();
        }

        compareLiterature.setAuthorName(authorName);
        //类型
        compareLiterature.setType(0);
        //装载排序
        compareLiterature.setSysOrder(updateBatchLiteratureDTO.getSysOrder());

        //当传id则为更新
        if (id != null) {
            compareLiterature.setId(updateBatchLiteratureDTO.getId());
            compareLiterature.updateById();

        } else {
            compareLiterature.insert();
        }
        try {
            importSinglePatentService.saveAssoPatentProjectToEs(projectId, patentWithIdVO.getId());
        } catch (Exception e) {
            throw new XiaoShiException("添加和es关联错误");
        }

        return compareLiterature.getId();

    }


    /**
     * 根据号码判断是否被加入过
     *
     * @param projectId
     * @param nos
     * @return
     */
    public Integer getHaveAddIdByNos(Integer projectId, String nos) {
        LambdaQueryWrapper<CompareLiterature> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CompareLiterature::getLiteratureNo, nos)
                .eq(CompareLiterature::getProjectId, projectId);
        CompareLiterature compareLiterature = this.getOne(queryWrapper, false);
        if (compareLiterature != null) {
            return compareLiterature.getId();
        }
        return null;
    }

    @Transactional(propagation = Propagation.REQUIRED, rollbackFor = Throwable.class)
    public Boolean deleteCompareLiterature(List<Integer> ids) throws IOException {
        if (ids == null || ids.size() <= 0) {
            throw new XiaoShiException("请选择对比文献");
        }
        List<CompareLiterature> literatures = compareLiteratureMapper.selectBatchIds(ids);
        if (!CollectionUtils.isEmpty(literatures)) {
            List<CompareLiterature> literatureList = literatures.stream().filter(i -> i.getType().equals(0)).collect(Collectors.toList());
            for (CompareLiterature literature : literatureList) {
                Integer number = esService.getPatent(literature.getLiteratureNo(), literature.getProjectId());
                if (number < 1) {
                    throw new XiaoShiException("删除失败");
                }
            }
        }
        return this.removeBatchByIds(ids);

    }


    public List<CompareLiteratureVO> getByIds(List<Integer> ids) {
        LambdaQueryWrapper<CompareLiterature> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(CompareLiterature::getId, ids)
                .orderByAsc(CompareLiterature::getSysOrder);
        List<CompareLiterature> compareLiteratures = this.list(queryWrapper);
        List<CompareLiteratureVO> compareLiteratureVOS = this.loadBaseMessage(compareLiteratures);
        return compareLiteratureVOS;
    }


    public List<CompareLiteratureVO> loadBaseMessage(List<CompareLiterature> compareLiteratures) {

        //查询标的专利号
        List<CompareLiteratureVO> compareLiteratureVOS = new ArrayList<>();

        //非专利文献列表
        List<String> guids = compareLiteratures.stream().filter(item -> item.getType().equals(1)).map(CompareLiterature::getLiteratureNo).collect(Collectors.toList());

        //专利文献列表
        List<String> patentNos = compareLiteratures.stream().filter(item -> item.getType().equals(0)).map(CompareLiterature::getLiteratureNo).collect(Collectors.toList());
        List<Patent> patentList = new ArrayList<>();


        if (patentNos.size() > 0) {
            try {
                patentList = esPatentService.getPatentsByNo(patentNos, false, null, null);
            } catch (Exception e) {
                throw new XiaoShiException("装载文献信息失败");
            }
        }


        //查询文件
        List<SystemFile> systemFiles = new ArrayList<>();

        //查询文件
        if (guids.size() != 0) {
            try {
                String res = fileManagerService.getSystemFileFromFMS(guids);
                if (res != null && !res.trim().equals("")) {
                    systemFiles = JSONObject.parseArray(res, SystemFile.class);
                }
            } catch (Exception e) {
                throw new XiaoShiException("装载错误");
            }
        }
        for (CompareLiterature compareLiterature : compareLiteratures) {
            Integer id = compareLiterature.getId();
            String literatureNo = compareLiterature.getLiteratureNo();
            Date publicDate = compareLiterature.getPublicDate();
            CompareLiteratureVO compareLiteratureVO = new CompareLiteratureVO();
            BeanUtils.copyProperties(compareLiterature, compareLiteratureVO);
            //当为专利文献时
            if (compareLiterature.getType().equals(0)) {
                compareLiteratureVO.setFitType(0);
                if (patentList.size() > 0) {
                    Patent patent = patentList.stream()
                            .filter(item -> literatureNo.equals(item.getAppNo())
                                    || literatureNo.equals(item.getPublicNo()) ||
                                    literatureNo.equals(item.getGrantNo())).findFirst().orElse(null);
                    if (patent != null) {
                        compareLiteratureVO.setAppNo(patent.getAppNo());
                        compareLiteratureVO.setAppDate(patent.getAppDate());
                        compareLiteratureVO.setPublicDate(patent.getPublicDate());
                        compareLiteratureVO.setPublicNo(patent.getPublicNo());
                        compareLiteratureVO.setGrantDate(patent.getGrantDate());
                        compareLiteratureVO.setGrantNo(patent.getGrantNo());

                    }
                }

            }
            //非专利文献
            else {
                //装载文件
                if (literatureNo != null && systemFiles != null && systemFiles.size() != 0) {
                    SystemFile systemFile = systemFiles.stream().filter(item -> item.getGuid().equals(literatureNo)).findFirst().orElse(null);
                    if (systemFile != null) {
                        compareLiteratureVO.setSystemFile(systemFile);
                    }
                }
            }
            compareLiteratureVOS.add(compareLiteratureVO);
        }

        return compareLiteratureVOS;
    }


    public Boolean copyCompareLiterature(Integer copiedProjectId, Integer projectId) {
        //根据报告id获得对比文件列表
        LambdaQueryWrapper<CompareLiterature> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(CompareLiterature::getProjectId, copiedProjectId);
        List<CompareLiterature> compareFilesList = this.list(wrapper);
        if (compareFilesList.size() != 0) {
            for (CompareLiterature compareFile : compareFilesList) {
                compareFile.setId(null);
                compareFile.setProjectId(projectId);
            }
            return this.saveBatch(compareFilesList);
        }
        return true;
    }



    public  void addAssoToEs(){
        List<String> patentNos =new ArrayList<>();
        LambdaQueryWrapper<CompareLiterature> compareLiteratureLambdaQueryWrapper =new LambdaQueryWrapper<>();
       compareLiteratureLambdaQueryWrapper.eq(CompareLiterature::getType,0);
        List<CompareLiterature> compareLiteratures =this.list(compareLiteratureLambdaQueryWrapper);
        int i=0;
        for (CompareLiterature item: compareLiteratures){
           i++;
            System.out.println(i);
            String patentNo =item.getLiteratureNo().trim();
            Integer projectId =item.getProjectId();
            try {
                PatentWithIdVO  patentWithIdVO = esService.getIdByPatentNo(patentNo);
                if(patentWithIdVO==null){
                        // 不存在该专利则从数据库获取著录信息并保存
                        patentWithIdVO = importSinglePatentService.addSinglePatent(patentNo);

                }
                importSinglePatentService.saveAssoPatentProjectToEs(projectId, patentWithIdVO.getId());
            }
catch (Exception e){
                e.printStackTrace();
    patentNos.add(patentNo);
            }

        }
System.out.println(patentNos);
    }


}