feat: 实现属性集和变换所有节点

-import { DeviceInfoItemType } from './model';
+import { DeviceInfoItemType, DeviceTypeItem } from './model';
 import { TBPaginationResult } from '/#/axios';
 import { defHttp } from '/@/utils/http/axios';
 
 enum Api {
   GET_DEVICE_INFOS = '/tenant/deviceInfos',
+  GET_DEVICE_TYPE = '/device/types',
 }
 
 export const getDeviceInfos = () => {
@@ -14,3 +15,12 @@ export const getDeviceInfos = () => {
     { joinPrefix: false }
   );
 };
+
+export const getDeviceTypes = () => {
+  return defHttp.get<TBPaginationResult<DeviceTypeItem[]>>(
+    {
+      url: Api.GET_DEVICE_TYPE,
+    },
+    { joinPrefix: false }
+  );
+};

@@ -38,3 +38,9 @@ export interface Configuration {
 export interface TransportConfiguration {
   type: string;
 }
+
+export interface DeviceTypeItem {
+  tenantId: Id;
+  entityType: string;
+  type: string;
+}

@@ -132,4 +132,7 @@ export type ComponentType =
   | 'OrgTreeSelect'
   | 'ExtendDesc'
   | 'JavaScriptFunctionEditor'
-  | 'JavaScriptFilterFunctionModal';
+  | 'JavascriptEditorWithTestModal'
+  | 'AttributeConfiguration'
+  | 'CorrelationFilters'
+  | 'RelationsQuery';

@@ -14,8 +14,13 @@ export enum DirectionNameEnum {
  * @description 关联类型
  */
 export enum RelationTypeEnum {
-  CONTAINS = 'contains',
-  MANAGES = 'manages',
+  CONTAINS = 'CONTAINS',
+  MANAGES = 'MANAGES',
+}
+
+export enum RelationTypeNameEnum {
+  CONTAINS = 'Contains',
+  MANAGES = 'Manages',
 }
 
 /**
@@ -119,3 +124,107 @@ export enum MessageTypesFilterNameEnum {
   RPC_TIMEOUT = 'RPC Timeout',
   RPC_FAILED = 'RPC Failed',
 }
+
+// Enrichment Customer details
+export enum DetailsListEnum {
+  TITLE = 'TITLE',
+  COUNTRY = 'COUNTRY',
+  STATE = 'STATE',
+  CITY = 'CITY',
+  ZIP = 'ZIP',
+  ADDRESS = 'ADDRESS',
+  ADDRESS_2 = 'ADDRESS_2',
+  PHONE = 'PHONE',
+  EMAIL = 'EMAIL',
+  ADDITIONAL_INFO = 'ADDITIONAL_INFO',
+}
+
+export enum DetailsListNameEnum {
+  TITLE = 'Title',
+  COUNTRY = 'Country',
+  STATE = 'State',
+  CITY = 'City',
+  ZIP = 'Zip',
+  ADDRESS = 'Address',
+  ADDRESS_2 = 'Address2',
+  PHONE = 'Phone',
+  EMAIL = 'Email',
+  ADDITIONAL_INFO = 'Additional Info',
+}
+
+// Enrichment Originator Telemetry FetchMode
+export enum FetchModeEnum {
+  FIRST = 'FIRST',
+  LAST = 'LAST',
+  ALL = 'ALL',
+}
+
+// Enrichment Originator Telemetry Time interval unit
+export enum TimeIntervalUnitEnum {
+  MILLISECONDS = 'MILLISECONDS',
+  SECONDS = 'SECONDS',
+  MINUTES = 'MINUTES',
+  HOURS = 'HOURS',
+  DAYS = 'DAYS',
+}
+
+export enum TimeIntervalUnitNameEnum {
+  MILLISECONDS = 'Milliseconds',
+  SECONDS = 'Seconds',
+  MINUTES = 'Minutes',
+  HOURS = 'Hours',
+  DAYS = 'Days',
+}
+
+// Enrichment Originator Telemetry OrderBy
+export enum OrderByEnum {
+  DESC = 'DESC',
+  ASC = 'ASC',
+}
+
+// Enrichment Originator Telemetry Aggregation
+export enum AggregationEnum {
+  MIN = 'MIN',
+  MAX = 'MAX',
+  AVG = 'AVG',
+  SUM = 'SUM',
+  COUNT = 'COUNT',
+  NONE = 'NONE',
+}
+
+export enum AggregationNameEnum {
+  MIN = '最少值',
+  MAX = '最大值',
+  AVG = '平均值',
+  SUM = '求和',
+  COUNT = '计数',
+  NONE = '空',
+}
+
+// Originator source
+export enum OriginatorSourceEnum {
+  CUSTOMER = 'CUSTOMER',
+  TENANT = 'TENANT',
+  RELATED = 'RELATED',
+  ALARM_ORIGINATOR = 'ALARM_ORIGINATOR',
+}
+
+export enum OriginatorSourceNameEnum {
+  CUSTOMER = 'Customer',
+  TENANT = 'Tenant',
+  RELATED = 'Related',
+  ALARM_ORIGINATOR = 'Alarm Originator',
+}
+
+// Transformation To Email
+export enum MailBodyTypeEnum {
+  DYNAMIC = 'dynamic',
+  HTML = 'true',
+  PLAIN_TEXT = 'false',
+}
+
+export enum MailBodyTypeNameEnum {
+  DYNAMIC = 'Dynamic',
+  HTML = 'HTML',
+  PLAIN_TEXT = 'Plain Text',
+}

+// Assign to customer
+export enum AssignToCustomerFieldsEnum {
+  CUSTOMER_NAME_PATTERN = 'customerNamePattern',
+  CREATE_CUSTOMER_IF_NOT_EXISTS = 'createCustomerIfNotExists',
+  CUSTOMER_CACHE_EXPIRATION = 'customerCacheExpiration',
+}
+
+export enum AssignToCustomerFieldsNameEnum {
+  CUSTOMER_NAME_PATTERN = 'Customer name pattern',
+  CREATE_CUSTOMER_IF_NOT_EXISTS = 'Create new customer if not exists',
+  CUSTOMER_CACHE_EXPIRATION = 'Customers cache expiration time(sec)',
+}
+
+// clear alarm
+export enum ClearAlarmFieldsEnum {
+  ALARM_TYPE = 'alarmType',
+  ALARM_DETAILS_BUILD_JS = 'alarmDetailsBuildJs',
+}
+
+export enum ClearAlarmFieldsNameEnum {
+  ALARM_TYPE = 'Alarm type',
+  ALARM_DETAILS_BUILD_JS = 'Alarm details builder',
+}
+
+// Create alarm
+export enum CreateAlarmFieldsEnum {
+  ALARM_DETAILS_BUILD_JS = 'alarmDetailsBuildJs',
+  USE_MESSAGE_ALARM_DATA = 'useMessageAlarmData',
+  OVERWRITE_ALARM_DETAILS = 'overwriteAlarmDetails',
+  ALARM_TYPE = 'alarmType',
+  SEVERITY = 'severity',
+  PROPAGATE = 'propagate',
+  RELATION_TYPES = 'relationTypes',
+  PROPAGATE_TO_OWNER = 'propagateToOwner',
+  PROPAGATE_TO_TENANT = 'propagateToTenant',
+  DYNAMIC_SEVERITY = 'dynamicSeverity',
+}
+
+export enum CreateAlarmFieldsNameEnum {
+  ALARM_DETAILS_BUILD_JS = 'Alarm details builder',
+  USE_MESSAGE_ALARM_DATA = 'Use message alarm data',
+  OVERWRITE_ALARM_DETAILS = 'overwriteAlarmDetails',
+  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',
+}

+export enum CommonFieldsEnum {
+  NAME = 'name',
+  DESCRIPTION = 'description',
+  DEBUG_MODE = 'debugMode',
+}
+
+export enum CommonFieldsNameEnum {
+  NAME = '名称',
+  DESCRIPTION = '说明',
+  DEBUG_MODE = '调试模式',
+}
+
+export const CommonFields = { ...CommonFieldsEnum };
+export const CommonFieldsName = { ...CommonFieldsNameEnum };
+export type CommonFieldsType = typeof CommonFields;

+// Enrichment Calculate delta
+export enum CalculateDeltaFieldsEnum {
+  INPUT_VALUE_KEY = 'inputValueKey',
+  OUTPUT_VALUE_KEY = 'outputValueKey',
+  ROUND = 'round',
+  USE_CACHE = 'useCache',
+  TELL_FAILURE_IF_DELTA_IS_NEGATIVE = 'tellFailureIfDeltaIsNegative',
+  ADD_PERIOD_BETWEEN_MSGS = 'addPeriodBetweenMsgs',
+  PERIOD_VALUE_KEY = 'periodValueKey',
+}
+
+export enum CalculateDeltaFieldsNameEnum {
+  INPUT_VALUE_KEY = 'Input value key',
+  OUTPUT_VALUE_KEY = 'Output value key',
+  ROUND = 'Decimals',
+  USE_CACHE = 'Use cache for latest value',
+  TELL_FAILURE_IF_DELTA_IS_NEGATIVE = 'Tell Failure if delta is negative',
+  ADD_PERIOD_BETWEEN_MSGS = 'Add period between messages',
+  PERIOD_VALUE_KEY = 'Period value key',
+}
+
+// Enrichment Customer Attributes
+export enum CustomerAttributesFieldsEnum {
+  ATTR_MAPING = 'attrMapping',
+  TELEMETRY = 'telemetry',
+}
+
+export enum CustomerAttributesFieldsNameEnum {
+  ATTR_MAPING = 'Attributes mapping',
+  TELEMETRY = 'Latest telemetry',
+}
+
+// Enrichment Customer details
+export enum CustomerDetailsFieldsEnum {
+  DETAILS_LIST = 'detailsList',
+  ADD_TO_METADATA = 'addToMetadata',
+}
+
+export enum CustomerDetailsFieldsNameEnum {
+  DETAILS_LIST = 'Select entity details',
+  ADD_TO_METADATA = 'Add selected details to message metadata',
+}
+
+// Enrichment Originator attributes
+export enum OriginatorAttributesEnum {
+  TELL_FAILURE_IF_ABSENT = 'tellFailureIfAbsent',
+  CLIENT_ATTRIBUTE_NAMES = 'clientAttributeNames',
+  SHARED_ATTRIBUTE_NAMES = 'sharedAttributeNames',
+  SERVER_ATTRIBUTE_NAMES = 'serverAttributeNames',
+  LATEST_TS_KEY_NAMES = 'latestTsKeyNames',
+  GET_LATEST_VALUE_WITH_TS = 'getLatestValueWithTs',
+}
+
+export enum OriginatorAttributesNameEnum {
+  TELL_FAILURE_IF_ABSENT = 'Tell Failure',
+  CLIENT_ATTRIBUTE_NAMES = 'Client attributes',
+  SHARED_ATTRIBUTE_NAMES = 'Shared attributes',
+  SERVER_ATTRIBUTE_NAMES = 'Server attributes',
+  LATEST_TS_KEY_NAMES = 'Latest timeseries',
+  GET_LATEST_VALUE_WITH_TS = 'Fetch Latest telemetry with Timestamp',
+}
+
+// Enrichment Originator Fields
+export enum OriginatorFieldsEnum {
+  FIELDS_MAPPING = 'fieldsMapping',
+}
+
+export enum OriginatorFieldsNameEnum {
+  FIELDS_MAPPING = 'Fields mapping',
+}
+
+// Enrichment originator telemetry
+export enum OriginatorTelemetryFieldsEnum {
+  AGGREGATION = 'aggregation',
+  FETCH_MODE = 'fetchMode',
+  ORDER_BY = 'orderBy',
+  LIMIT = 'limit',
+  USE_METADATA_INTERVAL_PATTERNS = 'useMetadataIntervalPatterns',
+  START_INTERVAL = 'startInterval',
+  START_INTERVAL_TIME_UNIT = 'startIntervalTimeUnit',
+  END_INTERVAL = 'endInterval',
+  END_INTERVAL_TIME_UNIT = 'endIntervalTimeUnit',
+  START_INTERVAL_PATTERN = 'startIntervalPattern',
+  END_INTERVAL_PATTERN = 'endIntervalPattern',
+}
+
+export enum OriginatorTelemetryFieldsNameEnum {
+  AGGREGATION = '数据聚合功能',
+  FETCH_MODE = 'Fetch Mode',
+  ORDER_BY = 'Order by',
+  LIMIT = 'Limit',
+  USE_METADATA_INTERVAL_PATTERNS = 'useMetadataIntervalPatterns',
+  START_INTERVAL = 'Start Interval',
+  START_INTERVAL_TIME_UNIT = 'Start Interval Time Unit',
+  END_INTERVAL = 'End Interval',
+  END_INTERVAL_TIME_UNIT = 'End Interval Time Unit',
+  START_INTERVAL_PATTERN = 'startIntervalPattern',
+  END_INTERVAL_PATTERN = 'endIntervalPattern',
+}
+
+// Enrichment Related attributes
+export enum RelatedAttributesFieldsEnum {
+  RELATIONS_QUERY = 'relationsQuery',
+  ATTR_MAPPING = 'attrMapping',
+}
+
+export enum RelatedAttributesFieldNameEnum {
+  RELATIONS_QUERY = 'Relations query',
+  ATTR_MAPPING = 'Attributes mapping',
+}
+
+// Enrichment Related device Attributes
+export enum RelatedDeviceAttributeFieldsEnum {
+  DEVICE_RELATIONS_QUERY = 'deviceRelationsQuery',
+  TELL_FAILURE_IF_ABSENT = 'tellFailureIfAbsent',
+  CLIENT_ATTRIBUTE_NAMES = 'clientAttributeNames',
+  SHARED_ATTRIBUTE_NAMES = 'sharedAttributeNames',
+  SERVER_ATTRIBUTE_NAMES = 'serverAttributeNames',
+  LATEST_TS_KEY_NAMES = 'latestTsKeyNames',
+  GET_LATEST_VALUE_WITH_TS = 'getLatestValueWithTs',
+  FETCH_LAST_LEVEL_ONLY = 'fetchLastLevelOnly',
+
+  // DEVICE_RELATIONS_QUERY
+  DIRECTION = 'direction',
+  MAX_LEVEL = 'maxLevel',
+  RELATION_TYPE = 'relationType',
+  DEVICE_TYPES = 'deviceTypes',
+}
+
+export enum RelatedDeviceAttributeFieldsNameEnum {
+  DEVICE_RELATIONS_QUERY = 'deviceRelationsQuery',
+  TELL_FAILURE_IF_ABSENT = 'Tell Failure',
+  CLIENT_ATTRIBUTE_NAMES = 'Client attributes',
+  SHARED_ATTRIBUTE_NAMES = 'Shared attributes',
+  SERVER_ATTRIBUTE_NAMES = 'Server attributes',
+  LATEST_TS_KEY_NAMES = 'Latest timeseries',
+  GET_LATEST_VALUE_WITH_TS = 'Fetch Latest telemetry with Timestamp',
+  FETCH_LAST_LEVEL_ONLY = '仅获取最后一级关联',
+
+  // DEVICE_RELATIONS_QUERY
+  DIRECTION = '方向',
+  MAX_LEVEL = 'Max relation level',
+  RELATION_TYPE = '关联类型',
+  DEVICE_TYPES = '设备类型',
+}
+
+// Enrichment Tenant details
+export enum TenantDetailsFieldsEnum {
+  DETAILS_LIST = 'detailsList',
+  ADD_TO_METADATA = 'addToMetadata',
+}
+
+export enum TenantDetailsFieldsNameEnum {
+  DETAILS_LIST = 'Add selected details to message metadata',
+  ADD_TO_METADATA = 'Select entity details',
+}
+
+export const EnrichmentCategoryFormFields = {
+  ...CalculateDeltaFieldsEnum,
+  ...CustomerAttributesFieldsEnum,
+  ...CustomerDetailsFieldsEnum,
+  ...OriginatorAttributesEnum,
+  ...OriginatorFieldsEnum,
+  ...OriginatorTelemetryFieldsEnum,
+  ...RelatedAttributesFieldsEnum,
+  ...RelatedDeviceAttributeFieldsEnum,
+  ...TenantDetailsFieldsEnum,
+};
+
+export const EnrichmentCategoryFormFieldsName = {
+  ...CalculateDeltaFieldsNameEnum,
+  ...CustomerAttributesFieldsNameEnum,
+  ...CustomerDetailsFieldsNameEnum,
+  ...OriginatorAttributesNameEnum,
+  ...OriginatorFieldsNameEnum,
+  ...OriginatorTelemetryFieldsNameEnum,
+  ...RelatedAttributesFieldNameEnum,
+  ...RelatedDeviceAttributeFieldsNameEnum,
+  ...TenantDetailsFieldsNameEnum,
+};
+
+export type EnrichmentCategoryType = typeof EnrichmentCategoryFormFields;

+// Filter Check Alarm Status Fields
+export enum FilterCheckAlarmStatusFieldEnum {
+  ALARM_STATUS_LIST = 'alarmStatusList',
+}
+
+export enum FilterCheckAlarmStatusFieldNameEnum {
+  ALARM_STATUS_LIST = 'Alarm status filter',
+}
+
+// Filter CHeck Existence Fields
+export enum CheckExistenceFieldsEnum {
+  MESSAGE_NAMES = 'messageNames',
+  METADATA_NAMES = 'metadataNames',
+  CHECK_ALL_KEYS = 'checkAllKeys',
+}
+
+export enum CheckExistenceFieldsNameEnum {
+  MESSAGE_NAMES = '消息数据',
+  METADATA_NAMES = '消息元数据',
+  CHECK_ALL_KEYS = '检查所有选择的键是否都存在',
+}
+
+// Filter Check Relation Fields
+export enum CheckRelationFieldsEnum {
+  DIRECTION = 'direction',
+  CHECK_FOR_SINGLE_ENTITY = 'checkForSingleEntity',
+  ENTITY_TYPE = 'entityType',
+  RELEATION_TYPE = 'relationType',
+  ENTITY_ID = 'entityId',
+}
+
+export enum CheckRelationFieldsNameEnum {
+  DIRECTION = '方向',
+  CHECK_FOR_SINGLE_ENTITY = 'Check relation to specific entity',
+  ENTITY_TYPE = '类型',
+  RELEATION_TYPE = '关联类型',
+}
+
+// Filter Gps geofencing filter
+export enum GpsGeofencingFilterFieldsEnum {
+  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',
+}
+
+export enum GpsGeofencingFilterFieldsNameEnum {
+  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',
+  CENTER_LATITUDE = 'Center latitude',
+  CENTER_LONGITUDE = 'Center longitude',
+  RANGE = 'Range',
+  RANGE_UNIT = 'Range unit',
+  PERIMETER_KEY_NAME = 'Perimeter key name',
+  POLYGONS_DEFINITION = 'Polygons definition',
+}
+
+// Filter Message Type
+export enum MessageTypeFieldsEnum {
+  MESSAGE_TYPES = 'messageTypes',
+}
+
+export enum MessageTypeFieldsNameEnum {
+  MESSAGE_TYPES = 'Message Types Filter',
+}
+
+// Filter Originator Type
+export enum OriginatorTypeFieldsEnum {
+  ORIGINATOR_TYPES = 'originatorTypes',
+}
+
+export enum OriginatorTypeFieldsNameEnum {
+  ORIGINATOR_TYPES = 'Originator types filter',
+}
+
+// Filter Script
+export enum ScriptFieldsEnum {
+  JS_SCRIPT = 'jsScript',
+}
+
+export enum ScriptFieldsNameEnum {
+  JS_SCRIPT = 'Filter',
+}
+
+export const FilterCategoryFormFields = {
+  ...FilterCheckAlarmStatusFieldEnum,
+  ...CheckExistenceFieldsEnum,
+  ...CheckRelationFieldsEnum,
+  ...GpsGeofencingFilterFieldsEnum,
+  ...MessageTypeFieldsEnum,
+  ...OriginatorTypeFieldsEnum,
+  ...ScriptFieldsEnum,
+};
+
+export const FilterCategoryFormFieldsName = {
+  ...FilterCheckAlarmStatusFieldNameEnum,
+  ...CheckExistenceFieldsNameEnum,
+  ...CheckRelationFieldsNameEnum,
+  ...GpsGeofencingFilterFieldsNameEnum,
+  ...MessageTypeFieldsNameEnum,
+  ...OriginatorTypeFieldsNameEnum,
+  ...ScriptFieldsNameEnum,
+};
+
+export type FilterCategoryFormType = typeof FilterCategoryFormFields;

+// Change originator
+export enum ChangeOriginatorFieldsEnum {
+  ORIGINATOR_SOURCE = 'originatorSource',
+  RELATIONS_QUERY = 'relationsQuery',
+}
+
+export enum ChangeOriginatorFieldsNameEnum {
+  ORIGINATOR_SOURCE = 'Originator source',
+  RELATIONS_QUERY = 'Relations Query',
+}
+
+export enum ScriptFieldsEnum {
+  JS_SCRIPT = 'jsScript',
+}
+
+export enum ScriptFieldsNameEnum {
+  JS_SCRIPT = 'Transform',
+}
+
+export enum ToEmailFieldsEnum {
+  FROM_TEMPLATE = 'fromTemplate',
+  TO_TEMPLATE = 'toTemplate',
+  CC_TEMPLATE = 'ccTemplate',
+  BCC_TEMPLATE = 'bccTemplate',
+  SUBJECT_TEMPLATE = 'subjectTemplate',
+  MAIL_BODY_TYPE = 'mailBodyType',
+  IS_HTML_TEMPLATE = 'isHtmlTemplate',
+  BODY_TEMPLATE = 'bodyTemplate',
+}
+
+export enum ToEmailFieldsNameEnum {
+  FROM_TEMPLATE = 'From Template',
+  TO_TEMPLATE = 'To Template',
+  CC_TEMPLATE = 'Cc Template',
+  BCC_TEMPLATE = 'Bcc Template',
+  SUBJECT_TEMPLATE = 'Subject Template',
+  MAIL_BODY_TYPE = 'Mail body type',
+  IS_HTML_TEMPLATE = 'Dynamic mail body type',
+  BODY_TEMPLATE = 'Body Template',
+}

+import { CommonFields, CommonFieldsName } from './formField/common';
+import {
+  EnrichmentCategoryFormFields,
+  EnrichmentCategoryFormFieldsName,
+} from './formField/enrichment';
+import { FilterCategoryFormFields, FilterCategoryFormFieldsName } from './formField/filter';
+
 export enum FetchNodeComFlagTypeENum {
   CONNECTION_MODAL = 'CONNECTION_MODAL',
   CREATE_MODAL = 'CREATE_MODAL',
 }
 
-export enum NodeBindDataFieldEnum {
-  NAME = 'name',
-  DESCRIPTION = 'description',
-  DEBUG_MODE = 'debugMode',
-
-  // Filter Check Alarm status
-  ALARM_STATUS_LIST = 'alarmStatusList',
-
-  // Filter Check Existence Fields
-  MESSAGE_NAMES = 'messageNames',
-  METADATA_NAMES = 'metadataNames',
-  CHECK_ALL_KEYS = 'checkAllKeys',
-
-  // Filter Check Relation
-  DIRECTION = 'direction',
-  CHECK_FOR_SINGLE_ENTITY = 'checkForSingleEntity',
-  ENTITY_TYPE = 'entityType',
-  RELEATION_TYPE = 'relationType',
-  ENTITY_ID = 'entityId',
-
-  // Filter Gps geofencing filter
-  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',
-
-  // Filter Message Type
-  MESSAGE_TYPES = 'messageTypes',
-
-  // Filter Originator Type
-  ORIGINATOR_TYPES = 'originatorTypes',
-
-  // Filter Script
-  JS_SCRIPT = 'jsScript',
-}
-
-export enum NodeBindDataFieldNameEnum {
-  NAME = '名称',
-  DESCRIPTION = '说明',
-  DEBUG_MODE = '调试模式',
-
-  // Filter Check Alarm status
-  ALARM_STATUS_LIST = 'Alarm status filter',
-
-  // Filter Check Existence Fields
-  MESSAGE_NAMES = '消息数据',
-  METADATA_NAMES = '消息元数据',
-  CHECK_ALL_KEYS = '检查所有选择的键是否都存在',
-
-  // Filter Check Relation
-  DIRECTION = '方向',
-  CHECK_FOR_SINGLE_ENTITY = 'Check relation to specific entity',
-  ENTITY_TYPE = '类型',
-  RELEATION_TYPE = '关联类型',
-
-  // Filter Gps geofencing filter
-  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',
-  CENTER_LATITUDE = 'Center latitude',
-  CENTER_LONGITUDE = 'Center longitude',
-  RANGE = 'Range',
-  RANGE_UNIT = 'Range unit',
-  PERIMETER_KEY_NAME = 'Perimeter key name',
-  POLYGONS_DEFINITION = 'Polygons definition',
-
-  // Filter Message Type
-  MESSAGE_TYPES = 'Message Types Filter',
-
-  // Filter Originator Type
-  ORIGINATOR_TYPES = 'Originator types filter',
-
-  // Filter Script
-  JS_SCRIPT = 'Filter',
-}
-
 export enum EdgeBindDataFieldEnum {
   TYPE = 'type',
 }
@@ -93,3 +17,15 @@ export enum EdgeBindDataFieldEnum {
 export enum EdgeBindDataFieldNameEnum {
   TYPE = '链接标签',
 }
+
+export const NodeBindDataFieldEnum = {
+  ...CommonFields,
+  ...FilterCategoryFormFields,
+  ...EnrichmentCategoryFormFields,
+};
+
+export const NodeBindDataFieldNameEnum = {
+  ...CommonFieldsName,
+  ...FilterCategoryFormFieldsName,
+  ...EnrichmentCategoryFormFieldsName,
+};

@@ -133,7 +133,6 @@ export function useRuleFlow(options: UseRuleFlowOptionsType) {
     if (!flag) return;
 
     const currentNode = findNode(node.id);
-
     (currentNode!.data as NodeData).data = data;
   });
 

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import {
+  AssignToCustomerFieldsEnum,
+  AssignToCustomerFieldsNameEnum,
+} from '../../../enum/formField/action';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
+    field: AssignToCustomerFieldsEnum.CUSTOMER_NAME_PATTERN,
     component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    label: AssignToCustomerFieldsNameEnum.CUSTOMER_NAME_PATTERN,
+    helpMessage:
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    componentProps: {
+      placeholder: `请输入${AssignToCustomerFieldsNameEnum.CUSTOMER_NAME_PATTERN}`,
+    },
+  },
+  {
+    field: AssignToCustomerFieldsEnum.CREATE_CUSTOMER_IF_NOT_EXISTS,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => ({
+      default: () => AssignToCustomerFieldsNameEnum.CREATE_CUSTOMER_IF_NOT_EXISTS,
+    }),
+  },
+  {
+    field: AssignToCustomerFieldsEnum.CUSTOMER_CACHE_EXPIRATION,
+    component: 'InputNumber',
+    label: AssignToCustomerFieldsNameEnum.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: {
+      placeholder: `请输入${AssignToCustomerFieldsNameEnum.CUSTOMER_CACHE_EXPIRATION}`,
+      min: 0,
+    },
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
-import { FormSchema } from '/@/components/Form';
+import { ClearAlarmFieldsEnum, ClearAlarmFieldsNameEnum } 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,
+    field: ClearAlarmFieldsEnum.ALARM_DETAILS_BUILD_JS,
+    component: 'JavascriptEditorWithTestModal',
+    label: ClearAlarmFieldsNameEnum.ALARM_DETAILS_BUILD_JS,
+    componentProps: {
+      javaScriptEditorProps: {
+        functionName: 'Details',
+        paramsName: ['msg', 'metadata', 'msgType'],
+      },
+      buttonName: 'Test details function',
+    },
+  },
+  {
+    field: ClearAlarmFieldsEnum.ALARM_TYPE,
     component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    label: ClearAlarmFieldsNameEnum.ALARM_TYPE,
+    required: true,
+    componentProps: {
+      placeholder: `请输入${ClearAlarmFieldsNameEnum.ALARM_TYPE}`,
+    },
   },
 ];

-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';
+import { CreateAlarmFieldsEnum, CreateAlarmFieldsNameEnum } 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: CreateAlarmFieldsEnum.USE_MESSAGE_ALARM_DATA,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => ({
+      default: () => CreateAlarmFieldsNameEnum.USE_MESSAGE_ALARM_DATA,
+    }),
+  },
+  {
+    field: CreateAlarmFieldsEnum.ALARM_DETAILS_BUILD_JS,
+    component: 'JavascriptEditorWithTestModal',
+    label: CreateAlarmFieldsNameEnum.ALARM_DETAILS_BUILD_JS,
   },
 ];

@@ -3,8 +3,64 @@ import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
+    field: NodeBindDataFieldEnum.INPUT_VALUE_KEY,
     component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    label: NodeBindDataFieldNameEnum.INPUT_VALUE_KEY,
+    required: true,
+    colProps: { span: 8 },
+  },
+  {
+    field: NodeBindDataFieldEnum.OUTPUT_VALUE_KEY,
+    component: 'Input',
+    label: NodeBindDataFieldNameEnum.OUTPUT_VALUE_KEY,
+    required: true,
+    colProps: { span: 8 },
+  },
+  {
+    field: NodeBindDataFieldEnum.ROUND,
+    component: 'InputNumber',
+    label: NodeBindDataFieldNameEnum.ROUND,
+    colProps: { span: 8 },
+    componentProps: {
+      step: 1,
+      max: 15,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.USE_CACHE,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => {
+      return {
+        default: () => NodeBindDataFieldNameEnum.USE_CACHE,
+      };
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.TELL_FAILURE_IF_DELTA_IS_NEGATIVE,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => {
+      return {
+        default: () => NodeBindDataFieldNameEnum.TELL_FAILURE_IF_DELTA_IS_NEGATIVE,
+      };
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.ADD_PERIOD_BETWEEN_MSGS,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => {
+      return {
+        default: () => NodeBindDataFieldNameEnum.ADD_PERIOD_BETWEEN_MSGS,
+      };
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.PERIOD_VALUE_KEY,
+    component: 'Input',
+    label: NodeBindDataFieldNameEnum.PERIOD_VALUE_KEY,
+    required: true,
+    ifShow: ({ model }) => model[NodeBindDataFieldEnum.ADD_PERIOD_BETWEEN_MSGS],
   },
 ];

 import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
-import { FormSchema } from '/@/components/Form';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
+import { AttributeConfiguration } from '/@/views/rule/designer/src/components/AttributeConfiguration';
+
+useComponentRegister('AttributeConfiguration', AttributeConfiguration);
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: NodeBindDataFieldEnum.TELEMETRY,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => {
+      return {
+        default: () => NodeBindDataFieldNameEnum.TELEMETRY,
+      };
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.ATTR_MAPING,
+    component: 'AttributeConfiguration',
+    label: NodeBindDataFieldNameEnum.ATTR_MAPING,
+    slot: NodeBindDataFieldEnum.ATTR_MAPING,
+    valueField: 'value',
+    changeEvent: 'update:value',
   },
 ];

@@ -3,25 +3,33 @@
   import { BasicForm, useForm } from '/@/components/Form';
   import { formSchemas } from './create.config';
   import { NodeData } from '../../../types/node';
+  import { AttributeConfiguration } from '/@/views/rule/designer/src/components/AttributeConfiguration';
+  import { ref, unref } from 'vue';
+  import { NodeBindDataFieldEnum } from '../../../enum/node';
 
   defineProps<{
     config: NodeData;
   }>();
 
+  const attributeControlElRef = ref<Nullable<InstanceType<typeof AttributeConfiguration>>>();
+
   const [register, { validate, getFieldsValue, setFieldsValue, resetFields }] = useForm({
     schemas: formSchemas,
     showActionButtonGroup: false,
   });
 
   const getValue: CreateModalDefineExposeType['getFieldsValue'] = async () => {
+    await unref(attributeControlElRef)?.validate();
     await validate();
     const value = getFieldsValue() || {};
-    return value;
+    const attrMapping = unref(attributeControlElRef)?.getFieldsValue();
+    return { ...value, [NodeBindDataFieldEnum.ATTR_MAPING]: attrMapping };
   };
 
   const setValue: CreateModalDefineExposeType['setFieldsValue'] = (value) => {
     resetFields();
     setFieldsValue(value);
+    unref(attributeControlElRef)?.setFieldsValue(value?.[NodeBindDataFieldEnum.ATTR_MAPING]);
   };
 
   defineExpose({
@@ -31,5 +39,32 @@
 </script>
 
 <template>
-  <BasicForm @register="register" />
+  <BasicForm @register="register">
+    <template #attrMapping="{ field, model }">
+      <AttributeConfiguration
+        v-model:value="model[field]"
+        ref="attributeControlElRef"
+        :keyLabel="`Source ${model[NodeBindDataFieldEnum.TELEMETRY] ? 'telemetry' : 'attribute'}`"
+        valueLabel="Target attribute"
+      >
+        <template #afterForm>
+          <div class="text-xs text-gray-500">
+            Hint: use
+            <code>
+              <span class="text-dark-500">${</span>
+              metadataKey
+              <span class="text-dark-500">}</span>
+            </code>
+            for value from metadata,
+            <code>
+              <span class="text-dark-500"> $[</span>
+              messageKey
+              <span class="text-dark-500">] </span>
+            </code>
+            for value from message body to substitute "Source" and "Target" key names
+          </div>
+        </template>
+      </AttributeConfiguration>
+    </template>
+  </BasicForm>
 </template>

+import { DetailsListEnum, DetailsListNameEnum } from '../../../enum/form';
 import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: NodeBindDataFieldEnum.DETAILS_LIST,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.DETAILS_LIST,
+    componentProps: {
+      mode: 'multiple',
+      options: Object.keys(DetailsListEnum).map((item) => ({
+        label: DetailsListNameEnum[item],
+        value: item,
+        getPopupContainer: () => document.body,
+      })),
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.ADD_TO_METADATA,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => {
+      return {
+        default: () => NodeBindDataFieldNameEnum.ADD_TO_METADATA,
+      };
+    },
   },
 ];

@@ -3,8 +3,73 @@ import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: NodeBindDataFieldEnum.TELL_FAILURE_IF_ABSENT,
+    component: 'Checkbox',
+    label: '',
+    // helpMessage: [
+    //   'If at least one selected key doesn\'t exist the outbound message will report "Failure".',
+    // ],
+    renderComponentContent: () => ({
+      default: () => NodeBindDataFieldNameEnum.TELL_FAILURE_IF_ABSENT,
+    }),
+  },
+  {
+    field: NodeBindDataFieldEnum.CLIENT_ATTRIBUTE_NAMES,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.CLIENT_ATTRIBUTE_NAMES,
+    helpMessage: [
+      `Hint: use \${metadataKey} for value from metadata, $[messageKey] for value from message body`,
+    ],
+    componentProps: {
+      mode: 'tags',
+      open: false,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.SHARED_ATTRIBUTE_NAMES,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.SHARED_ATTRIBUTE_NAMES,
+    helpMessage: [
+      `Hint: use \${metadataKey} for value from metadata, $[messageKey] for value from message body`,
+    ],
+    componentProps: {
+      mode: 'tags',
+      open: false,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.SERVER_ATTRIBUTE_NAMES,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.SERVER_ATTRIBUTE_NAMES,
+    helpMessage: [
+      `Hint: use \${metadataKey} for value from metadata, $[messageKey] for value from message body`,
+    ],
+    componentProps: {
+      mode: 'tags',
+      open: false,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.LATEST_TS_KEY_NAMES,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.LATEST_TS_KEY_NAMES,
+    helpMessage: [
+      `Hint: use \${metadataKey} for value from metadata, $[messageKey] for value from message body`,
+    ],
+    componentProps: {
+      mode: 'tags',
+      open: false,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.GET_LATEST_VALUE_WITH_TS,
+    component: 'Checkbox',
+    label: '',
+    // helpMessage: [
+    //   'If selected, latest telemetry values will be added to the outbound message metadata with timestamp, e.g: "temp": "{"ts":1574329385897, "value":42}"',
+    // ],
+    renderComponentContent: () => ({
+      default: () => NodeBindDataFieldNameEnum.GET_LATEST_VALUE_WITH_TS,
+    }),
   },
 ];

 import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
-import { FormSchema } from '/@/components/Form';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
+import { AttributeConfiguration } from '/@/views/rule/designer/src/components/AttributeConfiguration';
+
+useComponentRegister('AttributeConfiguration', AttributeConfiguration);
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: NodeBindDataFieldEnum.FIELDS_MAPPING,
+    component: 'AttributeConfiguration',
+    label: NodeBindDataFieldNameEnum.FIELDS_MAPPING,
+    slot: NodeBindDataFieldEnum.FIELDS_MAPPING,
+    valueField: 'value',
+    changeEvent: 'update:value',
   },
 ];

@@ -3,25 +3,33 @@
   import { BasicForm, useForm } from '/@/components/Form';
   import { formSchemas } from './create.config';
   import { NodeData } from '../../../types/node';
+  import { AttributeConfiguration } from '/@/views/rule/designer/src/components/AttributeConfiguration';
+  import { ref, unref } from 'vue';
+  import { NodeBindDataFieldEnum } from '../../../enum/node';
 
   defineProps<{
     config: NodeData;
   }>();
 
+  const fieldControlElRef = ref<Nullable<InstanceType<typeof AttributeConfiguration>>>();
+
   const [register, { validate, getFieldsValue, setFieldsValue, resetFields }] = useForm({
     schemas: formSchemas,
     showActionButtonGroup: false,
   });
 
   const getValue: CreateModalDefineExposeType['getFieldsValue'] = async () => {
+    await unref(fieldControlElRef)?.validate();
     await validate();
     const value = getFieldsValue() || {};
-    return value;
+    const fieldsMapping = unref(fieldControlElRef)?.getFieldsValue();
+    return { ...value, [NodeBindDataFieldEnum.FIELDS_MAPPING]: fieldsMapping };
   };
 
   const setValue: CreateModalDefineExposeType['setFieldsValue'] = (value) => {
     resetFields();
     setFieldsValue(value);
+    unref(fieldControlElRef)?.setFieldsValue(value?.[NodeBindDataFieldEnum.FIELDS_MAPPING]);
   };
 
   defineExpose({
@@ -31,5 +39,14 @@
 </script>
 
 <template>
-  <BasicForm @register="register" />
+  <BasicForm @register="register">
+    <template #fieldsMapping="{ field, model }">
+      <AttributeConfiguration
+        v-model:value="model[field]"
+        ref="fieldControlElRef"
+        keyLabel="Source Field"
+        valueLabel="Target attribute"
+      />
+    </template>
+  </BasicForm>
 </template>

+import {
+  AggregationEnum,
+  AggregationNameEnum,
+  FetchModeEnum,
+  OrderByEnum,
+  TimeIntervalUnitEnum,
+  TimeIntervalUnitNameEnum,
+} from '../../../enum/form';
 import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
+    field: NodeBindDataFieldEnum.LATEST_TS_KEY_NAMES,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.LATEST_TS_KEY_NAMES,
+    componentProps: {
+      mode: 'tags',
+      open: false,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.FETCH_MODE,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.FETCH_MODE,
+    required: true,
+    componentProps: {
+      options: Object.keys(FetchModeEnum).map((value) => ({ label: value, value })),
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.AGGREGATION,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.AGGREGATION,
+    required: true,
+    show: ({ model }) => model[NodeBindDataFieldEnum.FETCH_MODE] === FetchModeEnum.ALL,
+    componentProps: {
+      options: Object.keys(AggregationEnum).map((value) => ({
+        label: AggregationNameEnum[value],
+        value,
+      })),
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.ORDER_BY,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.ORDER_BY,
+    required: true,
+    show: ({ model }) => model[NodeBindDataFieldEnum.FETCH_MODE] === FetchModeEnum.ALL,
+    componentProps: {
+      options: Object.keys(OrderByEnum).map((value) => ({ label: value, value })),
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.ORDER_BY,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.ORDER_BY,
+    required: true,
+    helpMessage: ['Select to choose telemetry sampling order.'],
+    show: ({ model }) => model[NodeBindDataFieldEnum.FETCH_MODE] === FetchModeEnum.ALL,
+    componentProps: {
+      options: Object.keys(OrderByEnum).map((value) => ({ label: value, value })),
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.LIMIT,
+    component: 'InputNumber',
+    label: NodeBindDataFieldNameEnum.LIMIT,
+    required: true,
+    helpMessage: [
+      "Min limit value is 2, max - 1000. In case you want to fetch a single entry, select fetch mode 'FIRST' or 'LAST'.",
+    ],
+    show: ({ model }) => model[NodeBindDataFieldEnum.FETCH_MODE] === FetchModeEnum.ALL,
+    componentProps: {
+      min: 2,
+      max: 1000,
+      step: 1,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.USE_METADATA_INTERVAL_PATTERNS,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => ({
+      default: () => NodeBindDataFieldNameEnum.USE_METADATA_INTERVAL_PATTERNS,
+    }),
+  },
+  {
+    field: NodeBindDataFieldEnum.START_INTERVAL,
+    component: 'InputNumber',
+    label: NodeBindDataFieldNameEnum.START_INTERVAL,
+    colProps: { span: 12 },
+    required: true,
+    show: ({ model }) => !model[NodeBindDataFieldEnum.USE_METADATA_INTERVAL_PATTERNS],
+    componentProps: {
+      step: 1,
+      min: 0,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.START_INTERVAL_TIME_UNIT,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.START_INTERVAL_TIME_UNIT,
+    colProps: { span: 12 },
+    required: true,
+    show: ({ model }) => !model[NodeBindDataFieldEnum.USE_METADATA_INTERVAL_PATTERNS],
+    componentProps: {
+      options: Object.keys(TimeIntervalUnitEnum).map((value) => ({
+        label: TimeIntervalUnitNameEnum[value],
+        value,
+      })),
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.END_INTERVAL,
+    component: 'InputNumber',
+    label: NodeBindDataFieldNameEnum.END_INTERVAL,
+    colProps: { span: 12 },
+    required: true,
+    show: ({ model }) => !model[NodeBindDataFieldEnum.USE_METADATA_INTERVAL_PATTERNS],
+    componentProps: {
+      step: 1,
+      min: 0,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.END_INTERVAL_TIME_UNIT,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.END_INTERVAL_TIME_UNIT,
+    colProps: { span: 12 },
+    required: true,
+    show: ({ model }) => !model[NodeBindDataFieldEnum.USE_METADATA_INTERVAL_PATTERNS],
+    componentProps: {
+      options: Object.keys(TimeIntervalUnitEnum).map((value) => ({
+        label: TimeIntervalUnitNameEnum[value],
+        value,
+      })),
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.START_INTERVAL_PATTERN,
+    component: 'Input',
+    label: NodeBindDataFieldNameEnum.START_INTERVAL_PATTERN,
+    required: true,
+    helpMessage: [
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    show: ({ model }) => model[NodeBindDataFieldEnum.USE_METADATA_INTERVAL_PATTERNS],
+  },
+  {
+    field: NodeBindDataFieldEnum.END_INTERVAL_PATTERN,
     component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    label: NodeBindDataFieldNameEnum.END_INTERVAL_PATTERN,
+    required: true,
+    helpMessage: [
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    show: ({ model }) => model[NodeBindDataFieldEnum.USE_METADATA_INTERVAL_PATTERNS],
   },
 ];

 import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
-import { FormSchema } from '/@/components/Form';
+import { AttributeConfiguration } from '/@/views/rule/designer/src/components/AttributeConfiguration';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
+import { RelationsQuery } from '/@/views/rule/designer/src/components/RelationsQuery';
+
+useComponentRegister('RelationsQuery', RelationsQuery);
+useComponentRegister('AttributeConfiguration', AttributeConfiguration);
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: NodeBindDataFieldEnum.RELATIONS_QUERY,
+    component: 'RelationsQuery',
+    label: NodeBindDataFieldNameEnum.RELATIONS_QUERY,
+    changeEvent: 'update:value',
+    valueField: 'value',
+    slot: NodeBindDataFieldEnum.RELATIONS_QUERY,
+  },
+  {
+    field: NodeBindDataFieldEnum.TELEMETRY,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => ({
+      default: () => NodeBindDataFieldNameEnum.TELEMETRY,
+    }),
+  },
+  {
+    field: NodeBindDataFieldEnum.ATTR_MAPING,
+    component: 'AttributeConfiguration',
+    label: '',
+    slot: NodeBindDataFieldEnum.ATTR_MAPING,
   },
 ];

@@ -3,11 +3,19 @@
   import { BasicForm, useForm } from '/@/components/Form';
   import { formSchemas } from './create.config';
   import { NodeData } from '../../../types/node';
+  import { RelationsQuery } from '/@/views/rule/designer/src/components/RelationsQuery';
+  import { ref, unref } from 'vue';
+  import { NodeBindDataFieldEnum } from '../../../enum/node';
+  import { AttributeConfiguration } from '/@/views/rule/designer/src/components/AttributeConfiguration';
 
   defineProps<{
     config: NodeData;
   }>();
 
+  const relationsQueryElRef = ref<Nullable<InstanceType<typeof RelationsQuery>>>();
+
+  const attributeControlElRef = ref<Nullable<InstanceType<typeof AttributeConfiguration>>>();
+
   const [register, { validate, getFieldsValue, setFieldsValue, resetFields }] = useForm({
     schemas: formSchemas,
     showActionButtonGroup: false,
@@ -15,13 +23,25 @@
 
   const getValue: CreateModalDefineExposeType['getFieldsValue'] = async () => {
     await validate();
+    await unref(relationsQueryElRef)?.validate();
+    await unref(attributeControlElRef)?.validate();
     const value = getFieldsValue() || {};
-    return value;
+    const queryValue = unref(relationsQueryElRef)?.getFieldsValue();
+    const attrMapping = unref(attributeControlElRef)?.getFieldsValue();
+    return {
+      ...value,
+      [NodeBindDataFieldEnum.RELATIONS_QUERY]: queryValue,
+      [NodeBindDataFieldEnum.ATTR_MAPING]: attrMapping,
+    };
   };
 
   const setValue: CreateModalDefineExposeType['setFieldsValue'] = (value) => {
     resetFields();
     setFieldsValue(value);
+    unref(relationsQueryElRef)?.setFieldsValue(
+      value?.[NodeBindDataFieldEnum.RELATIONS_QUERY] as Recordable
+    );
+    unref(attributeControlElRef)?.setFieldsValue(value?.[NodeBindDataFieldEnum.ATTR_MAPING]);
   };
 
   defineExpose({
@@ -31,5 +51,35 @@
 </script>
 
 <template>
-  <BasicForm @register="register" />
+  <BasicForm @register="register">
+    <template #relationsQuery="{ field, model }">
+      <RelationsQuery ref="relationsQueryElRef" v-model:value="model[field]" />
+    </template>
+    <template #attrMapping="{ field, model }">
+      <AttributeConfiguration
+        v-model:value="model[field]"
+        ref="attributeControlElRef"
+        :keyLabel="`Source ${model[NodeBindDataFieldEnum.TELEMETRY] ? 'telemetry' : 'attribute'}`"
+        valueLabel="Target attribute"
+      >
+        <template #afterForm>
+          <div class="text-xs text-gray-500">
+            Hint: use
+            <code>
+              <span class="text-dark-500">${</span>
+              metadataKey
+              <span class="text-dark-500">}</span>
+            </code>
+            for value from metadata,
+            <code>
+              <span class="text-dark-500"> $[</span>
+              messageKey
+              <span class="text-dark-500">] </span>
+            </code>
+            for value from message body to substitute "Source" and "Target" key names
+          </div>
+        </template>
+      </AttributeConfiguration>
+    </template>
+  </BasicForm>
 </template>

+import {
+  DirectionEnum,
+  DirectionNameEnum,
+  RelationTypeEnum,
+  RelationTypeNameEnum,
+} from '../../../enum/form';
 import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import { getDeviceTypes } from '/@/api/ruleChainDesigner';
 import { FormSchema } from '/@/components/Form';
 
+export interface ValueType {
+  deviceRelationsQuery: DeviceRelationsQuery;
+  tellFailureIfAbsent: boolean;
+  clientAttributeNames: string[];
+  sharedAttributeNames: string[];
+  serverAttributeNames: string[];
+  latestTsKeyNames: string[];
+  getLatestValueWithTs: boolean;
+}
+
+export interface DeviceRelationsQuery {
+  fetchLastLevelOnly: boolean;
+  direction: string;
+  maxLevel: number;
+  relationType: string;
+  deviceTypes: string[];
+}
+
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: NodeBindDataFieldEnum.FETCH_LAST_LEVEL_ONLY,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => ({
+      default: () => NodeBindDataFieldNameEnum.FETCH_LAST_LEVEL_ONLY,
+    }),
+  },
+  {
+    field: NodeBindDataFieldEnum.DIRECTION,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.DIRECTION,
+    required: true,
+    colProps: { span: 12 },
+    componentProps: {
+      options: Object.keys(DirectionEnum).map((value) => ({
+        label: DirectionNameEnum[value],
+        value,
+      })),
+      placeholder: `请选择${NodeBindDataFieldNameEnum.DIRECTION}`,
+      getPopupContainer: () => document.body,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.MAX_LEVEL,
+    component: 'InputNumber',
+    label: NodeBindDataFieldNameEnum.MAX_LEVEL,
+    colProps: { span: 12 },
+    componentProps: {
+      min: 1,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.RELATION_TYPE,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.RELATION_TYPE,
+    componentProps: {
+      options: Object.keys(RelationTypeEnum).map((value) => ({
+        label: RelationTypeNameEnum[value],
+        value,
+      })),
+      placeholder: `请选择${NodeBindDataFieldNameEnum.RELATION_TYPE}`,
+      getPopupContainer: () => document.body,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.DEVICE_TYPES,
+    component: 'ApiSelect',
+    label: NodeBindDataFieldNameEnum.DEVICE_TYPES,
+    componentProps: {
+      mode: 'multiple',
+      api: getDeviceTypes,
+      labelField: 'type',
+      valueField: 'type',
+      getPopupContainer: () => document.body,
+      placeholder: `请选择${NodeBindDataFieldNameEnum.DEVICE_TYPES}`,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.TELL_FAILURE_IF_ABSENT,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => ({
+      default: () => NodeBindDataFieldNameEnum.TELL_FAILURE_IF_ABSENT,
+    }),
+  },
+  {
+    field: NodeBindDataFieldEnum.CLIENT_ATTRIBUTE_NAMES,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.CLIENT_ATTRIBUTE_NAMES,
+    componentProps: {
+      open: false,
+      mode: 'tags',
+      placeholder: NodeBindDataFieldNameEnum.CLIENT_ATTRIBUTE_NAMES,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.SHARED_ATTRIBUTE_NAMES,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.SHARED_ATTRIBUTE_NAMES,
+    componentProps: {
+      open: false,
+      mode: 'tags',
+      placeholder: NodeBindDataFieldNameEnum.SHARED_ATTRIBUTE_NAMES,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.SERVER_ATTRIBUTE_NAMES,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.SERVER_ATTRIBUTE_NAMES,
+    componentProps: {
+      open: false,
+      mode: 'tags',
+      placeholder: NodeBindDataFieldNameEnum.SERVER_ATTRIBUTE_NAMES,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.LATEST_TS_KEY_NAMES,
+    component: 'Select',
+    label: NodeBindDataFieldNameEnum.LATEST_TS_KEY_NAMES,
+    componentProps: {
+      open: false,
+      mode: 'tags',
+      placeholder: NodeBindDataFieldNameEnum.LATEST_TS_KEY_NAMES,
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.GET_LATEST_VALUE_WITH_TS,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => ({
+      default: () => NodeBindDataFieldNameEnum.GET_LATEST_VALUE_WITH_TS,
+    }),
   },
 ];

 <script lang="ts" setup>
   import type { CreateModalDefineExposeType } from '../../../types';
   import { BasicForm, useForm } from '/@/components/Form';
-  import { formSchemas } from './create.config';
+  import { DeviceRelationsQuery, formSchemas, ValueType } from './create.config';
   import { NodeData } from '../../../types/node';
+  import { NodeBindDataFieldEnum } from '../../../enum/node';
 
   defineProps<{
     config: NodeData;
@@ -16,12 +17,33 @@
   const getValue: CreateModalDefineExposeType['getFieldsValue'] = async () => {
     await validate();
     const value = getFieldsValue() || {};
-    return value;
+    return {
+      [NodeBindDataFieldEnum.DEVICE_RELATIONS_QUERY]: {
+        [NodeBindDataFieldEnum.FETCH_LAST_LEVEL_ONLY]:
+          value[NodeBindDataFieldEnum.FETCH_LAST_LEVEL_ONLY],
+        [NodeBindDataFieldEnum.DEVICE_TYPES]: value[NodeBindDataFieldEnum.DEVICE_TYPES],
+        [NodeBindDataFieldEnum.DIRECTION]: value[NodeBindDataFieldEnum.DIRECTION],
+        [NodeBindDataFieldEnum.MAX_LEVEL]: value[NodeBindDataFieldEnum.MAX_LEVEL],
+        [NodeBindDataFieldEnum.RELATION_TYPE]: value[NodeBindDataFieldEnum.RELATION_TYPE],
+      } as DeviceRelationsQuery,
+      [NodeBindDataFieldEnum.CLIENT_ATTRIBUTE_NAMES]:
+        value[NodeBindDataFieldEnum.CLIENT_ATTRIBUTE_NAMES],
+      [NodeBindDataFieldEnum.GET_LATEST_VALUE_WITH_TS]:
+        value[NodeBindDataFieldEnum.GET_LATEST_VALUE_WITH_TS],
+      [NodeBindDataFieldEnum.LATEST_TS_KEY_NAMES]: value[NodeBindDataFieldEnum.LATEST_TS_KEY_NAMES],
+      [NodeBindDataFieldEnum.SERVER_ATTRIBUTE_NAMES]:
+        value[NodeBindDataFieldEnum.SERVER_ATTRIBUTE_NAMES],
+      [NodeBindDataFieldEnum.SHARED_ATTRIBUTE_NAMES]:
+        value[NodeBindDataFieldEnum.SHARED_ATTRIBUTE_NAMES],
+      [NodeBindDataFieldEnum.TELL_FAILURE_IF_ABSENT]:
+        value[NodeBindDataFieldEnum.TELL_FAILURE_IF_ABSENT],
+    } as ValueType;
   };
 
   const setValue: CreateModalDefineExposeType['setFieldsValue'] = (value) => {
     resetFields();
-    setFieldsValue(value);
+    console.log(value);
+    setFieldsValue({ ...value, ...(value?.[NodeBindDataFieldEnum.DEVICE_RELATIONS_QUERY] || {}) });
   };
 
   defineExpose({

 import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
-import { FormSchema } from '/@/components/Form';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
+import { AttributeConfiguration } from '/@/views/rule/designer/src/components/AttributeConfiguration';
+
+useComponentRegister('AttributeConfiguration', AttributeConfiguration);
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: NodeBindDataFieldEnum.TELEMETRY,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => {
+      return {
+        default: () => NodeBindDataFieldNameEnum.TELEMETRY,
+      };
+    },
+  },
+  {
+    field: NodeBindDataFieldEnum.ATTR_MAPING,
+    component: 'AttributeConfiguration',
+    label: NodeBindDataFieldNameEnum.ATTR_MAPING,
+    slot: NodeBindDataFieldEnum.ATTR_MAPING,
+    valueField: 'value',
+    changeEvent: 'update:value',
   },
 ];

@@ -3,25 +3,33 @@
   import { BasicForm, useForm } from '/@/components/Form';
   import { formSchemas } from './create.config';
   import { NodeData } from '../../../types/node';
+  import { AttributeConfiguration } from '/@/views/rule/designer/src/components/AttributeConfiguration';
+  import { ref, unref } from 'vue';
+  import { NodeBindDataFieldEnum } from '../../../enum/node';
 
   defineProps<{
     config: NodeData;
   }>();
 
+  const attributeControlElRef = ref<Nullable<InstanceType<typeof AttributeConfiguration>>>();
+
   const [register, { validate, getFieldsValue, setFieldsValue, resetFields }] = useForm({
     schemas: formSchemas,
     showActionButtonGroup: false,
   });
 
   const getValue: CreateModalDefineExposeType['getFieldsValue'] = async () => {
+    await unref(attributeControlElRef)?.validate();
     await validate();
     const value = getFieldsValue() || {};
-    return value;
+    const attrMapping = unref(attributeControlElRef)?.getFieldsValue();
+    return { ...value, [NodeBindDataFieldEnum.ATTR_MAPING]: attrMapping };
   };
 
   const setValue: CreateModalDefineExposeType['setFieldsValue'] = (value) => {
     resetFields();
     setFieldsValue(value);
+    unref(attributeControlElRef)?.setFieldsValue(value?.[NodeBindDataFieldEnum.ATTR_MAPING]);
   };
 
   defineExpose({
@@ -31,5 +39,32 @@
 </script>
 
 <template>
-  <BasicForm @register="register" />
+  <BasicForm @register="register">
+    <template #attrMapping="{ field, model }">
+      <AttributeConfiguration
+        v-model:value="model[field]"
+        ref="attributeControlElRef"
+        :keyLabel="`Source ${model[NodeBindDataFieldEnum.TELEMETRY] ? 'telemetry' : 'attribute'}`"
+        valueLabel="Target attribute"
+      >
+        <template #afterForm>
+          <div class="text-xs text-gray-500">
+            Hint: use
+            <code>
+              <span class="text-dark-500">${</span>
+              metadataKey
+              <span class="text-dark-500">}</span>
+            </code>
+            for value from metadata,
+            <code>
+              <span class="text-dark-500"> $[</span>
+              messageKey
+              <span class="text-dark-500">] </span>
+            </code>
+            for value from message body to substitute "Source" and "Target" key names
+          </div>
+        </template>
+      </AttributeConfiguration>
+    </template>
+  </BasicForm>
 </template>

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import { DetailsListEnum, DetailsListNameEnum } from '../../../enum/form';
+import {
+  TenantDetailsFieldsEnum,
+  TenantDetailsFieldsNameEnum,
+} from '../../../enum/formField/enrichment';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: TenantDetailsFieldsEnum.DETAILS_LIST,
+    component: 'Select',
+    label: TenantDetailsFieldsNameEnum.DETAILS_LIST,
+    required: true,
+    componentProps: {
+      mode: 'multiple',
+      options: Object.keys(DetailsListEnum).map((value) => ({
+        label: DetailsListNameEnum[value],
+        value,
+      })),
+      getPopupContainer: () => document.body,
+      placeholder: `请选择${TenantDetailsFieldsNameEnum.DETAILS_LIST}`,
+    },
+  },
+  {
+    field: TenantDetailsFieldsEnum.ADD_TO_METADATA,
+    component: 'Checkbox',
+    label: '',
+    renderComponentContent: () => ({
+      default: () => TenantDetailsFieldsNameEnum.DETAILS_LIST,
+    }),
   },
 ];

@@ -8,6 +8,7 @@ export const formSchemas: FormSchema[] = [
     label: NodeBindDataFieldNameEnum.MESSAGE_NAMES,
     componentProps: {
       mode: 'tags',
+      open: false,
       getPopupContainer: () => document.body,
     },
   },
@@ -17,6 +18,7 @@ export const formSchemas: FormSchema[] = [
     label: NodeBindDataFieldNameEnum.METADATA_NAMES,
     componentProps: {
       mode: 'tags',
+      open: false,
       getPopupContainer: () => document.body,
     },
   },

@@ -4,6 +4,7 @@ import {
   EntityTypeEnum,
   EntityTypeNameEnum,
   RelationTypeEnum,
+  RelationTypeNameEnum,
 } from '../../../enum/form';
 import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
 import { deviceProfilePage } from '/@/api/device/deviceManager';
@@ -18,8 +19,10 @@ export const formSchemas: FormSchema[] = [
   {
     field: NodeBindDataFieldEnum.CHECK_FOR_SINGLE_ENTITY,
     component: 'Checkbox',
-    label: NodeBindDataFieldNameEnum.CHECK_FOR_SINGLE_ENTITY,
-    labelWidth: 220,
+    label: '',
+    renderComponentContent: () => ({
+      default: () => NodeBindDataFieldNameEnum.CHECK_FOR_SINGLE_ENTITY,
+    }),
   },
   {
     field: NodeBindDataFieldEnum.DIRECTION,
@@ -69,10 +72,10 @@ export const formSchemas: FormSchema[] = [
     label: NodeBindDataFieldNameEnum.RELEATION_TYPE,
     defaultValue: RelationTypeEnum.CONTAINS,
     componentProps: {
-      options: [
-        { label: RelationTypeEnum.CONTAINS, value: RelationTypeEnum.CONTAINS },
-        { label: RelationTypeEnum.MANAGES, value: RelationTypeEnum.MANAGES },
-      ],
+      options: Object.keys(RelationTypeEnum).map((value) => ({
+        label: RelationTypeNameEnum[value],
+        value,
+      })),
     },
   },
 ];

@@ -24,8 +24,10 @@ export const formSchemas: FormSchema[] = [
   {
     field: NodeBindDataFieldEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA,
     component: 'Checkbox',
-    label: NodeBindDataFieldNameEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA,
-    labelWidth: 350,
+    label: '',
+    renderComponentContent: () => ({
+      default: () => NodeBindDataFieldNameEnum.FETCH_PERIMETER_INFO_FROM_MESSAGE_METADATA,
+    }),
   },
   {
     field: NodeBindDataFieldEnum.PERIMETER_KEY_NAME,

@@ -2,14 +2,14 @@ import { h } from 'vue';
 import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
 import HelpMessage from './HelpMessage.vue';
-import JavaScriptFilterFunctionModal from './JavaScriptFilterFunctionModal.vue';
+import { JavascriptEditorWithTestModal } from '/@/views/rule/designer/src/components/JavaScriptFilterModal';
 
-useComponentRegister('JavaScriptFilterFunctionModal', JavaScriptFilterFunctionModal);
+useComponentRegister('JavascriptEditorWithTestModal', JavascriptEditorWithTestModal);
 
 export const formSchemas: FormSchema[] = [
   {
     field: NodeBindDataFieldEnum.JS_SCRIPT,
-    component: 'JavaScriptFilterFunctionModal',
+    component: 'JavascriptEditorWithTestModal',
     label: NodeBindDataFieldNameEnum.JS_SCRIPT,
     changeEvent: 'update:value',
     valueField: 'value',

 import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
-import JavaScriptFilterFunctionModal from '../Script/JavaScriptFilterFunctionModal.vue';
+import { JavascriptEditorWithTestModal } from '/@/views/rule/designer/src/components/JavaScriptFilterModal';
+
+useComponentRegister('JavascriptEditorWithTestModal', JavascriptEditorWithTestModal);
 
-useComponentRegister('JavaScriptFilterFunctionModal', JavaScriptFilterFunctionModal);
 export const formSchemas: FormSchema[] = [
   {
     field: NodeBindDataFieldEnum.JS_SCRIPT,
-    component: 'JavaScriptFilterFunctionModal',
+    component: 'JavascriptEditorWithTestModal',
     label: NodeBindDataFieldNameEnum.JS_SCRIPT,
     changeEvent: 'update:value',
     valueField: 'value',
     componentProps: {
       buttonName: 'Test Switch Function',
       javaScriptEditorProps: {
+        height: 230,
         functionName: 'Switch',
         paramsName: ['msg', 'metadata', 'mstType'],
       },

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
-import { FormSchema } from '/@/components/Form';
+import { OriginatorSourceEnum, OriginatorSourceNameEnum } from '../../../enum/form';
+import {
+  ChangeOriginatorFieldsEnum,
+  ChangeOriginatorFieldsNameEnum,
+} from '../../../enum/formField/transformation';
+import { RelationsQuery } from '../../../src/components/RelationsQuery';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
+
+useComponentRegister('RelationsQuery', RelationsQuery);
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
-    component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    field: ChangeOriginatorFieldsEnum.ORIGINATOR_SOURCE,
+    component: 'Select',
+    label: ChangeOriginatorFieldsNameEnum.ORIGINATOR_SOURCE,
+    required: true,
+    componentProps: {
+      options: Object.keys(OriginatorSourceEnum).map((value) => ({
+        label: OriginatorSourceNameEnum[value],
+        value,
+      })),
+      getPopupContainer: () => document.body,
+      placeholder: `请选择${ChangeOriginatorFieldsNameEnum.ORIGINATOR_SOURCE}`,
+    },
+  },
+  {
+    field: ChangeOriginatorFieldsEnum.RELATIONS_QUERY,
+    component: 'RelationsQuery',
+    label: ChangeOriginatorFieldsNameEnum.RELATIONS_QUERY,
+    slot: ChangeOriginatorFieldsEnum.RELATIONS_QUERY,
   },
 ];

@@ -3,11 +3,16 @@
   import { BasicForm, useForm } from '/@/components/Form';
   import { formSchemas } from './create.config';
   import { NodeData } from '../../../types/node';
+  import { RelationsQuery } from '../../../src/components/RelationsQuery';
+  import { ref, unref } from 'vue';
+  import { ChangeOriginatorFieldsEnum } from '../../../enum/formField/transformation';
 
   defineProps<{
     config: NodeData;
   }>();
 
+  const relationsQueryElRef = ref<Nullable<InstanceType<typeof RelationsQuery>>>();
+
   const [register, { validate, getFieldsValue, setFieldsValue, resetFields }] = useForm({
     schemas: formSchemas,
     showActionButtonGroup: false,
@@ -16,12 +21,14 @@
   const getValue: CreateModalDefineExposeType['getFieldsValue'] = async () => {
     await validate();
     const value = getFieldsValue() || {};
-    return value;
+    const relationsQuery = unref(relationsQueryElRef)?.getFieldsValue();
+    return { ...value, [ChangeOriginatorFieldsEnum.RELATIONS_QUERY]: relationsQuery };
   };
 
   const setValue: CreateModalDefineExposeType['setFieldsValue'] = (value) => {
     resetFields();
     setFieldsValue(value);
+    unref(relationsQueryElRef)?.setFieldsValue(value?.[ChangeOriginatorFieldsEnum.RELATIONS_QUERY]);
   };
 
   defineExpose({
@@ -31,5 +38,9 @@
 </script>
 
 <template>
-  <BasicForm @register="register" />
+  <BasicForm @register="register">
+    <template #relationsQuery="{ field, model }">
+      <RelationsQuery ref="relationsQueryElRef" v-model:value="model[field]" />
+    </template>
+  </BasicForm>
 </template>

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
-import { FormSchema } from '/@/components/Form';
+import { ScriptFieldsEnum, ScriptFieldsNameEnum } from '../../../enum/formField/transformation';
+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: ScriptFieldsEnum.JS_SCRIPT,
+    component: 'JavascriptEditorWithTestModal',
+    label: ScriptFieldsNameEnum.JS_SCRIPT,
+    changeEvent: 'update:value',
+    valueField: 'value',
+    componentProps: {
+      javaScriptEditorProps: {
+        functionName: 'Transform',
+        paramsName: ['msg', 'metadata', 'msgType'],
+      },
+      buttonName: 'Test transformer function',
+    },
   },
 ];

-import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+import { MailBodyTypeEnum, MailBodyTypeNameEnum } from '../../../enum/form';
+import { ToEmailFieldsEnum, ToEmailFieldsNameEnum } from '../../../enum/formField/transformation';
 import { FormSchema } from '/@/components/Form';
 
 export const formSchemas: FormSchema[] = [
   {
-    field: NodeBindDataFieldEnum.NAME,
+    field: ToEmailFieldsEnum.FROM_TEMPLATE,
     component: 'Input',
-    label: NodeBindDataFieldNameEnum.NAME,
+    label: ToEmailFieldsNameEnum.FROM_TEMPLATE,
+    helpMessage: [
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    componentProps: {
+      placeholder: `请输入${ToEmailFieldsNameEnum.FROM_TEMPLATE}`,
+    },
+  },
+  {
+    field: ToEmailFieldsEnum.TO_TEMPLATE,
+    component: 'Input',
+    label: ToEmailFieldsNameEnum.TO_TEMPLATE,
+    helpMessage: [
+      'Comma separated address list, use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    componentProps: {
+      placeholder: `请输入${ToEmailFieldsNameEnum.FROM_TEMPLATE}`,
+    },
+  },
+  {
+    field: ToEmailFieldsEnum.CC_TEMPLATE,
+    component: 'Input',
+    label: ToEmailFieldsNameEnum.CC_TEMPLATE,
+    helpMessage: [
+      'Comma separated address list, use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    componentProps: {
+      placeholder: `请输入${ToEmailFieldsNameEnum.FROM_TEMPLATE}`,
+    },
+  },
+  {
+    field: ToEmailFieldsEnum.BCC_TEMPLATE,
+    component: 'Input',
+    label: ToEmailFieldsNameEnum.BCC_TEMPLATE,
+    helpMessage: [
+      'Comma separated address list, use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    componentProps: {
+      placeholder: `请输入${ToEmailFieldsNameEnum.FROM_TEMPLATE}`,
+    },
+  },
+  {
+    field: ToEmailFieldsEnum.SUBJECT_TEMPLATE,
+    component: 'Input',
+    label: ToEmailFieldsNameEnum.SUBJECT_TEMPLATE,
+    helpMessage: [
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    componentProps: {
+      placeholder: `请输入${ToEmailFieldsNameEnum.FROM_TEMPLATE}`,
+    },
+  },
+  {
+    field: ToEmailFieldsEnum.MAIL_BODY_TYPE,
+    component: 'Select',
+    label: ToEmailFieldsNameEnum.MAIL_BODY_TYPE,
+    componentProps: ({ formActionType }) => {
+      const { setFieldsValue } = formActionType;
+      return {
+        options: [
+          { label: MailBodyTypeNameEnum.PLAIN_TEXT, value: MailBodyTypeEnum.PLAIN_TEXT },
+          { label: MailBodyTypeNameEnum.HTML, value: MailBodyTypeEnum.HTML },
+          { label: MailBodyTypeNameEnum.DYNAMIC, value: MailBodyTypeEnum.DYNAMIC },
+        ],
+        placeholder: `请选择${ToEmailFieldsNameEnum.MAIL_BODY_TYPE}`,
+        getPopupContainer: () => document.body,
+        onChange: () => {
+          setFieldsValue({ [ToEmailFieldsEnum.IS_HTML_TEMPLATE]: null });
+        },
+      };
+    },
+  },
+  {
+    field: ToEmailFieldsEnum.IS_HTML_TEMPLATE,
+    component: 'Input',
+    label: ToEmailFieldsNameEnum.IS_HTML_TEMPLATE,
+    show: ({ model }) => model[ToEmailFieldsEnum.MAIL_BODY_TYPE] === MailBodyTypeEnum.DYNAMIC,
+    helpMessage: [
+      'Hint: use ${metadataKey} for value from metadata, $[messageKey] for value from message body',
+    ],
+    componentProps: {
+      placeholder: `请输入${ToEmailFieldsNameEnum.IS_HTML_TEMPLATE}`,
+    },
+  },
+  {
+    field: ToEmailFieldsEnum.BODY_TEMPLATE,
+    component: 'InputTextArea',
+    label: ToEmailFieldsEnum.BODY_TEMPLATE,
+    componentProps: {
+      placeholder: `请输入${ToEmailFieldsNameEnum.BODY_TEMPLATE}`,
+      autoSize: { minRows: 3 },
+    },
   },
 ];

@@ -19,13 +19,17 @@ const BasicConnectionComponent = {
     import('../src/components/CreateEdgeModal/CustomRelations.vue'),
 };
 
-export const fetchNodeComponent = (key: string, flag: FetchNodeComFlagTypeENum) => {
+export const fetchNodeComponent = (config: NodeItemConfigType, flag: FetchNodeComFlagTypeENum) => {
+  const { key, categoryType } = config;
   const modules =
     flag === FetchNodeComFlagTypeENum.CONNECTION_MODAL ? connectionModules : createModules;
+
   const modulesName = Object.keys(modules);
   const path = modulesName.find((item) => {
     const temp = item.split('/');
-    return temp[temp.length - 2] === key;
+    const categoryName = temp[temp.length - 3];
+    const fileName = temp[temp.length - 2];
+    return fileName === key && categoryType.toUpperCase() === categoryName.toUpperCase();
   });
   return path ? modules[path] : null;
 };
@@ -40,8 +44,7 @@ export const fetchConnectionComponent = async (config: NodeItemConfigType) => {
 };
 
 export const fetchCreateComponent = async (config: NodeItemConfigType) => {
-  const { key } = config;
-  return fetchNodeComponent(key, FetchNodeComFlagTypeENum.CREATE_MODAL);
+  return fetchNodeComponent(config, FetchNodeComFlagTypeENum.CREATE_MODAL);
 };
 
 export const allComponents: Record<
@@ -56,14 +59,14 @@ export const allComponents: Record<
     category: EnrichmentCategoryConfig,
     components: EnrichmentComponents,
   },
-  [RuleNodeTypeEnum.ACTION]: {
-    category: ActionCategoryConfig,
-    components: ActionComponents,
-  },
   [RuleNodeTypeEnum.TRANSFORMATION]: {
     category: TransformationCategoryConfig,
     components: TransformationComponents,
   },
+  [RuleNodeTypeEnum.ACTION]: {
+    category: ActionCategoryConfig,
+    components: ActionComponents,
+  },
   [RuleNodeTypeEnum.EXTERNAL]: {
     category: ExternalCategoryConfig,
     components: ExternalComponents,

+export { default as AttributeConfiguration } from './index.vue';

+<script setup lang="ts">
+  import { Button, Tooltip, Row, Col } from 'ant-design-vue';
+  import { Icon } from '/@/components/Icon';
+  import { BasicForm, FormActionType, FormProps, FormSchema } from '/@/components/Form';
+  import { computed, ref, unref, watch } from 'vue';
+  import { buildShortUUID } from '/@/utils/uuid';
+  import { isNullOrUnDef } from '/@/utils/is';
+  import { ComponentType } from '/@/components/Form/src/types';
+
+  enum FormFieldEnum {
+    KEY = 'key',
+    VALUE = 'value',
+  }
+
+  interface ListItemType {
+    [FormFieldEnum.KEY]?: string;
+    [FormFieldEnum.VALUE]?: string;
+    uuid: string;
+  }
+
+  const props = withDefaults(
+    defineProps<{
+      value?: Recordable;
+      formProps?: FormProps;
+      hiddenInputBorder?: boolean;
+      showLabel?: boolean;
+      keyLabel?: string;
+      valueLabel?: string;
+      keyComponent?: ComponentType;
+      valueComponent?: ComponentType;
+    }>(),
+    {
+      keyComponent: 'Input',
+      valueComponent: 'Input',
+      value: () => ({}),
+      formProps: () => ({ layout: 'vertical' }),
+      showLabel: true,
+      hiddenInputBorder: true,
+    }
+  );
+
+  const emit = defineEmits(['update:value']);
+
+  const getPlaceholder = (label = '') => `请输入${label}`;
+
+  const getRules = (label = '') => {
+    return [{ required: true, message: getPlaceholder(label), trigger: ['change', 'blur'] }];
+  };
+
+  const mergeComponentProps = (label = '') => {
+    return {
+      placeholder: getPlaceholder(label),
+      onBlur: handleOnBlur,
+    };
+  };
+
+  const getSchemas = computed<FormSchema[]>(() => {
+    const { keyComponent, valueComponent, keyLabel, valueLabel } = props;
+    return [
+      {
+        field: FormFieldEnum.KEY,
+        label: '',
+        colProps: { span: 11 },
+        component: keyComponent,
+        rules: getRules(keyLabel),
+        componentProps: mergeComponentProps(keyLabel),
+      },
+      {
+        field: FormFieldEnum.VALUE,
+        label: '',
+        colProps: { span: 11, offset: 1 },
+        component: valueComponent,
+        rules: getRules(valueLabel),
+        componentProps: mergeComponentProps(valueLabel),
+      },
+    ] as FormSchema[];
+  });
+
+  const handleOnBlur = () => {
+    const value = getFieldsValue();
+
+    if (
+      unref(list).length === Object.keys(value).length &&
+      Object.values(value).some((item) => isNullOrUnDef(item))
+    )
+      return;
+    emit('update:value', value);
+  };
+
+  const list = ref<ListItemType[]>([{ uuid: buildShortUUID() }]);
+
+  const formListElRef = ref<Nullable<FormActionType>[]>([]);
+
+  const handleAdd = () => {
+    list.value.push({ uuid: buildShortUUID() });
+  };
+
+  const handleDelete = (string: string) => {
+    const index = unref(list).findIndex((item) => item.uuid === string);
+    ~index && unref(list).splice(index, 1);
+  };
+
+  const validate = async () => {
+    for (const item of unref(formListElRef)) {
+      await item?.validate();
+    }
+  };
+
+  const getFieldsValue = (): Recordable => {
+    return unref(formListElRef)
+      .map((item) => item?.getFieldsValue() as Record<FormFieldEnum, string>)
+      .reduce(
+        (prev, next) => ({ ...prev, ...(next.key ? { [next.key]: next.value } : {}) }),
+        {} as Recordable
+      );
+  };
+
+  const setFieldsValue = (record: Recordable) => {
+    const keys = Object.keys(record);
+
+    const valueList: ListItemType[] = [];
+
+    for (const key of keys) {
+      const value = record[key];
+      const itemValue: ListItemType = {
+        uuid: buildShortUUID(),
+        [FormFieldEnum.KEY]: key,
+        [FormFieldEnum.VALUE]: value,
+      };
+      valueList.push(itemValue);
+    }
+
+    list.value = valueList;
+
+    if (!list.value.length) list.value = [{ uuid: buildShortUUID() }];
+  };
+
+  watch(
+    () => props.value,
+    (value) => {
+      setFieldsValue(value);
+    },
+    {
+      immediate: true,
+    }
+  );
+
+  defineExpose({
+    validate,
+    getFieldsValue,
+    setFieldsValue,
+  });
+</script>
+
+<template>
+  <section
+    :class="[hiddenInputBorder && 'hidden-input-border', 'attribute-configuration-form']"
+    class="h-full flex flex-col"
+  >
+    <slot name="beforeForm"></slot>
+    <Row v-if="showLabel" type="flex" class="w-full h-6 font-medium">
+      <Col :span="11">{{ keyLabel }}</Col>
+      <Col :span="11" :offset="1">{{ valueLabel }}</Col>
+      <Col :span="1" />
+    </Row>
+    <section class="pr-2 overflow-x-hidden overflow-y-auto">
+      <main class="flex items-center justify-between" v-for="item in list" :key="item.uuid">
+        <BasicForm
+          ref="formListElRef"
+          :model="item"
+          class="w-full"
+          :schemas="getSchemas"
+          :showActionButtonGroup="false"
+        />
+        <Tooltip title="删除">
+          <Icon
+            icon="material-symbols:close"
+            class="cursor-pointer svg:text-2xl"
+            @click="handleDelete(item.uuid)"
+          />
+        </Tooltip>
+      </main>
+    </section>
+
+    <slot name="afterForm"></slot>
+
+    <footer>
+      <Button type="primary" class="text-light-50 mt-4 !flex items-center" @click="handleAdd">
+        <Icon icon="material-symbols:add" class="svg:text-xl" />
+        <span>添加</span>
+      </Button>
+    </footer>
+  </section>
+</template>
+
+<style lang="less" scoped>
+  .attribute-configuration-form.hidden-input-border {
+    :deep(.ant-input-affix-wrapper) {
+      @apply border-t-transparent border-l-transparent border-r-transparent;
+    }
+
+    :deep(.ant-input-affix-wrapper-focused) {
+      @apply shadow-none;
+    }
+  }
+</style>

+import { EntityTypeEnum, RelationTypeEnum } from '../../../enum/form';
+
+export enum FormFieldsEnum {
+  RELATION_TYPE = 'relationType',
+  ENTITY_TYPES = 'entityTypes',
+  UUID = 'uuid',
+}
+
+export interface ListItemType {
+  uuid?: string;
+  [FormFieldsEnum.RELATION_TYPE]: RelationTypeEnum;
+  [FormFieldsEnum.ENTITY_TYPES]: EntityTypeEnum[];
+}

+export { default as CorrelationFilters } from './index.vue';

+<script lang="ts" setup>
+  import { Card, Row, Button, Tooltip, Col, Empty } from 'ant-design-vue';
+  import { computed, nextTick, ref, toRaw, unref, watch } from 'vue';
+  import {
+    EntityTypeEnum,
+    EntityTypeNameEnum,
+    RelationTypeEnum,
+    RelationTypeNameEnum,
+  } from '../../../enum/form';
+  import { ListItemType, FormFieldsEnum } from './config';
+  import { BasicForm, FormActionType, FormSchema } from '/@/components/Form';
+  import { Icon } from '/@/components/Icon';
+  import { isArray } from '/@/utils/is';
+  import { buildShortUUID } from '/@/utils/uuid';
+
+  const props = withDefaults(
+    defineProps<{
+      value?: ListItemType[];
+      allowAddFilters?: boolean;
+      required?: boolean;
+    }>(),
+    {
+      value: () => [],
+      allowAddFilters: true,
+    }
+  );
+
+  const emit = defineEmits(['update:value', 'change']);
+
+  const list = ref<ListItemType[]>([]);
+
+  const listFormElRef = ref<Nullable<FormActionType>[]>([]);
+
+  const focusFlag = ref(false);
+
+  const getFormSchemas = computed<FormSchema[]>(() => {
+    const { required, allowAddFilters } = props;
+    return [
+      {
+        field: FormFieldsEnum.RELATION_TYPE,
+        component: 'Select',
+        label: allowAddFilters ? '' : '关联类型',
+        colProps: allowAddFilters ? { span: 11 } : undefined,
+        required,
+        componentProps: {
+          options: Object.keys(RelationTypeEnum).map((value) => ({
+            label: RelationTypeNameEnum[value],
+            value,
+          })),
+          placeholder: '请选择类型',
+          onFocus: () => (focusFlag.value = true),
+          onBlur: () => (focusFlag.value = false),
+          onChange: handleSelectChange,
+          getPopupContainer: () => document.body,
+        },
+      },
+      {
+        field: FormFieldsEnum.ENTITY_TYPES,
+        component: 'Select',
+        label: allowAddFilters ? '' : '设备类型',
+        colProps: allowAddFilters ? { span: 11, offset: 1 } : undefined,
+        required,
+        componentProps: {
+          mode: 'multiple',
+          options: Object.keys(EntityTypeEnum).map((value) => ({
+            label: EntityTypeNameEnum[value],
+            value,
+          })),
+          onFocus: () => (focusFlag.value = true),
+          onBlur: () => (focusFlag.value = false),
+          onChange: handleSelectChange,
+          placeholder: '请选择实体类型',
+          getPopupContainer: () => document.body,
+        },
+      },
+    ];
+  });
+
+  function getDefaultItem(): ListItemType {
+    return {
+      uuid: buildShortUUID(),
+      entityTypes: [],
+      relationType: RelationTypeEnum.CONTAINS,
+    };
+  }
+
+  function setFieldsValue(value: ListItemType[]) {
+    const res: ListItemType[] = [];
+    value = isArray(value) ? value : [];
+
+    for (const item of value) {
+      res.push({
+        ...item,
+        uuid: item.uuid ? item.uuid : buildShortUUID(),
+      });
+    }
+
+    if (!res.length) res.push(getDefaultItem());
+
+    list.value = res;
+  }
+
+  const handleAdd = () => {
+    emit('update:value', [...getFieldsValue(), getDefaultItem()]);
+  };
+
+  const handleDelete = (item: ListItemType) => {
+    const index = unref(list).findIndex((temp) => temp.uuid === item.uuid);
+    ~index && unref(list).splice(index, 1);
+    ~index && unref(listFormElRef).splice(index, 1);
+    emit('update:value', getFieldsValue());
+  };
+
+  const validate = async () => {
+    for (const item of unref(listFormElRef)) {
+      await item?.validate();
+    }
+
+    return getFieldsValue();
+  };
+
+  const getFieldsValue = (): ListItemType[] => {
+    return unref(listFormElRef).map((item) => ({
+      ...((item?.getFieldsValue() || {}) as ListItemType),
+      uuid: (item as any)?.model?.uuid,
+    }));
+  };
+
+  const handleSelectChange = async () => {
+    await nextTick();
+    const value = getFieldsValue();
+    emit('change', value);
+    emit('update:value', value);
+  };
+
+  watch(
+    () => props.value,
+    (target) => {
+      if (unref(focusFlag)) return;
+      setFieldsValue(toRaw(unref(target)));
+    },
+    {
+      immediate: true,
+    }
+  );
+
+  defineExpose({
+    validate,
+    setFieldsValue,
+    getFieldsValue,
+  });
+</script>
+
+<template>
+  <section class="correlation-filters-form">
+    <section v-if="allowAddFilters">
+      <Row v-if="list.length" class="w-full px-4 py-2 font-semibold">
+        <Col :span="11"> 类型 </Col>
+        <Col :span="11" :offset="1"> 实体类型 </Col>
+      </Row>
+      <Card v-for="item in list" :key="item.uuid" class="shadow-lg">
+        <main class="flex justify-between items-top">
+          <BasicForm
+            ref="listFormElRef"
+            class="w-full"
+            :schemas="getFormSchemas"
+            :model="item"
+            :showActionButtonGroup="false"
+          />
+          <Tooltip title="删除">
+            <Icon
+              icon="material-symbols:close"
+              class="svg:text-2xl cursor-pointer"
+              @click="handleDelete(item)"
+            />
+          </Tooltip>
+        </main>
+      </Card>
+
+      <Empty
+        v-if="!list.length"
+        description="任意关联"
+        :image="Empty.PRESENTED_IMAGE_SIMPLE"
+        class="text-gray-600"
+      />
+    </section>
+
+    <BasicForm
+      v-if="!allowAddFilters"
+      :schemas="getFormSchemas"
+      :model="list[0]"
+      :showActionButtonGroup="false"
+    />
+
+    <Button
+      v-if="allowAddFilters"
+      class="mt-4 !flex items-center"
+      @click="handleAdd"
+      type="primary"
+    >
+      <Icon icon="material-symbols:add" />
+      <span>添加</span>
+    </Button>
+  </section>
+</template>
+
+<style lang="less" scoped>
+  .correlation-filters-form {
+    :deep(.ant-card) {
+      & ~ .ant-card {
+        @apply mt-2;
+      }
+
+      .ant-card-body {
+        @apply p-4;
+      }
+    }
+  }
+</style>

@@ -17,18 +17,19 @@ export const TopFormSchemas: FormSchema[] = [
   {
     field: NodeBindDataFieldEnum.DEBUG_MODE,
     component: 'Checkbox',
-    label: NodeBindDataFieldNameEnum.DEBUG_MODE,
+    label: '',
     colProps: {
       offset: 2,
       span: 6,
     },
-    itemProps: {
-      labelCol: { span: 14 },
-      wrapperCol: { span: 10 },
-    },
     componentProps: {
       placeholder: `请输入${NodeBindDataFieldNameEnum.NAME}`,
     },
+    renderComponentContent: () => {
+      return {
+        default: () => NodeBindDataFieldNameEnum.DEBUG_MODE,
+      };
+    },
   },
 ];
 

 <script lang="ts" setup>
-  import { Card, Select, Tag, Form, Button, Input } from 'ant-design-vue';
-  import { ref, unref, watch } from 'vue';
+  import { Card, Select, Tag, Form, Button } from 'ant-design-vue';
+  import { ref, toRaw, unref, watch } from 'vue';
   import { MessageTypesFilterEnum, MessageTypesFilterNameEnum } from '../../../enum/form';
   import { JSONEditor } from '/@/components/CodeEditor';
-  import { buildShortUUID } from '/@/utils/uuid';
   import { Icon } from '/@/components/Icon';
   import { JavaScriptFunctionEditor } from '/@/components/Form';
   import { useJsonParse } from '/@/hooks/business/useJsonParse';
   import { useMessage } from '/@/hooks/web/useMessage';
-  import { isNullOrUnDef } from '/@/utils/is';
-
-  interface MetaDataItemType {
-    label: string;
-    value: string;
-    uuid: string;
-  }
+  import { AttributeConfiguration } from '../AttributeConfiguration';
 
   interface Value {
     msg: Recordable;
@@ -53,29 +46,17 @@
     humidity: 78,
   });
 
+  const attributeConfigurationElRef = ref<Nullable<InstanceType<typeof AttributeConfiguration>>>();
+
   const scriptContent = ref('return msg.temperature > 20;');
 
   const outputContent = ref('');
 
-  const metaData = ref<MetaDataItemType[]>([
-    { uuid: buildShortUUID(), label: 'deviceName', value: 'Test Device' },
-    { uuid: buildShortUUID(), label: 'deviceType', value: 'default' },
-    { uuid: buildShortUUID(), label: 'ts', value: Date.now().toString() },
-  ]);
-
-  const handleAddMetadata = () => {
-    metaData.value.push({ uuid: buildShortUUID(), label: '', value: '' });
-  };
-
-  const handleRemove = (data: MetaDataItemType) => {
-    const index = unref(metaData).findIndex((item) => item.uuid === data.uuid);
-    ~index && unref(metaData).splice(index, 1);
-  };
+  const metadata = ref({ deviceName: 'Test Device', deviceType: 'default', ts: Date.now() });
 
   const { createMessage } = useMessage();
-  const handleValidate = () => {
+  const handleValidate = async () => {
     const message = unref(messageContent);
-    const metadata = unref(metaData);
     const { flag } = useJsonParse(message);
 
     if (!flag) {
@@ -83,35 +64,26 @@
       return false;
     }
 
-    for (const item of metadata) {
-      const { label, value } = item;
-      if (isNullOrUnDef(label) || isNullOrUnDef(value)) {
-        createMessage.warning('元数据的键名和键值为必填项');
-        return false;
-      }
-    }
+    await unref(attributeConfigurationElRef)?.validate();
+
     return true;
   };
 
   const getValue = (): Value => {
     const msg = unref(messageContent);
     const msgType = unref(messageType);
-    const metadata = unref(metaData).reduce(
-      (prev, next) => ({ ...prev, [next.label]: next.value }),
-      {} as Recordable
-    );
     const javascriptFunction = unref(scriptContent);
-    return { msg, msgType, metadata, javascriptFunction };
-  };
 
-  const handleTestScript = () => {
-    const flag = handleValidate();
+    return { msg, msgType, metadata: toRaw(unref(metadata)), javascriptFunction };
+  };
 
+  const handleTestScript = async () => {
+    const flag = await handleValidate();
     flag && emit('test', getValue());
   };
 
-  const handleSave = () => {
-    const flag = handleValidate();
+  const handleSave = async () => {
+    const flag = await handleValidate();
     flag && emit('save', getValue());
   };
 
@@ -148,24 +120,19 @@
       </main>
       <main>
         <Card class="w-full h-full">
-          <div class="flex flex-col">
+          <div class="flex flex-col h-full">
             <div class="flex justify-between">
               <span class="text-gray-400">元数据</span>
               <Tag color="blue">元数据</Tag>
             </div>
-            <div class="mt-4 overflow-y-auto">
-              <div v-for="item in metaData" :key="item.uuid" class="flex mt-2 gap-2 items-end">
-                <Input v-model:value="item.label" placeholder="请输入键名" />
-                <Input v-model:value="item.value" placeholder="请输入键值" />
-                <Icon
-                  icon="material-symbols:close"
-                  class="svg:text-2xl cursor-pointer"
-                  @click="handleRemove(item)"
-                />
-              </div>
-            </div>
-            <div class="mt-4">
-              <Button type="primary" @click="handleAddMetadata">添加</Button>
+            <div class="pt-4 flex-auto">
+              <AttributeConfiguration
+                ref="attributeConfigurationElRef"
+                v-model:value="metadata"
+                keyLabel="键名"
+                valueLabel="键值"
+                :showLabel="false"
+              />
             </div>
           </div>
         </Card>

 <script lang="ts" setup>
   import { BasicModal, useModalInner } from '/@/components/Modal';
-  import ScriptFilterTest from './ScriptFilterTest.vue';
+  import JavaScriptFilterTest from './JavaScriptFilterTest.vue';
   import { MessageTypesFilterEnum } from '../../../enum/form';
   import { ref } from 'vue';
   import { JavaScriptFunctionEditor } from '/@/components/Form';
@@ -42,7 +42,7 @@
     :showOkBtn="false"
     :footer="null"
   >
-    <ScriptFilterTest
+    <JavaScriptFilterTest
       :javaScriptEditorProps="javaScriptEditorProps"
       :value="value"
       @cancel="closeModal()"

 <script setup lang="ts">
   import { JavaScriptFunctionEditor } from '/@/components/Form';
   import { Button } from 'ant-design-vue';
-  import FilterModal from './FilterModal.vue';
+  import JavaScriptTestModal from './JavaScriptTestModal.vue';
   import { useModal } from '/@/components/Modal';
   import { DataActionModeEnum } from '/@/enums/toolEnum';
   import { computed } from 'vue';
@@ -49,7 +49,7 @@
   <section>
     <JavaScriptFunctionEditor v-model:value="getValue" v-bind="javaScriptEditorProps" />
     <Button class="mt-4" type="primary" @click="handleOpen">{{ buttonName }}</Button>
-    <FilterModal
+    <JavaScriptTestModal
       :javaScriptEditorProps="javaScriptEditorProps"
       @register="register"
       @save="handleSave"

+export { default as JavaScriptTestModal } from './JavaScriptTestModal.vue';
+export { default as JavascriptEditorWithTestModal } from './JavascriptEditorWithTestModal.vue';
+export { default as JavaScriptFilterTest } from './JavaScriptFilterTest.vue';

+import { DirectionEnum, DirectionNameEnum } from '../../../enum/form';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
+import { CorrelationFilters } from '../CorrelationFilters';
+import { ListItemType } from '../CorrelationFilters/config';
+
+useComponentRegister('CorrelationFilters', CorrelationFilters);
+
+export enum RelationsQueryFormFieldsEnum {
+  FETCH_LAST_LEVEL_ONLY = 'fetchLastLevelOnly',
+  DIRECTION = 'direction',
+  MAX_LEVEL = 'maxLevel',
+  FILTERS = 'filters',
+}
+
+export enum RelationsQueryFormFieldsNameEnum {
+  FETCH_LAST_LEVEL_ONLY = '仅获取最后一级关联',
+  DIRECTION = '方向',
+  MAX_LEVEL = 'Max relation level',
+  FILTERS = '关联筛选器',
+}
+
+export interface ValueType {
+  [RelationsQueryFormFieldsEnum.DIRECTION]?: DirectionEnum;
+  [RelationsQueryFormFieldsEnum.FILTERS]?: ListItemType[];
+  [RelationsQueryFormFieldsEnum.FETCH_LAST_LEVEL_ONLY]?: boolean;
+  [RelationsQueryFormFieldsEnum.MAX_LEVEL]?: number;
+}
+
+export const getFormSchemas = (allowAddFilters: boolean): FormSchema[] => {
+  return [
+    {
+      field: RelationsQueryFormFieldsEnum.FETCH_LAST_LEVEL_ONLY,
+      component: 'Checkbox',
+      label: '',
+      required: true,
+      renderComponentContent: () => ({
+        default: () => RelationsQueryFormFieldsNameEnum.FETCH_LAST_LEVEL_ONLY,
+      }),
+    },
+    {
+      field: RelationsQueryFormFieldsEnum.DIRECTION,
+      component: 'Select',
+      label: RelationsQueryFormFieldsNameEnum.DIRECTION,
+      colProps: { span: 12 },
+      required: true,
+      componentProps: {
+        options: Object.keys(DirectionEnum).map((value) => ({
+          label: DirectionNameEnum[value],
+          value,
+        })),
+        getPopupContainer: () => document.body,
+        placeholder: `请选择${RelationsQueryFormFieldsNameEnum.DIRECTION}`,
+        componentProps: {},
+      },
+    },
+    {
+      field: RelationsQueryFormFieldsEnum.MAX_LEVEL,
+      label: RelationsQueryFormFieldsNameEnum.MAX_LEVEL,
+      component: 'InputNumber',
+      colProps: { span: 12 },
+      required: true,
+      componentProps: {
+        min: 1,
+      },
+    },
+    {
+      field: RelationsQueryFormFieldsEnum.FILTERS,
+      label: allowAddFilters ? RelationsQueryFormFieldsNameEnum.FILTERS : '',
+      component: 'CorrelationFilters',
+      valueField: 'value',
+      changeEvent: 'update:value',
+      slot: RelationsQueryFormFieldsEnum.FILTERS,
+    },
+  ];
+};

+export { default as RelationsQuery } from './index.vue';

+<script lang="ts" setup>
+  import { onMounted, ref, toRaw, unref, watch } from 'vue';
+  import { getFormSchemas, RelationsQueryFormFieldsEnum, ValueType } from './config';
+  import { BasicForm, useForm } from '/@/components/Form';
+  import { CorrelationFilters } from '../CorrelationFilters';
+  import { FormFieldsEnum as CorrelationFiltersFormFieldsEnum } from '../CorrelationFilters/config';
+
+  const props = withDefaults(
+    defineProps<{
+      value?: ValueType;
+      allowAddFilters?: boolean;
+    }>(),
+    {
+      value: () => ({}),
+      allowAddFilters: true,
+    }
+  );
+
+  const correlationFiltersElRef = ref<Nullable<InstanceType<typeof CorrelationFilters>>>();
+
+  const [register, formactionType] = useForm({
+    showActionButtonGroup: false,
+    schemas: getFormSchemas(props.allowAddFilters),
+  });
+
+  watch(
+    () => props.value,
+    (target) => {
+      setFieldsValue(toRaw(unref(target)));
+    }
+  );
+
+  onMounted(() => {
+    setFieldsValue(toRaw(unref(props.value)));
+  });
+
+  const getFieldsValue = () => {
+    const value = formactionType.getFieldsValue();
+    const correlationValue = unref(correlationFiltersElRef)?.getFieldsValue();
+    return {
+      ...value,
+      [RelationsQueryFormFieldsEnum.FILTERS]: correlationValue?.map((item) => ({
+        [CorrelationFiltersFormFieldsEnum.ENTITY_TYPES]:
+          item[CorrelationFiltersFormFieldsEnum.ENTITY_TYPES],
+        [CorrelationFiltersFormFieldsEnum.RELATION_TYPE]:
+          item[CorrelationFiltersFormFieldsEnum.RELATION_TYPE],
+      })),
+    };
+  };
+
+  const setFieldsValue = (value?: ValueType) => {
+    formactionType.setFieldsValue(value);
+    unref(correlationFiltersElRef)?.setFieldsValue(
+      value?.[RelationsQueryFormFieldsEnum.FILTERS] || []
+    );
+  };
+
+  const validate = async () => {
+    await formactionType.validate();
+    await unref(correlationFiltersElRef)?.validate();
+
+    return getFieldsValue();
+  };
+
+  defineExpose({
+    getFieldsValue,
+    setFieldsValue,
+    validate,
+  });
+</script>
+
+<template>
+  <BasicForm @register="register">
+    <template #filters="{ field, model }">
+      <CorrelationFilters
+        ref="correlationFiltersElRef"
+        v-model:value="model[field]"
+        :allowAddFilters="allowAddFilters"
+      />
+    </template>
+  </BasicForm>
+</template>

@@ -84,6 +84,7 @@
     showOkBtn
     @ok="handleModalOk"
     @close="handleCancel"
+    wrapper-class-name="rule-node-update-drawer"
   >
     <template #title>
       <h2 class="font-bold text-2xl truncate">{{ nodeData?.data?.name }}</h2>
@@ -96,7 +97,7 @@
     <Tabs>
       <Tabs.TabPane :tab="TabsPanelNameEnum[TabsPanelEnum.DETAIL]" :key="TabsPanelEnum.DETAIL">
         <Spin :spinning="spinning">
-          <section v-if="shadowComponent" class="w-full h-full">
+          <section v-if="shadowComponent" class="w-full h-full overflow-y-auto">
             <BasicForm @register="topFormRegister" @vue:mounted="handleTopFormMounted" />
             <component
               class="rule-node-form"
@@ -129,3 +130,35 @@
     }
   }
 </style>
+
+<style lang="less">
+  .rule-node-update-drawer {
+    .ant-drawer-wrapper-body {
+      @apply flex flex-col;
+
+      .ant-drawer-body {
+        @apply flex flex-auto overflow-hidden;
+
+        .ant-tabs-bar {
+          box-shadow: 6px -1px 9px 3px #00000040;
+        }
+
+        .scroll-container {
+          .scrollbar__wrap {
+            .scrollbar__view {
+              @apply h-full;
+
+              .ant-tabs {
+                @apply h-full flex flex-col;
+
+                .ant-tabs-content {
+                  @apply flex-auto overflow-x-hidden overflow-y-auto pr-4;
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+</style>