Wispro-CodeWarehouse-BackEnd/PAS/src/main/java/cn/cslg/pas/service/PatentSimpleFamilyService.java

package cn.cslg.pas.service;

import cn.cslg.pas.domain.PatentSimpleFamilyLink;
import cn.cslg.pas.common.utils.StringUtils;
import cn.cslg.pas.domain.Patent;
import cn.cslg.pas.domain.PatentSimpleFamily;
import cn.cslg.pas.mapper.PatentSimpleFamilyMapper;
import cn.cslg.pas.common.model.params.PatentSimpleFamilyParams;
import cn.cslg.pas.common.utils.PatentUtils;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import lombok.RequiredArgsConstructor;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

import java.util.List;
import java.util.stream.Collectors;

/**
 * <p>
 * 专利信息简单同族关联表 服务类
 * </p>
 *
 * @author 王岩
 * @since 2022-02-24
 */
@Service
@RequiredArgsConstructor(onConstructor_ = {@Lazy})
public class PatentSimpleFamilyService extends ServiceImpl<PatentSimpleFamilyMapper, PatentSimpleFamily> {

    private final PatentService patentService;
    private final PatentApplicantService patentApplicantService;
    private final PatentSimpleFamilyLinkService patentSimpleFamilyLinkService;

    public PatentSimpleFamily getPatentSimpleFamilyByIdsAndType(List<Integer> ids, Integer type) {
        if (ids == null || ids.size() == 0) {
            return null;
        }
        LambdaQueryWrapper<PatentSimpleFamily> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(PatentSimpleFamily::getId, ids);
        queryWrapper.eq(PatentSimpleFamily::getType, type);
        return this.getOne(queryWrapper);
    }

    public List<PatentSimpleFamily> getPatentSimpleFamilyByIds(List<Integer> ids) {
        if (ids == null || ids.size() == 0) {
            return null;
        }
        LambdaQueryWrapper<PatentSimpleFamily> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(PatentSimpleFamily::getId, ids);
        return this.list(queryWrapper);
    }

    public void importPatentSimpleFamily(Patent patent, List<PatentSimpleFamily> importPatentSimpleFamilyList,  List<PatentSimpleFamilyLink> importPatentSimpleFamilyLinkList) {
        List<PatentSimpleFamilyLink> importPatentSimpleFamilyLink = importPatentSimpleFamilyLinkList.stream().filter(item -> item.getFamilyId().equals(patent.getSimpleFamily())).collect(Collectors.toList());
        List<PatentSimpleFamilyLink> importPatentInpadocFamilyLink = importPatentSimpleFamilyLinkList.stream().filter(item -> item.getFamilyId().equals(patent.getInpadocFamily())).collect(Collectors.toList());
        List<PatentSimpleFamilyLink> importPatentPatSnapFamilyLink = importPatentSimpleFamilyLinkList.stream().filter(item -> item.getFamilyId().equals(patent.getPatSnapFamily())).collect(Collectors.toList());
        PatentSimpleFamilyParams patentSimpleFamilyParams = new PatentSimpleFamilyParams();
        patentSimpleFamilyParams.setPatentId(patent.getId());
        patentSimpleFamilyParams.setPatentNo(patent.getPatentNo());
        patentSimpleFamilyParams.setSimpleFamily(importPatentSimpleFamilyLink.stream().map(PatentSimpleFamilyLink::getPatentNo).collect(Collectors.toList()));
        patentSimpleFamilyParams.setInpadocFamily(importPatentInpadocFamilyLink.stream().map(PatentSimpleFamilyLink::getPatentNo).collect(Collectors.toList()));
        patentSimpleFamilyParams.setPatSnapFamily(importPatentPatSnapFamilyLink.stream().map(PatentSimpleFamilyLink::getPatentNo).collect(Collectors.toList()));
        this.updatePatentSimpleFamily(patentSimpleFamilyParams);
    }

    public void updatePatentSimpleFamily(PatentSimpleFamilyParams params) {
        if (params.getSimpleFamily() != null && params.getSimpleFamily().size() != 0) {
            this.updateData(params.getSimpleFamily(), params.getPatentNo(), params.getPatentId(), 1);
        }
        if (params.getInpadocFamily() != null && params.getInpadocFamily().size() != 0) {
            this.updateData(params.getInpadocFamily(), params.getPatentNo(), params.getPatentId(), 2);
        }
        if (params.getPatSnapFamily() != null && params.getPatSnapFamily().size() != 0) {
            this.updateData(params.getPatSnapFamily(), params.getPatentNo(), params.getPatentId(), 3);
        }
    }

    public PatentSimpleFamily add(Integer type) {
        PatentSimpleFamily patentSimpleFamily = new PatentSimpleFamily();
        patentSimpleFamily.setType(type);
        patentSimpleFamily.insert();
        return patentSimpleFamily;
    }

    public void updateData(List<String> familyNo, String patentNo, Integer patentId, Integer type) {
        //两个表 1.同族表 2.同组关联专利表
        //用专利号 获取同族关联专利表的信息
        List<PatentSimpleFamilyLink> patentSimpleFamilyLinkList = patentSimpleFamilyLinkService.getPatentSimpleFamilyLinkByPatentNo(patentNo);
        PatentSimpleFamily family;

        if (patentSimpleFamilyLinkList == null || patentSimpleFamilyLinkList.size() == 0) {
            //如果 同组关联专利表 内没有数据 就新建一条 同族表 的数据
            family = this.add(type);
        } else {
            //如果 同组关联专利表 内有数据 那么用查询出来的List中的 同族表 的ID来获取 同族表 内的其他对应信息
            PatentSimpleFamily patentSimpleFamily = this.getPatentSimpleFamilyByIdsAndType(patentSimpleFamilyLinkList.stream().map(PatentSimpleFamilyLink::getFamilyId).collect(Collectors.toList()), type);
            if (patentSimpleFamily == null) {
                family = this.add(type);
            } else {
                family = patentSimpleFamily;
            }
        }
        for (String patent : familyNo) {
            PatentSimpleFamilyLink temp = patentSimpleFamilyLinkService.getPatentSimpleFamilyLinkByPatentNoAndFamilyId(patent, family.getId());
            if (temp == null) {
                PatentSimpleFamilyLink patentSimpleFamilyLink = new PatentSimpleFamilyLink();
                patentSimpleFamilyLink.setFamilyId(family.getId());
                patentSimpleFamilyLink.setPatentNo(patent);
                patentSimpleFamilyLink.insert();
            } else {
                temp.setFamilyId(family.getId());
                temp.updateById();
            }


            Patent patent1 = patentService.getPublicDateAndPatentNoByPatentNo(patent);
            Patent patent2 = patentService.getPublicDateAndPatentNoByPatentNo(family.getPatentNo());
            if (patent1 != null) {
                switch (type) {
                    case 1:
                        patent1.setSimpleFamily(family.getId());
                        break;
                    case 2:
                        patent1.setInpadocFamily(family.getId());
                        break;
                    case 3:
                        patent1.setPatSnapFamily(family.getId());
                        break;
                }
                family.setPatentNo(patent1.getPatentNo());
                patent1.updateById();
            }
            if (patent2 != null) {
                switch (type) {
                    case 1:
                        patent2.setSimpleFamily(family.getId());
                        break;
                    case 2:
                        patent2.setInpadocFamily(family.getId());
                        break;
                    case 3:
                        patent2.setPatSnapFamily(family.getId());
                        break;
                }
                family.setPatentNo(patent2.getPatentNo());
                patent2.updateById();
            }


            if (StringUtils.isEmpty(family.getPatentNo())) {
                family.setPatentNo(patent);
            } else {
                if (patent1 != null && patent2 != null) {
                    String country1 = PatentUtils.getPatentCountry(patent1.getPatentNo());
                    String country2 = PatentUtils.getPatentCountry(patent2.getPatentNo());
                    if ("CN".equals(country1) && !"CN".equals(country2)) {
                        family.setPatentNo(patent1.getPatentNo());
                    }
                    if (!"CN".equals(country1) && "CN".equals(country2)) {
                        family.setPatentNo(patent2.getPatentNo());
                    }
                    if ("CN".equals(country1) && "CN".equals(country2)) {
                        Integer publicData1 = patent1.getPublicDate();
                        Integer publicData2 = patent2.getPublicDate();
                        if (publicData1 == null && publicData2 != null) {
                            family.setPatentNo(patent2.getPatentNo());
                        }
                        if (publicData1 != null && publicData2 == null) {
                            family.setPatentNo(patent1.getPatentNo());
                        }
                        if (publicData1 != null && publicData2 != null) {
                            if (publicData1 > publicData2) {
                                family.setPatentNo(patent2.getPatentNo());
                            } else {
                                family.setPatentNo(patent1.getPatentNo());
                            }
                        }
                    }
                }
            }
            family.updateById();
        }
    }
}