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

package cn.cslg.pas.service.getPatentStarPart;

import cn.cslg.pas.common.model.dto.GetPatentStarPartDTO;
import cn.cslg.pas.common.model.dto.PatentDTO;
import cn.cslg.pas.common.model.outApi.PatentStarListDto;
import cn.cslg.pas.common.model.vo.KeyValueVO;
import cn.cslg.pas.common.model.vo.PageVO;
import cn.cslg.pas.common.model.vo.UploadParamsVO;
import cn.cslg.pas.common.model.vo.outApi.StarPatentVO;
import cn.cslg.pas.domain.*;
import cn.cslg.pas.service.outApi.PatentStarApiService;
import cn.cslg.pas.service.upLoadPatent.ExcutePatentDataStar;
import com.alibaba.fastjson.JSON;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.codec.binary.Base64;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;

import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.sql.SQLException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 获取专利之星专利某部分（如权要、说明书等一项）业务层
 *
 * @Author chenyu
 * @Date 2023/6/30
 */
@Slf4j
@Service
@RequiredArgsConstructor
public class GetPatentStarPartService {
    private final ExcutePatentDataStar excutePatentDataStar;
    private final PatentStarApiService patentStarApiService;

    /**
     * 根据专利号或申请号获取专利指定部分项
     *
     * @param getPatentStarPartDTO 前端传输DTO对象
     * @return 返回装载着指定专利项的对象
     */
    public PatentDTO getPatentPart(GetPatentStarPartDTO getPatentStarPartDTO) throws IOException, SQLException {
        log.info("开始处理【根据专利号或申请号获取专利指定部分项】的业务，参数为：{}", getPatentStarPartDTO);

        Integer patentCell = getPatentStarPartDTO.getPatentCell();
        String appNo = getPatentStarPartDTO.getAppNo();
        String patentNo = getPatentStarPartDTO.getPatentNo();
        PatentDTO patentDTO;
        if (patentCell == 1) {
            patentDTO = getParentRight(appNo);  //拿权要
        } else if (patentCell == 2) {
            patentDTO = getInstructionText(appNo);  //拿说明书文本
        } else if (patentCell == 3) {
            patentDTO = getInstructionPDF(appNo, patentNo);  //拿说明书pdf
        } else if (patentCell == 4) {
            patentDTO = getPatentImage(appNo);  //拿摘要附图
        } else if (patentCell == 5) {
            patentDTO = getSimpleFamily(getPatentStarPartDTO);  //拿同族专利信息
        } else if (patentCell == 6) {
            patentDTO = getAffair(appNo);  //拿法律事务信息
        } else {
            patentDTO = new PatentDTO();
        }

        return patentDTO;
    }

    /**
     * 获取专利之星专利的权要
     *
     * @param appNo 申请号
     * @return 返回装载着权要的对象
     */
    public PatentDTO getParentRight(String appNo) throws IOException {
        StarPatentVO starPatentVO = new StarPatentVO()
                .setApplicationNo(appNo);
        UploadParamsVO uploadParamsVO = new UploadParamsVO();
        //调用"获得中国专利全文文本"接口，处理xml格式权要
        excutePatentDataStar.setPatentClaim(starPatentVO, uploadParamsVO, null);

        PatentDTO patentDTO = new PatentDTO();
        ArrayList<PatentRight> patentRights = new ArrayList<>();
        patentRights.add(uploadParamsVO.getPatentRight());
        patentDTO.setRights(patentRights);

        return patentDTO;
    }

    /**
     * 获取专利之星专利的说明书文本
     *
     * @param appNo 申请号
     * @return 返回装载着说明书文本的对象
     */
    public PatentDTO getInstructionText(String appNo) throws IOException {
        StarPatentVO starPatentVO = new StarPatentVO()
                .setApplicationNo(appNo);
        UploadParamsVO uploadParamsVO = new UploadParamsVO();
        //调用"获得中国专利全文文本"接口，处理xml格式说明书文本
        excutePatentDataStar.setPatentInstructionText(starPatentVO, uploadParamsVO, null);

        PatentDTO patentDTO = new PatentDTO();
        patentDTO.setInstruction(uploadParamsVO.getPatentInstructionText());

        return patentDTO;
    }

    /**
     * 获取专利之星专利的说明书pdf
     *
     * @param patentNo 专利号（公开号）
     * @return 返回装载着说明书pdf的对象
     */
    public PatentDTO getInstructionPDF(String appNo, String patentNo) throws IOException, SQLException {
        String applicationNo = appNo + "";
        if (appNo.contains(".")) {
            appNo = appNo.substring(0, appNo.lastIndexOf("."));
        }

        ArrayList<PatentInstruction> patentInstructions = new ArrayList<>();
        PatentDTO patentDTO = new PatentDTO();

        String pdfUrl = "", pdfUrl1 = "", pdfUrl2 = "";
        if (patentNo.contains("CN")) {
            //调用"获得中国专利pdf"接口，获得公开和授权中的1个或2个url
            String pdfUrlStr = patentStarApiService.getCnPdfApi(appNo);

            //若没有取到说明书pdf，则将当前申请号和备注信息存入问题记录表，并返回空对象
            if (pdfUrlStr.equals("")) {
                excutePatentDataStar.recordQuestionPatent(applicationNo, null, 4);
                return new PatentDTO();
            }

            if (pdfUrlStr.contains("|http")) {  //若两个都有
                String[] pdfUrlArr = pdfUrlStr.split("\\|http");
                pdfUrl1 = pdfUrlArr[0].substring(pdfUrlArr[0].indexOf("http"), pdfUrlArr[0].indexOf("?"));
                pdfUrlArr[1] = "http" + pdfUrlArr[1];
                pdfUrl2 = pdfUrlArr[1].substring(pdfUrlArr[1].indexOf("http"), pdfUrlArr[1].indexOf("?"));

                PatentInstruction patentInstruction = new PatentInstruction();
                PatentInstruction patentInstruction2 = new PatentInstruction();
                patentInstruction.setUrl(pdfUrl1);
                patentInstruction2.setUrl(pdfUrl2);
                patentInstruction.setPictureStringData(urlToBytes(pdfUrl1));
                patentInstruction2.setPictureStringData(urlToBytes(pdfUrl2));
                if (pdfUrl1.contains("0A_CN_0.pdf")) {
                    patentInstruction.setType(1);
                    patentInstruction2.setType(2);
                } else {
                    patentInstruction.setType(2);
                    patentInstruction2.setType(1);
                }
                patentInstructions.add(patentInstruction);
                patentInstructions.add(patentInstruction2);

            } else {  //若只有一个
                pdfUrl1 = pdfUrlStr.substring(pdfUrlStr.indexOf("http"), pdfUrlStr.indexOf("?"));
                PatentInstruction patentInstruction = new PatentInstruction();
                patentInstruction.setUrl(pdfUrl1);
                patentInstruction.setPictureStringData(urlToBytes(pdfUrl1));
                if (pdfUrl1.contains("0A_CN_0.pdf")) {
                    patentInstruction.setType(1);
                } else {
                    patentInstruction.setType(2);
                }
                patentInstructions.add(patentInstruction);
            }

        } else {
            //根据专利号调用"获得世界专利pdf"接口，获得pdf的url地址
            pdfUrl = patentStarApiService.getEnPdfApi(patentNo);

            //若没有取到说明书pdf，则将当前申请号和备注信息存入问题记录表，并返回空对象
            if (pdfUrl.equals("") || pdfUrl.equals("{}")) {
                excutePatentDataStar.recordQuestionPatent(applicationNo, null, 4);
                return new PatentDTO();
            }

            PatentInstruction patentInstruction = new PatentInstruction();
            patentInstruction.setUrl(pdfUrl);
            patentInstruction.setPictureStringData(urlToBytes(pdfUrl));
            patentInstruction.setType(1);
            patentInstructions.add(patentInstruction);

        }

        patentDTO.setPdf(patentInstructions);

        return patentDTO;
    }

    /**
     * 获取专利之星专利的摘要附图
     *
     * @param appNo 申请号
     * @return 返回装载着摘要附图的对象
     */
    public PatentDTO getPatentImage(String appNo) {
        //以下 ↓调用的是"获得中国专利摘要附图"接口，获得摘要附图的url地址
        if (appNo.contains(".")) {
            appNo = appNo.substring(0, appNo.lastIndexOf("."));
        }

        String pictureUrl = patentStarApiService.getPictureApi(appNo);

        PatentDTO patentDTO = new PatentDTO();
        ArrayList<PatentImage> patentImages = new ArrayList<>();
        PatentImage patentImage = new PatentImage();
        patentImage.setUrl(pictureUrl);
        patentImages.add(patentImage);
        patentDTO.setImage(patentImages);

        return patentDTO;
    }

    /**
     * 获取专利之星专利的同族专利
     *
     * @param getPatentStarPartDTO 获取专利之星专利指定项DTO类
     * @return 返回装载着同族专利的对象集合
     */
    public PatentDTO getSimpleFamily(GetPatentStarPartDTO getPatentStarPartDTO) throws IOException {
        //从DTO中取出公开号、当前页、每页条数
        String patentNo = getPatentStarPartDTO.getPatentNo();
        Integer current = getPatentStarPartDTO.getCurrent();
        Integer size = getPatentStarPartDTO.getSize();

        PatentDTO patentDTO = new PatentDTO();
        PageVO pageVO = new PageVO()
                .setCurrent(current)  //装载当前页
                .setSize(size);  //装载每页条数

        try {
            //1.从同族接口获取同族号单
            String familyPatentNoStr = patentStarApiService.getFamilyByPubNoApi(patentNo);
            //若接口返回"no data"即没有同族号，则返回空集合同族信息
            if (familyPatentNoStr.equals("no data")) {
                pageVO.setRecords(new ArrayList<>())
                        .setTotal(0);
                patentDTO.setFamilyPatentResult(pageVO);
                return patentDTO;
            }

            FamilyPatentNo familyPatentNo = JSON.parseObject(familyPatentNoStr, FamilyPatentNo.class);
            List<String> familyPatentNos = Arrays.asList(familyPatentNo.getFamilyinfo().split(";"));
            //装载总条数
            pageVO.setTotal(familyPatentNos.size());

            //2.根据分页条件截取需要位置的条数
            List<String> needShowFamilyPatentNos = pageBySubList(familyPatentNos, current, size);

            //3.拼接成检索式
            List<String> cNfamilyPatentNos = needShowFamilyPatentNos.stream().filter(item -> item.contains("CN")).collect(Collectors.toList());
            List<String> wDfamilyPatentNos = needShowFamilyPatentNos.stream().filter(item -> !item.contains("CN")).collect(Collectors.toList());

            String cNconditions = "", wDconditions = "";
            if (cNfamilyPatentNos.size() > 0) {
                cNconditions = "PN=(" + StringUtils.join(cNfamilyPatentNos, " OR ") + ")";
            }
            if (wDfamilyPatentNos.size() > 0) {
                wDconditions = "PN=(" + StringUtils.join(wDfamilyPatentNos, " OR ") + ")";
            }

            //根据专利的国家类型调用并使用对应的库(中国/世界库)，返回这些同族号专利的著录相关数据（标题、申请人、权利人、摘要附图）
            List<StarPatentVO> cNpatents = new ArrayList<>();
            List<StarPatentVO> wDpatents = new ArrayList<>();
            if (!cNconditions.equals("")) {
                PatentStarListDto patentStarListDto = new PatentStarListDto()
                        .setCurrentQuery(cNconditions)
                        .setOrderBy("ID")
                        .setOrderByType("DESC")
                        .setPageNum(1)
                        .setRowCount(size)
                        .setDBType("CN");
                Map<String, Object> resultMap = patentStarApiService.patentStarSearchApi(patentStarListDto);
                if (resultMap == null || (Integer) resultMap.get("total") == 0) {
                    for (String cNfamilyPatentNo : cNfamilyPatentNos) {
                        cNpatents.add(new StarPatentVO().setPatentNo(cNfamilyPatentNo));
                    }
                } else {
                    cNpatents = (List<StarPatentVO>) resultMap.get("records");
                }
            }
            if (!wDconditions.equals("")) {
                PatentStarListDto patentStarListDto = new PatentStarListDto()
                        .setCurrentQuery(wDconditions)
                        .setOrderBy("ID")
                        .setOrderByType("DESC")
                        .setPageNum(1)
                        .setRowCount(size)
                        .setDBType("WD");
                Map<String, Object> resultMap = patentStarApiService.patentStarSearchApi(patentStarListDto);
                if (resultMap == null || (Integer) resultMap.get("total") == 0) {
                    for (String wDfamilyPatentNo : wDfamilyPatentNos) {
                        wDpatents.add(new StarPatentVO().setPatentNo(wDfamilyPatentNo));
                    }
                } else {
                    wDpatents = (List<StarPatentVO>) resultMap.get("records");
                }
            }

            //将中国和外国专利数据合并
            ArrayList<StarPatentVO> patents = new ArrayList<>();
            patents.addAll(cNpatents);
            patents.addAll(wDpatents);

            List<PatentSimpleFamilyLink> records = new ArrayList<>();
            for (StarPatentVO starPatent : patents) {
                PatentSimpleFamilyLink patentSimpleFamilyLink = new PatentSimpleFamilyLink();
                patentSimpleFamilyLink.setPatentNo(starPatent.getPatentNo());  //装载专利号
                patentSimpleFamilyLink.setPublicNo(starPatent.getPublicNo());  //装载公开号
                patentSimpleFamilyLink.setApplicationNo(starPatent.getApplicationNo());  //装载申请号
                patentSimpleFamilyLink.setPublicDate(starPatent.getPublicDate());  //装载公开日
                patentSimpleFamilyLink.setPublicAccreditDate(starPatent.getPublicAccreditDate());  //装载公告日
                patentSimpleFamilyLink.setName(starPatent.getName());  //装载标题
                //装载申请人和权利人
                ArrayList<PatentApplicant> patentApplicants = new ArrayList<>();
                //装载申请人
                if (starPatent.getApplicantStr() != null && !starPatent.getApplicantStr().equals("")) {
                    String[] patentApplicantOriginalNames = starPatent.getApplicantStr().split(";");
                    for (String patentApplicantOriginalName : patentApplicantOriginalNames) {
                        PatentApplicant patentApplicant = new PatentApplicant();
                        patentApplicant.setName(patentApplicantOriginalName);
                        patentApplicant.setDataType(2);
                        patentApplicants.add(patentApplicant);  //装载申请人
                    }
                }
                //装载权利人
                if (starPatent.getCurrentApplicantStr() != null && !starPatent.getCurrentApplicantStr().equals("")) {
                    String[] patentApplicantCurrentNames = (starPatent.getCurrentApplicantStr().split(";"));
                    for (String patentApplicantCurrentName : patentApplicantCurrentNames) {
                        PatentApplicant patentApplicant = new PatentApplicant();
                        patentApplicant.setName(patentApplicantCurrentName);
                        patentApplicant.setDataType(1);
                        patentApplicants.add(patentApplicant);  //装载权利人
                    }
                }
                patentSimpleFamilyLink.setApplicant(patentApplicants);
                records.add(patentSimpleFamilyLink);
            }

            pageVO.setRecords(records);  //装载结果集
            patentDTO.setFamilyPatentResult(pageVO);

        } catch (Exception e) {
            pageVO.setRecords(new ArrayList<>())
                    .setTotal(0);
            patentDTO.setFamilyPatentResult(pageVO);
            return patentDTO;
        }

        return patentDTO;
    }

    public PatentDTO getAffair(String appNo) throws IOException {
        PatentDTO patentDTO = new PatentDTO();

        if (appNo.contains(".")) {
            appNo = appNo.substring(0, appNo.lastIndexOf("."));
        }
        //以下 ↓装载的是调用"获得中国专利法律状态"接口返回的专利相关数据
        try {
            String cnLegalApiStr = patentStarApiService.getCnLegalApi(appNo);
            if (!cnLegalApiStr.equals("")) {
                List<ChinaLeagalStatus> chinaLeagalStatuses = JSON.parseArray(cnLegalApiStr, ChinaLeagalStatus.class);
                if (chinaLeagalStatuses != null && chinaLeagalStatuses.size() > 0) {
                    ArrayList<KeyValueVO> lst = new ArrayList<>();
                    HashMap<Integer, String> nameMap = new HashMap<>();
                    HashMap<Integer, String> contentMap = new HashMap<>();
                    nameMap.put(0, "发生日期");
                    nameMap.put(1, "法律状态");
                    nameMap.put(2, "详细法律状态");
                    nameMap.put(3, "详细信息");
                    for (ChinaLeagalStatus chinaLeagalStatus : chinaLeagalStatuses) {
                        contentMap.put(0, chinaLeagalStatus.getLegalDate());
                        contentMap.put(1, chinaLeagalStatus.getLegalStatus());
                        contentMap.put(2, chinaLeagalStatus.getLegalStatusInfo());
                        contentMap.put(3, chinaLeagalStatus.getDETAIL());
                        ArrayList<KeyValueVO.InpadocData> inpadocDatas = new ArrayList<>();
                        for (int i = 0; i < 4; i++) {
                            KeyValueVO.InpadocData inpadocData = new KeyValueVO.InpadocData();
                            inpadocData.setName(nameMap.get(i));
                            inpadocData.setContent(contentMap.get(i));
                            inpadocDatas.add(inpadocData);
                        }
                        KeyValueVO keyValueVO = new KeyValueVO();
                        keyValueVO.setInpadocData(inpadocDatas);
                        lst.add(keyValueVO);
                    }
                    ArrayList<PatentAffair> patentAffairs = new ArrayList<>();
                    PatentAffair patentAffair = new PatentAffair();
                    patentAffair.setInpadoc(lst);
                    patentAffairs.add(patentAffair);
                    patentDTO.setAffair(patentAffairs);
                }
            }
        } catch (Exception e) {
            return patentDTO;
        }

        return patentDTO;
    }

    public String urlToBytes(String pdfUrl) throws IOException {
        ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
        URL url = new URL(pdfUrl);  //想要读取的url地址
        InputStream in = url.openStream();
        int bytesRead;
        byte[] buffer = new byte[8192];

        //读取url地址文件
        while ((bytesRead = in.read(buffer)) != -1) {
            outputStream.write(buffer, 0, bytesRead);
        }

        //关闭释放流
        in.close();

        byte[] bytes = outputStream.toByteArray();
        //BASE64Encoder encoder = new BASE64Encoder();
        //String data = encoder.encode(bytes);
        String data = Base64.encodeBase64String(bytes);
        return data;
    }

    /**
     * 根据分页信息，取同族号集合中分页区间内的同族号
     *
     * @param list    同族号集合
     * @param current 当前页
     * @param size    每页条数
     * @return 返回需要的同族号集合
     */
    public static List<String> pageBySubList(List<String> list, int current, int size) {
        int totalcount = list.size();
        int pagecount = 0;
        List<String> subList;

        int m = totalcount % size;
        if (m > 0) {
            pagecount = totalcount / size + 1;
        } else {
            pagecount = totalcount / size;
        }

        if (m == 0) {
            subList = list.subList((current - 1) * size, size * (current));
        } else {
            if (current == pagecount) {
                subList = list.subList((current - 1) * size, totalcount);
            } else {
                subList = list.subList((current - 1) * size, size * (current));
            }
        }

        return subList;

    }

}