PAS/src/main/java/cn/cslg/pas/service/ReportExportService.java

package cn.cslg.pas.service;

import cn.cslg.pas.common.dto.PatentColumnDTO;
import cn.cslg.pas.common.dto.PatentDTO;
import cn.cslg.pas.common.dto.es.EsCustomFieldValueDTO;
import cn.cslg.pas.common.model.SystemMO;
import cn.cslg.pas.common.model.cronModel.PersonnelVO;
import cn.cslg.pas.common.model.request.StringRequest;
import cn.cslg.pas.common.utils.*;
import cn.cslg.pas.common.vo.*;
import cn.cslg.pas.domain.ReportDocument;
import cn.cslg.pas.domain.business.*;
import cn.cslg.pas.domain.es.Patent;
import cn.cslg.pas.domain.es.Text;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.mapper.AvoidDesignMapper;
import cn.cslg.pas.service.business.*;
import cn.cslg.pas.service.business.es.*;
import cn.cslg.pas.service.common.FileManagerService;
import cn.hutool.core.util.IdUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.deepoove.poi.XWPFTemplate;
import com.deepoove.poi.config.Configure;
import com.deepoove.poi.data.PictureRenderData;
import com.deepoove.poi.data.PictureType;
import com.deepoove.poi.data.Pictures;
import com.deepoove.poi.plugin.table.LoopRowTableRenderPolicy;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.ddr.poi.html.HtmlRenderPolicy;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.time.format.DateTimeFormatter;
import java.util.*;
import java.util.stream.Collectors;

@Slf4j
@Service
public class ReportExportService {
    @Autowired
    private ReportTempleService templeService;
    @Autowired
    private FileUtils fileUtils;
    @Autowired
    private ReportProjectService reportProjectService;
    @Autowired
    private FileManagerService fileManagerService;
    @Autowired
    private EsPatentService esPatentService;
    @Autowired
    private AvoidDesignMapper avoidDesignMapper;

    @Autowired
    private TemplateConfigService templateConfigService;
    @Autowired
    private CustomFieldService customFieldService;
    @Autowired
    private EsService esService;
    @Autowired
    private FTOCompareRecordService ftoCompareRecordService;

    @Autowired
    private EsQuotePatentService esQuotePatentService;

    @Autowired
    private EsFamilyService esFamilyService;

    @Autowired
    private LoginUtils loginUtils;
    @Autowired
    private CacheUtils cacheUtils;
    @Autowired
    private EsLegalEventService esLegalEventService;

    /**
     * @param projectId
     * @param templeId
     * @return
     * @throws IOException
     * @function: 导出报告
     */
    public String exportReport(Integer projectId, Integer templeId) throws IOException {
        //根据模板ID获得模板
        ReportTemple reportTemplate = templeService.getById(templeId);
        //获得模板路径
        String templateFilePath = fileUtils.getPath(reportTemplate.getTemplatePath());
        //读取模板后保存生成word的地址
        String fileName = IdUtil.simpleUUID() + ".docx";
        String directoryName = fileUtils.createDirectory();
        String outPath = fileUtils.getSavePath(directoryName) + fileName;

        //根据ProjectId 获得报告
        LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ReportProject::getProjectId, projectId);
        ReportProject report = reportProjectService.getOne(queryWrapper, false);
        if (report == null) {
            throw new XiaoShiException("报告不存在");
        }
        XWPFTemplate template = null;
        if (report.getReportType() == 0 || report.getReportType() == 2) {
//           template = this.getstabilityTemplate(projectId, templateFilePath);
        } else if (report.getReportType() == 3) {
            template = this.FTOTemplate(projectId, templateFilePath, templeId);
        } else if (report.getReportType() == 4) {
            template = this.Torttemplate(projectId, templateFilePath);
        } else if (report.getReportType() == 5) {
            template = this.avoidDesignTemplate(projectId, templateFilePath);
        } else if (report.getReportType() == 1) {
//          template = this.getThirdTemplate(report, filePath);
        }
        // 读取模板、数据并渲染
//         文件是否已存在，则删除
        File file = new File(outPath);

//      生成word保存在指定目录
        template.writeToFile(outPath);
        template.close();
        //导出成功后，导出报告记录入库

        List<String> ids = fileManagerService.uploadFileGetGuid2(Arrays.asList(file));
        if (ids == null || ids.size() == 0) {
            throw new XiaoShiException("保存记录失败");
        }
//        PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        PersonnelVO personnelVO = new PersonnelVO();
        personnelVO.setId("1");
        ReportDocument reportDocument = new ReportDocument();
        reportDocument.setProjectId(projectId);
        reportDocument.setFileName(fileName);
        reportDocument.setFileGuid(ids.get(0));
        reportDocument.setCreateId(personnelVO.getId());
        reportDocument.setTemplateId(reportTemplate.getId());
        reportDocument.setTemplateName(reportTemplate.getTemplateName());
        reportDocument.insert();
        if (file.exists()) {
            file.delete();
        }
        return ids.get(0);
    }


    private XWPFTemplate Torttemplate(Integer reportId, String filePath) throws IOException {
        //根据报告Id查询标的专利号
        LambdaQueryWrapper<ReportProject> projectLambdaQueryWrapper = new LambdaQueryWrapper<>();
        projectLambdaQueryWrapper.eq(ReportProject::getProjectId, reportId);
        ReportProject report = reportProjectService.getOne(projectLambdaQueryWrapper, false);
        String patentNo = report.getSignPatentNo();
//        PatentVO patentVO = new PatentVO();
//        patentVO.setPatentNos(Arrays.asList(patentNo));
//        //根据专利号查询专利详细信息
//        String resBody = outInterfaceService.getPatentDTOListForRMS(patentVO);
//        JSONObject jsonObject = JSONObject.parseObject(resBody);
//        List<JSONObject> patentDTOS = JSON.parseArray(jsonObject.get("data").toString(), JSONObject.class);
//        //装载单个专利的信息
        Map<String, Object> patentMap = new HashMap<>();
//        JSONObject patent = patentDTOS.get(0);
//        List<JSONObject> applicantJSONs = JSON.parseArray(patent.get("applicant").toString(), JSONObject.class);
//        StringBuilder applicants = new StringBuilder();
//        StringBuilder rightPerson = new StringBuilder();
//        applicantJSONs.forEach(tem -> {
//            if (Integer.parseInt(tem.get("dataType").toString()) == 1) {
//                applicants.append(tem.get("name") + "\r");
//            } else {
//                rightPerson.append(tem.get("name") + "\r");
//            }
//        });
//        //装载同族信息
//        JSONObject familys = JSONObject.parseObject(patent.get("family").toString());
//        List<String> patSnaps = JSON.parseArray(familys.get("patSnap").toString(), String.class);
//        List<String> simples = JSON.parseArray(familys.get("simple").toString(), String.class);
//        List<String> inpadocs = JSON.parseArray(familys.get("inpadoc").toString(), String.class);
//        patSnaps.addAll(simples);
//        patSnaps.addAll(inpadocs);
//        String familyStr = StringUtils.join(patSnaps, ",");
//        //装载法律状态
//        StringBuilder affair = new StringBuilder();
//        List<JSONObject> affaires = JSON.parseArray(patent.get("affair").toString(), JSONObject.class);
//        affaires.forEach(item -> {
//                    affair.append(item.get("status") + "\r");
//                }
//        );
//        //同族专利
//        patentMap.put("simpleFamilys", familyStr);
//        //引用专利
//        patentMap.put("quotePatents", patent.get("quote"));
//        //申请日
//        patentMap.put("applicationDate", patent.get("applicationDate"));
//        //公开日
//        patentMap.put("publicDate", patent.get("publicDate"));
//        //专利号
//        patentMap.put("publicNo", patent.get("publicNo"));
//        patentMap.put("firstPublicDate", patent.get("firstPublicDate"));
//        patentMap.put("applicant", applicants);
//        patentMap.put("rightPerson", rightPerson);
//        patentMap.put("affair", affair);
//        patentMap.put("name", patent.get("name"));
        //图示
        patentMap.put("abstractPath", "");
        //获得专利对比记录的信息
//        Map<String, Object> temMap = compareMessageService.queryforTemplate(patent.get("patentNo").toString(), reportId);
//        List<CompareMessageVO> compareMessageVOS = (List<CompareMessageVO>) temMap.get("compareMessageVOs");
        //装载对比记录的信息
//        patentMap.put("cM", compareMessageVOS);
//        patentMap.put("rightNum", temMap.get("right"));
//        patentMap.put("mainRightNum", temMap.get("mainRight"));
        Map<String, Object> map = new HashMap<>();
        String date = DateUtils.formatDate(new Date(), DateUtils.YYYY_MM_DD);
        String[] ds = date.split("-");
        map.put("sys", new SystemMO(ds[0], ds[1], ds[2], "", "reportName"));
        map.put("patentMap", patentMap);
        map.put("", patentNo);
        // 为表格的显示绑定行循环
        LoopRowTableRenderPolicy policy = new LoopRowTableRenderPolicy();
        HtmlRenderPolicy htmlRenderPolicy = new HtmlRenderPolicy();
        // 将bz设置为行循环绑定的数据源的key,即key是bz的value会在模板中的{{bz}}处进行解析
        Configure configure = Configure.builder().bind("cM", policy).bind("targetDescription", htmlRenderPolicy).build();
        XWPFTemplate template = XWPFTemplate.compile(filePath, configure).render(map);
        return template;
    }

    private XWPFTemplate avoidDesignTemplate(Integer projectId, String path) throws IOException {
        String filePath = fileUtils.getPath(path);

        log.info("开始处理导出规避设计报告，参数为：{}, {}", projectId, filePath);
        LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(ReportProject::getProjectId, projectId);

        ReportProject report = reportProjectService.getOne(queryWrapper, false);
        String signPatentNo = report.getSignPatentNo();

        //装载标的专利信息


        ;

        //装载年月日
        String date = DateUtils.formatDate(new Date(), DateUtils.YYYY_MM_DD);
        String[] dates = date.split("-");
        SystemMO systemMO = new SystemMO()
                .setYear(dates[0])
                .setMonth(dates[1])
                .setDay(dates[2]);
//
        //装载特征、解释、回避设计方向、回避设计总体方向
        List<AvoidFeaturesVO> features = avoidDesignMapper.selectAvoidDesign(projectId);
//        String wholeDirection = avoidDesignWholeDirectionMapper.selectWholeDirectionByReportId(reportId);

//        map.put("wholeDirection", wholeDirection);
//
        //绑定政策(绑定集合和元素循环遍历)
        LoopRowTableRenderPolicy policy = new LoopRowTableRenderPolicy();
        //把指定元素内容识别传输成html格式
        HtmlRenderPolicy htmlRenderPolicy = new HtmlRenderPolicy();
        Configure configure = Configure.builder()
                .bind("signPatent.rights", policy)
                .bind("features", policy)
                .bind("explainText", htmlRenderPolicy)
                .bind("littleDirection", htmlRenderPolicy)
                .bind("wholeDirection", htmlRenderPolicy)
                .build();
        XWPFTemplate template = XWPFTemplate.compile(filePath, configure).render(new HashMap<>());
        return template;
    }


    private PictureRenderData guidToStream(String guid) {
        PictureRenderData pictureRenderData = null;
        byte[] bytes = null;

        try {
            bytes = fileManagerService.downloadSystemFileFromFMS(guid);
        } catch (Exception e) {

        }

        FileInputStream fileInputStream = FileUtils.byteToFile(bytes);
        pictureRenderData = Pictures.ofStream(fileInputStream, PictureType.PNG)
                .create();

        return pictureRenderData;
    }


    private List<Map<String, Object>> getClaimMaps(List<Text> claims, String patentNo) {
        List<Map<String, Object>> rights = new ArrayList<>();
        if (claims == null || claims.size() == 0) {
            return rights;

        }
        Text claim = claims.stream().filter(item -> item.getIfOrigin().equals(true)).findFirst().orElse(null);
        if (claim == null) {
            return rights;
        }
        PatentRightParams params = new PatentRightParams();
        params.setContent(claim.getTextContent());
        params.setPatentNo(patentNo);

        List<RePatentClaim> patentRights = PatentRightUtils.formatPatentRight(params);
        //给权要进行格式更改
        patentRights.forEach(item -> {
            Map<String, Object> temMap = new HashMap<>();
            temMap.put("rightName", "权" + (item.getSort() + 1));
            temMap.put("content", item.getContent());
            temMap.put("rightNameLong", "权利要求" + (item.getSort() + 1));
            temMap.put("parentSort", item.getParentSort());
            temMap.put("sort", item.getSort());
            rights.add(temMap);
        });
        return rights;
    }


    /**
     * @param projectId
     * @param filePath
     * @return
     * @description 装载FTO模板
     */
    private XWPFTemplate FTOTemplate(Integer projectId, String filePath, Integer templateId) throws IOException {
        //获得模板的配置信息
        LambdaQueryWrapper<TemplateConfig> templateConfigWrapper = new LambdaQueryWrapper<TemplateConfig>();
        templateConfigWrapper.eq(TemplateConfig::getTemplateId, templateId);
        List<TemplateConfig> templateConfigs = templateConfigService.list(templateConfigWrapper);
        List<Map<String, Object>> classifyMaps = new ArrayList<>();
        for (TemplateConfig templateConfig : templateConfigs) {
            Map<String, Object> classifyMap = new HashMap<>();

            String value = templateConfig.getValueName();
            //根据value 查询专利
            List<EsCustomFieldValueDTO> esCustomFieldDTOS = customFieldService.getCustomFieldByValueName(value, projectId);
            if (esCustomFieldDTOS.size() != 0) {
                classifyMap.put("classify", templateConfig.getMapName());
                StringRequest stringRequest = new StringRequest();
                stringRequest.setCustomFields(esCustomFieldDTOS);
                stringRequest.setProjectId(projectId);
                stringRequest.setCurrent(1L);
                stringRequest.setSize(999L);
                List<PatentColumnDTO> patentColumnDTOS = new ArrayList<>();
                try {
                    PatentDTO patentDTO = esService.esSearch(stringRequest);
                    patentColumnDTOS = patentDTO.getPatents();
                } catch (Exception e) {
                    return null;
                }
                //存放公告专利
                List<Map<String, Object>> announcePatents = new ArrayList<>();
                //存放公开专利
                List<Map<String, Object>> publicPatents = new ArrayList<>();
                //存放失效专利信息
                List<Map<String, Object>> lapsePatents = new ArrayList<>();
                for (PatentColumnDTO patent : patentColumnDTOS) {
                    String applicants = "";
                    String rightPerson = "";
                    if (patent.getApplicant() != null && patent.getApplicant().size() != 0) {
                        applicants = StringUtils.join(patent.getApplicant(), "\n");
                    }
                    if (patent.getRightHolder() != null && patent.getRightHolder().size() != 0) {
                        rightPerson = StringUtils.join(patent.getRightHolder(), "\n");
                    }
                    List<String> affairs = esLegalEventService.getStrLegalEvent(patent.getAppNo());
                    String affairStrs = "";
                    if (affairs != null && affairs.size() != 0) {
                        affairStrs = StringUtils.join(affairs, "\n");
                    }

                    //装载单个专利的信息
                    Map<String, Object> patentMap = new HashMap<>();

                    //同族专利
                    try {
                        //装载同族信息
                        List<Map<String, Object>> familyMaps = esFamilyService.getPatentFamilyByNos(Arrays.asList(patent.getPatentNo()), "inpadoc");
                        if (familyMaps != null && familyMaps.size() > 0) {
                            Map<String, Object> familyMap = familyMaps.get(0);
                            if (familyMap.get("nos") != null) {
                                List<String> nos = (List<String>) familyMap.get("nos");
                                if (nos != null && nos.size() > 0) {
                                    String nosStr = StringUtils.join(nos, "\n");
                                    patentMap.put("simpleFamilys", nosStr);
                                }
                            }
                        }
                    } catch (Exception e) {
                    }

                    //引用专利
                    try {
                        Map<String, Object> map = esQuotePatentService.getEsQutePatentByNos(patent.getPatentNo());
                        if (map.get("nos") != null) {
                            List<String> nos = (List<String>) map.get("nos");
                            if (nos != null && nos.size() > 0) {
                                String nosStr = StringUtils.join(nos, "\n");
                                patentMap.put("quotePatents", nosStr);
                            }
                        }

                    } catch (Exception e) {

                    }
                    SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
                    //申请日
                    if (patent.getAppDate() != null) {
                        patentMap.put("appDate", dateFormat.format(patent.getAppDate()));
                    }
                    //公开日
                    if (patent.getPublicDate() != null) {
                        patentMap.put("publicDate", dateFormat.format(patent.getPublicDate()));
                    }
                    //专利号
                    patentMap.put("publicNo", patent.getPatentNo());
                    patentMap.put("firstPublicDate", patent.getPublicDate());
                    patentMap.put("applicant", applicants);
                    patentMap.put("rightPerson", rightPerson);
                    patentMap.put("affair", affairStrs);

                    if (patent.getTitle() != null && patent.getTitle().size() > 0) {
                        patentMap.put("nameOut", patent.getTitle().get(0).getTextContent());
                    }


                    //优先权日
                    if (patent.getPriorities() != null && patent.getPriorities().size() != 0) {
                        patentMap.put("priorityDate", patent.getPriorities().get(0).getPriorityDate());
                    }

                    //图示
                    String guid = FormatUtil.getPictureFormat(patent.getAppNo());
                    PictureRenderData pictureData = this.guidToStream(guid);
                    if (pictureData != null) {
                        patentMap.put("abstractPath", pictureData);
                    }

                    //获得专利对比记录的信息
                    Map<String, Object> temMap = ftoCompareRecordService.LoadCompareMessageForExport(projectId, patent.getPatentNo());
                    List<CompareMessageVO> compareMessageVOS = (List<CompareMessageVO>) temMap.get("compareMessageVOs");
                    //装载对比记录的信息
                    patentMap.put("cM", compareMessageVOS);
                    patentMap.put("rightNum", temMap.get("rightNum"));

                    patentMap.put("mainNum", temMap.get("mainRightNum"));
                    Integer status = Integer.parseInt(patent.getSimpleStatus());
                    if (status == 1 || status == 5 || status == 6) {
                        announcePatents.add(patentMap);
                    } else if (status == 2) {
                        lapsePatents.add(patentMap);
                    } else if (status == 3) {
                        publicPatents.add(patentMap);
                    }
                    classifyMap.put("publicPatents", publicPatents);
                    classifyMap.put("lapsePatents", lapsePatents);
                    classifyMap.put("announcePatents", announcePatents);
                }
                classifyMaps.add(classifyMap);
            }
        }

        Map<String, Object> map = new HashMap<>();
        String date = DateUtils.formatDate(new Date(), DateUtils.YYYY_MM_DD);
        String[] ds = date.split("-");
        map.put("sys", new SystemMO(ds[0], ds[1], ds[2], "", "reportName"));
        map.put("classifys", classifyMaps);
        // 为表格的显示绑定行循环
        LoopRowTableRenderPolicy policy = new LoopRowTableRenderPolicy();
        HtmlRenderPolicy htmlRenderPolicy = new HtmlRenderPolicy();
        // 将bz设置为行循环绑定的数据源的key,即key是bz的value会在模板中的{{bz}}处进行解析
        Configure configure = Configure.builder().bind("cM", policy).bind("targetDescription", htmlRenderPolicy).build();
        XWPFTemplate template = XWPFTemplate.compile(filePath, configure).render(map);
        return template;

    }
//    private XWPFTemplate getstabilityTemplate(Integer projectId, String filePath) throws IOException {
//        List<PatentRight> patentRights = new ArrayList<>();
//
//        //装载标的专利信息
//        LambdaQueryWrapper<ReportProject> queryWrapper = new LambdaQueryWrapper<>();
//        queryWrapper.eq(ReportProject::getProjectId, projectId);
//        ReportProject report = reportProjectService.getOne(queryWrapper, false);
//        String signPatentNo = report.getSignPatentNo();
//        Map<String, Object> signPatent = this.signPantentMess(signPatentNo);
//        //根据报告Id获得报告信息
//        // 根据拆分人（报告的创建人）Id和报告ID获得所有特征
//        LambdaQueryWrapper<Features> allFeaturesWrapper = new LambdaQueryWrapper<>();
//        allFeaturesWrapper.eq(Features::getReportId, report.getId());
//        allFeaturesWrapper.and(wrapper -> wrapper.eq(Features::getPartnerId, report.getPersonId()).or().eq(Features::getPartnerId, report.getCreatePersonId()));
//
//        List<Features> allFeatures = featureService.list(allFeaturesWrapper);
//        //根据报告Id 查询出报告下所有的方案
//        LambdaQueryWrapper<CompareScenarios> queryWrapper = new LambdaQueryWrapper<>();
//        queryWrapper.eq(CompareScenarios::getReportId, report.getId());
//        List<CompareScenarios> compareScenarios = compareScenariosService.list(queryWrapper);
//        List<Integer> scenarioIds = compareScenarios.stream().map(CompareScenarios::getId).collect(Collectors.toList());
//        //根据对比方案Id 查询所有对比方案和（对比记录-特征）关联信息
//        List<AssoScenarIOS> scenariosRecords = new ArrayList<>();
//        if (scenarioIds != null && scenarioIds.size() != 0) {
//            LambdaQueryWrapper<AssoScenarIOS> queryRecordsByIDs = new LambdaQueryWrapper<>();
//            queryRecordsByIDs.in(AssoScenarIOS::getScenariosID, scenarioIds);
//            scenariosRecords = scenariosRecordsService.list(queryRecordsByIDs);
//        }
//        //获得对比记录-特征关联ID
//        List<Integer> recordfeatureRecordIds = scenariosRecords.stream().map(AssoScenarIOS::getFeatureRecordID).collect(Collectors.toList());
//        //从关联表里获得是公识的特征Id
//        List<Integer> knowedIds = scenariosRecords.stream().map(AssoScenarIOS::getFeaturesID).collect(Collectors.toList());
//        //根据对比记录-特征关联ID查出对比记录-特征关联信息
//        List<AssoRecordsFeature> assoRecordsFeatures = new ArrayList<>();
//        if (recordfeatureRecordIds != null && recordfeatureRecordIds.size() != 0) {
//            LambdaQueryWrapper<AssoRecordsFeature> wrapper = new LambdaQueryWrapper<>();
//            wrapper.in(AssoRecordsFeature::getId, recordfeatureRecordIds);
//            assoRecordsFeatures = assoRecordsFeatureService.list(wrapper);
//        }
//        List<AssoRecordsFeature> finalAsso = assoRecordsFeatures;
//        //从对比记录-特征关联信息里剔出对比记录Id
//        List<Integer> recordIds = assoRecordsFeatures.stream().map(AssoRecordsFeature::getRecordsId).collect(Collectors.toList());
//        //从对比记录-特征关联信息里剔出特征Id
//        List<Integer> sFeatureIds = assoRecordsFeatures.stream().map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
//        sFeatureIds.addAll(knowedIds);
//        //根据特征ID查询出报告所有方案的特征
//        List<Features> sFeatures = new ArrayList<>();
//        LambdaQueryWrapper<Features> sFeaturesWrapper = new LambdaQueryWrapper<>();
//        sFeaturesWrapper.eq(Features::getId, sFeatureIds);
//        if (sFeatures != null && sFeatures.size() != 0) {
//            sFeatures = featureService.list(sFeaturesWrapper);
//        }
//        //根据对比记录ID查询出报告所有方案的对比记录
//        List<CompareRecords> compareRecords = new ArrayList<>();
//        if (recordIds != null && recordIds.size() != 0) {
//            LambdaQueryWrapper<CompareRecords> queryPatentByIDs = new LambdaQueryWrapper<>();
//            queryPatentByIDs.in(CompareRecords::getId, recordIds);
//            compareRecords = compareRecordsService.list(queryPatentByIDs);
//        }
//        //根据对比记录ID获得专利号
//        List<String> PatentNos = compareRecords.stream().map(CompareRecords::getPatentNo).collect(Collectors.toList());
//        PatentVO patentVO = new PatentVO();
//        patentVO.setPatentNos(PatentNos);
//        //根据专利号查询专利的排序
//        LambdaQueryWrapper<CompareFiles> comWrapper = new LambdaQueryWrapper<>();
//        comWrapper
//                .eq(CompareFiles::getReportId, report.getId())
//                .last("ORDER BY IF(isnull(SYS_ORDER),1,0), SYS_ORDER ASC");
//        ;
//        List<CompareFiles> compareFiles = compareFilesService.list(comWrapper);
//        //专利号别名的map
//        Map<String, Object> OtherName = new HashMap<>();
//        int flag = 1;
//        for (CompareFiles item : compareFiles) {
//            Integer order = item.getSysOrder() == null ? flag : item.getSysOrder();
//            OtherName.put(item.getPatentNo(), order);
//            flag++;
//        }
//
//        //根据专利号查询专利详细信息
//        String resBody = outInterfaceService.getPatentDTOListForRMS(patentVO);
//        JSONObject jsonObject = JSONObject.parseObject(resBody);
//        List<JSONObject> patentDTOS = JSON.parseArray(jsonObject.get("data").toString(), JSONObject.class);
//        //存放专利信息的map集合
//        List<Map<String, Object>> patentListMaps = new ArrayList<>();
//        //填充专利数据到patentListMap
//        for (int i = 0; i < patentDTOS.size(); i++) {
//            JSONObject item = patentDTOS.get(i);
//            Map<String, Object> patentListMap = new HashMap<>();
//            List<JSONObject> applicantJSONs = JSON.parseArray(item.get("applicant").toString(), JSONObject.class);
//            ;
//            StringBuilder applicants = new StringBuilder();
//            applicantJSONs.forEach(tem -> {
//                applicants.append(tem.get("name") + "\r");
//            });
//            //填充相关揭露（对比记录文字和特征组合）
//            StringBuffer disclosures = new StringBuffer("");
//            //根据专利号获得对比记录
//            List<CompareRecords> pantentRecords = compareRecords.stream().filter(tem -> tem.getPatentNo().equals(item.get("publicNo"))).collect(Collectors.toList());
//            //遍历对比记录根据对比记录获得对比记录-特征关联信息并获得特征ID
//            for (CompareRecords tem : pantentRecords) {
//                //填充对比记录文字
//                disclosures.append(tem.getContent());
//                disclosures.append("\r");
//                disclosures.append("(");
//                disclosures.append(tem.getFields());
//                disclosures.append("[" + (tem.getPosition()) + "]");
//                disclosures.append(")");
//                List<Integer> featuresIds = assoRecordsFeatures.stream().filter(te -> te.getRecordsId().equals(tem.getId())).map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
//                //根据特征Id获得特征内容
//                List<String> feaListContent = sFeatures.stream().filter(te -> featuresIds.contains(te.getId())).map(Features::getContent).collect(Collectors.toList());
//                feaListContent.forEach(te -> disclosures.append("(" + te + ")"));
//                disclosures.append("\n");
//            }
//            int order = Integer.parseInt(OtherName.get(item.get("patentNo")).toString());
//
//            patentListMap.put("name", item.get("name"));
//            patentListMap.put("fileName", "D" + order);
//            patentListMap.put("publicDate", item.get("publicDate"));
//            patentListMap.put("publicNo", item.get("publicNo"));
//            patentListMap.put("SSIM", "");
//            patentListMap.put("applicant", applicants);
//            patentListMap.put("patentNo", item.get("patentNo"));
//            patentListMap.put("abstractStr", item.get("abstractStr"));
//            patentListMap.put("compareFileName", "对比文件" + (order));
//            patentListMap.put("applicationDate", item.get("applicationDate"));
//            patentListMap.put("abstractPath", pasFile + item.get("abstractPath"));
//            patentListMap.put("disclosures", disclosures);
//            patentListMap.put("order", order);
//            patentListMaps.add(patentListMap);
//
//        }
//        //存放对比方案信息的map集合
//        List<Map<String, Object>> scenariosMaps = new ArrayList<>(compareFiles.size());
//        //存放所有对比方案所有不重复的rightId
//        List<Integer> rightIds = new ArrayList<>();
//        for (int i = 0; i < compareScenarios.size(); i++) {
//            CompareScenarios item1 = compareScenarios.get(i);
//            //获得单个对比方案的
//            List<AssoScenarIOS> partScenariosRecords = scenariosRecords.stream().filter(item -> item.getScenariosID().equals(item1.getId())).collect(Collectors.toList());
//            List<Integer> featureRecordsIds = partScenariosRecords.stream().map(AssoScenarIOS::getFeatureRecordID).collect(Collectors.toList());
//            List<AssoRecordsFeature> assoRecordsFeatures1 = assoRecordsFeatures.stream().filter(item -> featureRecordsIds.contains(item.getId())).collect(Collectors.toList());
//            List<Integer> partRecordIds = assoRecordsFeatures1.stream().map(AssoRecordsFeature::getRecordsId).collect(Collectors.toList());
//            List<Integer> partFetIds = assoRecordsFeatures1.stream().map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
//            //获得公识特征的ID
//            List<Integer> comFetIds = partScenariosRecords.stream().map(AssoScenarIOS::getFeaturesID).collect(Collectors.toList());
//            partFetIds.addAll(comFetIds);
//            //获得单个对比方案的权要的所有特征
//            List<Features> partFeatures = allFeatures.stream().filter(item -> partFetIds.contains(item.getId())).collect(Collectors.toList());
//            List<CompareRecords> records = compareRecords.stream().filter(item -> partRecordIds.contains(item.getId())).collect(Collectors.toList());
//            //获得单条权要所有的特征
//            List<Features> allRightFeatures = allFeatures.stream().filter(item -> item.getRightId().equals(item1.getRightId())).collect(Collectors.toList());
//            //存放单条对比结果的map
//            Map<String, Object> temMap = new HashMap<>();
//            String a = partFeatures.get(0).getRightName().replace("\r", "");
//            if (partFeatures.size() != 0 && partFeatures.get(0).getRightType().equals(1)) {
//                temMap.put("rightName", "独立" + a);
//            } else {
//                temMap.put("rightName", "附属" + a);
//            }
//            temMap.put("rightId", item1.getRightId());
//            if (report.getType() == 1) {
//                String rightContent = patentRights.stream().filter(t -> t.getSort().equals(item1.getRightId())).map(PatentRight::getContent).findFirst().orElse("");
//                temMap.put("rightContent", rightContent);
//            }
//            temMap.put("remark", item1.getContrastResult());
//            // 从关联数据里获得特征id
//            if (!rightIds.contains(item1.getRightId())) {
//                rightIds.add(item1.getRightId());
//            }
//            //存放对比方案每一个特征记录
//            List<Map<String, Object>> maps = new ArrayList<>();
//            allRightFeatures.forEach(tem -> {
//
//                List<AssoRecordsFeature> assoRecordsFeatures2 = assoRecordsFeatures1.stream().filter(item -> item.getFeatureId().equals(tem.getId())).collect(Collectors.toList());
//                if (comFetIds.contains(tem.getId())) {
//                    Map<String, Object> map = new LinkedHashMap<>();
//                    map.put("featureContent", tem.getContent());
//                    map.put("compareResult", "公识");
//                    map.put("compareContent", "");
//                    maps.add(map);
//                } else if (assoRecordsFeatures2.size() != 0) {
//                    Map<String, Object> map = new LinkedHashMap<>();
//                    map.put("featureContent", tem.getContent());
//                    List<Map<String, Object>> temMap1 = new ArrayList<>();
//                    AssoRecordsFeature assoRecordsFeature = assoRecordsFeatures2.get(0);
//                    CompareRecords record = records.stream().filter(item -> item.getId().equals(assoRecordsFeature.getRecordsId())).findFirst().orElse(new CompareRecords());
//                    String compareContent = "";
//                    //获取对比内容
//                    String content = record.getContent() != null ? record.getContent() : "";
//                    //获得对比专利号
//                    String patentNo = record.getPatentNo() != null ? record.getPatentNo() : "";
//                    if (OtherName.containsKey(patentNo)) {
//                        patentNo = "D" + OtherName.get(patentNo).toString() + ":";
//                    } else if (!patentNo.equals("")) {
//                        patentNo += ":";
//                    }
//                    //获得解析过程
//                    String paresingProcess = record.getParesingProcess() != null ? "(" + record.getParesingProcess() + ")" : "";
//                    compareContent = patentNo + content + paresingProcess;
//                    //获取对比专利号
//                    if (maps.size() > 0) {
//                        Map<String, Object> lastMap = maps.get(maps.size() - 1);
//                        if (lastMap.get("compareContent").toString().equals(compareContent)) {
//                            lastMap.put("featureContent", lastMap.get("featureContent") + tem.getContent());
//                        } else {
//                            map.put("compareResult", assoRecordsFeature.getComResult() != null ? assoRecordsFeature.getComResult() : "不公开");
//                            map.put("compareContent", compareContent);
//                            map.put("figure", fileUtils.getSystemPath() + record.getFilePath());
//                            if (record.getFields() == null && record.getPosition() == null) {
//                                map.put("position", "");
//                            } else {
//                                map.put("position", "\r" + "(" + record.getFields() + "[" + record.getPosition() + "]" + ")");
//                            }
//                            maps.add(map);
//                        }
//                    } else {
//                        map.put("compareResult", assoRecordsFeature.getComResult() != null ? assoRecordsFeature.getComResult() : "不公开");
//                        map.put("compareContent", compareContent);
//                        map.put("figure", fileUtils.getSystemPath() + record.getFilePath());
//                        if (record.getFields() == null && record.getPosition() == null) {
//                            map.put("position", "");
//                        } else {
//                            map.put("position", "\r" + "(" + record.getFields() + "[" + record.getPosition() + "]" + ")");
//                        }
//                        maps.add(map);
//                    }
//
//                } else {
//                    Map<String, Object> map = new LinkedHashMap<>();
//                    map.put("featureContent", tem.getContent());
//                    map.put("compareResult", "未公开");
//                    map.put("compareContent", "");
//                    maps.add(map);
//                }
//
//            });
//            //方案内容
//            temMap.put("fileDetails", maps);
//            //新颖性模块
//            //获得本方案所有的专利号
//            List<String> patentNOs = new ArrayList<>();
//            records.forEach(item -> {
//                if (!patentNOs.contains(item.getPatentNo())) {
//                    patentNOs.add(item.getPatentNo());
//                }
//            });
//            //比较所有专利号和权要所有权要的大小，如果相等则将该专利加入到新颖性列表中
//            List<String> noveltyFiles = new ArrayList<>();
//            patentNOs.forEach(
//                    item -> {
//                        List<Integer> temRecordIds = records.stream().filter(tm -> tm.getPatentNo().equals(item)).map(CompareRecords::getId).collect(Collectors.toList());
//                        List<Integer> temFIds = finalAsso.stream().filter(tm -> temRecordIds.contains(tm.getRecordsId())).map(AssoRecordsFeature::getFeatureId).collect(Collectors.toList());
//                        String tmName = item;
//                        if (OtherName.containsKey(item)) {
//                            tmName = "D" + OtherName.get(item).toString();
//                        }
//                        if (temFIds.size() == allRightFeatures.size()) {
//                            noveltyFiles.add(tmName);
//                        }
//                    }
//            );
//            //创造性列表
//            List<String> creativeFiles = new ArrayList<>();
//            //当前方案所有的特征Id
//            records.forEach(
//                    item -> {
//                        String tmName = item.getPatentNo();
//                        if (OtherName.containsKey(tmName)) {
//                            tmName = "D" + OtherName.get(tmName).toString();
//                        }
//                        if (!creativeFiles.contains(tmName)) {
//                            creativeFiles.add(tmName);
//                        }
//                    }
//            );
//            List<AssoScenarIOS> andRecords = partScenariosRecords.stream().filter(tm -> tm.getScenariosID().equals(item1.getId()) && tm.getFeaturesID() != 0).collect(Collectors.toList());
//            if (andRecords.size() != 0) {
//                creativeFiles.add("C");
//            }
//            String creative = creativeFiles.size() == 0 ? "" : StringUtils.join(creativeFiles, "+");
//            String novelty = noveltyFiles.size() == 0 ? "" : StringUtils.join(noveltyFiles, "-");
//            //新颖性
//            temMap.put("novelty", novelty);
//            //创造性
//            temMap.put("creative", creative);
//            scenariosMaps.add(temMap);
//        }
//        List<Map<String, Object>> allRightScenarios = new ArrayList<>();
//        List<Map<String, Object>> resultMaps = new ArrayList<>();
//        // 存放创造性和新颖性的权要
//
//        rightIds.forEach(tem -> {
//            Map<String, Object> map = new HashMap<>();
//            Map<String, Object> resultMap = new HashMap<>();
//            List<Map<String, Object>> rightScenarios = new ArrayList<>();
//            //存放新颖性信息
//            List<String> noveList = new ArrayList<>();
//            List<String> creaList = new ArrayList<>();
//            //存放创造性信息
//            for (int t = 0; t < scenariosMaps.size(); t++) {
//                Map<String, Object> item = scenariosMaps.get(t);
//                if (item.get("rightId").equals(tem)) {
//                    item.put("scenariosName", "对比组合" + (t + 1));
//                    rightScenarios.add(item);
//                    if (item.get("novelty").toString() != "") {
//                        if (!noveList.contains(item.get("novelty").toString())) {
//                            noveList.add(item.get("novelty").toString());
//                        }
//                    }
//                    if (item.get("creative").toString() != "") {
//                        if (!creaList.contains(item.get("creative").toString())) {
//                            creaList.add(item.get("creative").toString());
//                        }
//                    }
//                }
//            }
//            map.put("rightScenrios", rightScenarios);
//            map.put("rightName", rightScenarios.get(0).get("rightName"));
//            String creative = creaList.size() == 0 ? "" : StringUtils.join(creaList, "、");
//            String novelty = noveList.size() == 0 ? "" : StringUtils.join(noveList, "-");
//            resultMap.put("rightName", rightScenarios.get(0).get("rightName"));
//            resultMap.put("rightNovelty", novelty);
//            resultMap.put("rightCreative", creative);
//            allRightScenarios.add(map);
//            resultMaps.add(resultMap);
//        });
//        //1.系统数据
//        //存放单条对比结果的map
//        Map<String, Object> map = new HashMap<>();
//        String date = DateUtils.formatDate(new Date(), DateUtils.YYYY_MM_DD);
//        String[] ds = date.split("-");
//        map.put("sys", new SystemMO(ds[0], ds[1], ds[2], "", "reportName"));
//        if (patentListMaps.size() > 1) {
//            patentListMaps = this.sortMap(patentListMaps);
//        }
//        map.put("patentList", patentListMaps);
//        map.put("combinations", allRightScenarios);
//        map.put("allResults", resultMaps);
//        map.put("signPatent", signPatent);
//        map.put("pantentNo", report.getSignPatentNo());
//        map.put("rights", signPatent.get("rights"));
//        // 为表格的显示绑定行循环
//        LoopRowTableRenderPolicy policy = new LoopRowTableRenderPolicy();
//        HtmlRenderPolicy htmlRenderPolicy = new HtmlRenderPolicy();
//        // 将bz设置为行循环绑定的数据源的key,即key是bz的value会在模板中的{{bz}}处进行解析
//        Configure configure = Configure.builder()
//                .bind("patentList", policy)
//                .bind("fileDetails", policy)
//                .bind("allResults", policy)
//                .bind("signPatent.rights", policy)
//                .bind("remark", htmlRenderPolicy)
//                .build();
//        // 读取模板、数据并渲染
//        XWPFTemplate template = XWPFTemplate.compile(filePath, configure).render(map);
//        return template;
//    }

    //
//    public Map<String, Object> signPantentMess(String patentNo) throws IOException {
//
//        Patent patent = new Patent();
//        try {
//            List<Patent> patentList = esPatentService.getPatentsByNo(Arrays.asList(patentNo), true, null, null);
//        if(patentList.size()>0){
//            patent=patentList.get(0);
//        }
//        } catch (Exception e) {
//            throw  new IOException();
//        }
//
//        //装载单个专利的信息
//        Map<String, Object> patentMap = new HashMap<>();
//        List<JSONObject> applicantJSONs = JSON.parseArray(patent.get("applicant").toString(), JSONObject.class);
//        StringBuilder applicants = new StringBuilder();
//        StringBuilder rightPerson = new StringBuilder();
//        applicantJSONs.forEach(tem -> {
//            if (Integer.parseInt(tem.get("dataType").toString()) == 1) {
//                applicants.append(tem.get("name") + "\r");
//            } else {
//                rightPerson.append(tem.get("name") + "\r");
//            }
//        });
//        //申请日
//        patentMap.put("applicationDate", patent.getAppDate());
//
//        //公开日
//        patentMap.put("publicDate", patent.getPublicDate());
//        //公开号
//        patentMap.put("publicNo", patent.getPublicNo());
//        //专利号
//        patentMap.put("patentNo", patent.getPatentNo());
//        //专利权人
//        patentMap.put("rightPerson", rightPerson);
//        //图示
//        patentMap.put("abstractPath", pasFile + patent.get("abstractPath"));
//        patentMap.put("name", patent.getTitle());
//        //查询专利权要
//        String resBody2 = outInterfaceService.getPatentRightFromPAS(patentNo);
//        JSONObject jsonObject2 = JSONObject.parseObject(resBody2);
//        //解析jason获得标的专利的权要
//        List<PatentRight> patentRightsOrgin = JSON.parseArray(jsonObject2.getString("data"), PatentRight.class);
//        List<Map<String, Object>> rights = new ArrayList<>();
//        //给权要进行格式更改
//        List<PatentRight> patentRights = featureService.FormatPatentRights(patentRightsOrgin, patentNo);
//        patentRights.forEach(item -> {
//            Map<String, Object> temMap = new HashMap<>();
//            temMap.put("rightName", "权" + (item.getSort() + 1));
//            temMap.put("content", item.getContent());
//            temMap.put("rightNameLong", "权利要求" + (item.getSort() + 1));
//            temMap.put("parentSort", item.getParentSort());
//            temMap.put("sort", item.getSort());
//            rights.add(temMap);
//        });
//        patentMap.put("rights", rights);
//        return patentMap;
//    }
}