PAS/src/main/java/cn/cslg/pas/service/business/CustomFieldService.java

package cn.cslg.pas.service.business;

import cn.cslg.pas.common.dto.AllFieldOrderDTO;
import cn.cslg.pas.common.dto.business.CustomFieldDTO;
import cn.cslg.pas.common.dto.business.UpdateCustomFieldDTO;
import cn.cslg.pas.common.dto.es.EsCustomFieldDTO;
import cn.cslg.pas.common.dto.es.EsCustomFieldValueDTO;
import cn.cslg.pas.common.dto.es.QueryEsCustomFieldDTO;
import cn.cslg.pas.common.model.cronModel.Personnel;
import cn.cslg.pas.common.model.cronModel.PersonnelVO;
import cn.cslg.pas.common.model.cronModel.Records;
import cn.cslg.pas.common.model.request.GroupRequest;
import cn.cslg.pas.common.model.request.QueryRequest;
import cn.cslg.pas.common.utils.*;
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.CustomFieldVO;
import cn.cslg.pas.common.vo.business.ProductVO;
import cn.cslg.pas.common.vo.es.QueryESCustomFieldVO;
import cn.cslg.pas.domain.business.*;
import cn.cslg.pas.domain.es.Patent;
import cn.cslg.pas.exception.UnLoginException;
import cn.cslg.pas.exception.XiaoShiException;
import cn.cslg.pas.factorys.businessFactory.Business;
import cn.cslg.pas.mapper.CustomFieldMapper;
import cn.cslg.pas.service.AssoTaskFieldService;
import cn.cslg.pas.service.business.es.EsCustomFieldService;
import cn.cslg.pas.service.business.es.EsService;
import cn.cslg.pas.service.permissions.PermissionService;
import cn.cslg.pas.service.query.FormatQueryService;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
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 org.springframework.web.multipart.MultipartFile;

import java.io.IOException;
import java.util.*;
import java.util.stream.Collectors;

/**
 * 自定义栏位Service层
 *
 * @Author xiexiang
 * @Date 2023/11/8
 */
@Service
public class CustomFieldService extends ServiceImpl<CustomFieldMapper, CustomField> implements Business {

    @Autowired
    private CacheUtils cacheUtils;

    @Autowired
    private LoginUtils loginUtils;

    @Autowired
    private FormatQueryService formatQueryService;

    @Autowired
    private CustomFieldMapper customFieldMapper;

    @Autowired
    private PermissionService permissionService;
    @Autowired
    private AssoProjectTreeNodeService assoProjectTreeNodeService;
    @Autowired
    private ProductCategoryService productCategoryService;
    @Autowired
    private ProductService productService;
    @Autowired
    private EsCustomFieldService esCustomFieldService;

    @Lazy
    @Autowired
    private CustomOptionService customOptionService;
    @Autowired
    private TreeNodeService treeNodeService;
    @Autowired
    private AssoTaskFieldService assoTaskFieldService;
    @Autowired
    private EsService esService;

    @Override
    public Object queryMessage(QueryRequest queryRequest) throws Exception {
        //根据专题库/报告id查询自定义栏位
        List<String> sqls = formatQueryService.reSqls(queryRequest, "customField");
        //根据sql查询自定义栏位信息
        List<CustomFieldVO> customFieldVOS = customFieldMapper.getCustomField(sqls.get(0), sqls.get(1), sqls.get(2));
        //查询总数
        Long total = customFieldMapper.getCustomFieldCount(sqls.get(0));
        //装载自定义栏位信息
        this.loadCustomField(customFieldVOS);
        //装载返回信息
        Records records = new Records();
        records.setCurrent(queryRequest.getCurrent());
        records.setSize(queryRequest.getSize());
        records.setData(customFieldVOS);
        records.setTotal(total);
        return records;
    }

    @Override
    public Object addMessage(Object object, List<MultipartFile> files) {
        return null;
    }

    @Override
    public Object deleteMessage(List<Integer> ids) throws IOException {
        if (ids == null || ids.size() == 0) {
            throw new XiaoShiException("ids不能为空");
        }
        this.removeBatchByIds(ids);
        //TODO 删除缓存中保存的栏位信息
        //TODO 删除与专题库的关联关系
        return ids;
    }

    @Override
    public Object updateMessage(Object object, List<MultipartFile> files) {
        return null;
    }

    @Override
    public Object getGroup(GroupRequest groupRequest, String tableName) throws Exception {
        return null;
    }

    @Override
    public Object addMessage(Object object) {
        if (object == null) {
            throw new XiaoShiException("参数不能为空");
        }
        //object to customFieldDTO
        CustomFieldDTO customFieldDTO = (CustomFieldDTO) object;
        //非空校验
        if (customFieldDTO.getProjectId().equals(null)) {
            throw new XiaoShiException("专题库/报告id不能为空！");
        }
        if (customFieldDTO.getName().equals(null) || customFieldDTO.getName().equals("")) {
            throw new XiaoShiException("自定义栏位名称不能为空！");
        }
        if (customFieldDTO.getType().equals(null)) {
            throw new XiaoShiException("自定义栏位类型不能为空！");
        }
        String name = customFieldDTO.getName();
        Integer projectId = customFieldDTO.getProjectId();
        //检查名称是否规范
        customFieldDTO.setName(name.trim());
        //同一个专题库/报告id下名称不能重复
        LambdaQueryWrapper<CustomField> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CustomField::getName, name);
        queryWrapper.eq(CustomField::getProjectId, projectId);
        List<CustomField> customFields = this.list(queryWrapper);
        if (customFields != null && customFields.size() != 0) {
            throw new XiaoShiException("名称不能重复");
        }
        //获取登录人信息
        PersonnelVO personnelVO = new PersonnelVO();
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());

        CustomField customField = new CustomField();
        BeanUtils.copyProperties(customFieldDTO, customField);
        customField.setCreateId(personnelVO.getId());
        customField.insert();
        //TODO 删除缓存中保存的栏位信息
        return customField.getId();
    }

    @Override
    public Object updateMessage(Object object) {
        if (object == null) {
            throw new XiaoShiException("参数不能为空");
        }
        //object to updateCustomFieldDTO
        UpdateCustomFieldDTO updateCustomFieldDTO = (UpdateCustomFieldDTO) object;
        //非空校验
        if (updateCustomFieldDTO.getProjectId().equals(null)) {
            throw new XiaoShiException("专题库/报告id不能为空！");
        }
        if (updateCustomFieldDTO.getName().equals(null) || updateCustomFieldDTO.getName().equals("")) {
            throw new XiaoShiException("自定义栏位名称不能为空！");
        }
        if (updateCustomFieldDTO.getType().equals(null)) {
            throw new XiaoShiException("自定义栏位类型不能为空！");
        }
        String name = updateCustomFieldDTO.getName();
        Integer projectId = updateCustomFieldDTO.getProjectId();
        CustomField customField = this.getById(updateCustomFieldDTO.getId());
        //检查名称是否规范
        updateCustomFieldDTO.setName(name.trim());
        //同一个专题库/报告id下名称不能重复
        LambdaQueryWrapper<CustomField> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CustomField::getName, name);
        queryWrapper.eq(CustomField::getProjectId, projectId);
        List<CustomField> customFields = this.list(queryWrapper);
        if (!name.equals(customField.getName()) && customFields.size() != 0) {
            throw new XiaoShiException("名称重复");
        }

        //TODO 删除缓存中保存的栏位信息
        BeanUtils.copyProperties(updateCustomFieldDTO, customField);
        customField.updateById();
        return customField.getId();
    }

    /**
     * 装载自定义栏位
     *
     * @param customFieldVOS
     */
    private void loadCustomField(List<CustomFieldVO> customFieldVOS) throws IOException {
        List<String> createIds = new ArrayList<>();
        customFieldVOS.forEach(
                item -> {
                    if (item.getCreateId() != null) {
                        createIds.add(item.getCreateId());
                    }
                }
        );
        List<Personnel> personnels = new ArrayList<>();
        //查询创建人名称
        if (createIds.size() != 0) {
            String res = permissionService.getPersonnelByIdsFromPCS(createIds);
            JSONObject jsonObject = JSONObject.parseObject(res);
            personnels = JSONObject.parseArray(jsonObject.getString("data"), Personnel.class);
        }
        for (CustomFieldVO customFieldVO : customFieldVOS) {
            //装载人员信息
            Personnel personnel = personnels.stream().filter(item -> item.getId().equals(customFieldVO.getCreateId())).findFirst().orElse(null);
            if (personnel != null) {
                customFieldVO.setCreateName(personnel.getPersonnelName());
            }
        }
    }


    public List<AllCustomFieldVO> getAllProjectCustomField(Integer projectId) {

        List<AllCustomFieldVO> allCustomFieldVOS = cacheUtils.getPatentCustomField(projectId);
        if (CollectionUtils.isEmpty(allCustomFieldVOS)) {
            allCustomFieldVOS = new ArrayList<>();
        }
        Integer order = allCustomFieldVOS.size();
        //根据 project获得栏位值
        List<CustomField> customFields = new ArrayList<>();
        LambdaQueryWrapper<CustomField> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CustomField::getProjectId, projectId);
        customFields = this.list(queryWrapper);
        //
        LambdaQueryWrapper<AssoProjectTreeNode> assoQueryWrapper = new LambdaQueryWrapper<>();
        assoQueryWrapper.eq(AssoProjectTreeNode::getProjectId, projectId);
        List<AssoProjectTreeNode> projectTreeNodes = assoProjectTreeNodeService.list(assoQueryWrapper);

        for (CustomField item : customFields) {
            AllCustomFieldVO allCustomFieldVO = allCustomFieldVOS.stream().filter(i -> i.getId().equals(item.getId()) && i.getType().equals(item.getType())).findFirst().orElse(null);
            if (allCustomFieldVO == null) {
                allCustomFieldVO = new AllCustomFieldVO();
                allCustomFieldVO.setId(item.getId());
                allCustomFieldVO.setName(item.getName());
                allCustomFieldVO.setType(item.getType());
                allCustomFieldVO.setSysOrder(order);
                allCustomFieldVOS.add(allCustomFieldVO);
                order += 1;
            }
        }

        for (AssoProjectTreeNode item : projectTreeNodes) {
            //根据类型和id
            AllCustomFieldVO allCustomFieldVO = allCustomFieldVOS.stream().filter(i -> i.getId().equals(item.getId()) && i.getType().equals(item.getTreeType())).findFirst().orElse(null);
            if (allCustomFieldVO == null) {
                allCustomFieldVO = new AllCustomFieldVO();
                allCustomFieldVO.setId(item.getFieldId());
                allCustomFieldVO.setSysOrder(order);
                //1产品类别，2产品，3技术分类，4自定义树
                switch (item.getTreeType()) {
                    case 2:
                        Product product = productService.getById(item.getFieldId());
                        allCustomFieldVO.setName(product.getName());
                        allCustomFieldVO.setType(7);
                        break;
                    case 3:
                        ProductCategory productCategory = productCategoryService.getById(item.getFieldId());
                        allCustomFieldVO.setName(productCategory.getName());
                        allCustomFieldVO.setType(8);
                        break;
                    case 1:
                        //TODO 技术类别
                        break;
                }
                allCustomFieldVOS.add(allCustomFieldVO);
                order += 1;
            }
        }

        return allCustomFieldVOS;
    }

    /**
     * @param taskId
     * @return
     */
    public List<AllCustomFieldVO> getAllTaskCustomField(Integer taskId) {
        Integer order = 0;
        List<AllCustomFieldVO> allCustomFieldVOS = cacheUtils.getTaskCustomField(taskId);
        if (allCustomFieldVOS == null || allCustomFieldVOS.size() == 0) {
            allCustomFieldVOS = new ArrayList<>();

            //根据任务id查询
            List<AssoTaskField> assoTaskFields = new ArrayList<>();
            LambdaQueryWrapper<AssoTaskField> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(AssoTaskField::getTaskId, taskId);
            assoTaskFields = assoTaskFieldService.list(queryWrapper);

            //
            if (assoTaskFields != null) {

                //从自定义栏位表中获得自定义栏位id
                List<Integer> fieldIds = assoTaskFields.stream()
                        .filter(item -> item.getFieldType().equals(0)
                                || item.getFieldType().equals(1)
                                || item.getFieldType().equals(2)
                                || item.getFieldType().equals(3)
                                || item.getFieldType().equals(4)
                                || item.getFieldType().equals(5)
                                || item.getFieldType().equals(6)).map(AssoTaskField::getFieldId).collect(Collectors.toList());

                if (fieldIds.size() != 0) {
                    LambdaQueryWrapper<CustomField> queryCWrapper = new LambdaQueryWrapper<>();
                    queryCWrapper.in(CustomField::getId, fieldIds);
                    List<CustomField> customFields = this.list(queryCWrapper);
                    for (CustomField item : customFields) {
                        AllCustomFieldVO allCustomFieldVO = new AllCustomFieldVO();
                        allCustomFieldVO.setId(item.getId());
                        allCustomFieldVO.setName(item.getName());
                        allCustomFieldVO.setType(item.getType());
                        allCustomFieldVO.setSysOrder(order);
                        allCustomFieldVOS.add(allCustomFieldVO);
                        order += 1;
                    }
                }

                //从关联表中获得产品id
                List<Integer> productIds = assoTaskFields.stream()
                        .filter(item -> item.getFieldId().equals(7))
                        .map(AssoTaskField::getFieldId).collect(Collectors.toList());
                if (productIds != null && productIds.size() != 0) {
                    LambdaQueryWrapper<Product> productLambdaQueryWrapper = new LambdaQueryWrapper<>();
                    List<Product> products = productService.list(productLambdaQueryWrapper);
                    for (Product item : products) {
                        AllCustomFieldVO allCustomFieldVO = new AllCustomFieldVO();
                        allCustomFieldVO.setId(item.getId());
                        allCustomFieldVO.setName(item.getName());
                        allCustomFieldVO.setType(7);
                        allCustomFieldVO.setSysOrder(order);
                        allCustomFieldVOS.add(allCustomFieldVO);
                        order += 1;
                    }
                }

                List<Integer> productCategoryIds = assoTaskFields.stream()
                        .filter(item -> item.getFieldId().equals(8))
                        .map(AssoTaskField::getFieldId).collect(Collectors.toList());
                if (productCategoryIds != null && productCategoryIds.size() != 0) {
                    LambdaQueryWrapper<ProductCategory> LambdaQueryWrapper = new LambdaQueryWrapper<>();
                    List<ProductCategory> productCategories = productCategoryService.list(LambdaQueryWrapper);
                    for (ProductCategory item : productCategories) {
                        AllCustomFieldVO allCustomFieldVO = new AllCustomFieldVO();
                        allCustomFieldVO.setId(item.getId());
                        allCustomFieldVO.setName(item.getName());
                        allCustomFieldVO.setType(8);
                        allCustomFieldVO.setSysOrder(order);
                        allCustomFieldVOS.add(allCustomFieldVO);
                        order += 1;
                    }
                }

                //TODO 技术类别
//            List<Integer> technicalIds = assoTaskFields.stream()
//                    .filter(item -> item.getFieldId().equals(9))
//                    .map(AssoTaskField::getFieldId).collect(Collectors.toList());

            }
            cacheUtils.addTaskCustomField(taskId, allCustomFieldVOS);
        }
        allCustomFieldVOS = allCustomFieldVOS.stream().sorted(Comparator.comparing(AllCustomFieldVO::getSysOrder)).collect(Collectors.toList());
        return allCustomFieldVOS;
    }

    /**
     * 查询栏位选项
     *
     * @param queryEsCustomFieldDTO
     * @return
     * @throws Exception
     */
    public Records getCustomFieldValues(QueryEsCustomFieldDTO queryEsCustomFieldDTO) throws Exception {

        List<FieldValueVO> fieldValueVOS = new ArrayList<>();
        Integer type = queryEsCustomFieldDTO.getFieldType();

        EsCustomFieldDTO esCustomFieldDTO = new EsCustomFieldDTO();
        esCustomFieldDTO.setFieldId(queryEsCustomFieldDTO.getFieldId());
        esCustomFieldDTO.setProjectId((queryEsCustomFieldDTO.getProjectId()));
        esCustomFieldDTO.setTaskId(queryEsCustomFieldDTO.getTaskId());
        esCustomFieldDTO.setPatentNo(queryEsCustomFieldDTO.getPatentNo());
        esCustomFieldDTO.setFieldType(queryEsCustomFieldDTO.getFieldType());

        PatentWithIdVO patentVO = esCustomFieldService.getEsCustomField(esCustomFieldDTO);
        if (patentVO != null) {
            List<String> value = patentVO.getPatent().getESCustomField().getFieldValue();
            switch (type) {
                case 0:

                case 1:

                case 2:
                    value.forEach(item -> {
                        FieldValueVO fieldValueVO = new FieldValueVO();
                        fieldValueVO.setValue(item);
                        fieldValueVOS.add(fieldValueVO);
                    });
                    break;
                case 3:

                case 4:

                case 5:
                    if (value != null && value.size() > 0) {
                        List<Integer> ids = FormatUtil.StringTOIntegerList(value);
                        LambdaQueryWrapper<CustomOption> queryWrapper = new LambdaQueryWrapper<>();
                        queryWrapper.in(CustomOption::getId, ids);
                        List<CustomOption> customOptions = customOptionService.list(queryWrapper);
                        customOptions.forEach(item -> {
                            FieldValueVO fieldValueVO = new FieldValueVO();
                            fieldValueVO.setValueId(item.getId());
                            fieldValueVO.setValue(item.getName());
                            fieldValueVOS.add(fieldValueVO);
                        });
                    }
                    break;
                case 6:
                case 7:
                case 8:

                case 9:
                    if (value != null && value.size() > 0) {
                        List<Integer> ids = FormatUtil.StringTOIntegerList(value);
                        LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
                        queryWrapper.in(TreeNode::getId, ids);
                        List<TreeNode> treeNodes = treeNodeService.list(queryWrapper);
                        treeNodes.forEach(item -> {
                            FieldValueVO fieldValueVO = new FieldValueVO();
                            fieldValueVO.setValueId(item.getId());
                            fieldValueVO.setPath(item.getPath());

                            List<String> idStrs = new ArrayList<>();
                            List<String> pathNames = new ArrayList<>();
                            if (item.getPath() != null && !item.getPath().equals("")) {
                                idStrs = Arrays.asList(item.getPath().split("/"));
                                pathNames = treeNodeService.getBaseMapper().getTreeFieldPath(idStrs);

                            }
                            pathNames.add(item.getName());
                            String pathValue = StringUtils.join(pathNames, "/");
                            fieldValueVO.setPathValue(pathValue);
                            fieldValueVO.setValue(pathValue);
                            fieldValueVOS.add(fieldValueVO);
                        });
                    }
                    break;

            }

        }
        Records records = new Records();
        records.setData(fieldValueVOS);
        return records;
    }

    public Records addAllPatentCustomFieldOrder(AllFieldOrderDTO allFieldOrderDTO) {
        Integer projectId = allFieldOrderDTO.getProjectId();
        List<AllCustomFieldVO> allCustomFieldVOS = allFieldOrderDTO.getAllCustomFieldVOs();
        if (allFieldOrderDTO.getTaskId() != null) {
            cacheUtils.addTaskCustomField(allFieldOrderDTO.getTaskId(), allCustomFieldVOS);
        } else {
            cacheUtils.addPatentCustomField(projectId, allCustomFieldVOS);
        }
        Records records = new Records();
        records.setData(allCustomFieldVOS);
        return records;
    }


    /**
     * 根据名称获得标引栏位以及标引值
     *
     * @param name
     * @param projectId
     */
    public List<EsCustomFieldValueDTO> getCustomFieldByValueName(String name, Integer projectId) {
        List<EsCustomFieldValueDTO> esCustomFieldDTOS = new ArrayList<>();
        //根据名称获得标引栏位以及标引值
        LambdaQueryWrapper<CustomField> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.in(CustomField::getType, Arrays.asList(4, 5))
                .eq(CustomField::getProjectId, projectId);
        List<CustomField> customFields = this.list(queryWrapper);
        List<Integer> ids = customFields.stream().map(CustomField::getId).collect(Collectors.toList());
        if (ids.size() == 0) {
            return esCustomFieldDTOS;
        }
        //从option 查询名称相同的选项
        LambdaQueryWrapper<CustomOption> optionWrapper = new LambdaQueryWrapper<>();
        optionWrapper.eq(CustomOption::getName, name)
                .in(CustomOption::getCustomFieldId, ids);
        List<CustomOption> options = customOptionService.list(optionWrapper);

        if (options != null && options.size() != 0) {
            options.forEach(item -> {
                EsCustomFieldValueDTO esCustomFieldDTO = esCustomFieldDTOS.stream()
                        .filter(i -> i.getFieldId()
                                .equals(item.getCustomFieldId()))
                        .findFirst().orElse(null);
                if (esCustomFieldDTO == null) {
                    esCustomFieldDTO = new EsCustomFieldValueDTO();
                    esCustomFieldDTO.setFieldId(item.getCustomFieldId().toString());
                    List<String> values = new ArrayList<>();
                    values.add(item.getId().toString());
                    esCustomFieldDTO.setFieldValue(values);
                    esCustomFieldDTOS.add(esCustomFieldDTO);
                } else {
                    esCustomFieldDTO.getFieldValue().add(item.getId().toString());
                }
            });
        }

        return esCustomFieldDTOS;
    }

    public List<EsCustomFieldDTO> getCustomFieldDTOs(List<UploadParamsVO.Field> customerFieldList, Integer projectId, Integer taskId) {
        List<EsCustomFieldDTO> esCustomFieldDTOS = new ArrayList<>();
        for (UploadParamsVO.Field field : customerFieldList) {
            String key = field.getKey();
            List<String> fields = StringUtils.changeStringToString(key, ":");
            if (fields.size() == 2) {
                String name = fields.get(0);
                Integer fieldId = null;
                List<String> value = field.getFieldList();
                Integer type = Integer.parseInt(fields.get(1));
                List<String> select = field.getFieldList();
                if (StringUtils.isNull(select)) {
                    return esCustomFieldDTOS;
                }

                switch (type) {
                    case 0:
                        ;
                    case 1:
                        ;
                    case 2:
                        ;
                    case 3:
                        fieldId = this.GetIdByName(name, projectId, type);
                        break;
                    case 4:

                    case 5:
                        fieldId = this.GetIdByName(name, projectId, type);
                        value = customOptionService.getIdsByNames(value, fieldId);
                        break;
                    case 6:
                        //TODO 根据名称和类型查询
                        fieldId = this.GetIdByName(name, projectId, type);
                        value = treeNodeService.getIdByNames(value, fieldId, type);
                        break;
                }

                EsCustomFieldDTO esCustomFieldDTO = new EsCustomFieldDTO();
                esCustomFieldDTO.setFieldType(type);
                esCustomFieldDTO.setFieldId(fieldId.toString());
                esCustomFieldDTO.setFieldValue(value);
                esCustomFieldDTO.setProjectId(projectId);
                esCustomFieldDTO.setTaskId(taskId);
                esCustomFieldDTOS.add(esCustomFieldDTO);
            }

        }
        return esCustomFieldDTOS;

    }

    /**
     * 根据名称获得自定义字段id
     *
     * @param name
     * @param projectId
     * @param type
     * @return
     */
    public Integer GetIdByName(String name, Integer projectId, Integer type) {
        LambdaQueryWrapper<CustomField> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CustomField::getName, name)
                .eq(CustomField::getProjectId, projectId)
                .eq(CustomField::getType, type);
        CustomField customField = this.getOne(queryWrapper);
        if (customField != null) {
            return customField.getId();
        }
        CustomField customField1 = new CustomField();
        customField1.setName(name);
        customField1.setProjectId(projectId);
        customField1.setType(type);
        customField1.insert();
        return customField1.getId();
    }

    public void copyCustomField(Integer oldProject, Integer newProject) {
        LambdaQueryWrapper<CustomField> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CustomField::getProjectId, oldProject);
        List<CustomField> fields = this.list(queryWrapper);
        if (fields.size() != 0) {
            for (CustomField customField : fields) {
                CustomField newCustomField = new CustomField();
                BeanUtils.copyProperties(fields, newCustomField);
                newCustomField.setId(null);
                newCustomField.setProjectId(newProject);
                newCustomField.insert();
                this.copyCustomFieldValues(customField, newCustomField);
            }
            this.saveBatch(fields);
        }


    }


    public void copyCustomFieldValues(CustomField customField, CustomField newCustomField) {

        Integer type = customField.getType();
        switch (type) {
            case 0:
                ;
            case 1:
                ;
            case 2:
                ;
            case 3:
                this.copyTextValues(customField, newCustomField);
                break;
            case 4:


            case 5:
                this.copyOptionValues(customField, newCustomField);
                break;
            case 6:
                this.copyTreeValues(customField, newCustomField);
                break;

        }


    }

    public void copyTextValues(CustomField customField, CustomField newCustomField) {

        List<PatentWithIdVO> patents = esCustomFieldService.getEsCustomFields(customField.getId().toString(), customField.getType(), customField.getProjectId());
        for (PatentWithIdVO patentWithIdVO : patents) {
            Patent patent = patentWithIdVO.getPatent();
            patent.getESCustomField().setField(newCustomField.getId().toString());
            patent.getESCustomField().setCreateTime(new Date());
            patent.getESCustomField().setTaskId(null);
            patent.getESCustomField().setProjectId(newCustomField.getProjectId());
            String parentId = patent.getPatentJoin().getParent();
            try {
                esService.addChildPatent(patent, parentId);
            } catch (Exception e) {
                throw new XiaoShiException("保存出错");
            }

        }


    }

    public void copyOptionValues(CustomField customField, CustomField newCustomField) {
        Integer newId = newCustomField.getId();
        //查询自定义栏位的选项值
        Map<String, String> map = new HashMap<>();
        LambdaQueryWrapper<CustomOption> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CustomOption::getCustomFieldId, customField.getId());
        List<CustomOption> customOptions = customOptionService.list(queryWrapper);
        for (CustomOption customOption : customOptions) {
            CustomOption customOption1 = new CustomOption();
            BeanUtils.copyProperties(customOption, customOption1);
            customOption1.setCustomFieldId(newId);
            customOption1.insert();
            map.put(customOption.getId().toString(), customOption1.getId().toString());

        }
        List<PatentWithIdVO> patents = esCustomFieldService.getEsCustomFields(customField.getId().toString(), customField.getType(), customField.getProjectId());
        for (PatentWithIdVO patentWithIdVO : patents) {
            Patent patent = patentWithIdVO.getPatent();
            patent.getESCustomField().setField(customField.getId().toString());
            patent.getESCustomField().setCreateTime(new Date());
            patent.getESCustomField().setTaskId(null);
            List<String> fieldValues = patent.getESCustomField().getFieldValue();
            fieldValues.forEach(item -> item = map.get(item));
            patent.getESCustomField().setFieldValue(fieldValues);
            patent.getESCustomField().setStatsValue(fieldValues);
            String parentId = patent.getPatentJoin().getParent();
            try {
                esService.addChildPatent(patent, parentId);
            } catch (Exception e) {
                throw new XiaoShiException("保存出错");
            }

        }

    }


    public void copyTreeValues(CustomField customField, CustomField newCustomField) {
        Integer newId = newCustomField.getId();
        Map<String, String> map = new HashMap<>();
        //查询自定义栏位的选项值
        LambdaQueryWrapper<TreeNode> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(TreeNode::getTypeId, customField.getId())
                .eq(TreeNode::getType, customField.getType())
                .orderByAsc(TreeNode::getLevel);
        List<TreeNode> treeNodes = treeNodeService.list(queryWrapper);
        for (TreeNode treeNode : treeNodes) {
            TreeNode treeNode1 = new TreeNode();
            BeanUtils.copyProperties(treeNode, treeNode1);
            treeNode1.setTypeId(newCustomField.getId());
            treeNode1.setId(null);
            String path = treeNode.getPath();
            if (path != null && !path.trim().equals("")) {
                List<String> paths = Arrays.asList(path.split("/"));
                paths.forEach(item -> item = map.get(item));
                path = StringUtils.join(paths, "/");
                treeNode1.setPath(path);
            }
            treeNode1.insert();
            map.put(treeNode.getId().toString(), treeNode1.getId().toString());

        }
        List<PatentWithIdVO> patents = esCustomFieldService.getEsCustomFields(customField.getId().toString(), customField.getType(), customField.getProjectId());
        for (PatentWithIdVO patentWithIdVO : patents) {
            Patent patent = patentWithIdVO.getPatent();
            patent.getESCustomField().setField(customField.getId().toString());
            patent.getESCustomField().setCreateTime(new Date());
            patent.getESCustomField().setTaskId(null);
            List<String> fieldValues = patent.getESCustomField().getFieldValue();
            List<String> statusValues = patent.getESCustomField().getStatsValue();
            fieldValues.forEach(item -> item = map.get(item));
            statusValues.forEach(item -> item = map.get(item));
            patent.getESCustomField().setFieldValue(fieldValues);
            patent.getESCustomField().setStatsValue(statusValues);
            String parentId = patent.getPatentJoin().getParent();
            //TODO添加path
            try {
                esService.addChildPatent(patent, parentId);
            } catch (Exception e) {
                throw new XiaoShiException("保存出错");
            }

        }

    }



    /**
     * @param customerFieldList
     */
    public  List<EsCustomFieldDTO> getFieldDTOByStrings(List<UploadParamsVO.Field> customerFieldList, Integer projectId,Integer contionId) {
      List<EsCustomFieldDTO>  esCustomFieldDTOs =new ArrayList<>();
        if (customerFieldList != null && customerFieldList.size() != 0) {

            for (UploadParamsVO.Field field : customerFieldList) {
                EsCustomFieldDTO esCustomFieldDTO =new EsCustomFieldDTO();
                String key = field.getKey();
                List<String> fieldList = field.getFieldList();
                String[] keys = key.split(":");
                if (keys.length < 2) {
                    continue;
                }
                String type = keys[1].trim();
                String fieldName = keys[0].trim();
                Integer typeInt = Integer.parseInt(type);
                Integer fieldId = this.GetIdByName(fieldName, projectId, typeInt);
                esCustomFieldDTO.setFieldId(fieldId.toString());
                List<String> values =new ArrayList<>();
                switch (type) {
                    case "0":
                    case "1":
                    case "2":
                        esCustomFieldDTO.setFieldType(Integer.parseInt(type));
                        values =fieldList;
                        break;
                    case "4":
                    case "5":
                        esCustomFieldDTO.setFieldType(Integer.parseInt(type));
                        values = customOptionService.getIdsByNames(fieldList,fieldId);
                        break;
                    case "6":
                        esCustomFieldDTO.setFieldType(Integer.parseInt(type));
                       values =treeNodeService.getIdByNames(fieldList,fieldId,contionId);
                        break;
                }
                esCustomFieldDTO.setFieldValue(values);

                esCustomFieldDTO.setProjectId(projectId);
                esCustomFieldDTOs.add(esCustomFieldDTO);
            }

        }
     return esCustomFieldDTOs;
    }



    public Integer addCustomField(CustomFieldDTO customFieldDTO) {


        //非空校验
        if (customFieldDTO.getProjectId().equals(null)) {
            throw new XiaoShiException("专题库/报告id不能为空！");
        }
        if (customFieldDTO.getName().equals(null) || customFieldDTO.getName().equals("")) {
            throw new XiaoShiException("自定义栏位名称不能为空！");
        }
        if (customFieldDTO.getType().equals(null)) {
            throw new XiaoShiException("自定义栏位类型不能为空！");
        }
        String name = customFieldDTO.getName();
        Integer projectId = customFieldDTO.getProjectId();
        //检查名称是否规范
        customFieldDTO.setName(name.trim());
        //同一个专题库/报告id下名称不能重复
        LambdaQueryWrapper<CustomField> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(CustomField::getName, name);
        queryWrapper.eq(CustomField::getProjectId, projectId);
        List<CustomField> customFields = this.list(queryWrapper);
        if (customFields != null && customFields.size() != 0) {
            throw new XiaoShiException("名称不能重复");
        }

        CustomField customField = new CustomField();
        BeanUtils.copyProperties(customFieldDTO, customField);
        customField.setCreateId(customFieldDTO.getPersonId());
        customField.insert();
        return customField.getId();
    }

}