PAS/src/main/java/cn/cslg/pas/service/novelty/NoveltyCompareLiteratureService.java

package cn.cslg.pas.service.novelty;

import cn.cslg.pas.common.dto.AddCompareFileDTO;
import cn.cslg.pas.common.dto.CompareFileIdDTO;
import cn.cslg.pas.common.dto.EditCompareFileDTO;
import cn.cslg.pas.common.dto.QueryCompareFileDTO;
import cn.cslg.pas.common.dto.business.LiteratureQueryDTO;
import cn.cslg.pas.common.model.cronModel.Records;
import cn.cslg.pas.common.utils.GenerateObjectUtil;
import cn.cslg.pas.common.vo.CompareLiteratureVO;
import cn.cslg.pas.common.vo.GetReportInfoFromWDVO;
import cn.cslg.pas.common.vo.NoveltyProjectVO.NoveltyCompareLiteratureVO;
import cn.cslg.pas.common.vo.NoveltyProjectVO.NoveltyCompareRecordVO;
import cn.cslg.pas.common.vo.QueryCompareFileVO;
import cn.cslg.pas.common.vo.QueryNoveltyProjectVO;
import cn.cslg.pas.domain.business.CompareLiterature;
import cn.cslg.pas.domain.es.Marking;
import cn.cslg.pas.domain.es.Patent;
import cn.cslg.pas.domain.es.PatentPerson;
import cn.cslg.pas.mapper.CompareLiteratureMapper;
import cn.cslg.pas.mapper.RetrieveRecordMapper;
import cn.cslg.pas.mapper.novelty.NoveltyCompareLiteratureMapper;
import cn.cslg.pas.service.business.CompareLiteratureService;
import cn.cslg.pas.service.business.es.EsPatentService;
import cn.cslg.pas.service.business.es.EsScratchWordsService;
import cn.cslg.pas.service.importPatent.ImportSinglePatentService;
import cn.cslg.pas.service.permissions.GetReportInfoFromWDService;
import com.alibaba.fastjson2.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import cn.cslg.pas.domain.business.novelty.NoveltyCompareLiterature;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.ObjectUtils;
import org.apache.commons.lang3.StringUtils;
import org.openqa.selenium.By;
import org.openqa.selenium.WebElement;
import org.springframework.beans.BeanUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;

import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * @author admin
 * @description 针对表【novelty_compare_literature(查新报告对比文件)】的数据库操作Service实现
 * @createDate 2024-09-29 09:10:32
 */

@Service
@Slf4j
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class NoveltyCompareLiteratureService extends ServiceImpl<NoveltyCompareLiteratureMapper, NoveltyCompareLiterature> {

    @Autowired
    private NoveltyCompareLiteratureMapper noveltyCompareLiteratureMapper;

    @Autowired
    private RetrieveRecordMapper retrieveRecordMapper;

    @Autowired
    private GetReportInfoFromWDService getReportInfoFromWDService;

    @Autowired
    private CompareLiteratureMapper compareLiteratureMapper;
    @Autowired
    private CompareLiteratureService compareLiteratureService;
    @Autowired
    private EsScratchWordsService esScratchWordsService;
    @Autowired
    private EsPatentService esPatentService;
    @Autowired
    private ImportSinglePatentService importSinglePatentService;

    public Records queryNoveltyCompareLiterature(LiteratureQueryDTO vo) throws Exception {
        Integer projectId = vo.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 (vo.getCurrent() != null && vo.getSize() != null) {
            Page<CompareLiterature> page = compareLiteratureService.page(new Page<>(vo.getCurrent(), vo.getSize()), queryWrapper);
            compareLiteratures = page.getRecords();
            records.setTotal(page.getTotal());
            records.setSize(Long.parseLong(vo.getSize().toString()));
            records.setCurrent(Long.parseLong(vo.getCurrent().toString()));
        } else {
            compareLiteratures = compareLiteratureService.list(queryWrapper);
        }
        List<CompareLiteratureVO> literatureVOS = this.loadCompareLiterature(compareLiteratures);
        this.loadCompareLiteratureVOS(literatureVOS, projectId);
        records.setData(literatureVOS);
        return records;
    }

    public List<CompareLiteratureVO> loadCompareLiterature(List<CompareLiterature> compareLiteratures) throws Exception {
        List<CompareLiteratureVO> compareLiteratureVOS = new ArrayList<>();
        List<String> patentNos = compareLiteratures.stream().map(CompareLiterature::getLiteratureNo).collect(Collectors.toList());
        List<Patent> patentList = esPatentService.getPatentsByNo(patentNos, false, null, null);
        for (CompareLiterature compareLiterature : compareLiteratures) {
            String literatureNo = compareLiterature.getLiteratureNo();
            Patent patent = patentList.stream()
                    .filter(item -> literatureNo.equals(item.getAppNo())
                            || literatureNo.equals(item.getPublicNo()) ||
                            literatureNo.equals(item.getGrantNo())).findFirst().orElse(null);
            CompareLiteratureVO compareLiteratureVO = new CompareLiteratureVO();
            BeanUtils.copyProperties(compareLiterature, compareLiteratureVO);
            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());
                if (StringUtils.isNotEmpty(compareLiteratureVO.getAuthorName())) {
                    List<PatentPerson> personList = new ArrayList<>();
                    PatentPerson person = new PatentPerson();
                    person.setName(compareLiteratureVO.getAuthorName());
                    personList.add(person);
                    compareLiteratureVO.setApplicant(personList);
                } else {
                    compareLiteratureVO.setApplicant(patent.getApplicant());
                }
            }
            compareLiteratureVOS.add(compareLiteratureVO);
        }
        return compareLiteratureVOS;
    }

    public void loadCompareLiteratureVOS(List<CompareLiteratureVO> compareLiteratureVOS, Integer projectId) throws Exception {
        if (!CollectionUtils.isEmpty(compareLiteratureVOS)) {
            List<Integer> literatureIds = compareLiteratureVOS.stream().map(CompareLiteratureVO::getId).collect(Collectors.toList());
            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 (!org.springframework.util.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());
                    literatureVO.setNoveltyCompareRecordVOS(collect);
                }
            }
        }
    }


    public List<QueryCompareFileVO> queryCompareFile(QueryCompareFileDTO vo) {
        return noveltyCompareLiteratureMapper.queryCompareFile(vo);
    }

    public Integer addCompareFile(AddCompareFileDTO vo) {
        Integer compareLitertureId = vo.getId();
        NoveltyCompareLiterature literature = noveltyCompareLiteratureMapper.selectOne(new LambdaQueryWrapper<NoveltyCompareLiterature>()
                .eq(NoveltyCompareLiterature::getCompareLitertureId, compareLitertureId));
        if (ObjectUtils.isEmpty(literature)) {
            literature = new NoveltyCompareLiterature();
            BeanUtils.copyProperties(vo, literature);
            literature.setId(null);
            literature.setCompareLitertureId(compareLitertureId);
            literature.insert();
        }
        else {
            if(literature.getRetrieveRecordId()==null){
                literature.setRetrieveRecordId(vo.getRetrieveRecordId());
                literature.updateById();
            }
        }
        return literature.getId();
    }

    public Integer editCompareFile(AddCompareFileDTO vo) {
        NoveltyCompareLiterature literature = noveltyCompareLiteratureMapper.selectById(vo.getCompareFileId());
        literature.setCompareLitertureId(vo.getId());
        literature.setRetrieveRecordId(vo.getRetrieveRecordId());
        literature.setRelevance(vo.getRelevance());
        literature.setRemark(vo.getRemark());
        literature.setGeneralRemark(vo.getGeneralRemark());
        literature.setIfEffectinv(vo.getIfEffectinv());
        literature.setBeneficialEffect(vo.getBeneficialEffect());
        literature.setExcuteCase(vo.getExcuteCase());
        literature.setTechnicalPoints(vo.getTechnicalPoints());
        literature.updateById();
        return literature.getId();
    }

    public Integer editCompareFileByProjectId(EditCompareFileDTO vo) throws Exception {
        CompareLiterature compareLiterature = compareLiteratureMapper.selectOne(new LambdaQueryWrapper<CompareLiterature>()
                .eq(CompareLiterature::getLiteratureNo, vo.getPatentNo())
                .eq(CompareLiterature::getProjectId, vo.getProjectId()));
        NoveltyCompareLiterature literature = noveltyCompareLiteratureMapper.selectOne(new LambdaQueryWrapper<NoveltyCompareLiterature>()
                .eq(NoveltyCompareLiterature::getCompareLitertureId, compareLiterature.getId()));
        if (ObjectUtils.isEmpty(literature)) {
            literature = new NoveltyCompareLiterature();
            literature.setCompareLitertureId(compareLiterature.getId());
            literature.insert();
        }
        if (StringUtils.equals(vo.getField(), "fileRemark")) {
            vo.setField("remark");
        }
        GenerateObjectUtil.setObjectProperty(literature, vo.getField(), vo.getValue());
        literature.updateById();
        return literature.getId();
    }

    public void delCompareFile(CompareFileIdDTO vo) {
        NoveltyCompareLiterature noveltyCompareLiterature = noveltyCompareLiteratureMapper.selectOne(new QueryWrapper<NoveltyCompareLiterature>()
                .lambda()
                .eq(NoveltyCompareLiterature::getCompareLitertureId, vo.getCompareLitertureId()));
        if (ObjectUtils.isNotEmpty(noveltyCompareLiterature)) {
            //TODO  缺少对比记录方法，判断是否有对比记录，有的话则提示
            noveltyCompareLiteratureMapper.deleteById(noveltyCompareLiterature.getId());
        }

        compareLiteratureMapper.deleteById(vo.getCompareLitertureId());
    }

    public QueryNoveltyProjectVO getReportInfoFromWD(String caseNo) throws IOException {
        String result = getReportInfoFromWDService.getReportInfoFromWD(caseNo);
        QueryNoveltyProjectVO projectVO = new QueryNoveltyProjectVO();
        if (StringUtils.isNotEmpty(result)) {
            GetReportInfoFromWDVO wdvo = JSONObject.parseObject(result, GetReportInfoFromWDVO.class);
            projectVO.setInnerCaseNumber(wdvo.getCaseNo());
            projectVO.setCaseName(wdvo.getCaseName());
            if (ObjectUtils.isNotEmpty(wdvo.getCustomer()) && StringUtils.isNotEmpty(wdvo.getCustomer().getName())) {
                projectVO.setApplicants(wdvo.getCustomer().getName());
            }
        }
        return projectVO;
    }


    public static String getSelectText(WebElement element) {
        String strValue = element.getAttribute("value");

        if (strValue == null || strValue.isEmpty()) {
            return null;
        }

        List<WebElement> ops = element.findElements(By.tagName("option"));
        for (WebElement op : ops) {
            if (op.getAttribute("value").equals(strValue)) {
                return op.getText();
            }
        }
        return null;
    }

    public List<Integer> copyCompareFile(List<Integer> ids, Integer toProjectId, Integer fromProjectId) throws Exception {

        if (ids == null || ids.size() == 0) {
            return new ArrayList<>();
        }
        QueryCompareFileDTO queryCompareFileDTOFrom = new QueryCompareFileDTO();
        queryCompareFileDTOFrom.setIds(ids);
        List<QueryCompareFileVO> queryCompareFileVOSFrom = this.getBaseMapper().queryCompareFile(queryCompareFileDTOFrom);
        List<String> patentNos = queryCompareFileVOSFrom.stream().map(QueryCompareFileVO::getLiteratureNo).collect(Collectors.toList());

        QueryCompareFileDTO queryCompareFileDTOTo = new QueryCompareFileDTO();
        queryCompareFileDTOTo.setPatentNos(patentNos);
        queryCompareFileDTOTo.setProjectId(toProjectId);
        List<QueryCompareFileVO> queryCompareFileVOSTo = this.getBaseMapper().queryCompareFile(queryCompareFileDTOTo);

        for (QueryCompareFileVO queryCompareFileVO : queryCompareFileVOSFrom) {
            importSinglePatentService.addPatentToProject(queryCompareFileVO.getLiteratureNo(),toProjectId);
            QueryCompareFileVO queryCompareFileVOTo = queryCompareFileVOSTo.stream().filter(item -> item.getLiteratureNo().equals(queryCompareFileVO.getLiteratureNo())).findFirst().orElse(null);
            if (queryCompareFileVOTo == null) {
                CompareLiterature compareLiterature = new CompareLiterature();
                BeanUtils.copyProperties(queryCompareFileVO, compareLiterature);
                compareLiterature.setRemark(queryCompareFileVO.getLiteratureRemark());
                compareLiterature.setProjectId(toProjectId);
                compareLiterature.setId(null);
                compareLiterature.insert();
                NoveltyCompareLiterature noveltyCompareLiterature = new NoveltyCompareLiterature();
                BeanUtils.copyProperties(queryCompareFileVO, noveltyCompareLiterature);
                noveltyCompareLiterature.setRemark(queryCompareFileVO.getFileRemark());

                noveltyCompareLiterature.setCompareLitertureId(compareLiterature.getId());
                noveltyCompareLiterature.insert();
            } else {
                Integer fromId = queryCompareFileVO.getCompareFileId();
                if (fromId == null) {
                    //什么都不需要做
                } else {
                    Integer toId = queryCompareFileVOTo.getCompareFileId();
                    if (toId == null) {
                        NoveltyCompareLiterature noveltyCompareLiterature = new NoveltyCompareLiterature();
                        BeanUtils.copyProperties(queryCompareFileVO, noveltyCompareLiterature);
                        noveltyCompareLiterature.setRemark(queryCompareFileVO.getFileRemark());

                        noveltyCompareLiterature.setCompareLitertureId(queryCompareFileVOTo.getCompareLitertureId());
                        noveltyCompareLiterature.insert();
                    } else {
                        NoveltyCompareLiterature noveltyCompareLiterature = new NoveltyCompareLiterature();
                        BeanUtils.copyProperties(queryCompareFileVOTo, noveltyCompareLiterature);
                        noveltyCompareLiterature.setRemark(queryCompareFileVO.getFileRemark());

                        if (queryCompareFileVO.getBeneficialEffect() != null) {
                            noveltyCompareLiterature.setBeneficialEffect(noveltyCompareLiterature.getBeneficialEffect() + queryCompareFileVO.getBeneficialEffect());
                        }
                        if (queryCompareFileVO.getRelevance() != null) {
                            noveltyCompareLiterature.setRelevance(noveltyCompareLiterature.getRelevance() + queryCompareFileVO.getRelevance());
                        }
                        if (queryCompareFileVO.getLiteratureRemark() != null) {
                            noveltyCompareLiterature.setRemark(noveltyCompareLiterature.getRemark() + queryCompareFileVO.getLiteratureRemark());
                        }
                        if (queryCompareFileVO.getGeneralRemark() != null) {
                            noveltyCompareLiterature.setGeneralRemark(noveltyCompareLiterature.getGeneralRemark() + queryCompareFileVO.getGeneralRemark());
                        }
                        if (queryCompareFileVO.getTechnicalPoints() != null) {
                            noveltyCompareLiterature.setGeneralRemark(noveltyCompareLiterature.getTechnicalPoints() + queryCompareFileVO.getTechnicalPoints());
                        }
                        if (queryCompareFileVO.getExcuteCase() != null) {
                            noveltyCompareLiterature.setExcuteCase(noveltyCompareLiterature.getExcuteCase() + queryCompareFileVO.getExcuteCase());

                        }
                        if (queryCompareFileVO.getBeneficialEffect() != null) {
                            noveltyCompareLiterature.setBeneficialEffect(noveltyCompareLiterature.getBeneficialEffect() + queryCompareFileVO.getBeneficialEffect());
                        }
                    }

                }

            }

        }
        //添加标注
        if (patentNos != null && patentNos.size() > 0) {
            List<NoveltyCompareRecordVO> noveltyCompareRecordVOS = esScratchWordsService.queryMarkingByNo(fromProjectId, patentNos);
            List<NoveltyCompareRecordVO> noveltyCompareRecordVOList = esScratchWordsService.queryMarkingByNo(toProjectId, patentNos);
            List<Marking> markings = new ArrayList<>();

            noveltyCompareRecordVOS.forEach(item -> {
                NoveltyCompareRecordVO noveltyCompareRecordVO = noveltyCompareRecordVOList.stream().filter(t -> t.getPatentNo().equals(item.getPatentNo())).findFirst().orElse(null);
                Marking marking = new Marking();
                if (noveltyCompareRecordVO != null) {
                    BeanUtils.copyProperties(noveltyCompareRecordVO, marking);
                    if (noveltyCompareRecordVO.getMarkNoteText() != null) {
                        marking.setMarkNoteText(noveltyCompareRecordVO.getMarkNoteText() + item.getMarkNoteText());
                    } else {
                        marking.setMarkNoteText(item.getMarkNoteText());
                    }
                    esScratchWordsService.updateScratchWords(noveltyCompareRecordVO.getId(), marking);
                } else {
                    BeanUtils.copyProperties(item, marking);
                    marking.setProjectId(toProjectId);
                    markings.add(marking);
                }
            });

            esScratchWordsService.saveListToEs(markings);
        }
        return ids;
    }

    /**
     * 根据检索记录ids查询专利信息
     *
     * @param retrieveIds
     * @return
     */
    public Map<Integer, List<NoveltyCompareLiteratureVO>> getPatentNoByRetrieveIds(List<Integer> retrieveIds) {
        Map<Integer, List<NoveltyCompareLiteratureVO>> noveltyMap = new HashMap<>();
        for (Integer retrieveId : retrieveIds) {
            List<NoveltyCompareLiteratureVO> noveltyCompareLiteratureVOS = noveltyCompareLiteratureMapper.getPatentNoByRetrieveId(retrieveId);
            if (noveltyCompareLiteratureVOS != null && noveltyCompareLiteratureVOS.size() != 0) {
                noveltyMap.put(retrieveId, noveltyCompareLiteratureVOS);
            }
        }
        return noveltyMap;
    }
}