feat: 实现动作类型的规则节点

@@ -85,6 +85,7 @@
     () => props.value,
     (target) => {
       // const position = unref(editoreRef)?.getCursorPosition();
+      if (unref(isFocus)) return;
       unref(editoreRef)?.setValue(getFormatValue(target));
       unref(editoreRef)?.clearSelection();
       // position && unref(editoreRef)?.moveCursorToPosition(position!);

@@ -228,3 +228,16 @@ export enum MailBodyTypeNameEnum {
   HTML = 'HTML',
   PLAIN_TEXT = 'Plain Text',
 }
+
+// Action Push to edge
+export enum ScopeEnum {
+  SERVER_SCOPE = 'SERVER_SCOPE',
+  CLIENT_SCOPE = 'CLIENT_SCOPE',
+  SHARED_SCOPE = 'SHARED_SCOPE',
+}
+
+export enum ScopeNameEnum {
+  SERVER_SCOPE = '服务端属性',
+  CLIENT_SCOPE = '客户端属性',
+  SHARED_SCOPE = '共享属性',
+}

@@ -39,12 +39,234 @@ export enum CreateAlarmFieldsEnum {
 export enum CreateAlarmFieldsNameEnum {
   ALARM_DETAILS_BUILD_JS = 'Alarm details builder',
   USE_MESSAGE_ALARM_DATA = 'Use message alarm data',
-  OVERWRITE_ALARM_DETAILS = 'overwriteAlarmDetails',
+  OVERWRITE_ALARM_DETAILS = 'Overwrite alarm details',
   ALARM_TYPE = 'Alarm type',
   SEVERITY = 'Alarm severity pattern',
   PROPAGATE = 'Propagate alarm to related entities',
   RELATION_TYPES = 'Relation types to propagate',
   PROPAGATE_TO_OWNER = 'Propagate alarm to entity owner (Customer or Tenant)',
   PROPAGATE_TO_TENANT = 'Propagate alarm to Tenant',
-  DYNAMIC_SEVERITY = 'dynamicSeverity',
+  DYNAMIC_SEVERITY = 'Use alarm severity pattern',
+}
+
+// Create relation
+export enum CreateRelationFieldsEnum {
+  DIRECTION = 'direction',
+  ENTITY_TYPE = 'entityType',
+  ENTITY_NAME_PATTERN = 'entityNamePattern',
+  ENTITY_TYPE_PATTERN = 'entityTypePattern',
+  RELATION_TYPE = 'relationType',
+  CREATE_ENTITY_IF_NOT_EXISTS = 'createEntityIfNotExists',
+  REMOVE_CURRENT_RELATIONS = 'removeCurrentRelations',
+  CHANGE_ORIGINATOR_TO_RELATED_ENTITY = 'changeOriginatorToRelatedEntity',
+  ENTITY_CACHE_EXPIRATION = 'entityCacheExpiration',
+}
+
+export enum CreateRelationFieldsNameEnum {
+  DIRECTION = '方向',
+  ENTITY_TYPE = '类型',
+  ENTITY_NAME_PATTERN = 'Name pattern',
+  ENTITY_TYPE_PATTERN = 'Type pattern',
+  RELATION_TYPE = 'Relation type pattern',
+  CREATE_ENTITY_IF_NOT_EXISTS = 'Create new entity if not exists',
+  REMOVE_CURRENT_RELATIONS = 'Remove current relations',
+  CHANGE_ORIGINATOR_TO_RELATED_ENTITY = 'Change originator to related entity',
+  ENTITY_CACHE_EXPIRATION = 'Entities cache expiration time(sec)',
+}
+
+// Delay deprecated
+export enum DelayDeprecatedFieldsEnum {
+  USE_METADATA_PERIOD_IN_SECONDS_PATTERNS = 'useMetadataPeriodInSecondsPatterns',
+  PERIOD_IN_SECONDS = 'periodInSeconds',
+  PERIOD_IN_SECONDS_PATTERN = 'periodInSecondsPattern',
+  MAX_PENDING_MSGS = 'maxPendingMsgs',
+}
+
+export enum DelayDeprecatedFieldsNameEnum {
+  USE_METADATA_PERIOD_IN_SECONDS_PATTERNS = 'Use period in seconds pattern',
+  PERIOD_IN_SECONDS = 'Period in seconds',
+  PERIOD_IN_SECONDS_PATTERN = 'Period in seconds',
+  MAX_PENDING_MSGS = 'Maximum pending messages',
+}
+
+export enum DeleteRelationFieldsEnum {
+  DELETE_FOR_SINGLE_ENTITY = 'deleteForSingleEntity',
+  DIRECTION = 'direction',
+  ENTITY_TYPE = 'entityType',
+  ENTITY_NAME_PATTERN = 'entityNamePattern',
+  RELATION_TYPE = 'relationType',
+  ENTITY_CACHE_EXPIRATION = 'entityCacheExpiration',
+}
+
+export enum DeleteRelationFieldsNameEnum {
+  DELETE_FOR_SINGLE_ENTITY = 'Delete relation to specific entity',
+  DIRECTION = '方向',
+  ENTITY_TYPE = '类型',
+  ENTITY_NAME_PATTERN = 'Name pattern',
+  RELATION_TYPE = 'Relation type pattern',
+  ENTITY_CACHE_EXPIRATION = 'Entities cache expiration time(sec)',
+}
+
+// device profile
+export enum DeviceProfileFieldsEnum {
+  PERSIST_ALARM_RULES_STATE = 'persistAlarmRulesState',
+  FETCH_ALARM_RULES_STATE_ON_START = 'fetchAlarmRulesStateOnStart',
+}
+
+export enum DeviceProfileFieldsNameEnum {
+  PERSIST_ALARM_RULES_STATE = 'Persist state of alarm rules',
+  FETCH_ALARM_RULES_STATE_ON_START = 'Fetch state of alarm rules',
+}
+
+// Generator
+export enum GeneratorFieldsEnum {
+  MSG_COUNT = 'msgCount',
+  PERIOD_IN_SECONDS = 'periodInSeconds',
+  JS_SCRIPT = 'jsScript',
+  ORIGINATOR_ID = 'originatorId',
+  ORIGINATOR_TYPE = 'originatorType',
+}
+
+export enum GeneratorFieldsNameEnum {
+  MSG_COUNT = 'Message count(0 - unlimited)',
+  PERIOD_IN_SECONDS = 'Period in seconds',
+  JS_SCRIPT = 'Generate',
+  // ORIGINATOR_ID = 'Originator',
+  ORIGINATOR_TYPE = 'Originator',
+}
+
+// Gps geofencing events
+export enum GpsGeofencingEventsFieldsEnum {
+  LATITUDE_KEY_NAME = 'latitudeKeyName',
+  LONGITUDE_KEY_NAME = 'longitudeKeyName',
+  PERIMETER_TYPE = 'perimeterType',
+  FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA = 'fetchPerimeterInfoFromMessageMetadata',
+  PERIMETER_KEY_NAME = 'perimeterKeyName',
+  CENTER_LATITUDE = 'centerLatitude',
+  CENTER_LONGITUDE = 'centerLongitude',
+  RANGE = 'range',
+  RANGE_UNIT = 'rangeUnit',
+  POLYGONS_DEFINITION = 'polygonsDefinition',
+  MIN_INSIDE_DURATION = 'minInsideDuration',
+  MIN_INSIDE_DURATION_TIME_UNIT = 'minInsideDurationTimeUnit',
+  MIN_OUTSIDE_DURATION = 'minOutsideDuration',
+  MIN_OUTSIDE_DURATION_TIME_UNIT = 'minOutsideDurationTimeUnit',
+}
+
+export enum GpsGeofencingEventsFieldsNameEnum {
+  LATITUDE_KEY_NAME = 'Latitude key name',
+  LONGITUDE_KEY_NAME = 'longitude key name',
+  PERIMETER_TYPE = 'Perimeter type',
+  FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA = 'Fetch perimeter information from message metadata',
+  PERIMETER_KEY_NAME = 'Perimeter key name',
+  CENTER_LATITUDE = 'Center Latitude',
+  CENTER_LONGITUDE = 'Center Longitude',
+  RANGE = 'Range',
+  RANGE_UNIT = 'Range units',
+  POLYGONS_DEFINITION = 'Polygon definition',
+  MIN_INSIDE_DURATION = 'Minimal inside duration',
+  MIN_INSIDE_DURATION_TIME_UNIT = 'Minimal inside duration time unit',
+  MIN_OUTSIDE_DURATION = 'Minimal outside duration',
+  MIN_OUTSIDE_DURATION_TIME_UNIT = 'Minimal outside duration time unit',
+}
+
+// Log
+export enum LogFieldsEnum {
+  JS_SCRIPT = 'jsScript',
+}
+
+export enum LogFieldsNameEnum {
+  JS_SCRIPT = 'To string',
+}
+
+// Message Count
+export enum MessageCountFieldsEnum {
+  INTERVAL = 'interval',
+  TELEMETRY_PREFIX = 'telemetryPrefix',
+}
+
+export enum MessageCountFieldsNameEnum {
+  INTERVAL = 'Interval in seconds',
+  TELEMETRY_PREFIX = 'Output timeseries key prefix',
+}
+
+// Push to edge
+export enum PushToEdgeFieldsEnum {
+  SCOPE = 'scope',
+}
+
+export enum PushToEdgeFieldsNameEnum {
+  SCOPE = '设备属性范围',
+}
+// Rpc call reply
+export enum RpcCallReplyFieldsEnum {
+  REQUEST_ID_META_DATA_ATTRIBUTE = 'requestIdMetaDataAttribute',
+}
+
+export enum RpcCallReplyFieldsNameEnum {
+  REQUEST_ID_META_DATA_ATTRIBUTE = 'Request Id Metadata attribute name',
+}
+
+// Rpc call request
+export enum RpcCallRequestFieldsEnum {
+  TIMEOUT_IN_SECONDS = 'timeoutInSeconds',
+}
+
+export enum RpcCallRequestFieldsNameEnum {
+  TIMEOUT_IN_SECONDS = 'Timeout in seconds',
+}
+
+// Save attribute
+export enum SaveAttributesFieldsEnum {
+  NOTIFY_DEVICE = 'notifyDevice',
+  SCOPE = 'scope',
+}
+
+export enum SaveAttributesFieldsNameEnum {
+  NOTIFY_DEVICE = 'Notify Device',
+  SCOPE = '设备属性范围',
+}
+
+// Save event
+export enum SaveEventFieldsEnum {
+  CONFIGURATION = 'CONFIGURATION',
+}
+
+export enum SaveEventFieldsNameEnum {
+  CONFIGURATION = '配置',
+}
+
+// Save timeseries
+export enum SaveTimeseriesFieldsEnum {
+  DEFAULT_TTL = 'defaultTTL',
+  SKIP_LATEST_PERSISTENCE = 'skipLatestPersistence',
+  USE_SERVER_TS = 'useServerTs',
+}
+
+export enum SaveTimeseriesFieldsNameEnum {
+  DEFAULT_TTL = 'Default TTL in seconds',
+  SKIP_LATEST_PERSISTENCE = 'Skit latest persistence',
+  USE_SERVER_TS = 'Use server ts',
+}
+
+// save to custom table
+export enum SaveToCustomTableFieldsEnum {
+  FIELDS_MAPPING = 'fieldsMapping',
+  TABLE_NAME = 'tableName',
+}
+
+export enum SaveToCustomTableFieldsNameEnum {
+  FIELDS_MAPPING = 'Fields mapping',
+  TABLE_NAME = 'Custom table name',
+}
+
+// Unassign from customer
+export enum UnassignFromCustomerFieldsEnum {
+  CUSTOMER_NAME_PATTERN = 'customerNamePattern',
+  CUSTOMER_CACHE_EXPIRATION = 'customerCacheExpiration',
+}
+
+export enum UnassignFromCustomerFieldsNameEnum {
+  CUSTOMER_NAME_PATTERN = 'Customer name pattern',
+  CUSTOMER_CACHE_EXPIRATION = 'Customer cache expiration time(sec)',
 }

@@ -14,8 +14,102 @@ export const formSchemas: FormSchema[] = [
     }),
   },
   {
+    field: CreateAlarmFieldsEnum.OVERWRITE_ALARM_DETAILS,
+    component: 'Checkbox',
+    label: '',
+    show: ({ model }) => model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
+    renderComponentContent: () => ({
+      default: () => CreateAlarmFieldsNameEnum.OVERWRITE_ALARM_DETAILS,
+    }),
+  },
+  {
     field: CreateAlarmFieldsEnum.ALARM_DETAILS_BUILD_JS,
     component: 'JavascriptEditorWithTestModal',
     label: CreateAlarmFieldsNameEnum.ALARM_DETAILS_BUILD_JS,
+    valueField: 'value',
+    changeEvent: 'update:value',
+    show: ({ model }) =>
+      !(
+        !model[CreateAlarmFieldsEnum.OVERWRITE_ALARM_DETAILS] &&
+        model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA]
+      ),
+    componentProps: {
+      javaScriptEditorProps: {
+        functionName: 'Details',
+        paramsName: ['msg', 'metadata', 'msgType'],
+      },
+      buttonName: 'Test details function',
+    },
+  },
+  {
+    field: CreateAlarmFieldsEnum.ALARM_TYPE,
+    component: 'Input',
+    label: CreateAlarmFieldsNameEnum.ALARM_TYPE,
+    helpMessage: [
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
+    componentProps: {
+      placeholder: `请输入${CreateAlarmFieldsNameEnum.ALARM_TYPE}`,
+    },
+  },
+  {
+    field: CreateAlarmFieldsEnum.DYNAMIC_SEVERITY,
+    component: 'Checkbox',
+    label: '',
+    show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
+    renderComponentContent: () => ({
+      default: () => CreateAlarmFieldsNameEnum.DYNAMIC_SEVERITY,
+    }),
+  },
+  {
+    field: CreateAlarmFieldsEnum.SEVERITY,
+    component: 'Input',
+    label: CreateAlarmFieldsNameEnum.SEVERITY,
+    show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
+    helpMessage: [
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body. Alarm severity should be system (CRITICAL, MAJOR etc.)',
+    ],
+    componentProps: {
+      placeholder: `请输入${CreateAlarmFieldsNameEnum.SEVERITY}`,
+    },
+  },
+  {
+    field: CreateAlarmFieldsEnum.PROPAGATE,
+    component: 'Checkbox',
+    label: '',
+    show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
+    renderComponentContent: () => ({
+      default: () => CreateAlarmFieldsNameEnum.PROPAGATE,
+    }),
+  },
+  {
+    field: CreateAlarmFieldsEnum.RELATION_TYPES,
+    component: 'Select',
+    label: CreateAlarmFieldsNameEnum.RELATION_TYPES,
+    show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
+    componentProps: {
+      open: false,
+      mode: 'tags',
+      placeholder: `请输入${CreateAlarmFieldsNameEnum.RELATION_TYPES}`,
+    },
+  },
+  {
+    field: CreateAlarmFieldsEnum.PROPAGATE_TO_TENANT,
+    component: 'Checkbox',
+    label: '',
+    show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
+    renderComponentContent: () => ({
+      default: () => CreateAlarmFieldsNameEnum.PROPAGATE_TO_TENANT,
+    }),
+  },
+  {
+    field: CreateAlarmFieldsEnum.PROPAGATE_TO_OWNER,
+    component: 'Checkbox',
+    label: '',
+    show: ({ model }) => !model[CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA],
+    renderComponentContent: () => ({
+      default: () => CreateAlarmFieldsNameEnum.PROPAGATE_TO_OWNER,
+    }),
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import {
+  DirectionEnum,
+  DirectionNameEnum,
+  EntityTypeEnum,
+  EntityTypeNameEnum,
+} from '../../../enum/form';
+import {
+  CreateRelationFieldsEnum,
+  CreateRelationFieldsNameEnum,
+} from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
+    field: CreateRelationFieldsEnum.DIRECTION,
+    component: 'Select',
+    label: CreateRelationFieldsNameEnum.DIRECTION,
+    required: true,
+    componentProps: {
+      options: Object.keys(DirectionEnum).map((value) => ({
+        label: DirectionNameEnum[value],
+        value,
+      })),
+      getPopupContainer: () => document.body,
+      placeholder: `请选择${CreateRelationFieldsNameEnum.DIRECTION}`,
+    },
+  },
+  {
+    field: CreateRelationFieldsEnum.ENTITY_TYPE,
+    component: 'Select',
+    label: CreateRelationFieldsNameEnum.ENTITY_TYPE,
+    colProps: { span: 8 },
+    required: true,
+    componentProps: {
+      options: Object.keys(EntityTypeEnum).map((value) => ({
+        label: EntityTypeNameEnum[value],
+        value,
+      })),
+      placeholder: `请选择${CreateRelationFieldsNameEnum.ENTITY_TYPE}`,
+    },
+  },
+  {
+    field: CreateRelationFieldsEnum.ENTITY_NAME_PATTERN,
+    component: 'Input',
+    label: CreateRelationFieldsNameEnum.ENTITY_NAME_PATTERN,
+    colProps: { span: 8 },
+    required: true,
+    helpMessage: [
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    componentProps: {
+      placeholder: `请选择${CreateRelationFieldsNameEnum.ENTITY_NAME_PATTERN}`,
+    },
+  },
+  {
+    field: CreateRelationFieldsEnum.ENTITY_TYPE_PATTERN,
+    component: 'Input',
+    label: CreateRelationFieldsNameEnum.ENTITY_TYPE_PATTERN,
+    colProps: { span: 8 },
+    required: true,
+    helpMessage: [
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    show: ({ model }) => {
+      const type = model[CreateRelationFieldsEnum.ENTITY_TYPE];
+      return [EntityTypeEnum.ASSET, EntityTypeEnum.DEVICE].includes(type);
+    },
+    componentProps: {
+      placeholder: `请选择${CreateRelationFieldsNameEnum.ENTITY_TYPE_PATTERN}`,
+    },
+  },
+  {
+    field: CreateRelationFieldsEnum.RELATION_TYPE,
     component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    label: CreateRelationFieldsNameEnum.RELATION_TYPE,
+    helpMessage: [
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    componentProps: {
+      placeholder: `请输入${CreateRelationFieldsNameEnum.RELATION_TYPE}`,
+    },
+  },
+  {
+    field: CreateRelationFieldsEnum.CREATE_ENTITY_IF_NOT_EXISTS,
+    component: 'Checkbox',
+    label: '',
+    helpMessage: 'Create a new entity set above if it does not exist.',
+    show: ({ model }) => {
+      const type = model[CreateRelationFieldsEnum.ENTITY_TYPE];
+      return [EntityTypeEnum.ASSET, EntityTypeEnum.DEVICE, EntityTypeEnum.CUSTOMER].includes(type);
+    },
+    renderComponentContent: () => ({
+      default: () => CreateRelationFieldsNameEnum.CREATE_ENTITY_IF_NOT_EXISTS,
+    }),
+  },
+  {
+    field: CreateRelationFieldsEnum.REMOVE_CURRENT_RELATIONS,
+    component: 'Checkbox',
+    label: '',
+    helpMessage:
+      'Removes current relations from the originator of the incoming message based on direction and type.',
+    renderComponentContent: () => ({
+      default: () => CreateRelationFieldsNameEnum.REMOVE_CURRENT_RELATIONS,
+    }),
+  },
+  {
+    field: CreateRelationFieldsEnum.CHANGE_ORIGINATOR_TO_RELATED_ENTITY,
+    component: 'Checkbox',
+    label: '',
+    helpMessage: 'Used to process submitted message as a message from another entity.',
+    renderComponentContent: () => ({
+      default: () => CreateRelationFieldsNameEnum.CHANGE_ORIGINATOR_TO_RELATED_ENTITY,
+    }),
+  },
+  {
+    field: CreateRelationFieldsEnum.ENTITY_CACHE_EXPIRATION,
+    component: 'InputNumber',
+    label: CreateRelationFieldsNameEnum.ENTITY_CACHE_EXPIRATION,
+    required: true,
+    componentProps: {
+      min: 0,
+      placeholder: `请输入${CreateRelationFieldsNameEnum.ENTITY_CACHE_EXPIRATION}`,
+    },
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import {
+  DelayDeprecatedFieldsEnum,
+  DelayDeprecatedFieldsNameEnum,
+} from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
+    field: DelayDeprecatedFieldsEnum.USE_METADATA_PERIOD_IN_SECONDS_PATTERNS,
+    label: DelayDeprecatedFieldsNameEnum.USE_METADATA_PERIOD_IN_SECONDS_PATTERNS,
+    component: 'Checkbox',
+    renderComponentContent: () => ({
+      default: () =>
+        'If selected, rule node use period in seconds interval pattern from message metadata or data assuming that intervals are in the seconds.',
+    }),
+  },
+  {
+    field: DelayDeprecatedFieldsEnum.PERIOD_IN_SECONDS_PATTERN,
     component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    label: DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS_PATTERN,
+    required: true,
+    show: ({ model }) => model[DelayDeprecatedFieldsEnum.USE_METADATA_PERIOD_IN_SECONDS_PATTERNS],
+    componentProps: {
+      min: 0,
+      placeholder: `请输入${DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS_PATTERN}`,
+    },
+  },
+  {
+    field: DelayDeprecatedFieldsEnum.PERIOD_IN_SECONDS,
+    component: 'InputNumber',
+    label: DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS,
+    required: true,
+    show: ({ model }) => !model[DelayDeprecatedFieldsEnum.USE_METADATA_PERIOD_IN_SECONDS_PATTERNS],
+    componentProps: {
+      min: 0,
+      placeholder: `请输入${DelayDeprecatedFieldsNameEnum.PERIOD_IN_SECONDS}`,
+    },
+  },
+  {
+    field: DelayDeprecatedFieldsEnum.MAX_PENDING_MSGS,
+    component: 'InputNumber',
+    label: DelayDeprecatedFieldsNameEnum.MAX_PENDING_MSGS,
+    required: true,
+    componentProps: {
+      min: 0,
+      placeholder: `请输入${DelayDeprecatedFieldsNameEnum.MAX_PENDING_MSGS}`,
+    },
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import { DirectionEnum, DirectionNameEnum } from '../../../enum/form';
+import {
+  DeleteRelationFieldsEnum,
+  DeleteRelationFieldsNameEnum,
+} from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
+    field: DeleteRelationFieldsEnum.DELETE_FOR_SINGLE_ENTITY,
+    component: 'Checkbox',
+    label: DeleteRelationFieldsNameEnum.DELETE_FOR_SINGLE_ENTITY,
+    renderComponentContent: () => ({
+      default: () =>
+        'Deletes relation from the originator of the incoming message to the specified entity or list of entities based on direction and type.',
+    }),
+  },
+  {
+    field: DeleteRelationFieldsEnum.DIRECTION,
+    component: 'Select',
+    label: DeleteRelationFieldsNameEnum.DIRECTION,
+    required: true,
+    colProps: { span: 12 },
+    show: ({ model }) => model[DeleteRelationFieldsEnum.DELETE_FOR_SINGLE_ENTITY],
+    componentProps: {
+      options: Object.keys(DirectionEnum).map((value) => ({
+        label: DirectionNameEnum[value],
+        value,
+      })),
+      getPopupContainer: () => document.body,
+      placeholder: `请选择${DeleteRelationFieldsNameEnum.DELETE_FOR_SINGLE_ENTITY}`,
+    },
+  },
+  {
+    field: DeleteRelationFieldsEnum.ENTITY_NAME_PATTERN,
     component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    label: DeleteRelationFieldsNameEnum.ENTITY_NAME_PATTERN,
+    required: true,
+    colProps: { span: 12 },
+    show: ({ model }) => model[DeleteRelationFieldsEnum.DELETE_FOR_SINGLE_ENTITY],
+    helpMessage: [
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    componentProps: {
+      placeholder: `请输入${DeleteRelationFieldsNameEnum.ENTITY_NAME_PATTERN}`,
+    },
+  },
+  {
+    field: DeleteRelationFieldsEnum.RELATION_TYPE,
+    component: 'Input',
+    label: DeleteRelationFieldsNameEnum.RELATION_TYPE,
+    required: true,
+    helpMessage: [
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    componentProps: {
+      placeholder: `请输入${DeleteRelationFieldsNameEnum.RELATION_TYPE}`,
+    },
+  },
+  {
+    field: DeleteRelationFieldsEnum.ENTITY_CACHE_EXPIRATION,
+    component: 'InputNumber',
+    label: DeleteRelationFieldsNameEnum.ENTITY_CACHE_EXPIRATION,
+    required: true,
+    helpMessage: [
+      'Specifies maximum time interval allowed to store found entity records. 0 value means that records will never expire.',
+    ],
+    componentProps: {
+      min: 0,
+      placeholder: `请输入${DeleteRelationFieldsNameEnum.DELETE_FOR_SINGLE_ENTITY}`,
+    },
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import {
+  DeviceProfileFieldsEnum,
+  DeviceProfileFieldsNameEnum,
+} from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: DeviceProfileFieldsEnum.PERSIST_ALARM_RULES_STATE,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => ({
+      default: () => DeviceProfileFieldsNameEnum.PERSIST_ALARM_RULES_STATE,
+    }),
+  },
+  {
+    field: DeviceProfileFieldsEnum.FETCH_ALARM_RULES_STATE_ON_START,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => ({
+      default: () => DeviceProfileFieldsNameEnum.FETCH_ALARM_RULES_STATE_ON_START,
+    }),
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
-import { FormSchema } from '/@/components/Form';
+import { EntityTypeEnum, EntityTypeNameEnum } from '../../../enum/form';
+import { GeneratorFieldsEnum, GeneratorFieldsNameEnum } from '../../../enum/formField/action';
+import { JavascriptEditorWithTestModal } from '../../../src/components/JavaScriptFilterModal';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
+
+useComponentRegister('JavascriptEditorWithTestModal', JavascriptEditorWithTestModal);
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: GeneratorFieldsEnum.MSG_COUNT,
+    component: 'InputNumber',
+    label: GeneratorFieldsNameEnum.MSG_COUNT,
+    required: true,
+    componentProps: {
+      min: 0,
+      placeholder: `请输入${GeneratorFieldsNameEnum.MSG_COUNT}`,
+    },
+  },
+  {
+    field: GeneratorFieldsEnum.PERIOD_IN_SECONDS,
+    component: 'InputNumber',
+    label: GeneratorFieldsNameEnum.PERIOD_IN_SECONDS,
+    required: true,
+    componentProps: {
+      min: 0,
+      placeholder: `请输入${GeneratorFieldsNameEnum.PERIOD_IN_SECONDS}`,
+    },
+  },
+  {
+    field: GeneratorFieldsEnum.ORIGINATOR_TYPE,
+    component: 'Select',
+    label: GeneratorFieldsNameEnum.ORIGINATOR_TYPE,
+    colProps: { span: 8 },
+    componentProps: {
+      options: Object.keys(EntityTypeEnum).map((value) => ({
+        label: EntityTypeNameEnum[value],
+        value,
+      })),
+      placeholder: `请选择${GeneratorFieldsNameEnum.ORIGINATOR_TYPE}`,
+    },
+  },
+  {
+    field: GeneratorFieldsEnum.ORIGINATOR_ID,
+    component: 'Select',
+    label: GeneratorFieldsNameEnum.ORIGINATOR_TYPE,
+    colProps: { span: 16 },
+  },
+  {
+    field: GeneratorFieldsEnum.JS_SCRIPT,
+    component: 'JavascriptEditorWithTestModal',
+    label: GeneratorFieldsNameEnum.JS_SCRIPT,
+    valueField: 'value',
+    changeEvent: 'update:value',
+    componentProps: {
+      javaScriptEditorProps: {
+        functionName: 'Generate',
+        paramsName: ['prevMsg', 'prevMetadata', 'prevMsgType'],
+      },
+      buttonName: 'Test generator function',
+    },
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import { PerimeterTypeEnum, RangeUtilEnum, RangeUtilNameEnum } from '../../../enum/form';
+import {
+  GpsGeofencingEventsFieldsEnum,
+  GpsGeofencingEventsFieldsNameEnum,
+} from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
+    field: GpsGeofencingEventsFieldsEnum.LATITUDE_KEY_NAME,
     component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    label: GpsGeofencingEventsFieldsNameEnum.LATITUDE_KEY_NAME,
+    required: true,
+    componentProps: {
+      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.LATITUDE_KEY_NAME}`,
+    },
+  },
+  {
+    field: GpsGeofencingEventsFieldsEnum.LONGITUDE_KEY_NAME,
+    component: 'Input',
+    label: GpsGeofencingEventsFieldsNameEnum.LONGITUDE_KEY_NAME,
+    required: true,
+    componentProps: {
+      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.LONGITUDE_KEY_NAME}`,
+    },
+  },
+  {
+    field: GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE,
+    component: 'Select',
+    label: GpsGeofencingEventsFieldsNameEnum.PERIMETER_TYPE,
+    required: true,
+    componentProps: {
+      options: Object.keys(PerimeterTypeEnum).map((value) => ({ label: value, value })),
+      placeholder: `请选择${GpsGeofencingEventsFieldsNameEnum.PERIMETER_TYPE}`,
+    },
+  },
+  {
+    field: GpsGeofencingEventsFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => ({
+      default: () => GpsGeofencingEventsFieldsNameEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA,
+    }),
+  },
+  {
+    field: GpsGeofencingEventsFieldsEnum.PERIMETER_KEY_NAME,
+    component: 'Input',
+    label: GpsGeofencingEventsFieldsNameEnum.PERIMETER_KEY_NAME,
+    required: true,
+    show: ({ model }) =>
+      model[GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.POLYGON &&
+      model[GpsGeofencingEventsFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA],
+    componentProps: {
+      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.PERIMETER_KEY_NAME}`,
+    },
+  },
+  {
+    field: GpsGeofencingEventsFieldsEnum.POLYGONS_DEFINITION,
+    component: 'Input',
+    label: GpsGeofencingEventsFieldsNameEnum.POLYGONS_DEFINITION,
+    helpMessage:
+      'Please, use the following format for manual definition of polygon: [[lat1,lon1],[lat2,lon2], ... ,[latN,lonN]].',
+    required: true,
+    show: ({ model }) =>
+      model[GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.POLYGON &&
+      !model[GpsGeofencingEventsFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA],
+    componentProps: {
+      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.POLYGONS_DEFINITION}`,
+    },
+  },
+  {
+    field: GpsGeofencingEventsFieldsEnum.CENTER_LATITUDE,
+    component: 'InputNumber',
+    label: GpsGeofencingEventsFieldsNameEnum.CENTER_LATITUDE,
+    colProps: { span: 12 },
+    required: true,
+    show: ({ model }) =>
+      model[GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.CIRCLE &&
+      !model[GpsGeofencingEventsFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA],
+    componentProps: {
+      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.CENTER_LATITUDE}`,
+    },
+  },
+  {
+    field: GpsGeofencingEventsFieldsEnum.CENTER_LONGITUDE,
+    component: 'InputNumber',
+    label: GpsGeofencingEventsFieldsNameEnum.CENTER_LONGITUDE,
+    colProps: { span: 12 },
+    show: ({ model }) =>
+      model[GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.CIRCLE &&
+      !model[GpsGeofencingEventsFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA],
+    componentProps: {
+      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.CENTER_LONGITUDE}`,
+    },
+  },
+  {
+    field: GpsGeofencingEventsFieldsEnum.RANGE,
+    component: 'InputNumber',
+    label: GpsGeofencingEventsFieldsNameEnum.RANGE,
+    colProps: { span: 12 },
+    required: true,
+    show: ({ model }) =>
+      model[GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.CIRCLE &&
+      !model[GpsGeofencingEventsFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA],
+    componentProps: {
+      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.RANGE}`,
+    },
+  },
+  {
+    field: GpsGeofencingEventsFieldsEnum.RANGE_UNIT,
+    component: 'Select',
+    label: GpsGeofencingEventsFieldsNameEnum.RANGE_UNIT,
+    colProps: { span: 12 },
+    required: true,
+    show: ({ model }) =>
+      model[GpsGeofencingEventsFieldsEnum.PERIMETER_TYPE] === PerimeterTypeEnum.CIRCLE &&
+      !model[GpsGeofencingEventsFieldsEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA],
+    componentProps: {
+      options: Object.keys(RangeUtilEnum).map((value) => ({
+        label: RangeUtilNameEnum[value],
+        value,
+      })),
+      getPopupContainer: () => document.body,
+      placeholder: `请选择${GpsGeofencingEventsFieldsNameEnum.RANGE_UNIT}`,
+    },
+  },
+  {
+    field: GpsGeofencingEventsFieldsEnum.MIN_INSIDE_DURATION,
+    component: 'InputNumber',
+    label: GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION,
+    colProps: { span: 12 },
+    required: true,
+    componentProps: {
+      min: 1,
+      max: 2147483647,
+      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION}`,
+    },
+  },
+  {
+    field: GpsGeofencingEventsFieldsEnum.MIN_INSIDE_DURATION_TIME_UNIT,
+    component: 'Select',
+    label: GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION_TIME_UNIT,
+    colProps: { span: 12 },
+    required: true,
+    componentProps: {
+      options: Object.keys(RangeUtilEnum).map((value) => ({
+        label: RangeUtilNameEnum[value],
+        value,
+      })),
+      getPopupContainer: () => document.body,
+      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.MIN_INSIDE_DURATION_TIME_UNIT}`,
+    },
+  },
+  {
+    field: GpsGeofencingEventsFieldsEnum.MIN_OUTSIDE_DURATION,
+    component: 'InputNumber',
+    label: GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION,
+    colProps: { span: 12 },
+    required: true,
+    componentProps: {
+      min: 1,
+      max: 2147483647,
+      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION}`,
+    },
+  },
+  {
+    field: GpsGeofencingEventsFieldsEnum.MIN_OUTSIDE_DURATION_TIME_UNIT,
+    component: 'Select',
+    label: GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION_TIME_UNIT,
+    colProps: { span: 12 },
+    required: true,
+    componentProps: {
+      options: Object.keys(RangeUtilEnum).map((value) => ({
+        label: RangeUtilNameEnum[value],
+        value,
+      })),
+      getPopupContainer: () => document.body,
+      placeholder: `请输入${GpsGeofencingEventsFieldsNameEnum.MIN_OUTSIDE_DURATION_TIME_UNIT}`,
+    },
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
-import { FormSchema } from '/@/components/Form';
+import { LogFieldsEnum, LogFieldsNameEnum } from '../../../enum/formField/action';
+import { JavascriptEditorWithTestModal } from '../../../src/components/JavaScriptFilterModal';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
+
+useComponentRegister('JavascriptEditorWithTestModal', JavascriptEditorWithTestModal);
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: LogFieldsEnum.JS_SCRIPT,
+    component: 'JavascriptEditorWithTestModal',
+    label: LogFieldsNameEnum.JS_SCRIPT,
+    valueField: 'value',
+    changeEvent: 'update:value',
+    componentProps: {
+      javaScriptEditorProps: {
+        functionName: 'ToString',
+        paramsName: ['msg', 'metadata', 'msgType'],
+      },
+      buttonName: 'Test to string function',
+    },
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import { MessageCountFieldsEnum, MessageCountFieldsNameEnum } from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
+    field: MessageCountFieldsEnum.INTERVAL,
+    component: 'InputNumber',
+    label: MessageCountFieldsNameEnum.INTERVAL,
+    required: true,
+    componentProps: {
+      step: 1,
+      precision: 0,
+      placeholder: `请输入${MessageCountFieldsNameEnum.INTERVAL}`,
+    },
+  },
+  {
+    field: MessageCountFieldsEnum.TELEMETRY_PREFIX,
     component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    label: MessageCountFieldsNameEnum.TELEMETRY_PREFIX,
+    required: true,
+    componentProps: {
+      placeholder: `请输入${MessageCountFieldsNameEnum.TELEMETRY_PREFIX}`,
+    },
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import { ScopeEnum, ScopeNameEnum } from '../../../enum/form';
+import { PushToEdgeFieldsEnum, PushToEdgeFieldsNameEnum } from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: PushToEdgeFieldsEnum.SCOPE,
+    component: 'Select',
+    label: PushToEdgeFieldsNameEnum.SCOPE,
+    required: true,
+    componentProps: {
+      options: Object.keys(ScopeEnum).map((value) => ({ label: ScopeNameEnum[value], value })),
+      getPopupContainer: () => document.body,
+      placeholder: `请选择${PushToEdgeFieldsNameEnum.SCOPE}`,
+    },
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import { RpcCallReplyFieldsEnum, RpcCallReplyFieldsNameEnum } from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
+    field: RpcCallReplyFieldsEnum.REQUEST_ID_META_DATA_ATTRIBUTE,
     component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    label: RpcCallReplyFieldsNameEnum.REQUEST_ID_META_DATA_ATTRIBUTE,
+    componentProps: {
+      placeholder: `请输入${RpcCallReplyFieldsNameEnum.REQUEST_ID_META_DATA_ATTRIBUTE}`,
+    },
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import {
+  RpcCallRequestFieldsEnum,
+  RpcCallRequestFieldsNameEnum,
+} from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: RpcCallRequestFieldsEnum.TIMEOUT_IN_SECONDS,
+    component: 'InputNumber',
+    label: RpcCallRequestFieldsNameEnum.TIMEOUT_IN_SECONDS,
+    required: true,
+    componentProps: {
+      min: 0,
+      placeholder: `请输入${RpcCallRequestFieldsNameEnum.TIMEOUT_IN_SECONDS}`,
+    },
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import { ScopeEnum, ScopeNameEnum } from '../../../enum/form';
+import {
+  SaveAttributesFieldsEnum,
+  SaveAttributesFieldsNameEnum,
+} from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: SaveAttributesFieldsEnum.SCOPE,
+    component: 'Select',
+    label: SaveAttributesFieldsNameEnum.SCOPE,
+    required: true,
+    componentProps: {
+      options: Object.keys(ScopeEnum).map((value) => ({ label: ScopeNameEnum[value], value })),
+      getPopupContainer: () => document.body,
+      placeholder: `请选择${SaveAttributesFieldsNameEnum.SCOPE}`,
+    },
+  },
+  {
+    field: SaveAttributesFieldsEnum.NOTIFY_DEVICE,
+    component: 'Checkbox',
+    label: SaveAttributesFieldsNameEnum.NOTIFY_DEVICE,
+    renderComponentContent: () => ({
+      default: () =>
+        'If the message arrives from the device, we will push it back to the device by default.',
+    }),
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import { SaveEventFieldsEnum, SaveEventFieldsNameEnum } from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: SaveEventFieldsEnum.CONFIGURATION,
+    component: 'JSONEditor',
+    label: SaveEventFieldsNameEnum.CONFIGURATION,
+    valueField: 'value',
+    changeEvent: 'update:value',
   },
 ];

@@ -3,6 +3,8 @@
   import { BasicForm, useForm } from '/@/components/Form';
   import { formSchemas } from './create.config';
   import { NodeData } from '../../../types/node';
+  import { SaveEventFieldsEnum } from '../../../enum/formField/action';
+  import { useJsonParse } from '/@/hooks/business/useJsonParse';
 
   defineProps<{
     config: NodeData;
@@ -16,12 +18,12 @@
   const getValue: CreateModalDefineExposeType['getFieldsValue'] = async () => {
     await validate();
     const value = getFieldsValue() || {};
-    return value;
+    return useJsonParse(value?.[SaveEventFieldsEnum.CONFIGURATION]).value || {};
   };
 
   const setValue: CreateModalDefineExposeType['setFieldsValue'] = (value) => {
     resetFields();
-    setFieldsValue(value);
+    setFieldsValue({ [SaveEventFieldsEnum.CONFIGURATION]: JSON.stringify(value, null, 2) });
   };
 
   defineExpose({

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import {
+  SaveTimeseriesFieldsEnum,
+  SaveTimeseriesFieldsNameEnum,
+} from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: SaveTimeseriesFieldsEnum.DEFAULT_TTL,
+    component: 'InputNumber',
+    label: SaveTimeseriesFieldsNameEnum.DEFAULT_TTL,
+    required: true,
+    componentProps: {
+      min: 0,
+      placeholder: `请输入${SaveTimeseriesFieldsNameEnum.DEFAULT_TTL}`,
+    },
+  },
+  {
+    field: SaveTimeseriesFieldsEnum.SKIP_LATEST_PERSISTENCE,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => ({
+      default: () => SaveTimeseriesFieldsNameEnum.DEFAULT_TTL,
+    }),
+  },
+  {
+    field: SaveTimeseriesFieldsEnum.USE_SERVER_TS,
+    component: 'Checkbox',
+    label: SaveTimeseriesFieldsNameEnum.USE_SERVER_TS,
+    renderComponentContent: () => ({
+      default: () =>
+        'Enable this setting to use the timestamp of the message processing instead of the timestamp from the message. Useful for all sorts of sequential processing if you merge messages from multiple sources (devices, assets, etc).',
+    }),
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
-import { FormSchema } from '/@/components/Form';
+import {
+  SaveToCustomTableFieldsEnum,
+  SaveToCustomTableFieldsNameEnum,
+} from '../../../enum/formField/action';
+import { AttributeConfiguration } from '../../../src/components/AttributeConfiguration';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
+import { isObject } from '/@/utils/is';
 
+useComponentRegister('AttributeConfiguration', AttributeConfiguration);
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
+    field: SaveToCustomTableFieldsEnum.TABLE_NAME,
     component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    label: SaveToCustomTableFieldsNameEnum.TABLE_NAME,
+    required: true,
+    componentProps: {
+      placeholder: `请输入${SaveToCustomTableFieldsEnum.TABLE_NAME}`,
+    },
+  },
+  {
+    field: SaveToCustomTableFieldsEnum.FIELDS_MAPPING,
+    component: 'AttributeConfiguration',
+    label: SaveToCustomTableFieldsNameEnum.FIELDS_MAPPING,
+    required: true,
+    valueField: 'value',
+    changeEvent: 'update:value',
+    rules: [
+      {
+        required: true,
+        validator(_rule, value) {
+          console.log(value);
+          if (!isObject(value) || !Object.keys(value).length)
+            return Promise.reject('至少应该指定一个字段映射。');
+          return Promise.resolve();
+        },
+      },
+    ],
+    slot: SaveToCustomTableFieldsEnum.FIELDS_MAPPING,
   },
 ];

@@ -3,11 +3,16 @@
   import { BasicForm, useForm } from '/@/components/Form';
   import { formSchemas } from './create.config';
   import { NodeData } from '../../../types/node';
+  import { AttributeConfiguration } from '../../../src/components/AttributeConfiguration';
+  import { ref, unref } from 'vue';
+  import { SaveToCustomTableFieldsEnum } from '../../../enum/formField/action';
 
   defineProps<{
     config: NodeData;
   }>();
 
+  const attributeConfigurationElRef = ref<Nullable<InstanceType<typeof AttributeConfiguration>>>();
+
   const [register, { validate, getFieldsValue, setFieldsValue, resetFields }] = useForm({
     schemas: formSchemas,
     showActionButtonGroup: false,
@@ -15,13 +20,21 @@
 
   const getValue: CreateModalDefineExposeType['getFieldsValue'] = async () => {
     await validate();
+    await unref(attributeConfigurationElRef)?.validate();
     const value = getFieldsValue() || {};
-    return value;
+    const fieldsValue = unref(attributeConfigurationElRef)?.getFieldsValue();
+    return {
+      [SaveToCustomTableFieldsEnum.TABLE_NAME]: value?.[SaveToCustomTableFieldsEnum.TABLE_NAME],
+      [SaveToCustomTableFieldsEnum.FIELDS_MAPPING]: fieldsValue,
+    };
   };
 
   const setValue: CreateModalDefineExposeType['setFieldsValue'] = (value) => {
     resetFields();
     setFieldsValue(value);
+    unref(attributeConfigurationElRef)?.setFieldsValue(
+      value?.[SaveToCustomTableFieldsEnum.FIELDS_MAPPING]
+    );
   };
 
   defineExpose({
@@ -31,5 +44,14 @@
 </script>
 
 <template>
-  <BasicForm @register="register" />
+  <BasicForm @register="register">
+    <template #fieldsMapping="{ field, model }">
+      <AttributeConfiguration
+        ref="attributeConfigurationElRef"
+        v-model:value="model[field]"
+        keyLabel="Message field"
+        valueLabel="Table column"
+      />
+    </template>
+  </BasicForm>
 </template>

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
 import { FormSchema } from '/@/components/Form';
 
-export const formSchemas: FormSchema[] = [
-  {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
-  },
-];
+export const formSchemas: FormSchema[] = [];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
 import { FormSchema } from '/@/components/Form';
 
-export const formSchemas: FormSchema[] = [
-  {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
-  },
-];
+export const formSchemas: FormSchema[] = [];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import {
+  UnassignFromCustomerFieldsEnum,
+  UnassignFromCustomerFieldsNameEnum,
+} from '../../../enum/formField/action';
+
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
+    field: UnassignFromCustomerFieldsEnum.CUSTOMER_NAME_PATTERN,
+    label: UnassignFromCustomerFieldsNameEnum.CUSTOMER_NAME_PATTERN,
     component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    required: true,
+    helpMessage: [
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    componentProps: {
+      placeholder: `请输入${UnassignFromCustomerFieldsNameEnum.CUSTOMER_NAME_PATTERN}`,
+    },
+  },
+  {
+    field: UnassignFromCustomerFieldsEnum.CUSTOMER_CACHE_EXPIRATION,
+    component: 'InputNumber',
+    label: UnassignFromCustomerFieldsNameEnum.CUSTOMER_CACHE_EXPIRATION,
+    required: true,
+    helpMessage: [
+      'Specifies maximum time interval allowed to store found customer records. 0 value means that records will never expire.',
+    ],
+    componentProps: {
+      min: 0,
+      placeholder: `请输入${UnassignFromCustomerFieldsNameEnum.CUSTOMER_CACHE_EXPIRATION}`,
+    },
   },
 ];