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.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.permissions.PermissionService;
import cn.cslg.pas.service.query.FormatQueryService;
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.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.List;
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;

    @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();
        try {
            personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        } catch (Exception e) {
            throw new UnLoginException("未登录");
        }
        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());
            } else {
                throw new XiaoShiException("未获取到当前登陆人信息");
            }
        }
    }


    public List<AllCustomFieldVO> getAllProjectCustomField(Integer projectId) {
        Integer order = 0;
        List<AllCustomFieldVO> allCustomFieldVOS = cacheUtils.getPatentCustomField(projectId);
        if (CollectionUtils.isEmpty(allCustomFieldVOS)) {
            allCustomFieldVOS = new ArrayList<>();
            //根据 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 = 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 = new AllCustomFieldVO();
                allCustomFieldVO.setId(item.getId());
                allCustomFieldVO.setType(item.getTreeType());
                allCustomFieldVO.setSysOrder(order);
                switch (item.getTreeType()) {
                    case 7:
                        Product product = productService.getById(item.getId());
                        allCustomFieldVO.setName(product.getName());
                        break;
                    case 8:
                        ProductCategory productCategory = productCategoryService.getById(item.getId());
                        allCustomFieldVO.setName(productCategory.getName());
                        break;
                    case 9:
                        //TODO 技术类别
                        break;
                }
                allCustomFieldVOS.add(allCustomFieldVO);
                order += 1;
            }

            cacheUtils.addPatentCustomField(projectId, allCustomFieldVOS);
        }

        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.setValue(item.getName());
                            fieldValueVO.setPath(item.getPath());
                            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, 6))
                .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);
        // 从 treeNode 查询名称相同的节点
        LambdaQueryWrapper<TreeNode> treeNodeWrapper = new LambdaQueryWrapper<>();
        treeNodeWrapper.eq(TreeNode::getName, name)
                .eq(TreeNode::getType, 4)
                .in(TreeNode::getTypeId, ids);
        List<TreeNode> treeNodes = treeNodeService.list(treeNodeWrapper);

        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.setFieldId(item.getCustomFieldId().toString());
                    List<String> values = new ArrayList<>();
                    values.add(item.getId().toString());
                    esCustomFieldDTO.setFieldValue(values);
                } else {
                    esCustomFieldDTO.getFieldValue().add(item.getId().toString());
                }
            });
        }

        if (treeNodes != null && treeNodes.size() != 0) {
            treeNodes.forEach(item -> {
                EsCustomFieldValueDTO esCustomFieldDTO = esCustomFieldDTOS.stream()
                        .filter(i -> i.getFieldId()
                                .equals(item.getTypeId()))
                        .findFirst().orElse(null);
                if (esCustomFieldDTO == null) {
                    esCustomFieldDTO.setFieldId(item.getTypeId().toString());
                    List<String> values = new ArrayList<>();
                    values.add(item.getId().toString());
                    esCustomFieldDTO.setFieldValue(values);
                } 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);
                        ;
                }

                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();
        }
        PersonnelVO personnelVO = cacheUtils.getLoginUser(loginUtils.getId());
        CustomField customField1 = new CustomField();
        customField1.setName(name);
        customField1.setProjectId(projectId);
        customField1.setType(type);
        customField1.setCreateId(personnelVO.getId());
        customField1.insert();
        return customField1.getId();
    }

}