teableio / teable / 10523150885

import {

  BadRequestException,

  Injectable,

  InternalServerErrorException,

  Logger,

} from '@nestjs/common';

import type {

  IFieldPropertyKey,

  ILookupOptionsVo,

  IOtOperation,

  ISelectFieldChoice,

  IConvertFieldRo,

  IFilterSet,

  ISelectFieldOptionsRo,

  ISelectFieldOptions,

  IFilterItem,

  IFilter,

} from '@teable/core';

import {

  ColorUtils,

  DbFieldType,

  FIELD_VO_PROPERTIES,

  FieldOpBuilder,

  FieldType,

  generateChoiceId,

  isMultiValueLink,

  RecordOpBuilder,

  getValidFilterOperators,

  ViewOpBuilder,

} from '@teable/core';

import { PrismaService } from '@teable/db-main-prisma';

import { Knex } from 'knex';

import { difference, intersection, isEmpty, isEqual, keyBy, set, find, differenceBy } from 'lodash';

import { InjectModel } from 'nest-knexjs';

import { majorFieldKeysChanged } from '../../../utils/major-field-keys-changed';

import { BatchService } from '../../calculation/batch.service';

import { FieldCalculationService } from '../../calculation/field-calculation.service';

import type { ICellContext } from '../../calculation/link.service';

import { LinkService } from '../../calculation/link.service';

import type { IOpsMap } from '../../calculation/reference.service';

import { ReferenceService } from '../../calculation/reference.service';

import { formatChangesToOps } from '../../calculation/utils/changes';

import { composeOpMaps } from '../../calculation/utils/compose-maps';

import { CollaboratorService } from '../../collaborator/collaborator.service';

import { ViewService } from '../../view/view.service';

import { FieldService } from '../field.service';

import type { IFieldInstance, IFieldMap } from '../model/factory';

import { createFieldInstanceByRaw, createFieldInstanceByVo } from '../model/factory';

import { FormulaFieldDto } from '../model/field-dto/formula-field.dto';

import type { LinkFieldDto } from '../model/field-dto/link-field.dto';

import type { MultipleSelectFieldDto } from '../model/field-dto/multiple-select-field.dto';

import type { RatingFieldDto } from '../model/field-dto/rating-field.dto';

import { RollupFieldDto } from '../model/field-dto/rollup-field.dto';

import type { SingleSelectFieldDto } from '../model/field-dto/single-select-field.dto';

import type { UserFieldDto } from '../model/field-dto/user-field.dto';

import { FieldConvertingLinkService } from './field-converting-link.service';

import { FieldSupplementService } from './field-supplement.service';

interface IModifiedOps {

  recordOpsMap?: IOpsMap;

  fieldOps?: IOtOperation[];

}

@Injectable()

export class FieldConvertingService {

  private readonly logger = new Logger(FieldConvertingService.name);

  constructor(

    private readonly viewService: ViewService,

    private readonly linkService: LinkService,

    private readonly fieldService: FieldService,

    private readonly batchService: BatchService,

    private readonly prismaService: PrismaService,

    private readonly referenceService: ReferenceService,

    private readonly fieldConvertingLinkService: FieldConvertingLinkService,

    private readonly fieldSupplementService: FieldSupplementService,

    private readonly fieldCalculationService: FieldCalculationService,

    private readonly collaboratorService: CollaboratorService,

    @InjectModel('CUSTOM_KNEX') private readonly knex: Knex

  ) {}

  private fieldOpsMap() {

    const fieldOpsMap: IOpsMap = {};

    return {

      pushOpsMap: (tableId: string, fieldId: string, op: IOtOperation | IOtOperation[]) => {

        const ops = Array.isArray(op) ? op : [op];

        if (!fieldOpsMap[tableId]?.[fieldId]) {

          set(fieldOpsMap, [tableId, fieldId], ops);

        } else {

          fieldOpsMap[tableId][fieldId].push(...ops);

        }

      },

      getOpsMap: () => fieldOpsMap,

    };

  }

  /**

   * Mutate field instance directly, because we should update fieldInstance in fieldMap for next field operation

   */

  private buildOpAndMutateField(field: IFieldInstance, key: IFieldPropertyKey, value: unknown) {

    if (isEqual(field[key], value)) {

      return;

    }

    const oldValue = field[key];

    (field[key] as unknown) = value;

    return FieldOpBuilder.editor.setFieldProperty.build({ key, oldValue, newValue: value });

  }

  /**

   * 1. check if the lookup field is valid, if not mark error

   * 2. update lookup field properties

   */

  // eslint-disable-next-line sonarjs/cognitive-complexity

  private updateLookupField(field: IFieldInstance, fieldMap: IFieldMap): IOtOperation[] {

    const ops: (IOtOperation | undefined)[] = [];

    const lookupOptions = field.lookupOptions as ILookupOptionsVo;

    const linkField = fieldMap[lookupOptions.linkFieldId] as LinkFieldDto;

    const lookupField = fieldMap[lookupOptions.lookupFieldId];

    const { showAs: _, ...inheritableOptions } = lookupField.options as Record<string, unknown>;

    const {

      formatting = inheritableOptions.formatting,

      showAs,

      ...inheritOptions

    } = field.options as Record<string, unknown>;

    const cellValueTypeChanged = field.cellValueType !== lookupField.cellValueType;

    if (field.type !== lookupField.type) {

      ops.push(this.buildOpAndMutateField(field, 'type', lookupField.type));

    }

    if (lookupOptions.relationship !== linkField.options.relationship) {

    if (!isEqual(inheritOptions, inheritableOptions)) {

      ops.push(

        this.buildOpAndMutateField(field, 'options', {

          ...inheritableOptions,

          ...(formatting ? { formatting } : {}),

          ...(showAs ? { showAs } : {}),

        })

      );

    }

    if (cellValueTypeChanged) {

      ops.push(this.buildOpAndMutateField(field, 'cellValueType', lookupField.cellValueType));

      if (formatting || showAs) {

        ops.push(this.buildOpAndMutateField(field, 'options', inheritableOptions));

      }

    }

    const isMultipleCellValue = lookupField.isMultipleCellValue || linkField.isMultipleCellValue;

    if (field.isMultipleCellValue !== isMultipleCellValue) {

    return ops.filter(Boolean) as IOtOperation[];

  }

  private updateFormulaField(field: FormulaFieldDto, fieldMap: IFieldMap) {

    const ops: (IOtOperation | undefined)[] = [];

    const { cellValueType, isMultipleCellValue } = FormulaFieldDto.getParsedValueType(

      field.options.expression,

      fieldMap

    );

    if (field.cellValueType !== cellValueType) {

      ops.push(this.buildOpAndMutateField(field, 'cellValueType', cellValueType));

    }

    if (field.isMultipleCellValue !== isMultipleCellValue) {

    return ops.filter(Boolean) as IOtOperation[];

  }

  private updateRollupField(field: RollupFieldDto, fieldMap: IFieldMap) {

  private updateDbFieldType(field: IFieldInstance) {

    const ops: IOtOperation[] = [];

    const dbFieldType = this.fieldSupplementService.getDbFieldType(

      field.type,

      field.cellValueType,

      field.isMultipleCellValue

    );

    if (field.dbFieldType !== dbFieldType) {

      const op1 = this.buildOpAndMutateField(field, 'dbFieldType', dbFieldType);

      op1 && ops.push(op1);

    }

    return ops;

  }

  private async generateReferenceFieldOps(fieldId: string) {

    const topoOrdersContext = await this.fieldCalculationService.getTopoOrdersContext([fieldId]);

    const { fieldMap, topoOrdersByFieldId, fieldId2TableId } = topoOrdersContext;

    const topoOrders = topoOrdersByFieldId[fieldId];

    if (topoOrders.length <= 1) {

      return {};

    }

    const { pushOpsMap, getOpsMap } = this.fieldOpsMap();

    for (let i = 1; i < topoOrders.length; i++) {

      const topoOrder = topoOrders[i];

      // curField will be mutate in loop

      const curField = fieldMap[topoOrder.id];

      const tableId = fieldId2TableId[curField.id];

      if (curField.isLookup) {

        pushOpsMap(tableId, curField.id, this.updateLookupField(curField, fieldMap));

      } else if (curField.type === FieldType.Formula) {

        pushOpsMap(tableId, curField.id, this.updateFormulaField(curField, fieldMap));

      } else if (curField.type === FieldType.Rollup) {

      pushOpsMap(tableId, curField.id, this.updateDbFieldType(curField));

    }

    return getOpsMap();

  }

  /**

   * get deep deference in options, and return changes

   * formatting, showAs should be ignore

   */

  private getOptionsChanges(

    newOptions: Record<string, unknown>,

    oldOptions: Record<string, unknown>,

    valueTypeChange?: boolean

  ): Record<string, unknown> {

    const optionsChanges: Record<string, unknown> = {};

    newOptions = { ...newOptions };

    oldOptions = { ...oldOptions };

    const nonInfectKeys = ['formatting', 'showAs'];

    nonInfectKeys.forEach((key) => {

      delete newOptions[key];

      delete oldOptions[key];

    });

    const newOptionsKeys = Object.keys(newOptions);

    const oldOptionsKeys = Object.keys(oldOptions);

    const addedOptionsKeys = difference(newOptionsKeys, oldOptionsKeys);

    const removedOptionsKeys = difference(oldOptionsKeys, newOptionsKeys);

    const editedOptionsKeys = intersection(newOptionsKeys, oldOptionsKeys).filter(

      (key) => !isEqual(oldOptions[key], newOptions[key])

    );

    addedOptionsKeys.forEach((key) => (optionsChanges[key] = newOptions[key]));

    editedOptionsKeys.forEach((key) => (optionsChanges[key] = newOptions[key]));

    removedOptionsKeys.forEach((key) => (optionsChanges[key] = null));

    // clean formatting, showAs when valueType change

    valueTypeChange && nonInfectKeys.forEach((key) => (optionsChanges[key] = null));

    return optionsChanges;

  }

  private infectPropertyChanged(newField: IFieldInstance, oldField: IFieldInstance) {

    // those key will infect the reference field

    const infectProperties = ['type', 'cellValueType', 'isMultipleCellValue'] as const;

    const changedProperties = infectProperties.filter(

      (key) => !isEqual(newField[key], oldField[key])

    );

    const valueTypeChanged = changedProperties.some((key) =>

      ['cellValueType', 'isMultipleCellValue'].includes(key)

    );

    // options may infect the lookup field

    const optionsChanges = this.getOptionsChanges(

      newField.options,

      oldField.options,

      valueTypeChanged

    );

    return Boolean(changedProperties.length || !isEmpty(optionsChanges));

  }

  // lookupOptions of lookup field and rollup field must be consistent with linkField Settings

  // And they don't belong in the referenceField

  private async updateLookupRollupRef(

    newField: IFieldInstance,

    oldField: IFieldInstance

  ): Promise<IOpsMap | undefined> {

    if (newField.type !== FieldType.Link || oldField.type !== FieldType.Link) {

      return;

    }

    // ignore foreignTableId change

    if (newField.options.foreignTableId !== oldField.options.foreignTableId) {

      return;

    }

    const { relationship, fkHostTableName, foreignKeyName, selfKeyName } = newField.options;

    if (

      relationship === oldField.options.relationship &&

      fkHostTableName === oldField.options.fkHostTableName &&

      foreignKeyName === oldField.options.foreignKeyName &&

      selfKeyName === oldField.options.selfKeyName

    ) {

      return;

    }

    const relatedFieldsRaw = await this.prismaService.field.findMany({

      where: {

        lookupLinkedFieldId: newField.id,

        deletedTime: null,

      },

    });

    const relatedFields = relatedFieldsRaw.map(createFieldInstanceByRaw);

    const lookupToFields = await this.prismaService.field.findMany({

      where: {

        id: {

          in: relatedFields.map((field) => field.lookupOptions?.lookupFieldId as string),

        },

      },

    });

    const relatedFieldsRawMap = keyBy(relatedFieldsRaw, 'id');

    const lookupToFieldsMap = keyBy(lookupToFields, 'id');

    const { pushOpsMap, getOpsMap } = this.fieldOpsMap();

    relatedFields.forEach((field) => {

      const lookupOptions = field.lookupOptions!;

      const ops: IOtOperation[] = [];

      ops.push(

        FieldOpBuilder.editor.setFieldProperty.build({

          key: 'lookupOptions',

          newValue: {

            ...lookupOptions,

            relationship,

            fkHostTableName,

            foreignKeyName,

            selfKeyName,

          },

          oldValue: lookupOptions,

        })

      );

      const lookupToFieldRaw = lookupToFieldsMap[lookupOptions.lookupFieldId];

      if (field.isLookup) {

        const isMultipleCellValue =

          newField.isMultipleCellValue || lookupToFieldRaw.isMultipleCellValue || false;

        if (isMultipleCellValue !== field.isMultipleCellValue) {

          ops.push(

            FieldOpBuilder.editor.setFieldProperty.build({

              key: 'isMultipleCellValue',

              newValue: isMultipleCellValue,

              oldValue: field.isMultipleCellValue,

            }),

            FieldOpBuilder.editor.setFieldProperty.build({

              key: 'dbFieldType',

              newValue: this.fieldSupplementService.getDbFieldType(

                field.type,

                field.cellValueType,

                isMultipleCellValue

              ),

              oldValue: field.dbFieldType,

            })

          );

        }

        const newOptions = this.fieldSupplementService.prepareFormattingShowAs(

          field.options,

          JSON.parse(lookupToFieldRaw.options as string),

          field.cellValueType,

          isMultipleCellValue

        );

        if (!isEqual(newOptions, field.options)) {

      }

      pushOpsMap(relatedFieldsRawMap[field.id].tableId, field.id, ops);

    });

    return getOpsMap();

  }

  /**

   * modify a field will causes the properties of the field that depend on it to change

   * example：

   * 1. modify a field's type will cause the the lookup field's type change

   * 2. cellValueType / isMultipleCellValue change will cause the formula / rollup / lookup field's cellValueType / formatting change

   * 3. options change will cause the lookup field options change

   * 4. options in link field change may cause all lookup field run in to error, should mark them as error

   */

  private async updateReferencedFields(newField: IFieldInstance, oldField: IFieldInstance) {

    if (!this.infectPropertyChanged(newField, oldField)) {

      return;

    }

    const refFieldOpsMap = await this.updateLookupRollupRef(newField, oldField);

    const fieldOpsMap = await this.generateReferenceFieldOps(newField.id);

    await this.submitFieldOpsMap(composeOpMaps([refFieldOpsMap, fieldOpsMap]));

  }

  private async updateOptionsFromMultiSelectField(

    tableId: string,

    updatedChoiceMap: { [old: string]: string | null },

    field: MultipleSelectFieldDto

  ): Promise<IOpsMap | undefined> {

    const { dbTableName } = await this.prismaService.txClient().tableMeta.findFirstOrThrow({

      where: { id: tableId, deletedTime: null },

      select: { dbTableName: true },

    });

    const opsMap: { [recordId: string]: IOtOperation[] } = {};

    const nativeSql = this.knex(dbTableName)

      .select('__id', field.dbFieldName)

      .where((builder) => {

        for (const value of Object.keys(updatedChoiceMap)) {

          builder.orWhere(

            this.knex.raw(`CAST(?? AS text)`, [field.dbFieldName]),

            'LIKE',

            `%"${value}"%`

          );

        }

      })

      .toSQL()

      .toNative();

    const result = await this.prismaService

      .txClient()

      .$queryRawUnsafe<

        { __id: string; [dbFieldName: string]: string }[]

      >(nativeSql.sql, ...nativeSql.bindings);

    for (const row of result) {

      const oldCellValue = field.convertDBValue2CellValue(row[field.dbFieldName]) as string[];

      const newCellValue = oldCellValue.reduce<string[]>((pre, value) => {

        // if key not in updatedChoiceMap, we should keep it

        if (!(value in updatedChoiceMap)) {

        const newValue = updatedChoiceMap[value];

        if (newValue !== null) {

          pre.push(newValue);

        }

        return pre;

      }, []);

      opsMap[row.__id] = [

        RecordOpBuilder.editor.setRecord.build({

          fieldId: field.id,

          oldCellValue,

          newCellValue,

        }),

      ];

    }

    return isEmpty(opsMap) ? undefined : { [tableId]: opsMap };

  }

  private async updateOptionsFromSingleSelectField(

    tableId: string,

    updatedChoiceMap: { [old: string]: string | null },

    field: SingleSelectFieldDto

  ): Promise<IOpsMap | undefined> {

    const { dbTableName } = await this.prismaService.txClient().tableMeta.findFirstOrThrow({

      where: { id: tableId, deletedTime: null },

      select: { dbTableName: true },

    });

    const opsMap: { [recordId: string]: IOtOperation[] } = {};

    const nativeSql = this.knex(dbTableName)

      .select('__id', field.dbFieldName)

      .where((builder) => {

        for (const value of Object.keys(updatedChoiceMap)) {

          builder.orWhere(field.dbFieldName, value);

        }

      })

      .toSQL()

      .toNative();

    const result = await this.prismaService

      .txClient()

      .$queryRawUnsafe<

        { __id: string; [dbFieldName: string]: string }[]

      >(nativeSql.sql, ...nativeSql.bindings);

    for (const row of result) {

      const oldCellValue = field.convertDBValue2CellValue(row[field.dbFieldName]) as string;

      opsMap[row.__id] = [

        RecordOpBuilder.editor.setRecord.build({

          fieldId: field.id,

          oldCellValue,

          newCellValue: updatedChoiceMap[oldCellValue],

        }),

      ];

    }

    return isEmpty(opsMap) ? undefined : { [tableId]: opsMap };

  }

  private async updateOptionsFromSelectField(

    tableId: string,

    updatedChoiceMap: { [old: string]: string | null },

    field: SingleSelectFieldDto | MultipleSelectFieldDto

  ): Promise<IOpsMap | undefined> {

    if (field.type === FieldType.SingleSelect) {

      return this.updateOptionsFromSingleSelectField(tableId, updatedChoiceMap, field);

    }

    if (field.type === FieldType.MultipleSelect) {

      return this.updateOptionsFromMultiSelectField(tableId, updatedChoiceMap, field);

    }

  private async modifySelectOptions(

    tableId: string,

    newField: SingleSelectFieldDto | MultipleSelectFieldDto,

    oldField: SingleSelectFieldDto | MultipleSelectFieldDto

  ) {

    const newChoiceMap = keyBy(newField.options.choices, 'id');

    const updatedChoiceMap: { [old: string]: string | null } = {};

    oldField.options.choices.forEach((item) => {

      if (!newChoiceMap[item.id]) {

        updatedChoiceMap[item.name] = null;

        return;

      }

      if (newChoiceMap[item.id].name !== item.name) {

        updatedChoiceMap[item.name] = newChoiceMap[item.id].name;

      }

    });

    if (isEmpty(updatedChoiceMap)) {

      return;

    }

    return this.updateOptionsFromSelectField(tableId, updatedChoiceMap, newField);

  }

  private async updateOptionsFromRatingField(

    tableId: string,

    field: RatingFieldDto

  ): Promise<IOpsMap | undefined> {

    const { dbTableName } = await this.prismaService.txClient().tableMeta.findFirstOrThrow({

      where: { id: tableId, deletedTime: null },

      select: { dbTableName: true },

    });

    const opsMap: { [recordId: string]: IOtOperation[] } = {};

    const newMax = field.options.max;

    const nativeSql = this.knex(dbTableName)

      .select('__id', field.dbFieldName)

      .where(field.dbFieldName, '>', newMax)

      .toSQL()

      .toNative();

    const result = await this.prismaService

      .txClient()

      .$queryRawUnsafe<

        { __id: string; [dbFieldName: string]: string }[]

      >(nativeSql.sql, ...nativeSql.bindings);

    for (const row of result) {

      const oldCellValue = field.convertDBValue2CellValue(row[field.dbFieldName]) as number;

      opsMap[row.__id] = [

        RecordOpBuilder.editor.setRecord.build({

          fieldId: field.id,

          oldCellValue,

          newCellValue: newMax,

        }),

      ];

    }

    return isEmpty(opsMap) ? undefined : { [tableId]: opsMap };

  }

  private async modifyRatingOptions(

    tableId: string,

    newField: RatingFieldDto,

    oldField: RatingFieldDto

  ) {

    const newMax = newField.options.max;

    const oldMax = oldField.options.max;

    if (newMax >= oldMax) return;

    return await this.updateOptionsFromRatingField(tableId, newField);

  }

  private async updateOptionsFromUserField(

  private async modifyUserOptions(tableId: string, newField: UserFieldDto, oldField: UserFieldDto) {

  private async modifyOptions(

    tableId: string,

    newField: IFieldInstance,

    oldField: IFieldInstance

  ): Promise<IModifiedOps | undefined> {

    if (newField.isLookup) {

    switch (newField.type) {

      case FieldType.Link:

        return this.fieldConvertingLinkService.modifyLinkOptions(

          tableId,

          newField as LinkFieldDto,

          oldField as LinkFieldDto

        );

      case FieldType.SingleSelect:

      case FieldType.MultipleSelect: {

        const rawOpsMap = await this.modifySelectOptions(

          tableId,

          newField as SingleSelectFieldDto,

          oldField as SingleSelectFieldDto

        );

        return { recordOpsMap: rawOpsMap };

      }

      case FieldType.Rating: {

        const rawOpsMap = await this.modifyRatingOptions(

          tableId,

          newField as RatingFieldDto,

          oldField as RatingFieldDto

        );

        return { recordOpsMap: rawOpsMap };

      }

      case FieldType.User: {

    }

  }

  private getOriginFieldKeys(newField: IFieldInstance, oldField: IFieldInstance) {

    return FIELD_VO_PROPERTIES.filter((key) => !isEqual(newField[key], oldField[key]));

  }

  private getOriginFieldOps(newField: IFieldInstance, oldField: IFieldInstance) {

    return this.getOriginFieldKeys(newField, oldField).map((key) =>

      FieldOpBuilder.editor.setFieldProperty.build({

        key,

        newValue: newField[key],

        oldValue: oldField[key],

      })

    );

  }

  private async getDerivateByLink(tableId: string, innerOpsMap: IOpsMap['key']) {

    const changes: ICellContext[] = [];

    for (const recordId in innerOpsMap) {

      for (const op of innerOpsMap[recordId]) {

        const context = RecordOpBuilder.editor.setRecord.detect(op);

        if (!context) {

        changes.push({

          recordId,

          fieldId: context.fieldId,

          oldValue: null, // old value by no means when converting

          newValue: context.newCellValue,

        });

      }

    }

    const derivate = await this.linkService.getDerivateByLink(tableId, changes, true);

    const cellChanges = derivate?.cellChanges || [];

    const opsMapByLink = cellChanges.length ? formatChangesToOps(cellChanges) : {};

    return {

      opsMapByLink,

      saveForeignKeyToDb: derivate?.saveForeignKeyToDb,

    };

  }

  private async calculateAndSaveRecords(

    tableId: string,

    field: IFieldInstance,

    recordOpsMap: IOpsMap | void

  ) {

    if (!recordOpsMap || isEmpty(recordOpsMap)) {

      return;

    }

    let saveForeignKeyToDb: (() => Promise<void>) | undefined;

    if (field.type === FieldType.Link && !field.isLookup) {

      const result = await this.getDerivateByLink(tableId, recordOpsMap[tableId]);

      saveForeignKeyToDb = result?.saveForeignKeyToDb;

      recordOpsMap = composeOpMaps([recordOpsMap, result.opsMapByLink]);

    }

    const {

      opsMap: calculatedOpsMap,

      fieldMap,

      tableId2DbTableName,

    } = await this.referenceService.calculateOpsMap(recordOpsMap, saveForeignKeyToDb);

    const composedOpsMap = composeOpMaps([recordOpsMap, calculatedOpsMap]);

    await this.batchService.updateRecords(composedOpsMap, fieldMap, tableId2DbTableName);

  }

  private async getExistRecords(tableId: string, newField: IFieldInstance) {

    const { dbTableName } = await this.prismaService.txClient().tableMeta.findFirstOrThrow({

      where: { id: tableId },

      select: { dbTableName: true },

    });

    const result = await this.fieldCalculationService.getRecordsBatchByFields({

      [dbTableName]: [newField],

    });

    const records = result[dbTableName];

    if (!records) {

    return records;

  }

  // eslint-disable-next-line sonarjs/cognitive-complexity

  private async convert2Select(

    tableId: string,

    newField: SingleSelectFieldDto | MultipleSelectFieldDto,

    oldField: IFieldInstance

  ) {

    const fieldId = newField.id;

    const records = await this.getExistRecords(tableId, oldField);

    const choices = newField.options.choices;

    const opsMap: { [recordId: string]: IOtOperation[] } = {};

    const fieldOps: IOtOperation[] = [];

    const choicesMap = keyBy(choices, 'name');

    const newChoicesSet = new Set<string>();

    records.forEach((record) => {

      const oldCellValue = record.fields[fieldId];

      if (oldCellValue == null) {

      if (!opsMap[record.id]) {

        opsMap[record.id] = [];

      }

      const cellStr = oldField.cellValue2String(oldCellValue);

      const newCellValue = newField.convertStringToCellValue(cellStr, true);

      if (Array.isArray(newCellValue)) {

        newCellValue.forEach((item) => {

          if (!choicesMap[item]) {

            newChoicesSet.add(item);

          }

        });

      } else if (newCellValue && !choicesMap[newCellValue]) {

        newChoicesSet.add(newCellValue);

      }

      opsMap[record.id].push(

        RecordOpBuilder.editor.setRecord.build({

          fieldId,

          newCellValue,

          oldCellValue,

        })

      );

    });

    if (newChoicesSet.size) {

      const colors = ColorUtils.randomColor(

        choices.map((item) => item.color),

        newChoicesSet.size

      );

      const newChoices = choices.concat(

        Array.from(newChoicesSet).map<ISelectFieldChoice>((item, i) => ({

          id: generateChoiceId(),

          name: item,

          color: colors[i],

        }))

      );

      const fieldOp = this.buildOpAndMutateField(newField, 'options', {

        ...newField.options,

        choices: newChoices,

      });

      fieldOp && fieldOps.push(fieldOp);

    }

    return {

      recordOpsMap: isEmpty(opsMap) ? undefined : { [tableId]: opsMap },

      fieldOps,

    };

  }

  private async convert2User(tableId: string, newField: UserFieldDto, oldField: IFieldInstance) {