PAS/src/main/java/cn/cslg/pas/service/project/CopyProjectService.java

package cn.cslg.pas.service.project;

import cn.cslg.pas.common.dto.PatentExport.PatentExportVO;
import cn.cslg.pas.common.dto.business.PatentProjectDTO;
import cn.cslg.pas.common.dto.business.ProjectEventDTO;
import cn.cslg.pas.common.dto.business.ProjectTreesDTO;
import cn.cslg.pas.common.dto.es.EsCustomFieldDTO;
import cn.cslg.pas.common.dto.es.EsQueryPatentFieldsDTO;
import cn.cslg.pas.common.dto.es.InnerFields;
import cn.cslg.pas.common.model.addPatentToReport.PatentNoWithIdVO;
import cn.cslg.pas.common.model.cronModel.SystemFile;
import cn.cslg.pas.common.model.project.CopyProjectDTO;
import cn.cslg.pas.common.vo.FieldValueVO;
import cn.cslg.pas.common.vo.PatentWithIdVO;
import cn.cslg.pas.common.vo.UploadParamsVO;
import cn.cslg.pas.common.vo.business.AllCustomFieldVO;
import cn.cslg.pas.common.vo.business.PatentProjectVO;
import cn.cslg.pas.common.vo.es.EsPatentCommonVO;
import cn.cslg.pas.common.vo.es.EsPatentFieldsVO;
import cn.cslg.pas.common.vo.es.InnerPatentFieldsVO;
import cn.cslg.pas.domain.es.Patent;
import cn.cslg.pas.domain.es.PatentJoin;
import cn.cslg.pas.domain.es.PatentMergePerson;
import cn.cslg.pas.exception.ExceptionEnum;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.mapper.PatentProjectMapper;
import cn.cslg.pas.service.business.CustomFieldService;
import cn.cslg.pas.service.business.PatentProjectService;
import cn.cslg.pas.service.business.es.EsCustomFieldService;
import cn.cslg.pas.service.business.es.EsMergePersonService;
import cn.cslg.pas.service.business.es.EsPatentService;
import cn.cslg.pas.service.business.es.EsService;
import co.elastic.clients.elasticsearch.ElasticsearchClient;
import co.elastic.clients.elasticsearch.core.SearchRequest;
import co.elastic.clients.elasticsearch.core.SearchResponse;
import co.elastic.clients.elasticsearch.core.search.Hit;
import lombok.Data;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Lazy;
import org.springframework.stereotype.Service;

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

@Service
@Slf4j
@RequiredArgsConstructor
public class CopyProjectService {

    private final EsCustomFieldService esCustomFieldService;

    private final EsService esService;
    private final ElasticsearchClient client;
    private final EsPatentService esPatentService;
    private final CustomFieldService customFieldService;
    private final PatentProjectMapper patentProjectMapper;
    private final PatentProjectService patentProjectService;
    private final EsMergePersonService esMergePersonService;

    public void copyPatentProjectAll(CopyProjectDTO copyProjectDTO) {
        Integer projectId = copyProjectDTO.getProjectId();
        EsPatentCommonVO esPatentCommonVO = new EsPatentCommonVO();
        esPatentCommonVO.setProjectId(projectId);
        esPatentCommonVO.setSearchCondition("");
        esPatentCommonVO.setStartNum(1l);
        esPatentCommonVO.setEndNum(2l);
        esPatentCommonVO.setSemanteme("");
        Long total = 0l;
        Integer newProjectId = null;
        newProjectId = this.copyPatentProject(projectId);
        List<AllCustomFieldVO> customFieldVOS = customFieldService.getAllProjectCustomField(projectId);
        List<InnerFields> innerFields = this.transforToInner(customFieldVOS);
        EsQueryPatentFieldsDTO esQueryPatentFieldsDTO = new EsQueryPatentFieldsDTO();
        esQueryPatentFieldsDTO.setProjectId(projectId);
        esQueryPatentFieldsDTO.setInnerFields(innerFields);

        try {
            SearchRequest.Builder builder = esService.getCommonPatent(esPatentCommonVO);
            builder.trackTotalHits(i -> i.enabled(true));
            SearchResponse<Patent> response = null;
            response = client.search(builder.build(), Patent.class);
            List<Hit<Patent>> hits = response.hits().hits();
            total = response.hits().total().value();

            Long startIndex = 1l;
            Long endIndex = 100l;
            if (endIndex > total) {
                endIndex = total;
            }
            while (startIndex <= total) {
                esPatentCommonVO.setStartNum(startIndex);
                esPatentCommonVO.setEndNum(endIndex);
                builder = esService.getCommonPatent(esPatentCommonVO);
                response = client.search(builder.build(), Patent.class);
                hits = response.hits().hits();

                for (Hit<Patent> hit : hits) {
                    String id = hit.id();
                    String patentNo = hit.source().getPatentNo();
                    PatentNoWithIdVO patentWithIdVO = new PatentNoWithIdVO();
                    patentWithIdVO.setId(hit.id());
                    patentWithIdVO.setPatentNo(hit.source().getPatentNo());
                    //保存专利关联
                    this.savePatentProject(id, newProjectId);
                    this.saveCustomField(id, patentNo, esQueryPatentFieldsDTO, projectId, newProjectId, customFieldVOS);
                    this.saveMergePerson(hit.source(), id, projectId, newProjectId);
                }
                startIndex += 100l;
                endIndex += 100l;
                if (endIndex > total) {
                    endIndex = total;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }

    }

    private void saveMergePerson(Patent patent, String patentId, Integer projectId, Integer newProjectId) {
        try {
//            List<PatentMergePerson> applicants = esPatentService.getMergeApp2(projectId, patentId);
//            List<PatentMergePerson> rightHolders = esPatentService.getMergeRight2(projectId, patentId);
//            List<PatentMergePerson> inventors = esPatentService.getMergeInventor2(projectId, patentId);
//            esMergePersonService.addMergePersonToEs2(applicants, patentId, newProjectId, "merge_applicat");
//            esMergePersonService.addMergePersonToEs2(rightHolders, patentId, newProjectId, "merge_right_holder");
//            esMergePersonService.addMergePersonToEs2(inventors, patentId, newProjectId, "merge_inventor");
            esMergePersonService.addDefaultMergePerson(patent, patentId, newProjectId);

        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "保存合并人员失败");
        }

    }

    public void transTo() {

    }

    private void savePatentProject(String patentId, Integer projectId) {

        Patent patentChild = new Patent();
        PatentJoin patentJoin = new PatentJoin();
        patentJoin.setParent(patentId);
        patentJoin.setName("project");
        patentChild.setPatentJoin(patentJoin);
        patentChild.setProjectId(projectId);
        try {
            esService.addChildPatent(patentChild, patentId);
        } catch (Exception e) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "保存专利错误");
        }
    }

    private void saveCustomField(String patentId, String patentNo, EsQueryPatentFieldsDTO esQueryPatentFieldsDTO, Integer projectId, Integer newProjectId, List<AllCustomFieldVO> customFieldVOS) {

        esQueryPatentFieldsDTO.setPatentNos(Arrays.asList(patentNo));
        try {
            List<EsPatentFieldsVO> esPatentFieldsVOS = esCustomFieldService.getPatentFields(esQueryPatentFieldsDTO);
            EsPatentFieldsVO esPatentFieldsVO = esPatentFieldsVOS.get(0);
            List<InnerPatentFieldsVO> innerClassFields = esPatentFieldsVO.getInnerClassFields();
            List<UploadParamsVO.Field> fields = new ArrayList<>();
            for (InnerPatentFieldsVO innerPatentFieldsVO : innerClassFields) {
                List<FieldValueVO> fieldValueVOS = innerPatentFieldsVO.getFieldValueVOS();
                if (fieldValueVOS != null && fieldValueVOS.size() > 0) {
                    List<String> values = fieldValueVOS.stream().map(FieldValueVO::getValue).collect(Collectors.toList());
                    String key = innerPatentFieldsVO.getField();
                    AllCustomFieldVO customFieldVO = customFieldVOS.stream().filter(item -> item.getId().toString().equals(key)).findFirst().orElse(null);
                    if (customFieldVO != null) {
                        Integer type = innerPatentFieldsVO.getFieldType();
                        if (type <= 6) {
                            String finalKey = customFieldVO.getName() + ":" + type;

                            UploadParamsVO.Field field = new UploadParamsVO.Field();
                            field.setKey(finalKey);
                            field.setFieldList(values);
                            fields.add(field);
                        }
                    }
                }

            }
            if (fields.size() > 0) {
                List<EsCustomFieldDTO> esCustomFieldDTOList = customFieldService.getFieldDTOByStrings(fields, newProjectId, null);
                for (EsCustomFieldDTO esCustomFieldDTO : esCustomFieldDTOList) {
                    esCustomFieldDTO.setPatentId(patentId);
                    esCustomFieldDTO.setOptionType(2);
                    esCustomFieldDTO.setPatentNo(patentNo);
                    if (esCustomFieldDTO.getFieldType() == null) {
                        System.out.println(1);
                    }
                    esCustomFieldService.addCustomField(esCustomFieldDTO);
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "保存自定义栏位错误");
        }
    }

    private List<InnerFields> transforToInner(List<AllCustomFieldVO> customFieldVOS) {
        List<InnerFields> innerFieldsList = new ArrayList<>();
        for (AllCustomFieldVO allCustomFieldVO : customFieldVOS) {
            InnerFields innerFields = new InnerFields();
            innerFields.setFieldId(allCustomFieldVO.getId().toString());
            innerFields.setFieldType(allCustomFieldVO.getType());
            innerFieldsList.add(innerFields);
        }
        return innerFieldsList;
    }

    private Integer copyPatentProject(Integer targetId) {
        List<String> sqls = new ArrayList<>();
        sqls.add("id=" + targetId);
        sqls.add("order by t.createTime desc");
        sqls.add("limit 0,10");

        List<PatentProjectVO> patentProjectVOS = patentProjectMapper.getPatentProject(sqls.get(0), sqls.get(1), sqls.get(2));
        if (patentProjectVOS == null || patentProjectVOS.size() == 0) {
            throw new XiaoShiException(ExceptionEnum.BUSINESS_ERROR, "未找到专题库");
        }
        try {
            patentProjectService.loadPatentProject(patentProjectVOS);
        } catch (Exception e) {
            e.printStackTrace();
        }
        PatentProjectVO patentProjectVO = patentProjectVOS.get(0);
        PatentProjectDTO patentProjectDTO = this.transformToPatentProjectDTO(patentProjectVO);
        Integer newProjectId = (Integer) patentProjectService.addMessage(patentProjectDTO);
        return newProjectId;
    }

    public PatentProjectDTO transformToPatentProjectDTO(PatentProjectVO patentProjectVO) {
        PatentProjectDTO patentProjectDTO = new PatentProjectDTO();
        patentProjectDTO.setIfUpdate(patentProjectVO.getIfUpdate());
        patentProjectDTO.setStatus(patentProjectVO.getStatus());
        patentProjectDTO.setName(patentProjectVO.getName() + "-副本");
        patentProjectDTO.setEntrustId(patentProjectVO.getEntrustId());
        patentProjectDTO.setHeadId(patentProjectVO.getHeadId());
        patentProjectDTO.setDepartmentId(patentProjectVO.getDepartmentId());
        patentProjectDTO.setContractNo(patentProjectVO.getContractNo());
        patentProjectDTO.setVolumeNumber(patentProjectVO.getVolumeNumber());
        patentProjectDTO.setCommissionCaseDay(patentProjectVO.getCommissionCaseDay());
        patentProjectDTO.setDescription(patentProjectVO.getDescription());
        patentProjectDTO.setScenarioIds(patentProjectVO.getScenarioIds());
        patentProjectDTO.setMatterIds(patentProjectVO.getMatterIds());
        patentProjectDTO.setCrons(patentProjectVO.getCrons());
        patentProjectDTO.setPersonId(patentProjectVO.getCreateId());
        patentProjectDTO.setUpdateCycle(patentProjectVO.getUpdateCycle());
        if (patentProjectVO.getSystemFileList() != null) {
            List<String> fileGuids = patentProjectVO.getSystemFileList().stream().map(SystemFile::getGuid).collect(Collectors.toList());
            patentProjectDTO.setFileGuids(fileGuids);
        }
        if (patentProjectVO.getEventIds() != null) {
            List<ProjectEventDTO> projectEventDTOS = new ArrayList<>();
            patentProjectVO.getEventIds().forEach(item -> {
                ProjectEventDTO projectEventDTO = new ProjectEventDTO();
                projectEventDTO.setEventId(item);
                projectEventDTOS.add(projectEventDTO);
            });
            patentProjectDTO.setEvents(projectEventDTOS);
        }
        List<ProjectTreesDTO> projectTreesDTOS = new ArrayList<>();
        if (patentProjectVO.getProductOrCategory() != null) {
            ProjectTreesDTO projectTreesDTO = new ProjectTreesDTO();
            projectTreesDTO.setTreeType(patentProjectVO.getProductOrCategory().getType());
            projectTreesDTO.setValueIds(patentProjectVO.getProductOrCategory().getValueIds());
            projectTreesDTO.setFieldId(patentProjectVO.getProductOrCategory().getId());
            projectTreesDTOS.add(projectTreesDTO);
            patentProjectDTO.setTrees(projectTreesDTOS);
        }
        return patentProjectDTO;

    }
}