Merge branch 'main_dev' into ft

@@ -5,22 +5,28 @@
     "public/resource/tinymce/langs"
   ],
   "cSpell.words": [
+    "ACKS",
+    "clazz",
     "Cmds",
     "COAP",
     "echarts",
     "edrx",
-    "EFENTO", 
+    "EFENTO",
     "fingerprintjs",
     "flvjs",
-    "flvjs",
     "inited",
     "liveui",
     "MQTT",
+    "noconflict",
     "notif",
     "PROTOBUF",
+    "Rabbitmq",
     "rtsp",
     "SCADA",
+    "SMTPS",
     "SNMP",
+    "TSLV",
+    "UNACK",
     "unref",
     "vben",
     "videojs",

+import { NodeItemConfigType } from '/@/views/rule/designer/types/node';
+
+export const components: Partial<
+  NodeItemConfigType & { id: { id: string }; createdTime: number; actions: any }
+>[] = [];

+import { join } from 'path';
+import { pathExists, ensureFile, writeFile } from 'fs-extra';
+import { NodeItemConfigType } from '/@/views/rule/designer/types/node';
+import { camelCase, upperFirst, snakeCase } from 'lodash-es';
+import { components } from './components';
+type GroupNodeType = { [key: string]: NodeItemConfigType[] };
+
+const RULE_CHAIN_FILE_PATH = join(process.cwd(), '/src/views/rule/designer');
+
+const list: NodeItemConfigType[] = components;
+
+const getCategoryConfigName = (name: string) => {
+  return `${upperFirst(camelCase(name))}CategoryConfig`;
+};
+
+const getNodeConfigName = (name: string) => {
+  return `${upperFirst(camelCase(name))}Config`;
+};
+
+const getCagegoryEnumName = (name: string) => {
+  return `${upperFirst(name.toLowerCase())}CategoryComponentEnum`;
+};
+
+const getEnumKeyName = (name: string) => {
+  return snakeCase(name).toUpperCase();
+};
+
+const createFile = async (fileName: string, fileContent?: string, replace = false) => {
+  const path = join(RULE_CHAIN_FILE_PATH, './packages', fileName);
+
+  const flag = await pathExists(path);
+
+  if (flag && !replace) return false;
+
+  await ensureFile(path);
+
+  fileContent && (await writeFile(path, fileContent, { encoding: 'utf-8' }));
+};
+
+const groupByType = () => {
+  const group: { [key: string]: NodeItemConfigType[] } = {};
+
+  list.forEach((item) => {
+    if (!group[item.type]) group[item.type] = [];
+    group[item.type].push(item);
+  });
+
+  return group;
+};
+
+const generateCategoryEnumFile = async (data: GroupNodeType) => {
+  const defaultContent = `
+export enum EntryCategoryComponentEnum {
+  INPUT = 'Input',
+}
+  `;
+
+  const fileContent = Object.keys(data).reduce((prev, next) => {
+    const enumName = getCagegoryEnumName(next);
+
+    const enumKeys = data[next].map((item) => getEnumKeyName(item.name));
+
+    const content = `export enum ${enumName} {
+        ${enumKeys.map((name) => `${name} = '${upperFirst(camelCase(name))}'`)}
+    }`;
+
+    return `${prev} \n ${content}`;
+  }, defaultContent);
+
+  createFile('../enum/category.ts', fileContent, true);
+  return fileContent;
+};
+
+const generateRuleNodeEnumFile = async (data: GroupNodeType) => {
+  const categoryKeys = Object.keys(data).map((type) => type.toUpperCase());
+  const filePath = join(RULE_CHAIN_FILE_PATH, './packages/index.type.ts');
+  const fileContent = `
+export enum RuleNodeTypeEnum {
+  ${categoryKeys.map((item) => `${item} = '${item}'`).join(',\n')}
+}  
+  `;
+
+  await writeFile(filePath, fileContent, {
+    encoding: 'utf-8',
+  });
+
+  return fileContent;
+};
+
+const generateCategoryIndexFile = async (type: string, data: NodeItemConfigType[]) => {
+  const getComponentsName = data.map((temp) => `${upperFirst(camelCase(temp.name))}`);
+  const importContent = getComponentsName.map(
+    (name) => `import { ${name}Config } from './${name}';\n`
+  );
+
+  const components = getComponentsName.map((item) => `${item}Config`);
+
+  const content = `import type { CategoryConfigType, NodeItemConfigType } from '../../types/node';
+import { RuleNodeTypeEnum } from '../index.type';
+${importContent.join('')}
+
+export const ${getCategoryConfigName(type)}: CategoryConfigType = {
+  category: RuleNodeTypeEnum.${type.toUpperCase()},
+  title: '${type}',
+  icon: 'tabler:circuit-ground',
+  description: '使用配置条件筛选传入消息',
+};
+
+export const ${upperFirst(type.toLowerCase())}Components: NodeItemConfigType[] = [${components}];
+`;
+
+  createFile(`./${upperFirst(type.toLowerCase())}/index.ts`, content, true);
+
+  return content;
+};
+
+const generateNodeIndexFile = async (type: string, data: NodeItemConfigType) => {
+  const categoryEnumName = getCagegoryEnumName(type);
+
+  const nodeConfigName = getNodeConfigName(data.name);
+
+  const content = `
+  import { ${categoryEnumName} } from '../../../enum/category';
+  import { useCreateNodeKey } from '../../../hook/useCreateNodeKey';
+  import type { NodeItemConfigType } from '../../../types/node';
+  import { RuleNodeTypeEnum } from '../../index.type';
+
+  const keys = useCreateNodeKey(${categoryEnumName}.${getEnumKeyName(data.name)});
+
+  export interface ${upperFirst(camelCase(data.name))}DataType {
+    someConfiguration?: Recordable
+  }
+
+  export const ${nodeConfigName}: NodeItemConfigType = {
+    ...keys,
+    clazz: '${data.clazz}',
+    categoryType: RuleNodeTypeEnum.${type.toUpperCase()},
+    name: '${data.name}',
+    configurationDescriptor: ${JSON.stringify(data.configurationDescriptor, null, 2)}
+  };
+  `;
+
+  createFile(
+    `./${upperFirst(type.toLowerCase())}/${upperFirst(camelCase(data.name))}/index.ts`,
+    content
+  );
+
+  return content;
+};
+
+const generateNodeVueTemplateFile = async (type: string, data: NodeItemConfigType) => {
+  const content = `
+  <script lang="ts" setup>
+    import type { CreateModalDefineExposeType } from '../../../types';
+    import { BasicForm, useForm } from '/@/components/Form';
+    import { formSchemas } from './create.config';
+    import { NodeData } from '../../../types/node';
+
+    defineProps<{
+      config: NodeData;
+    }>();
+
+    const [register, { validate, getFieldsValue, setFieldsValue, resetFields }] = useForm({
+      schemas: formSchemas,
+      showActionButtonGroup: false,
+    });
+
+    const getValue: CreateModalDefineExposeType['getFieldsValue'] = async () => {
+      await validate();
+      const value = getFieldsValue() || {};
+      return value;
+    };
+
+    const setValue: CreateModalDefineExposeType['setFieldsValue'] = (value) => {
+      resetFields();
+      setFieldsValue(value);
+    };
+
+    defineExpose({
+      setFieldsValue: setValue,
+      getFieldsValue: getValue,
+    } as CreateModalDefineExposeType);
+  </script>
+
+  <template>
+    <BasicForm @register="register" />
+  </template>
+  `;
+
+  createFile(
+    `./${upperFirst(type.toLowerCase())}/${upperFirst(camelCase(data.name))}/create.vue`,
+    content
+  );
+  return content;
+};
+
+const generateNodeVueConfigFile = async (type: string, data: NodeItemConfigType) => {
+  const content = `
+  import { NodeBindDataFieldEnum, NodeBindDataFieldNameEnum } from '../../../enum/node';
+  import { FormSchema } from '/@/components/Form';
+
+  export const formSchemas: FormSchema[] = [
+    {
+      field: NodeBindDataFieldEnum.NAME,
+      component: 'Input',
+      label: NodeBindDataFieldNameEnum.NAME,
+    }
+  ];
+  `;
+
+  createFile(
+    `./${upperFirst(type.toLowerCase())}/${upperFirst(camelCase(data.name))}/create.config.ts`,
+    content
+  );
+  return content;
+};
+
+const generateNodeConfigFile = async (type: string, data: NodeItemConfigType) => {
+  const nodeConfigName = getNodeConfigName(data.name);
+  const categoryConfigName = getCategoryConfigName(type);
+  const content = `
+  import { cloneDeep } from 'lodash-es';
+  import { PublicNodeItemClass } from '../../../types/node';
+  import type {
+    CategoryConfigType,
+    CreateComponentType,
+    NodeItemConfigType,
+  } from '../../../types/node';
+  import { ${categoryConfigName} } from '..';
+  import { ${nodeConfigName} } from '.';
+
+  export class Config extends PublicNodeItemClass implements CreateComponentType {
+    public config: NodeItemConfigType = cloneDeep(${nodeConfigName});
+
+    public categoryConfig: CategoryConfigType = cloneDeep(${categoryConfigName});
+
+    constructor() {
+      super();
+    }
+  }
+  `;
+
+  createFile(
+    `./${upperFirst(type.toLowerCase())}/${upperFirst(camelCase(data.name))}/config.ts`,
+    content
+  );
+  return content;
+};
+
+const bootstrap = async () => {
+  const groupData = groupByType();
+  await generateRuleNodeEnumFile(groupData);
+  await generateCategoryEnumFile(groupData);
+  for (const type of Object.keys(groupData)) {
+    const item = groupData[type];
+    await generateCategoryIndexFile(type, item);
+    for (const temp of item) {
+      await generateNodeConfigFile(type, temp);
+      await generateNodeIndexFile(type, temp);
+      await generateNodeVueConfigFile(type, temp);
+      await generateNodeVueTemplateFile(type, temp);
+    }
+  }
+};
+
+bootstrap();

@@ -32,13 +32,18 @@
     "reinstall": "rimraf yarn.lock && rimraf package.lock.json && rimraf node_modules && npm run bootstrap",
     "prepare": "husky install",
     "gen:icon": "esno ./build/generate/icon/index.ts",
-    "gen:iconfont": "esno ./build/generate/iconfont/index.ts"
+    "gen:iconfont": "esno ./build/generate/iconfont/index.ts",
+    "gen:rule": "esno ./build/generate/ruleChain/index.ts && npx eslint \"src/views/rule/designer/**/*.{vue,ts,tsx}\" --fix"
   },
   "dependencies": {
     "@fingerprintjs/fingerprintjs": "^3.4.1",
     "@iconify/iconify": "^2.0.3",
     "@logicflow/core": "^0.6.9",
     "@logicflow/extension": "^0.6.9",
+    "@vue-flow/background": "^1.2.0",
+    "@vue-flow/controls": "^1.1.0",
+    "@vue-flow/core": "^1.22.1",
+    "@vue-flow/node-toolbar": "^1.1.0",
     "@vueuse/core": "^10.1.0",
     "@zxcvbn-ts/core": "^1.0.0-beta.0",
     "ace-builds": "^1.4.14",
@@ -53,6 +58,7 @@
     "flv.js": "^1.6.2",
     "hls.js": "^1.0.10",
     "intro.js": "^4.1.0",
+    "js-beautify": "^1.14.9",
     "jsoneditor": "^9.7.2",
     "jwt-decode": "^3.1.2",
     "lodash-es": "^4.17.21",
@@ -68,7 +74,7 @@
     "vditor": "^3.8.6",
     "video.js": "^7.20.3",
     "videojs-flvjs-es6": "^1.0.1",
-    "vue": "3.2.31",
+    "vue": "3.3.4",
     "vue-i18n": "9.1.7",
     "vue-json-pretty": "^2.0.4",
     "vue-router": "^4.0.11",

+import { DeviceInfoItemType, DeviceTypeItem, PageParams } from './model';
+import { TBPaginationResult } from '/#/axios';
+import { defHttp } from '/@/utils/http/axios';
+
+enum Api {
+  GET_DEVICE_INFOS = '/tenant/deviceInfos',
+  GET_DEVICE_TYPE = '/device/types',
+  TENANT_QUEUE = '/tenant/queues',
+}
+
+enum Entity {
+  DEVICES = '/tenant/devices',
+  ASSETS = '/tenant/assets',
+  ENTITY_VIEW = '/tenant/entityViews',
+  TENANT = '/tenant',
+  CUSTOMER = '/customers',
+  DASHBOARD = '/tenant/dashboards',
+  USER = '/users',
+  EDGE = '/tenant/edges',
+}
+
+export const getDeviceInfos = () => {
+  return defHttp.get<TBPaginationResult<DeviceInfoItemType>>(
+    {
+      url: Api.GET_DEVICE_INFOS,
+    },
+    { joinPrefix: false }
+  );
+};
+
+export const getDeviceTypes = () => {
+  return defHttp.get<TBPaginationResult<DeviceTypeItem[]>>(
+    {
+      url: Api.GET_DEVICE_TYPE,
+    },
+    { joinPrefix: false }
+  );
+};
+
+export const getTenantQueue = (params: Recordable) => {
+  return defHttp.get<string[]>(
+    {
+      url: Api.TENANT_QUEUE,
+      params,
+    },
+    { joinPrefix: false }
+  );
+};
+
+export const getEntityDevice = (params: PageParams) => {
+  return defHttp.get(
+    {
+      url: Entity.DEVICES,
+      params,
+    },
+    {
+      joinPrefix: false,
+    }
+  );
+};
+
+export const getEntityAssets = (params: PageParams) => {
+  return defHttp.get(
+    {
+      url: Entity.ASSETS,
+      params,
+    },
+    {
+      joinPrefix: false,
+    }
+  );
+};
+
+export const getEntityViews = (params: PageParams) => {
+  return defHttp.get(
+    {
+      url: Entity.ENTITY_VIEW,
+      params,
+    },
+    {
+      joinPrefix: false,
+    }
+  );
+};
+
+export const getEntityTenant = (params: Record<'tenantId', string>) => {
+  return defHttp.get(
+    {
+      url: `${Entity.TENANT}/${params.tenantId}`,
+      params,
+    },
+    {
+      joinPrefix: false,
+    }
+  );
+};
+
+export const getEntityCustomer = (params: PageParams) => {
+  return defHttp.get(
+    {
+      url: Entity.CUSTOMER,
+      params,
+    },
+    {
+      joinPrefix: false,
+    }
+  );
+};
+
+export const getEntityUser = (params: PageParams) => {
+  return defHttp.get(
+    {
+      url: Entity.USER,
+      params,
+    },
+    {
+      joinPrefix: false,
+    }
+  );
+};
+
+export const getEntityDashboard = (params: PageParams) => {
+  return defHttp.get(
+    {
+      url: Entity.DASHBOARD,
+      params,
+    },
+    {
+      joinPrefix: false,
+    }
+  );
+};
+
+export const getEntityEdge = (params: PageParams) => {
+  return defHttp.get(
+    {
+      url: Entity.EDGE,
+      params,
+    },
+    {
+      joinPrefix: false,
+    }
+  );
+};

+export interface DeviceInfoItemType {
+  id: Id;
+  createdTime: number;
+  additionalInfo: AdditionalInfo;
+  tenantId: Id;
+  customerId: Id;
+  name: string;
+  type: string;
+  label: string;
+  deviceProfileId: Id;
+  deviceData: DeviceData;
+  firmwareId: any;
+  softwareId: any;
+  customerTitle: any;
+  customerIsPublic: boolean;
+  deviceProfileName: string;
+}
+
+export interface Id {
+  entityType: string;
+  id: string;
+}
+
+export interface DeviceData {
+  configuration: Configuration;
+  transportConfiguration: TransportConfiguration;
+}
+
+export interface AdditionalInfo {
+  gateway: boolean;
+  description: string;
+  overwriteActivityTime: boolean;
+}
+export interface Configuration {
+  type: string;
+}
+
+export interface TransportConfiguration {
+  type: string;
+}
+
+export interface DeviceTypeItem {
+  tenantId: Id;
+  entityType: string;
+  type: string;
+}
+
+export interface PageParams {
+  pageSize?: number;
+  page?: number;
+  textSearch?: string;
+  sortProperty?: string;
+  sortOrder?: string;
+}

+import { RuleChainPaginationItemType } from './model/type';
+import { TBPaginationResult } from '/#/axios';
+import { defHttp } from '/@/utils/http/axios';
+import { RuleChainDetail, RuleChainType } from '/@/views/rule/designer/types/ruleNode';
+
+enum Api {
+  GET_RULE_CHAINS_DETAIL = '/ruleChain',
+  SAVE = '/ruleChain/metadata',
+  GET_RULE_CHAINES = '/ruleChains',
+  GET_RULE_NODE_EVENTS = '/events/RULE_NODE',
+}
+
+export const getRuleChainDetail = (id: string) => {
+  return defHttp.get<RuleChainDetail>(
+    {
+      url: `${Api.GET_RULE_CHAINS_DETAIL}/${id}`,
+    },
+    { joinPrefix: false }
+  );
+};
+
+export const getRuleChainData = (id: string) => {
+  return defHttp.get<RuleChainType>(
+    {
+      url: `/ruleChain/${id}/metadata`,
+    },
+    { joinPrefix: false }
+  );
+};
+
+export const saveRuleChainData = (data: RuleChainType) => {
+  return defHttp.post(
+    {
+      url: Api.SAVE,
+      data,
+    },
+    { joinPrefix: false }
+  );
+};
+
+export const getRuleChains = (params: Recordable) => {
+  return defHttp.get<TBPaginationResult<RuleChainPaginationItemType>>(
+    {
+      url: Api.GET_RULE_CHAINES,
+      params,
+    },
+    {
+      joinPrefix: false,
+    }
+  );
+};
+
+export const getRuleNodeEventList = (
+  ruleNodeId: string,
+  params: Recordable,
+  data: Recordable & Record<'eventType', string>
+) => {
+  return defHttp.post<TBPaginationResult>(
+    {
+      url: `${Api.GET_RULE_NODE_EVENTS}/${ruleNodeId}`,
+      params,
+      data,
+    },
+    { joinPrefix: false }
+  );
+};

+export interface RuleChainPaginationItemType {
+  id: Id;
+  createdTime: number;
+  additionalInfo?: AdditionalInfo;
+  tenantId: Id;
+  name: string;
+  type: string;
+  firstRuleNodeId: Id;
+  root: boolean;
+  debugMode: boolean;
+  configuration: any;
+}
+
+export interface Id {
+  entityType: string;
+  id: string;
+}
+
+export interface AdditionalInfo {
+  description: string;
+}

@@ -22,6 +22,8 @@ enum ScreenManagerApi {
   GET_ATTRBUTELIST = '/device/attributes/',
   ALARM_PROFILE = '/alarm/profile/',
   MASTER_GET_DEVICE = '/device/list',
+  RULE_CHAINS = '/ruleChains',
+  RULE_CHAIN = '/ruleChain',
 }
 
 /**
@@ -130,3 +132,45 @@ export const byOrganizationIdGetMasterDevice = (params: {
   });
 };
 //TODO-fengtao
+
+/**
+ * 分页查询规则链库
+ */
+
+export const getRuleChinsList = (params) => {
+  return defHttp.get(
+    {
+      url: `${ScreenManagerApi.RULE_CHAINS}`,
+      params,
+    },
+    { joinPrefix: false }
+  );
+};
+
+/**
+ * 新增规则链
+ */
+
+export const createRuleChine = (params) => {
+  return defHttp.post(
+    {
+      url: `${ScreenManagerApi.RULE_CHAIN}`,
+      params,
+    },
+    { joinPrefix: false }
+  );
+};
+
+/**
+ * 删除规则链
+ */
+
+export const deleteRuleChine = (params) => {
+  return defHttp.delete(
+    {
+      url: `${ScreenManagerApi.RULE_CHAIN}/`,
+      params,
+    },
+    { joinPrefix: false }
+  );
+};

 <script lang="ts" setup>
-  import { ref, watch } from 'vue';
-  import JSONEditor, { JSONEditorOptions } from 'jsoneditor';
-  import 'jsoneditor/dist/jsoneditor.min.css';
-  import { unref } from 'vue';
-  import { onMounted } from 'vue';
-  import { computed } from '@vue/reactivity';
-  import { onUnmounted } from 'vue';
+  import { onMounted, computed, onUnmounted, unref, ref, watch } from 'vue';
+  import { Tooltip } from 'ant-design-vue';
+  import { Icon } from '/@/components/Icon';
+  import { useFullscreen } from '@vueuse/core';
+  import { isNumber, isObject, isString } from '/@/utils/is';
+  import AceEditor, { Ace } from 'ace-builds';
+  import workerJsonUrl from 'ace-builds/src-noconflict/worker-json?url';
+  import githubTheme from 'ace-builds/src-noconflict/theme-github?url';
+  import 'ace-builds/src-noconflict/mode-json';
 
   enum EventEnum {
     UPDATE_VALUE = 'update:value',
@@ -16,89 +18,134 @@
 
   const props = withDefaults(
     defineProps<{
-      value?: string;
-      options?: JSONEditorOptions;
-      height?: number;
+      value?: string | Recordable;
+      height?: number | string;
+      title?: string;
+      disabled?: boolean;
     }>(),
     {
-      options: () =>
-        ({
-          mode: 'code',
-          mainMenuBar: false,
-          statusBar: false,
-        } as JSONEditorOptions),
       height: 150,
     }
   );
 
   const emit = defineEmits<{
-    (e: EventEnum.UPDATE_VALUE, value: any, instance?: JSONEditor): void;
-    (e: EventEnum.CHANGE, value: any, instance?: JSONEditor): void;
-    (e: EventEnum.BLUR, event: Event, instance?: JSONEditor): void;
-    (e: EventEnum.FOCUS, event: Event, instance?: JSONEditor): void;
+    (e: EventEnum.UPDATE_VALUE, value: any, instance?: Ace.Editor): void;
+    (e: EventEnum.CHANGE, value: any, instance?: Ace.Editor): void;
+    (e: EventEnum.BLUR, event: Event, instance?: Ace.Editor): void;
+    (e: EventEnum.FOCUS, event: Event, instance?: Ace.Editor): void;
   }>();
 
   const jsonEditorElRef = ref<Nullable<any>>();
 
-  const editoreRef = ref<JSONEditor>();
+  const editoreRef = ref<Ace.Editor>();
 
   const isFocus = ref(false);
 
-  const handleChange = (value: any) => {
+  const handleOnChange = () => {
+    const value = get();
     emit(EventEnum.UPDATE_VALUE, value, unref(editoreRef));
     emit(EventEnum.CHANGE, value, unref(editoreRef));
   };
 
-  const handleEmit = (event: Event, key: EventEnum) => {
-    emit(key as EventEnum[keyof EventEnum], event, unref(editoreRef));
+  const handleOnBlur = (event: Event) => {
+    isFocus.value = false;
+    emit(EventEnum.BLUR, event, unref(editoreRef));
   };
 
-  const getOptions = computed(() => {
-    const { options } = props;
-    return {
-      ...options,
-      onChangeText: handleChange,
-      onBlur: (event: Event) => {
-        isFocus.value = false;
-        handleEmit(event, EventEnum.BLUR);
-      },
-      onFocus: (event: Event) => {
-        isFocus.value = true;
-        handleEmit(event, EventEnum.FOCUS);
-      },
-    } as JSONEditorOptions;
-  });
+  const handleOnFocus = (event: Event) => {
+    isFocus.value = true;
+    emit(EventEnum.FOCUS, event, unref(editoreRef));
+  };
+
+  const getFormatValue = (value: Recordable | string = '') => {
+    return isObject(value) ? JSON.stringify(value, null, 2) : value;
+  };
 
   const initialize = () => {
-    editoreRef.value = new JSONEditor(unref(jsonEditorElRef), unref(getOptions));
+    AceEditor.config.setModuleUrl('ace/mode/json_worker', workerJsonUrl);
+    AceEditor.config.setModuleUrl('ace/theme/github', githubTheme);
+    const editor = AceEditor.edit(unref(jsonEditorElRef)!, {
+      mode: 'ace/mode/json',
+    });
+    editor.setTheme('ace/theme/github');
+    editor.setOptions({
+      fontSize: 14,
+    });
+
+    editor.on('change', handleOnChange);
+    editor.on('blur', handleOnBlur);
+    editor.on('focus', handleOnFocus);
+
+    editoreRef.value = editor;
+    unref(editoreRef)?.setValue(getFormatValue(props.value), 1);
+    unref(editoreRef)?.setReadOnly(props.disabled);
   };
 
   watch(
     () => props.value,
     (target) => {
+      // const position = unref(editoreRef)?.getCursorPosition();
       if (unref(isFocus)) return;
-      unref(editoreRef)?.setText(target || '');
+      unref(editoreRef)?.setValue(getFormatValue(target));
+      unref(editoreRef)?.clearSelection();
+      // position && unref(editoreRef)?.moveCursorToPosition(position!);
     },
     {
       immediate: true,
     }
   );
 
+  watch(
+    () => props.disabled,
+    (value) => {
+      unref(editoreRef)?.setReadOnly(value);
+    }
+  );
+
   const get = (): string => {
-    return unref(editoreRef)?.getText() || '';
+    return unref(editoreRef)?.getValue() || '';
   };
 
   const set = (data: any) => {
-    return unref(editoreRef)?.set(data);
+    return unref(editoreRef)?.setValue(getFormatValue(data));
   };
 
   onMounted(() => {
     initialize();
-    unref(editoreRef)?.setText(props.value || '');
+    unref(editoreRef)?.setValue(getFormatValue(props.value));
   });
 
   onUnmounted(() => {
+    unref(editoreRef)?.off('change', handleOnChange);
+    unref(editoreRef)?.off('blur', handleOnBlur);
+    unref(editoreRef)?.off('focus', handleOnFocus);
     unref(editoreRef)?.destroy();
+    unref(editoreRef)?.container.remove();
+  });
+
+  const handleFormat = () => {
+    const value = get();
+    if (isString(value) && !value) return;
+    unref(editoreRef)?.setValue(JSON.stringify(JSON.parse(value), null, 2));
+    unref(editoreRef)?.clearSelection();
+  };
+
+  const handleCompress = () => {
+    const value = get();
+    if (isString(value) && !value) return;
+    unref(editoreRef)?.setValue(JSON.stringify(JSON.parse(value)));
+    unref(editoreRef)?.clearSelection();
+  };
+
+  const jsonEditorContainerElRef = ref<Nullable<HTMLDivElement>>();
+  const { isFullscreen, isSupported, toggle } = useFullscreen(jsonEditorContainerElRef);
+  const handleFullScreen = () => {
+    toggle();
+  };
+
+  const getHeight = computed(() => {
+    const { height } = props;
+    return isNumber(height) ? `${height}px` : height;
   });
 
   defineExpose({
@@ -108,22 +155,41 @@
 </script>
 
 <template>
-  <div class="p-2 bg-gray-200" :style="{ height: `${height}px` }">
-    <div ref="jsonEditorElRef" class="jsoneditor"></div>
+  <div
+    ref="jsonEditorContainerElRef"
+    class="p-2 bg-gray-200 flex flex-col"
+    :style="{ height: getHeight }"
+  >
+    <div class="w-full h-8 flex justify-between items-center">
+      <div>
+        {{ title }}
+      </div>
+      <slot name="header"></slot>
+      <div class="flex h-8 gap-3 justify-end items-center text-dark-500 svg:text-2xl">
+        <slot name="beforeFormat"></slot>
+        <Tooltip title="整洁">
+          <Icon @click="handleFormat" class="cursor-pointer" icon="gg:format-left" />
+        </Tooltip>
+        <slot name="beforeCompress"></slot>
+
+        <Tooltip title="迷你">
+          <Icon @click="handleCompress" class="cursor-pointer" icon="material-symbols:compress" />
+        </Tooltip>
+        <slot name="beforeFullScreen"></slot>
+
+        <Tooltip title="全屏">
+          <Icon
+            v-if="isSupported"
+            class="cursor-pointer"
+            :icon="
+              isFullscreen ? 'material-symbols:fullscreen-exit' : 'material-symbols:fullscreen'
+            "
+            @click="handleFullScreen"
+          />
+        </Tooltip>
+        <slot name="afterFullScreen"></slot>
+      </div>
+    </div>
+    <div ref="jsonEditorElRef" class="flex-auto"></div>
   </div>
 </template>
-
-<style lang="less" scoped>
-  .jsoneditor {
-    border: none !important;
-
-    :deep(.jsoneditor) {
-      border: none !important;
-
-      .ace-jsoneditor,
-      textarea.jsoneditor-text {
-        min-height: auto;
-      }
-    }
-  }
-</style>

@@ -13,6 +13,7 @@ export { default as ApiRadioGroup } from './src/components/ApiRadioGroup.vue';
 export { default as ApiUpload } from './src/components/ApiUpload.vue';
 
 export { default as StructForm } from './src/externalCompns/components/StructForm/StructForm.vue';
+export { default as JavaScriptFunctionEditor } from './src/components/JavaScriptFunctionEditor.vue';
 
 //注册自定义组件
 export {

@@ -14,6 +14,7 @@
   import { get, omit } from 'lodash-es';
   import { LoadingOutlined } from '@ant-design/icons-vue';
   import { useI18n } from '/@/hooks/web/useI18n';
+  import { useDebounceFn } from '@vueuse/shared';
 
   const emit = defineEmits(['options-change', 'change']);
   const props = withDefaults(
@@ -27,6 +28,7 @@
       labelField?: string;
       valueField?: string;
       immediate?: boolean;
+      searchField?: string;
       queryEmptyDataAgin?: boolean;
       onChangeHook?: ({ options }: OnChangeHookParams) => void;
       dropdownVisibleChangeHook?: ({ options }: OnChangeHookParams) => void;
@@ -35,6 +37,7 @@
       resultField: '',
       labelField: 'label',
       valueField: 'value',
+      searchField: 'text',
       immediate: true,
       queryEmptyDataAgin: true,
     }
@@ -53,17 +56,27 @@
     const { labelField, valueField = 'value', numberToString } = props;
     return unref(options).reduce((prev, next: Recordable) => {
       if (next) {
-        const value = next[valueField];
+        const value = get(next, valueField);
+        const label = get(next, labelField);
         prev.push({
-          label: next[labelField],
-          value: numberToString ? `${value}` : value,
           ...omit(next, [labelField, valueField]),
+          label,
+          value: numberToString ? `${value}` : value,
         });
       }
       return prev;
     }, [] as OptionsItem[]);
   });
 
+  const getBindProps = computed(() => {
+    const { searchApi } = props;
+    return {
+      ...attrs,
+      showSearch: true,
+      filterOption: !searchApi,
+    };
+  });
+
   watchEffect(() => {
     props.immediate && fetch();
   });
@@ -122,8 +135,9 @@
     onChangeHook({ options });
   }
 
+  const debounceSearchFunction = useDebounceFn(handleSearch, 300);
   async function handleSearch(params?: string) {
-    let { searchApi, api } = props;
+    let { searchApi, api, searchField } = props;
     if (!searchApi || !isFunction(searchApi)) {
       if (!api || !isFunction(api)) return;
       searchApi = api;
@@ -131,7 +145,7 @@
     options.value = [];
     try {
       loading.value = true;
-      const res = await searchApi({ ...props.params, text: params });
+      const res = await searchApi({ ...props.params, [searchField]: params });
       if (Array.isArray(res)) {
         options.value = res;
         emitChange();
@@ -152,11 +166,10 @@
 <template>
   <Select
     @dropdownVisibleChange="handleFetch"
-    v-bind="attrs"
-    show-search
+    v-bind="getBindProps"
     @change="handleChange"
     :options="getOptions"
-    @search="handleSearch"
+    @search="debounceSearchFunction"
     v-model:value="state"
   >
     <template #[item]="data" v-for="item in Object.keys($slots)">

@@ -6,7 +6,7 @@
 <script lang="ts" setup>
   import { ref, watchEffect, computed, unref, watch, reactive } from 'vue';
   import { Select, Spin } from 'ant-design-vue';
-  import { isFunction } from '/@/utils/is';
+  import { isFunction, isNullAndUnDef } from '/@/utils/is';
   import { useRuleFormItem } from '/@/hooks/component/useFormItem';
   import { useAttrs } from '/@/hooks/core/useAttrs';
   import { get, omit } from 'lodash-es';
@@ -30,8 +30,11 @@
       labelField?: string;
       valueField?: string;
       immediate?: boolean;
-      pagenation?: Pagination;
+      searchField?: string;
+      pagination?: Pagination;
       queryEmptyDataAgin?: boolean;
+      fetchSearch?: boolean;
+      filterOption?: (inputValue: string, options: Recordable) => boolean;
     }>(),
     {
       resultField: '',
@@ -39,14 +42,15 @@
       valueField: 'value',
       immediate: true,
       queryEmptyDataAgin: true,
-      pagenation: () => ({ page: 1, pageSize: 10 }),
+      pagination: () => ({ page: 1, pageSize: 10 }),
+      fetchSearch: false,
     }
   );
 
   const OptionsItem = (_, { attrs }: { attrs: { vNode: any } }) => attrs.vNode;
 
   const options = ref<OptionsItem[]>([]);
-  const pagination = reactive(Object.assign({ total: 0, page: 1, pageSize: 10 }, props.pagenation));
+  const pagination = reactive<Record<'total' | 'page' | 'pageSize', number>>({} as any);
   const scrollLoading = ref(false);
   const lock = ref(false);
   const loading = ref(false);
@@ -55,6 +59,13 @@
   const attrs = useAttrs();
   const { t } = useI18n();
 
+  const getPagination = computed(() => {
+    return {
+      ...props.pagination,
+      ...unref(pagination),
+    };
+  });
+
   // Embedded in the form, just use the hook binding to perform form verification
   const [state] = useRuleFormItem(props, 'value', 'change', emitData);
 
@@ -86,16 +97,18 @@
     { deep: true }
   );
 
-  async function fetch() {
-    const api = props.api;
+  async function fetch(searchText?: string) {
+    const { api, searchField, fetchSearch } = props;
     if (!api || !isFunction(api)) return;
+    const isFetchSearchFlag = fetchSearch && !isNullAndUnDef(searchText) && searchField;
     try {
       !unref(getOptions).length ? (loading.value = true) : (scrollLoading.value = true);
       lock.value = true;
       const { total, items } = await api({
         ...props.params,
-        page: pagination.page,
-        pageSize: pagination.pageSize,
+        page: unref(getPagination).page,
+        pageSize: unref(getPagination).pageSize,
+        ...(isFetchSearchFlag ? { [searchField!]: searchText } : {}),
       });
 
       pagination.total = total;
@@ -105,11 +118,13 @@
         return;
       }
       if (props.resultField) {
-        options.value = [...options.value, ...(get(items, props.resultField) || [])];
+        options.value = isFetchSearchFlag
+          ? get(items, props.resultField) || []
+          : [...options.value, ...(get(items, props.resultField) || [])];
       }
       emitChange();
     } catch (error) {
-      pagination.page = Math.ceil(unref(getOptions).length / pagination.pageSize);
+      pagination.page = Math.ceil(unref(getOptions).length / unref(getPagination).pageSize);
       console.warn(error);
     } finally {
       isFirstLoad.value = false;
@@ -134,17 +149,39 @@
     emitData.value = args;
   }
 
+  const sleep = async (number: number) => {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(number);
+      }, number);
+    });
+  };
+
   async function handlePopupScroll(event: MouseEvent) {
     const { scrollHeight, scrollTop, clientHeight } = event.target as HTMLDivElement;
     if (scrollTop + clientHeight >= scrollHeight) {
-      if (unref(getOptions).length < pagination.total && !unref(lock)) {
-        pagination.page = pagination.page + 1;
+      if (unref(getOptions).length < unref(getPagination).total && !unref(lock)) {
+        pagination.page = unref(getPagination).page + 1;
+        scrollLoading.value = true;
+        await sleep(500);
         await fetch();
       }
     }
   }
 
   const debounceHandlePopupScroll = useDebounceFn(handlePopupScroll, 100);
+
+  const handleFilterOption = async (inputValue: string, option: Recordable) => {
+    const { filterOption, fetchSearch } = props;
+    if (filterOption && isFunction(filterOption)) {
+      filterOption?.(inputValue, option);
+      return;
+    }
+
+    if (fetchSearch) {
+      await fetch(inputValue);
+    }
+  };
 </script>
 
 <template>
@@ -153,6 +190,8 @@
     v-bind="attrs"
     @change="handleChange"
     :options="getOptions"
+    :filterOption="handleFilterOption"
+    :showSearch="true"
     v-model:value="state"
     @popup-scroll="debounceHandlePopupScroll"
   >

@@ -40,16 +40,19 @@
       accept?: string;
       maxSize?: number;
       disabled?: boolean;
-      listType?: string;
+      listType?: 'text' | 'picture-card' | 'picture';
       multiple?: boolean;
       maxFileLimit?: number;
-      showUploadList?: boolean | { showPreviewIcon?: boolean; showRemoveIcon?: boolean };
+      showUploadList?: InstanceType<typeof Upload>['$props']['showUploadList'];
       transformFile?: (file: File) => string | Blob | Promise<string | Blob | File>;
       api: (file: string | Blob | Promise<string | Blob | File>) => Promise<FileItem>;
+      overFileLimitHiddenUploadEntry?: boolean;
     }>(),
     {
       fileList: () => [],
       maxSize: 5 * 1024 * 1024,
+      overFileLimitHiddenUploadEntry: true,
+      listType: 'text',
       showUploadList: () => ({ showPreviewIcon: true, showRemoveIcon: true }),
     }
   );
@@ -75,7 +78,7 @@
 
   const getMaxFileLimit = computed(() => {
     const { maxFileLimit } = props;
-    return isPictureCard.value ? 1 : maxFileLimit;
+    return isPictureCard.value ? 1 : maxFileLimit || 1;
   });
 
   const handleUpload = async (file: File | string | Blob | Promise<string | Blob | File>) => {
@@ -131,11 +134,15 @@
     :list-type="props.listType"
     :disabled="getDisabled"
     :before-upload="handleBeforeUpload"
+    :show-upload-list="showUploadList"
     @preview="handlePreview"
     @download="handleDownload"
     :remove="handleRemove"
   >
-    <Spin v-if="!fileList.length" :spinning="loading">
+    <Spin
+      v-if="!(fileList.length >= getMaxFileLimit) || overFileLimitHiddenUploadEntry"
+      :spinning="loading"
+    >
       <div class="w-full h-full flex flex-col justify-center content-center">
         <Tooltip title="点击上传或拖拽上传">
           <InboxOutlined class="text-[3rem] !text-blue-500" />

+<script lang="ts" setup>
+  import { Icon } from '/@/components/Icon';
+  import { Tooltip } from 'ant-design-vue';
+  import { computed, onMounted, onUnmounted, ref, shallowRef, unref, watch } from 'vue';
+  import AceEditor, { Ace } from 'ace-builds';
+  import workerJavascriptUrl from 'ace-builds/src-noconflict/worker-javascript?url';
+  import githubTheme from 'ace-builds/src-noconflict/theme-github?url';
+  import 'ace-builds/src-noconflict/mode-javascript';
+  import 'ace-builds/src-noconflict/ext-searchbox';
+  import 'ace-builds/src-noconflict/ext-language_tools';
+  import 'ace-builds/src-noconflict/snippets/javascript';
+  import { useBeautify } from '/@/hooks/business/useBeautify';
+  import { useFullscreen } from '@vueuse/core';
+  import { isNumber } from '/@/utils/is';
+
+  const emit = defineEmits(['update:value', 'focus', 'blur']);
+  const props = withDefaults(
+    defineProps<{
+      functionName?: string;
+      paramsName?: string[];
+      height?: number | string;
+      value?: string;
+      disabled?: boolean;
+      validateStatus?: boolean;
+    }>(),
+    {
+      functionName: 'method',
+      paramsName: () => [],
+      height: 200,
+      value: '',
+    }
+  );
+
+  const getHeight = computed(() => {
+    const { height } = props;
+    return isNumber(height) ? `${height}px` : height;
+  });
+
+  const javaScriptEditorElRef = ref<Nullable<HTMLDivElement>>();
+  const editorInstance = shallowRef<Ace.Editor>();
+  const isFocus = ref(false);
+
+  const handleFocus = () => {
+    isFocus.value = true;
+    emit('focus', unref(editorInstance));
+  };
+
+  const handleBlur = () => {
+    isFocus.value = false;
+    emit('update:value', get());
+    emit('blur', unref(editorInstance));
+  };
+
+  const handleChange = () => {
+    emit('update:value', get());
+  };
+
+  const initEditor = () => {
+    AceEditor.config.setModuleUrl('ace/mode/javascript_worker', workerJavascriptUrl);
+    AceEditor.config.setModuleUrl('ace/theme/github', githubTheme);
+    const editor = AceEditor.edit(unref(javaScriptEditorElRef)!, {
+      mode: 'ace/mode/javascript',
+    });
+    editor.setTheme('ace/theme/github');
+    editor.setOptions({
+      fontSize: 14,
+      enableBasicAutocompletion: true,
+      enableSnippets: true,
+      enableLiveAutocompletion: true,
+    });
+
+    editor.on('focus', handleFocus);
+    editor.on('blur', handleBlur);
+    editor.on('change', handleChange);
+    editorInstance.value = editor;
+    editor.setValue(props.value);
+    editor?.clearSelection();
+    unref(editorInstance)?.setReadOnly(props.disabled);
+  };
+
+  const get = () => {
+    return unref(editorInstance)?.getValue();
+  };
+
+  const set = (val: string, cursorPos?: number) => {
+    return unref(editorInstance)?.setValue(val, cursorPos);
+  };
+
+  onMounted(() => {
+    initEditor();
+  });
+
+  onUnmounted(() => {
+    unref(editorInstance)?.off('change', handleChange);
+    unref(editorInstance)?.off('focus', handleFocus);
+    unref(editorInstance)?.off('blur', handleBlur);
+    unref(editorInstance)?.destroy();
+    unref(editorInstance)?.container.remove();
+  });
+
+  const { beautifyJs } = useBeautify();
+  const handleFormatCode = async () => {
+    const res = await beautifyJs(get() || '', { indent_size: 4, wrap_line_length: 60 });
+    set(res || '', -1);
+  };
+
+  const jsFunctionContainerElRef = ref<Nullable<HTMLDivElement>>();
+  const { isFullscreen, isSupported, toggle } = useFullscreen(jsFunctionContainerElRef);
+  const handleFullScreen = () => {
+    toggle();
+  };
+
+  watch(
+    () => props.value,
+    (value) => {
+      // const position = unref(editorInstance)?.getCursorPosition();
+      if (unref(isFocus)) return;
+      set(value);
+      unref(editorInstance)?.clearSelection();
+      // position && unref(editorInstance)?.moveCursorToPosition(position!);
+    },
+    {
+      immediate: true,
+    }
+  );
+
+  watch(
+    () => props.disabled,
+    (value) => {
+      unref(editorInstance)?.setReadOnly(value);
+    }
+  );
+
+  defineExpose({
+    get,
+    set,
+  });
+</script>
+
+<template>
+  <section
+    ref="jsFunctionContainerElRef"
+    class="p-2 bg-gray-200 flex flex-col"
+    :style="{ height: getHeight }"
+  >
+    <head class="flex justify-between h-8 items-center">
+      <div class="font-bold">
+        <span>function</span>
+        <span class="ml-1">{{ functionName }}</span>
+        <span>({{ paramsName.join(',') }})</span>
+        <span class="ml-1">{</span>
+      </div>
+      <div class="flex gap-3 items-center svg:text-2xl">
+        <slot name="beforeFormat"></slot>
+
+        <Tooltip title="整洁">
+          <Icon class="cursor-pointer" icon="gg:format-left" @click="handleFormatCode" />
+        </Tooltip>
+        <slot name="beforeFullScreen"></slot>
+        <Tooltip title="全屏">
+          <Icon
+            v-if="isSupported"
+            class="cursor-pointer"
+            :icon="
+              isFullscreen ? 'material-symbols:fullscreen-exit' : 'material-symbols:fullscreen'
+            "
+            @click="handleFullScreen"
+          />
+        </Tooltip>
+        <slot name="afterFullScreen"></slot>
+      </div>
+    </head>
+    <main ref="javaScriptEditorElRef" class="flex-auto"> </main>
+    <footer class="font-bold">}</footer>
+  </section>
+</template>

@@ -130,4 +130,11 @@ export type ComponentType =
   | 'ControlGroup'
   | 'JSONEditor'
   | 'OrgTreeSelect'
-  | 'ExtendDesc';
+  | 'ExtendDesc'
+  | 'JavaScriptFunctionEditor'
+  | 'JavascriptEditorWithTestModal'
+  | 'AttributeConfiguration'
+  | 'CorrelationFilters'
+  | 'RelationsQuery'
+  | 'CredentialsCard'
+  | 'ApiComplete';

+export enum AlarmStatus {
+  CLEARED_UN_ACK = 'CLEARED_UNACK',
+  ACTIVE_UN_ACK = 'ACTIVE_UNACK',
+  CLEARED_ACK = 'CLEARED_ACK',
+  ACTIVE_ACK = 'ACTIVE_ACK',
+}
+
+export enum AlarmStatusMean {
+  CLEARED_UNACK = '清除未确认',
+  ACTIVE_UNACK = '激活未确认',
+  CLEARED_ACK = '清除已确认',
+  ACTIVE_ACK = '激活已确认',
+}

@@ -38,6 +38,11 @@ export const PLATFORM = 'PLATFORM';
 export const PLATFORM_INFO_CACHE_KEY = 'PLATFORM_INFO';
 
 export const MENU_LIST = 'MENU_LIST';
+
+export const RULE_NODE_LOCAL_CACHE_KEY = 'RULE__NODE__KEY__';
+
+export const RULE_NODE_KEY = 'RULE_NODE';
+
 export enum CacheTypeEnum {
   SESSION,
   LOCAL,

@@ -19,4 +19,8 @@ export enum DictEnum {
   DISABLE_CUSTOMER_AUTH = 'disabled_customer_auth',
   // 寄存器数据格式
   REGISTER_DATA_FORMAT = 'register_data_format',
+  // 消息类型 规则节点 Filter message type switch
+  MESSAGE_TYPES_FILTER = 'message_types_filter',
+  // 实体类型 规则节点 Filter originator types switch
+  ORIGINATOR_TYPES = 'originator_types',
 }

@@ -16,4 +16,6 @@ export const PageEnum = {
   DEVICE_LIST: '/device/list',
 
   SHARE_PAGE: '/share/:viewType/:id/:publicId',
+
+  RULE_CHAIN_DETAIL: '/rule/chain/:id',
 };

+import { saveOrEditDictItem } from '/@/api/system/dict';
+import { SysDictItem } from '/@/api/system/model/dictModel';
+
+interface BatchSettingParamsType {
+  dictId: string;
+  list: any[];
+  transformText: (item: any) => any;
+  transformValue: (item: any) => any;
+  update?: boolean;
+}
+
+export function useBatchSettingDict() {
+  const batchSetting = async (options: BatchSettingParamsType) => {
+    const { dictId, list, transformText, transformValue, update = false } = options;
+    if (!transformText || !transformValue) return;
+    let index = 1;
+    for (const item of list) {
+      const params: Partial<SysDictItem> & { dictId: string } = {
+        dictId,
+        sort: index++,
+        status: 1,
+        itemText: transformText(item),
+        itemValue: transformValue(item),
+      };
+
+      await saveOrEditDictItem(params as SysDictItem, update);
+    }
+  };
+
+  const batchDelete = () => {};
+
+  return {
+    batchSetting,
+    batchDelete,
+  };
+}

+export function useBeautify() {
+  let jsBeautifyModule: any;
+
+  async function loadJsBeautify() {
+    if (jsBeautifyModule) return jsBeautifyModule;
+    jsBeautifyModule = await import('js-beautify/js/lib/beautifier');
+    return jsBeautifyModule;
+  }
+
+  async function beautifyJs(source: string, options?: any) {
+    const module = await loadJsBeautify();
+    return module.js(source, options);
+  }
+  return { beautifyJs };
+}

+import { isObject, isString } from '/@/utils/is';
+
+export function useJsonParse(value: any, defaultValue = {}) {
+  let flag = false;
+  try {
+    value = JSON.parse(value);
+    if (isObject(value) || (isString(value) && value.trim() === '')) flag = true;
+  } catch (error) {
+    value = defaultValue;
+  }
+  return { flag, value };
+}

@@ -3,6 +3,7 @@ import { RouteLocationNormalizedLoaded } from 'vue-router';
 const menuMap = new Map();
 
 menuMap.set('/visual/board/detail/:boardId/:boardName?', '/visual/board');
+menuMap.set('/rule/chain/:id', '/rule/chain');
 
 export const useMenuActiveFix = (route: RouteLocationNormalizedLoaded) => {
   let flag = false;

@@ -3,20 +3,7 @@ import { FormSchema } from '/@/components/Form';
 import { BasicColumn } from '/@/components/Table';
 import moment from 'moment';
 import { findDictItemByCode } from '/@/api/system/dict';
-
-export enum AlarmStatus {
-  CLEARED_UN_ACK = 'CLEARED_UNACK',
-  ACTIVE_UN_ACK = 'ACTIVE_UNACK',
-  CLEARED_ACK = 'CLEARED_ACK',
-  ACTIVE_ACK = 'ACTIVE_ACK',
-}
-
-export enum AlarmStatusMean {
-  CLEARED_UNACK = '清除未确认',
-  ACTIVE_UNACK = '激活未确认',
-  CLEARED_ACK = '清除已确认',
-  ACTIVE_ACK = '激活已确认',
-}
+import { AlarmStatus, AlarmStatusMean } from '/@/enums/alarmEnum';
 
 export const alarmSearchSchemas: FormSchema[] = [
   {

-import { AlarmStatus, AlarmStatusMean } from '../config/detail.config';
 import { clearOrAckAlarm, getDeviceAlarm } from '/@/api/device/deviceManager';
 import { notification, Button, Tag } from 'ant-design-vue';
 import { h, onMounted, onUnmounted } from 'vue';
@@ -8,6 +7,7 @@ import { RoleEnum } from '/@/enums/roleEnum';
 import { usePermission } from '/@/hooks/web/usePermission';
 import { useUserStore } from '/@/store/modules/user';
 import { useGlobSetting } from '/@/hooks/setting';
+import { AlarmStatus, AlarmStatusMean } from '/@/enums/alarmEnum';
 
 interface UseAlarmNotifyParams {
   alarmNotifyStatus?: AlarmStatus;

@@ -91,7 +91,7 @@ export const formSchema: FormSchema[] = [
     valueField: 'fileList',
     componentProps: () => {
       return {
-        listType: 'picture-card',
+        // listType: 'picture-card',
         maxFileLimit: 1,
         api: async (file: File) => {
           try {
@@ -110,6 +110,10 @@ export const formSchema: FormSchema[] = [
         onPreview: (fileList: FileItem) => {
           createImgPreview({ imageList: [fileList.url!] });
         },
+        showUploadList: {
+          showDownloadIcon: true,
+          showRemoveIcon: true,
+        },
       };
     },
   },

@@ -57,7 +57,7 @@ export const formSchema: FormSchema[] = [
     valueField: 'fileList',
     componentProps: () => {
       return {
-        listType: 'picture-card',
+        // listType: 'picture-card',
         maxFileLimit: 1,
         api: async (file: File) => {
           try {
@@ -73,6 +73,10 @@ export const formSchema: FormSchema[] = [
             return {};
           }
         },
+        showUploadList: true,
+        onDownload(file) {
+          console.log(file);
+        },
         onPreview: (fileList: FileItem) => {
           createImgPreview({ imageList: [fileList.url!] });
         },

@@ -23,7 +23,7 @@
     layout: 'vertical',
   });
 
-  const { genForm } = useGenDynamicForm();
+  const { genForm, transformValue } = useGenDynamicForm();
 
   const keys = ref<string[]>([]);
 
@@ -159,8 +159,8 @@
 
         sendValue.value = await genModbusCommand(unref(modBUSForm));
       } else {
-        const _value = getFieldsValue();
-
+        await validate();
+        const _value = transformValue(getFieldsValue());
         sendValue.value = unref(keys).reduce((prev, next) => {
           return { ...prev, [next]: _value[next] };
         }, {});

 import { DataType, Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
 import { JSONEditor } from '/@/components/CodeEditor';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
+import { useJsonParse } from '/@/hooks/business/useJsonParse';
 import { DataTypeEnum } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
 
 export interface BasicCreateFormParams {
@@ -106,6 +107,19 @@ export const useGenDynamicForm = () => {
       field: identifier,
       label: functionName,
       component: 'JSONEditor',
+      valueField: 'value',
+      changeEvent: 'update:value',
+      rules: [
+        {
+          validator: (_rule, value: any) => {
+            if (value) {
+              const { flag } = useJsonParse(value);
+              if (!flag) return Promise.reject(`${functionName} 不是一个有效的JSON对象`);
+            }
+            return Promise.resolve();
+          },
+        },
+      ],
     };
   };
 
@@ -117,11 +131,14 @@ export const useGenDynamicForm = () => {
     [DataTypeEnum.IS_STRUCT]: createInputJson,
   };
 
+  const fieldTypeMap = new Map<string, DataTypeEnum>();
   const genForm = (schemas: StructJSON[]) => {
+    fieldTypeMap.clear();
     const formSchema = schemas.map((item) => {
       const { functionName, identifier, dataType } = item;
       const { type } = dataType || {};
 
+      fieldTypeMap.set(identifier!, dataType!.type);
       const method = schemaMethod[type!];
 
       const formSchema = method?.({
@@ -136,5 +153,21 @@ export const useGenDynamicForm = () => {
     return formSchema.filter(Boolean);
   };
 
-  return { genForm };
+  const transformValue = (value: Recordable) => {
+    return Object.keys(value || {}).reduce((prev, next) => {
+      const dataType = fieldTypeMap.get(next)!;
+
+      let itemValue = value[next];
+      if (dataType === DataTypeEnum.IS_STRUCT) {
+        const { value } = useJsonParse(itemValue);
+        itemValue = value;
+      }
+      return {
+        ...prev,
+        [next]: itemValue,
+      };
+    }, {} as Recordable);
+  };
+
+  return { genForm, transformValue };
 };

+<template>
+  <div>
+    <BasicModal
+      destroyOnClose
+      v-bind="$attrs"
+      width="30rem"
+      @register="register"
+      title="添加规则链"
+      @ok="handleSuccess"
+      @close="handleClose"
+    >
+      <div>
+        <BasicForm @register="registerForm" />
+      </div>
+    </BasicModal>
+  </div>
+</template>
+<script setup lang="ts">
+  import { BasicModal, useModalInner } from '/@/components/Modal';
+  import { ExecuteReportRecord } from '/@/api/export/model/exportModel';
+  import { useForm, BasicForm } from '/@/components/Form';
+  import { formSchema } from './config';
+  import { createRuleChine } from '/@/api/ruleengine/ruleengineApi';
+  import { useMessage } from '/@/hooks/web/useMessage';
+
+  const emit = defineEmits(['register', 'success']);
+
+  const { createMessage } = useMessage();
+
+  const [registerForm, { getFieldsValue, validate }] = useForm({
+    labelWidth: 120,
+    schemas: formSchema,
+    showActionButtonGroup: false,
+  });
+
+  const [register, { setModalProps, closeModal }] = useModalInner(
+    async (data: { record: ExecuteReportRecord }) => {
+      setModalProps({ loading: true });
+      console.log(data, 'record');
+    }
+  );
+
+  const handleClose = () => {
+    closeModal();
+  };
+
+  const handleSuccess = async () => {
+    console.log(1, '1', getFieldsValue());
+    await validate();
+    const record = getFieldsValue();
+    const { description, debugMode, name } = record;
+    const form = {
+      additionalInfo: {
+        description,
+      },
+      debugMode,
+      name,
+      type: 'CORE',
+    };
+
+    await createRuleChine(form);
+    createMessage.success('添加成功');
+    handleClose();
+    emit('success');
+  };
+</script>
+<style lang="less" scoped></style>

+import { FormSchema } from '/@/components/Form';
+
+export const formSchema: FormSchema[] = [
+  {
+    field: 'name',
+    label: '名称',
+    colProps: { span: 16 },
+    component: 'Input',
+    required: true,
+    componentProps: {
+      placeholder: '请输入名称',
+    },
+  },
+  {
+    field: 'debugMode',
+    label: '调试模式',
+    component: 'Checkbox',
+    colProps: { span: 8 },
+    componentProps: {},
+  },
+  {
+    field: 'description',
+    label: '说明',
+    component: 'InputTextArea',
+  },
+];

+import RuleChainModal from './RuleChainModal.vue';
+
+export { RuleChainModal };

+import { BasicColumn, FormSchema } from '/@/components/Table';
+import { transformTime } from '/@/hooks/web/useDateToLocaleString';
+
+export const columns: BasicColumn[] = [
+  {
+    title: '创建时间',
+    dataIndex: 'createdTime',
+    width: 200,
+    format: (_text: string, record: Recordable) => {
+      return transformTime(record.createdTime);
+    },
+  },
+  {
+    title: '名称',
+    dataIndex: 'name',
+    width: 200,
+  },
+  {
+    title: '是否跟链',
+    dataIndex: 'root',
+    slots: {
+      customRender: 'root',
+    },
+    width: 200,
+  },
+];
+
+export const searchFormSchema: FormSchema[] = [
+  {
+    field: 'textSearch',
+    label: '名称',
+    component: 'Input',
+
+    colProps: { span: 8 },
+    componentProps: {
+      placeholder: '请输入名称',
+    },
+  },
+];
+
+export const encode = (string: string) => {
+  return encodeURIComponent(string);
+};

+<template>
+  <div>
+    <BasicTable @register="registerTable">
+      <template #toolbar>
+        <Authority>
+          <a-button type="primary" @click="handleAdd"> 新增规则链 </a-button>
+        </Authority>
+        <!-- <Authority>
+          <Popconfirm
+            title="您确定要批量删除数据"
+            ok-text="确定"
+            cancel-text="取消"
+            @confirm="handleDeleteOrBatchDelete(null)"
+          >
+            <a-button color="error" :disabled="hasBatchDelete"> 批量删除 </a-button>
+          </Popconfirm>
+        </Authority> -->
+      </template>
+      <template #root="{ record }">
+        <Tag :color="record.root ? 'green' : 'red'"> {{ record.root ? '是' : '否' }}</Tag>
+      </template>
+      <template #action="{ record }">
+        <TableAction
+          :actions="[
+            {
+              label: '查看',
+              icon: 'ant-design:eye-outlined',
+              onClick: handleView.bind(null, record),
+            },
+            {
+              label: '删除',
+              icon: 'ant-design:delete-outlined',
+              color: 'error',
+              ifShow: !record.root,
+              popConfirm: {
+                title: '是否确认删除',
+                confirm: handleDeleteOrBatchDelete.bind(null, record),
+              },
+            },
+          ]"
+        />
+      </template>
+    </BasicTable>
+    <RuleChainModal @register="registerModal" @success="handleSuccess" />
+  </div>
+</template>
+<script lang="ts" setup>
+  import { BasicTable, useTable, TableAction } from '/@/components/Table';
+  import { columns, encode, searchFormSchema } from './config/config.data';
+  import { deleteRuleChine, getRuleChinsList } from '/@/api/ruleengine/ruleengineApi';
+  import { useModal } from '/@/components/Modal';
+  import { Authority } from '/@/components/Authority';
+  import { Tag } from 'ant-design-vue';
+  import { RuleChainModal } from './component/index';
+  import { useMessage } from '/@/hooks/web/useMessage';
+  import { usePermission } from '/@/hooks/web/usePermission';
+  import { useRouter } from 'vue-router';
+
+  const [registerTable, { reload, setProps }] = useTable({
+    title: '规则链库',
+    api: getRuleChinsList,
+    columns,
+    formConfig: {
+      labelWidth: 120,
+      schemas: searchFormSchema,
+    },
+    fetchSetting: {
+      pageField: 'page',
+      listField: 'data',
+    },
+    pagination: true,
+    useSearchForm: true,
+    showTableSetting: true,
+    bordered: true,
+    showIndexColumn: false,
+    beforeFetch(params) {
+      Reflect.set(params, 'page', params.page - 1);
+      Reflect.set(params, 'sortProperty', 'createdTime');
+      Reflect.set(params, 'sortOrder', 'DESC');
+      return params;
+    },
+    actionColumn: {
+      width: 200,
+      title: '操作',
+      dataIndex: 'action',
+      slots: { customRender: 'action' },
+      fixed: 'right',
+    },
+  });
+
+  const [registerModal, { openModal }] = useModal();
+
+  const handleSuccess = () => {
+    reload();
+  };
+
+  const handleAdd = () => {
+    openModal(true);
+  };
+
+  const { createMessage } = useMessage();
+  const { hasPermission } = usePermission();
+  const router = useRouter();
+
+  const handleView = (record: Recordable) => {
+    const hasDetailPermission = hasPermission('rule:chain:detail');
+    if (hasDetailPermission) {
+      const boardId = encode(record.id.id);
+      router.push(`/rule/chain/${boardId}`);
+    } else createMessage.warning('没有权限');
+  };
+
+  const handleDeleteOrBatchDelete = async (record: Recordable) => {
+    setProps({
+      loading: true,
+    });
+    try {
+      await deleteRuleChine(record.id.id);
+      createMessage.success('删除成功');
+    } finally {
+      setProps({
+        loading: false,
+      });
+    }
+    reload();
+  };
+</script>

+export enum EntryCategoryComponentEnum {
+  INPUT = 'Input',
+}
+
+export enum FlowCategoryComponentEnum {
+  ACKNOWLEDGE = 'Acknowledge',
+  CHECKPOINT = 'Checkpoint',
+  RULE_CHAIN = 'RuleChain',
+  OUTPUT = 'Output',
+}
+export enum EnrichmentCategoryComponentEnum {
+  CUSTOMER_ATTRIBUTES = 'CustomerAttributes',
+  ORIGINATOR_TELEMETRY = 'OriginatorTelemetry',
+  ORIGINATOR_FIELDS = 'OriginatorFields',
+  CALCULATE_DELTA = 'CalculateDelta',
+  TENANT_ATTRIBUTES = 'TenantAttributes',
+  RELATED_DEVICE_ATTRIBUTES = 'RelatedDeviceAttributes',
+  RELATED_ATTRIBUTES = 'RelatedAttributes',
+  TENANT_DETAILS = 'TenantDetails',
+  ORIGINATOR_ATTRIBUTES = 'OriginatorAttributes',
+  CUSTOMER_DETAILS = 'CustomerDetails',
+}
+export enum ExternalCategoryComponentEnum {
+  ALARM_NOTICE = 'AlarmNotice',
+  MQTT = 'Mqtt',
+  GCP_PUBSUB = 'GcpPubsub',
+  SEND_SMS = 'SendSms',
+  AZURE_IOT_HUB = 'AzureIotHub',
+  REST_API_CALL = 'RestApiCall',
+  KAFKA = 'Kafka',
+  AWS_SNS = 'AwsSns',
+  SEND_EMAIL = 'SendEmail',
+  RABBITMQ = 'Rabbitmq',
+  AWS_SQS = 'AwsSqs',
+}
+export enum ActionCategoryComponentEnum {
+  CREATE_ALARM = 'CreateAlarm',
+  PUSH_TO_EDGE = 'PushToEdge',
+  GENERATOR = 'Generator',
+  ASSIGN_TO_CUSTOMER = 'AssignToCustomer',
+  UNASSIGN_FROM_CUSTOMER = 'UnassignFromCustomer',
+  SAVE_TIMESERIES = 'SaveTimeseries',
+  GPS_GEOFENCING_EVENTS = 'GpsGeofencingEvents',
+  DEVICE_PROFILE = 'DeviceProfile',
+  RPC_CALL_REPLY = 'RpcCallReply',
+  COPY_TO_VIEW = 'CopyToView',
+  LOG = 'Log',
+  SAVE_TO_CUSTOM_TABLE = 'SaveToCustomTable',
+  CLEAR_ALARM = 'ClearAlarm',
+  DELETE_RELATION = 'DeleteRelation',
+  DELAY_DEPRECATED = 'DelayDeprecated',
+  MESSAGE_COUNT = 'MessageCount',
+  SAVE_EVENT = 'SaveEvent',
+  RPC_CALL_REQUEST = 'RpcCallRequest',
+  SYNCHRONIZATION_START = 'SynchronizationStart',
+  SYNCHRONIZATION_END = 'SynchronizationEnd',
+  SAVE_ATTRIBUTES = 'SaveAttributes',
+  CREATE_RELATION = 'CreateRelation',
+}
+export enum FilterCategoryComponentEnum {
+  SCRIPT = 'Script',
+  SCENE_REACT = 'SceneReact',
+  CHECK_EXISTENCE_FIELDS = 'CheckExistenceFields',
+  ORIGINATOR_TYPE_SWITCH = 'OriginatorTypeSwitch',
+  CHECK_RELATION = 'CheckRelation',
+  MESSAGE_TYPE = 'MessageType',
+  ORIGINATOR_TYPE = 'OriginatorType',
+  MESSAGE_TYPE_SWITCH = 'MessageTypeSwitch',
+  SWITCH = 'Switch',
+  GPS_GEOFENCING_FILTER = 'GpsGeofencingFilter',
+  CHECK_ALARM_STATUS = 'CheckAlarmStatus',
+}
+export enum TransformationCategoryComponentEnum {
+  CHANGE_ORIGINATOR = 'ChangeOriginator',
+  SCRIPT = 'Script',
+  TO_EMAIL = 'ToEmail',
+}

+export enum RuleChainEntityType {
+  RULE_NODE = 'RULE_NODE',
+  RULE_CHAIN = 'RULE_CHAIN',
+}

+/**
+ * @description 方向
+ */
+export enum DirectionEnum {
+  FROM = 'FROM',
+  TO = 'TO',
+}
+
+export enum DirectionNameEnum {
+  FROM = '从',
+  TO = '到',
+}
+/**
+ * @description 关联类型
+ */
+export enum RelationTypeEnum {
+  CONTAINS = 'CONTAINS',
+  MANAGES = 'MANAGES',
+}
+
+export enum RelationTypeNameEnum {
+  CONTAINS = 'Contains',
+  MANAGES = 'Manages',
+}
+
+/**
+ * @description 类型
+ */
+export enum EntityTypeEnum {
+  DEVICE = 'DEVICE',
+  ASSET = 'ASSET',
+  ENTITY_VIEW = 'ENTITY_VIEW',
+  TENANT = 'TENANT',
+  CUSTOMER = 'CUSTOMER',
+  USER = 'USER',
+  DASHBOARD = 'DASHBOARD',
+  EDGE = 'EDGE',
+}
+
+export enum EntityTypeNameEnum {
+  DEVICE = '设备',
+  ASSET = '资产',
+  ENTITY_VIEW = '实体视图',
+  TENANT = '租户',
+  CUSTOMER = '客户',
+  USER = '用户',
+  DASHBOARD = '仪表板',
+  EDGE = '边缘',
+}
+
+/**
+ * @description Filter Perimeter type
+ */
+export enum PerimeterTypeEnum {
+  POLYGON = 'POLYGON',
+  CIRCLE = 'CIRCLE',
+}
+
+export enum MessageTypesEnum {
+  POST_ATTRIBUTES_REQUEST = 'POST_ATTRIBUTES_REQUEST',
+  POST_TELEMETRY_REQUEST = 'POST_TELEMETRY_REQUEST',
+  TO_SERVER_RPC_REQUEST = 'TO_SERVER_RPC_REQUEST',
+  RPC_CALL_FROM_SERVER_TO_DEVICE = 'RPC_CALL_FROM_SERVER_TO_DEVICE',
+  ACTIVITY_EVENT = 'ACTIVITY_EVENT',
+  INACTIVITY_EVENT = 'INACTIVITY_EVENT',
+  CONNECT_EVENT = 'CONNECT_EVENT',
+  DISCONNECT_EVENT = 'DISCONNECT_EVENT',
+  ENTITY_CREATED = 'ENTITY_CREATED',
+  ENTITY_UPDATED = 'ENTITY_UPDATED',
+  ENTITY_DELETED = 'ENTITY_DELETED',
+  ENTITY_ASSIGNED = 'ENTITY_ASSIGNED',
+  ENTITY_UNASSIGNED = 'ENTITY_UNASSIGNED',
+  ATTRIBUTES_UPDATED = 'ATTRIBUTES_UPDATED',
+  ATTRIBUTES_DELETED = 'ATTRIBUTES_DELETED',
+  TIMESERIES_UPDATED = 'TIMESERIES_UPDATED',
+  TIMESERIES_DELETED = 'TIMESERIES_DELETED',
+  RPC_QUEUED = 'RPC_QUEUED',
+  RPC_DELIVERED = 'RPC_DELIVERED',
+  RPC_SUCCESSFUL = 'RPC_SUCCESSFUL',
+  RPC_TIMEOUT = 'RPC_TIMEOUT',
+  RPC_FAILED = 'RPC_FAILED',
+}
+
+export enum MessageTypesNameEnum {
+  POST_ATTRIBUTES_REQUEST = 'Post attributes',
+  POST_TELEMETRY_REQUEST = 'Post telemetry',
+  TO_SERVER_RPC_REQUEST = 'RPC Request from Device',
+  RPC_CALL_FROM_SERVER_TO_DEVICE = 'RPC Request to Device',
+  ACTIVITY_EVENT = 'Activity Event',
+  INACTIVITY_EVENT = 'Inactivity Event',
+  CONNECT_EVENT = 'Connect Event',
+  DISCONNECT_EVENT = 'Disconnect Event',
+  ENTITY_CREATED = 'Entity Created',
+  ENTITY_UPDATED = 'Entity Updated',
+  ENTITY_DELETED = 'Entity Deleted',
+  ENTITY_ASSIGNED = 'Entity Assigned',
+  ENTITY_UNASSIGNED = 'Entity Unassigned',
+  ATTRIBUTES_UPDATED = 'Attributes Updated',
+  ATTRIBUTES_DELETED = 'Attributes Deleted',
+  TIMESERIES_UPDATED = 'Timeseries Updated',
+  TIMESERIES_DELETED = 'Timeseries Deleted',
+  RPC_QUEUED = 'RPC Queued',
+  RPC_DELIVERED = 'RPC Delivered',
+  RPC_SUCCESSFUL = 'RPC Successful',
+  RPC_TIMEOUT = 'RPC Timeout',
+  RPC_FAILED = 'RPC Failed',
+}
+/**
+ * @description Filter Range util
+ */
+export enum RangeUtilEnum {
+  METER = 'METER',
+  KILOMETER = 'KILOMETER',
+  FOOT = 'FOOT',
+  MILE = 'MILE',
+  NAUTICAL_MILE = 'NAUTICAL_MILE',
+}
+
+export enum RangeUtilNameEnum {
+  METER = 'Meter',
+  KILOMETER = 'Kilometer',
+  FOOT = 'Foot',
+  MILE = 'Mile',
+  NAUTICAL_MILE = 'Nautical mile',
+}
+
+// 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',
+}
+
+// Action Push to edge
+export enum ScopeEnum {
+  SERVER_SCOPE = 'SERVER_SCOPE',
+  CLIENT_SCOPE = 'CLIENT_SCOPE',
+  SHARED_SCOPE = 'SHARED_SCOPE',
+}
+
+export enum ScopeNameEnum {
+  SERVER_SCOPE = '服务端属性',
+  CLIENT_SCOPE = '客户端属性',
+  SHARED_SCOPE = '共享属性',
+}
+
+// External Queue type
+export enum QueueTypeEnum {
+  STANDARD = 'STANDARD',
+  FIFO = 'FIFO',
+}
+
+export enum QueueTypeNameEnum {
+  STANDARD = 'Standard',
+  FIFO = 'FIFO',
+}
+
+// Charset encoding
+export enum CharsetEncodingEnum {
+  US_ASCII = 'US_ASCII',
+  ISO_8859_1 = 'ISO_8859_1',
+  UTF_8 = 'UTF_8',
+  UTF_16BE = 'UTF_16BE',
+  UTF_16LE = 'UTF_16LE',
+  UTF_16 = 'UTF_16',
+}
+
+export enum CharsetEncodingNameEnum {
+  US_ASCII = 'US-ASCII',
+  ISO_8859_1 = 'ISO-8859-1',
+  UTF_8 = 'UTF-8',
+  UTF_16BE = 'UTF-16BE',
+  UTF_16LE = 'UTF-16LE',
+  UTF_16 = 'UTF-16',
+}
+
+// Rabbitmq Message properties
+export enum MessagePropertiesEnum {
+  BASIC = 'BASIC',
+  TEXT_PLAIN = 'TEXT_PLAIN',
+  MINIMAL_BASIC = 'MINIMAL_BASIC',
+  MINIMAL_PERSISTENT_BASIC = 'MINIMAL_PERSISTENT_BASIC',
+  PERSISTENT_BASIC = 'PERSISTENT_BASIC',
+  PERSISTENT_TEXT_PLAIN = 'PERSISTENT_TEXT_PLAIN',
+}
+
+// rest api call Request method
+export enum RequestMethodEnum {
+  GET = 'GET',
+  POST = 'POST',
+  PUT = 'PUT',
+  DELETE = 'DELETE',
+}
+
+export enum ProtocolEnum {
+  HTTP = 'HTTP',
+  HTTPS = 'HTTPS',
+}
+
+export enum ProtocolNameEnum {
+  HTTP = 'http',
+  HTTPS = 'https',
+}
+
+export enum EmailProtocolEnum {
+  SMTP = 'SMTP',
+  SMTPS = 'SMTPS',
+}
+
+export enum EmailProtocolNameEnum {
+  SMTP = 'smtp',
+  SMTPS = 'smtps',
+}
+
+export enum TSLVersionEnum {
+  TSLV1 = 'TSLV1',
+  TSLV1_1 = 'TSLV1_1',
+  TSLV1_2 = 'TSLV1_2',
+  TSLV1_3 = 'TSLV1_3',
+}
+
+export enum TSLVersionNameEnum {
+  TSLV1 = 'TSLV1',
+  TSLV1_1 = 'TSLV1.1',
+  TSLV1_2 = 'TSLV1.2',
+  TSLV1_3 = 'TSLV1.3',
+}
+
+export enum SMSServiceProviderEnum {
+  AWS_SNS = 'AWS_SNS',
+  TWILIO = 'TWILIO',
+}
+
+export enum SMSServiceProviderNameEnum {
+  AWS_SNS = '亚马逊社交网站',
+  TWILIO = 'Twilio',
+}

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

+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 {
+  LATEST_TS_KEY_NAMES = 'latestTsKeyNames',
+  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 {
+  LATEST_TS_KEY_NAMES = 'Latest timeseries',
+  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',
+  TELEMETRY = 'telemetry',
+}
+
+export enum RelatedAttributesFieldsNameEnum {
+  RELATIONS_QUERY = 'Relations query',
+  ATTR_MAPPING = 'Attributes mapping',
+  TELEMETRY = 'Latest telemetry',
+}
+
+// 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 = '设备类型',
+}
+
+// Tenant attributes
+export enum TenantAttributesFieldsEnum {
+  ATTR_MAPING = 'attrMapping',
+  TELEMETRY = 'telemetry',
+}
+
+export enum TenantAttributesFieldsNameEnum {
+  ATTR_MAPING = 'attrMapping',
+  TELEMETRY = 'Latest telemetry',
+}
+
+// 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',
+}

+// Alarm notice
+export enum AlarmNoticeFieldsEnum {
+  CONFIGURATION = 'CONFIGURATION',
+}
+
+export enum AlarmNoticeFieldsNameEnum {
+  CONFIGURATION = '配置',
+}
+
+// aws sns
+export enum AwsSnsFieldsEnum {
+  TOPIC_ARN_PATTERN = 'topicArnPattern',
+  ACCESS_KEY_ID = 'accessKeyId',
+  SECRET_ACCESS_KEY = 'secretAccessKey',
+  REGION = 'region',
+}
+
+export enum AwsSnsFieldsNameEnum {
+  TOPIC_ARN_PATTERN = 'Topic ARN pattern',
+  ACCESS_KEY_ID = 'AWS Access Key ID',
+  SECRET_ACCESS_KEY = 'AWS Secret Access Key',
+  REGION = 'AWS Region',
+}
+
+// Aws sqs
+export enum AwsSqsFieldsEnum {
+  QUEUE_TYPE = 'queueType',
+  QUEUE_URL_PATTERN = 'queueUrlPattern',
+  DELAY_SECONDS = 'delaySeconds',
+  MESSAGE_ATTRIBUTES = 'messageAttributes',
+  ACCESS_KEY_ID = 'accessKeyId',
+  SECRET_ACCESS_KEY = 'secretAccessKey',
+  REGION = 'region',
+}
+
+export enum AwsSqsFieldsNameEnum {
+  QUEUE_TYPE = 'Queue type',
+  QUEUE_URL_PATTERN = 'Queue URL pattern',
+  DELAY_SECONDS = 'Delay(seconds)',
+  MESSAGE_ATTRIBUTES = 'Message attributes',
+  ACCESS_KEY_ID = 'AWS Access Key ID',
+  SECRET_ACCESS_KEY = 'AWS Secret Access Key',
+  REGION = 'AWS Region',
+}
+
+// Azure iot hub
+export enum AzureIotHubFieldsEnum {
+  TOPIC_PATTERN = 'topicPattern',
+  HOST = 'host',
+  PORT = 'port',
+  CONNECT_TIMEOUT_SEC = 'connectTimeoutSec',
+  CLIENT_ID = 'clientId',
+  CLEAN_SESSION = 'cleanSession',
+  SSL = 'ssl',
+  CREDENTIALS = 'credentials',
+
+  TYPE = 'type',
+  SAS_KEY = 'sasKey',
+  CA_CERT = 'caCert',
+  CA_CERT_FILE_NAME = 'caCertFileName',
+  PRIVATE_KEY = 'privateKey',
+  PRIVATE_KEY_FILE_NAME = 'privateKeyFileName',
+  CERT = 'cert',
+  CERT_FILE_NAME = 'certFileName',
+  PASSWORD = 'password',
+}
+
+export enum AzureIotHubFieldsNameEnum {
+  TOPIC_PATTERN = 'Topic',
+  HOST = 'Hostname',
+  PORT = 'port',
+  CONNECT_TIMEOUT_SEC = 'connectTimeoutSec',
+  CLIENT_ID = 'Device ID',
+  CLEAN_SESSION = 'cleanSession',
+  SSL = 'ssl',
+  CREDENTIALS = 'credentials',
+
+  TYPE = 'Credentials type',
+  SAS_KEY = 'sasKey',
+  CA_CERT = 'CA certificate file',
+  CA_CERT_FILE_NAME = 'caCertFileName',
+  PRIVATE_KEY = 'Client private key file',
+  PRIVATE_KEY_FILE_NAME = 'privateKeyFileName',
+  CERT = 'Client certificate file',
+  CERT_FILE_NAME = 'certFileName',
+  PASSWORD = 'Private key password',
+}
+
+// GCP pubsub
+export enum GcpPubsubFieldsEnum {
+  PROJECT_ID = 'projectId',
+  TOPIC_NAME = 'topicName',
+  SERVICE_ACCOUNT_KEY = 'serviceAccountKey',
+  SERVICE_ACCOUNT_KEY_FILE_NAME = 'serviceAccountKeyFileName',
+  MESSAGE_ATTRIBUTES = 'messageAttributes',
+}
+
+export enum GcpPubsubFieldsNameEnum {
+  PROJECT_ID = 'GCP project ID',
+  TOPIC_NAME = 'Topic name',
+  SERVICE_ACCOUNT_KEY = 'GCP service account key file',
+  SERVICE_ACCOUNT_KEY_FILE_NAME = 'serviceAccountKeyFileName',
+  MESSAGE_ATTRIBUTES = 'Message attributes',
+}
+
+// Kafka
+export enum KafkaFieldsEnum {
+  TOPIC_PATTERN = 'topicPattern',
+  BOOTSTRAP_SERVERS = 'bootstrapServers',
+  RETRIES = 'retries',
+  BATCH_SIZE = 'batchSize',
+  LINGER = 'linger',
+  BUFFER_MEMORY = 'bufferMemory',
+  ACKS = 'acks',
+  KEY_SERIALIZER = 'keySerializer',
+  VALUE_SERIALIZER = 'valueSerializer',
+  OTHER_PROPERTIES = 'otherProperties',
+  ADD_METADATA_KEY_VALUES_AS_KAFKA_HEADERS = 'addMetadataKeyValuesAsKafkaHeaders',
+  KAFKA_HEADERS_CHARSET = 'kafkaHeadersCharset',
+}
+
+export enum KafkaFieldsNameEnum {
+  TOPIC_PATTERN = 'Topic pattern',
+  BOOTSTRAP_SERVERS = 'Bootstrap servers',
+  RETRIES = 'Automatically retry times if fails',
+  BATCH_SIZE = 'Produces batch size in bytes',
+  LINGER = 'Time to buffer locally(ms)',
+  BUFFER_MEMORY = 'Client buffer max size in bytes',
+  ACKS = 'Number of acknowledgments',
+  KEY_SERIALIZER = 'Key serializer',
+  VALUE_SERIALIZER = 'Value serializer',
+  OTHER_PROPERTIES = 'Other properties',
+  ADD_METADATA_KEY_VALUES_AS_KAFKA_HEADERS = 'Add Message metadata key-value pairs to Kafka record headers',
+  KAFKA_HEADERS_CHARSET = 'Charset encoding',
+}
+
+// Mqtt
+export enum MqttFieldsEnum {
+  TOPIC_PATTERN = 'topicPattern',
+  HOST = 'host',
+  PORT = 'port',
+  CONNECT_TIMEOUT_SEC = 'connectTimeoutSec',
+  CLIENT_ID = 'clientId',
+  APPEND_CLIENT_ID_SUFFIX = 'appendClientIdSuffix',
+  CLEAN_SESSION = 'cleanSession',
+  SSL = 'ssl',
+  CREDENTIALS = 'credentials',
+
+  TYPE = 'type',
+  PASSWORD = 'password',
+  CA_CERT = 'caCert',
+  CA_CERT_FILE_NAME = 'caCertFileName',
+  PRIVATE_KEY = 'privateKey',
+  PRIVATE_KEY_FILE_NAME = 'privateKeyFileName',
+  CERT = 'cert',
+  CERT_FILE_NAME = 'certFileName',
+  USERNAME = 'username',
+}
+
+export enum MqttFieldsNameEnum {
+  TOPIC_PATTERN = 'Topic pattern',
+  HOST = 'Hose',
+  PORT = 'Port',
+  CONNECT_TIMEOUT_SEC = 'Connection timeout(sec)',
+  CLIENT_ID = 'Client ID',
+  APPEND_CLIENT_ID_SUFFIX = 'Add Service ID as suffix to Client ID',
+  CLEAN_SESSION = 'Clean session',
+  SSL = 'Enable SSL',
+  CREDENTIALS = 'credentials',
+
+  TYPE = 'Credentials type',
+  PASSWORD = 'Password',
+  CA_CERT = 'Server CA certificate file',
+  CA_CERT_FILE_NAME = 'caCertFileName',
+  PRIVATE_KEY = 'Client private key file',
+  PRIVATE_KEY_FILE_NAME = 'privateKeyFileName',
+  CERT = 'Client certificate file',
+  CERT_FILE_NAME = 'certFileName',
+  USERNAME = 'Username',
+}
+
+// Rabbitmq
+export enum RabbitmqFieldsEnum {
+  EXCHANGE_NAME_PATTERN = 'exchangeNamePattern',
+  ROUTING_KEY_PATTERN = 'routingKeyPattern',
+  MESSAGE_PROPERTIES = 'messageProperties',
+  HOST = 'host',
+  PORT = 'port',
+  VIRTUAL_HOST = 'virtualHost',
+  USERNAME = 'username',
+  PASSWORD = 'password',
+  AUTOMATIC_RECOVERY_ENABLED = 'automaticRecoveryEnabled',
+  CONNECTION_TIMEOUT = 'connectionTimeout',
+  HANDSHAKE_TIMEOUT = 'handshakeTimeout',
+  CLIENT_PROPERTIES = 'clientProperties',
+}
+
+export enum RabbitmqFieldsNameEnum {
+  EXCHANGE_NAME_PATTERN = 'Exchange name pattern',
+  ROUTING_KEY_PATTERN = 'Routing key pattern',
+  MESSAGE_PROPERTIES = 'Message properties',
+  HOST = 'Host',
+  PORT = 'Port',
+  VIRTUAL_HOST = 'Virtual host',
+  USERNAME = 'Username',
+  PASSWORD = 'Password',
+  AUTOMATIC_RECOVERY_ENABLED = 'Automatic recovery',
+  CONNECTION_TIMEOUT = 'Connection timeout(ms)',
+  HANDSHAKE_TIMEOUT = 'Handshake timeout(ms)',
+  CLIENT_PROPERTIES = 'Client properties',
+}
+
+// Rest api call
+export enum RestApiCallFieldsEnum {
+  REST_ENDPOINT_URL_PATTERN = 'restEndpointUrlPattern',
+  REQUEST_METHOD = 'requestMethod',
+  USE_SIMPLE_CLIENT_HTTP_FACTORY = 'useSimpleClientHttpFactory',
+  IGNORE_REQUEST_BODY = 'ignoreRequestBody',
+  ENABLE_PROXY = 'enableProxy',
+  USE_SYSTEM_PROXY_PROPERTIES = 'useSystemProxyProperties',
+  PROXY_SCHEME = 'proxyScheme',
+  PROXY_HOST = 'proxyHost',
+  PROXY_PORT = 'proxyPort',
+  PROXY_USER = 'proxyUser',
+  PROXY_PASSWORD = 'proxyPassword',
+  READ_TIMEOUT_MS = 'readTimeoutMs',
+  MAX_PARALLEL_REQUESTS_COUNT = 'maxParallelRequestsCount',
+  HEADERS = 'headers',
+  USE_REDIS_QUEUE_FOR_MSG_PERSISTENCE = 'useRedisQueueForMsgPersistence',
+  TRIM_QUEUE = 'trimQueue',
+  MAX_QUEUE_SIZE = 'maxQueueSize',
+  CREDENTIALS = 'credentials',
+
+  TYPE = 'type',
+  PASSWORD = 'password',
+  CA_CERT = 'caCert',
+  CA_CERT_FILE_NAME = 'caCertFileName',
+  PRIVATE_KEY = 'privateKey',
+  PRIVATE_KEY_FILE_NAME = 'privateKeyFileName',
+  CERT = 'cert',
+  CERT_FILE_NAME = 'certFileName',
+  USERNAME = 'username',
+}
+
+export enum RestApiCallFieldsNameEnum {
+  REST_ENDPOINT_URL_PATTERN = 'Endpoint URL pattern',
+  REQUEST_METHOD = 'Request method',
+  USE_SIMPLE_CLIENT_HTTP_FACTORY = 'Use simple client HTTP factory',
+  IGNORE_REQUEST_BODY = 'Without request body',
+  ENABLE_PROXY = 'Enable proxy',
+  USE_SYSTEM_PROXY_PROPERTIES = 'Use system proxy properties',
+  PROXY_SCHEME = 'Proxy scheme',
+  PROXY_HOST = 'Proxy host',
+  PROXY_PORT = 'Proxy port',
+  PROXY_USER = 'Proxy user',
+  PROXY_PASSWORD = 'Proxy password',
+  READ_TIMEOUT_MS = 'Read timeout in millis',
+  MAX_PARALLEL_REQUESTS_COUNT = 'Max number of parallel request',
+  HEADERS = 'Header',
+  USE_REDIS_QUEUE_FOR_MSG_PERSISTENCE = 'Use redis queue for message persistence',
+  TRIM_QUEUE = 'Trim redis queue',
+  MAX_QUEUE_SIZE = 'Redis queue max size',
+  CREDENTIALS = 'Credentials',
+
+  TYPE = 'Credentials type',
+  PASSWORD = 'Password',
+  CA_CERT = 'Server CA certificate file',
+  CA_CERT_FILE_NAME = 'caCertFileName',
+  PRIVATE_KEY = 'Client private key file',
+  PRIVATE_KEY_FILE_NAME = 'privateKeyFileName',
+  CERT = 'Client certificate file',
+  CERT_FILE_NAME = 'certFileName',
+  USERNAME = 'Username',
+}
+
+// send email
+export enum SendEmailFieldsEnum {
+  USE_SYSTEM_SMTP_SETTINGS = 'useSystemSmtpSettings',
+  SMTP_PROTOCOL = 'smtpProtocol',
+  SMTP_HOST = 'smtpHost',
+  SMTP_PORT = 'smtpPort',
+  TIMEOUT = 'timeout',
+  ENABLE_TLS = 'enableTls',
+  TLS_VERSION = 'tlsVersion',
+  ENABLE_PROXY = 'enableProxy',
+  PROXY_HOST = 'proxyHost',
+  PROXY_PORT = 'proxyPort',
+  PROXY_USER = 'proxyUser',
+  PROXY_PASSWORD = 'proxyPassword',
+  USERNAME = 'username',
+  PASSWORD = 'password',
+}
+
+export enum SendEmailFieldsNameEnum {
+  USE_SYSTEM_SMTP_SETTINGS = 'Use system SMTP settings',
+  SMTP_PROTOCOL = 'Protocol',
+  SMTP_HOST = 'SMTP host',
+  SMTP_PORT = 'SMTP port',
+  TIMEOUT = 'Timeout ms',
+  ENABLE_TLS = 'Enable TLS',
+  TLS_VERSION = 'TLS version',
+  ENABLE_PROXY = 'Enable proxy',
+  PROXY_HOST = 'Proxy host',
+  PROXY_PORT = 'Proxy port',
+  PROXY_USER = 'Proxy user',
+  PROXY_PASSWORD = 'Proxy password',
+  USERNAME = 'Username',
+  PASSWORD = 'Password',
+}
+
+export enum SendSMSFieldsEnum {
+  NUMBERS_TO_TEMPLATE = 'numbersToTemplate',
+  SMS_MESSAGE_TEMPLATE = 'smsMessageTemplate',
+  USE_SYSTEM_SMS_SETTINGS = 'useSystemSmsSettings',
+  SMS_PROVIDER_CONFIGURATION = 'smsProviderConfiguration',
+
+  ACCESS_KEY_ID = 'accessKeyId',
+  SECRET_ACCESS_KEY = 'secretAccessKey',
+  REGION = 'region',
+  TYPE = 'type',
+  NUMBER_FROM = 'numberFrom',
+  ACCOUNT_SID = 'accountSid',
+  ACCOUNT_TOKEN = 'accountToken',
+}
+
+export enum SendSMSFieldsNameEnum {
+  NUMBERS_TO_TEMPLATE = 'Phone Numbers To Template',
+  SMS_MESSAGE_TEMPLATE = 'SMS message Template',
+  USE_SYSTEM_SMS_SETTINGS = 'User system SMS provider settings',
+  SMS_PROVIDER_CONFIGURATION = 'smsProviderConfiguration',
+
+  ACCESS_KEY_ID = 'AWS访问密钥ID',
+  SECRET_ACCESS_KEY = 'AWS访问密钥',
+  REGION = 'AWS地区',
+  TYPE = 'SMS服务商类型',
+  NUMBER_FROM = '发送方电话号码',
+  ACCOUNT_SID = 'Twilio账户SID',
+  ACCOUNT_TOKEN = 'Twilio账户令牌',
+}

+// Filter Check Alarm Status Fields
+export enum CheckAlarmStatusFieldEnum {
+  ALARM_STATUS_LIST = 'alarmStatusList',
+}
+
+export enum CheckAlarmStatusFieldNameEnum {
+  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',
+}
+
+// Filter Switch
+export enum SwitchFieldsEnum {
+  JS_SCRIPT = 'jsScript',
+}
+
+export enum SwitchFieldsNameEnum {
+  JS_SCRIPT = 'Filter',
+}

+export enum CheckPointFieldsEnum {
+  QUEUE_NAME = 'queueName',
+}
+
+export enum CheckPointFieldsNameEnum {
+  QUEUE_NAME = '队列名称',
+}
+
+export enum RuleChainFieldsEnum {
+  RULE_CHAIN_ID = 'ruleChainId',
+}
+
+export enum RuleChainFieldsNameEnum {
+  RULE_CHAIN_ID = '规则链',
+}

+// 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',
+}

+export enum HandleTypeEnum {
+  SOURCE = 'source',
+  TARGET = 'target',
+}
+
+export enum NodeTypeEnum {
+  CUSTOM = 'custom',
+}
+
+export enum EdgeTypeEnum {
+  CUSTOM = 'custom',
+}
+
+export enum BasicConnectionModalEnum {
+  BASIC = 'BASIC',
+  CUSTOM = 'CUSTOM',
+}
+
+export enum MarkerArrowEnum {
+  BASIC_ARROW = 'basicArrow',
+  BASIC_ARROW_SELECTED = 'basicArrowSelected',
+}
+
+export enum ElementsTypeEnum {
+  NODE = 'NODE',
+  EDGE = 'EDGE',
+}

+import { CommonFields, CommonFieldsName } from './formField/common';
+
+export enum FetchNodeComFlagTypeENum {
+  CONNECTION_MODAL = 'CONNECTION_MODAL',
+  CREATE_MODAL = 'CREATE_MODAL',
+}
+
+export enum EdgeBindDataFieldEnum {
+  TYPE = 'type',
+}
+
+export enum EdgeBindDataFieldNameEnum {
+  TYPE = '链接标签',
+}
+
+export const NodeBindDataFieldEnum = {
+  ...CommonFields,
+};
+
+export const NodeBindDataFieldNameEnum = {
+  ...CommonFieldsName,
+};

+import type { Connection } from '@vue-flow/core';
+import { EdgeTypeEnum } from '../enum';
+import type { EdgeData } from '../types/node';
+import { buildUUID } from '/@/utils/uuid';
+
+export function useAddEdges() {
+  const getAddedgesParams = (params: Connection, data: string | string[] | any) => {
+    return { type: EdgeTypeEnum.CUSTOM, data: { data } as EdgeData, id: buildUUID(), ...params };
+  };
+
+  return { getAddedgesParams };
+}

+import { Node } from '@vue-flow/core';
+import { NodeTypeEnum } from '../enum';
+import { buildUUID } from '/@/utils/uuid';
+import { NodeData } from '../types/node';
+
+export const useAddNodes = () => {
+  const getAddNodesParams = (
+    position: Node['position'],
+    data: NodeData,
+    options?: Partial<Node>
+  ): Node => {
+    return {
+      id: buildUUID(),
+      type: NodeTypeEnum.CUSTOM,
+      position,
+      data,
+      ...options,
+    };
+  };
+
+  return { getAddNodesParams };
+};

+import { Component, computed, ref, shallowRef, toRaw, unref } from 'vue';
+import { fetchConnectionComponent, fetchCreateComponent } from '../packages';
+import { CreateModalDefineExposeType, AwaitPopupWindowReturnDataType } from '../types';
+import { EdgeData, NodeData } from '../types/node';
+import { DataActionModeEnum } from '/@/enums/toolEnum';
+import { ElementsTypeEnum } from '../enum';
+
+interface OptionsType {
+  mode: DataActionModeEnum;
+  type: ElementsTypeEnum;
+}
+
+export interface ElementInfo {
+  id: string;
+  type: ElementsTypeEnum;
+}
+
+export function useAwaitPopupWindowBindData(
+  options: OptionsType = { mode: DataActionModeEnum.CREATE, type: ElementsTypeEnum.NODE }
+) {
+  const { type, mode } = options;
+
+  const visible = ref(false);
+
+  const nodeData = ref<NodeData>();
+
+  const edgeData = ref<EdgeData>();
+
+  const spinning = ref(false);
+
+  const resolveFn = ref<(options: AwaitPopupWindowReturnDataType) => void>();
+
+  const createComponentEl = ref<Nullable<CreateModalDefineExposeType>>();
+
+  const shadowComponent = shallowRef<Nullable<Component>>();
+
+  const elementInfo = ref<ElementInfo>();
+
+  const getNodeSetValue = computed(() => {
+    return unref(mode) === DataActionModeEnum.CREATE
+      ? unref(nodeData)?.config?.configurationDescriptor.nodeDefinition.defaultConfiguration
+      : unref(nodeData)?.data?.configuration;
+  });
+
+  const getEdgeSetValue = computed(() => {
+    return {
+      type:
+        unref(mode) === DataActionModeEnum.CREATE
+          ? unref(nodeData)?.config?.configurationDescriptor?.nodeDefinition.relationTypes
+          : unref(edgeData)?.data,
+    };
+  });
+
+  const getSetValue = computed(() =>
+    unref(type) === ElementsTypeEnum.EDGE ? unref(getEdgeSetValue) : unref(getNodeSetValue)
+  );
+
+  const getComponentKey = computed(() => unref(nodeData)?.config?.key);
+
+  const handleFetchComponent = async (nodeOptions: NodeData, edgeOptions?: EdgeData) => {
+    nodeData.value = nodeOptions;
+    edgeData.value = edgeOptions;
+
+    spinning.value = true;
+    shadowComponent.value = null;
+    const modules =
+      ElementsTypeEnum.NODE === type
+        ? await fetchCreateComponent(nodeOptions.config!)
+        : await fetchConnectionComponent(nodeOptions.config!);
+
+    const component = (await modules?.()) as Record<'default', Component>;
+    shadowComponent.value = component?.default;
+    spinning.value = false;
+  };
+
+  const open = async (
+    nodeData: NodeData,
+    edgeData?: EdgeData,
+    _elementInfo?: ElementInfo
+  ): Promise<AwaitPopupWindowReturnDataType> => {
+    elementInfo.value = _elementInfo;
+    await handleFetchComponent(nodeData, edgeData);
+    return new Promise((_resolve) => {
+      visible.value = true;
+      resolveFn.value = _resolve;
+    });
+  };
+
+  const handleOnMounted = () => {
+    unref(createComponentEl)?.setFieldsValue?.(toRaw(unref(getSetValue)), toRaw(unref(nodeData)));
+  };
+
+  const validate = async () => {
+    return (await unref(createComponentEl)?.validate?.()) || { flag: true };
+  };
+
+  const handleSubmitData = (extraData: Recordable = {}, value: Recordable = {}) => {
+    return Object.assign(
+      {},
+      extraData,
+      unref(type) === ElementsTypeEnum.NODE ? { configuration: toRaw(unref(value)) } : value
+    );
+  };
+
+  const handleSubmit = async (extraData: Recordable = {}) => {
+    const { flag } = await validate();
+    if (!flag) return;
+    const value = await unref(createComponentEl)?.getFieldsValue?.();
+    unref(resolveFn)?.({
+      flag: true,
+      data: handleSubmitData(extraData, value),
+    } as AwaitPopupWindowReturnDataType);
+    visible.value = false;
+  };
+
+  const handleCancel = () => {
+    unref(resolveFn)?.({ flag: false, data: null } as AwaitPopupWindowReturnDataType);
+    visible.value = false;
+  };
+
+  return {
+    visible,
+    nodeData,
+    spinning,
+    elementInfo,
+    shadowComponent,
+    createComponentEl,
+    getComponentKey,
+    open,
+    handleOnMounted,
+    handleSubmit,
+    handleCancel,
+  };
+}

+import { Ref, toRaw, unref } from 'vue';
+import { BasicNodeBindData, NodeData } from '../types/node';
+import { Elements, GraphNode } from '@vue-flow/core';
+import { RuleChainType } from '../types/ruleNode';
+import { allComponents } from '../packages';
+import { RuleNodeTypeEnum } from '../packages/index.type';
+import { buildUUID } from '/@/utils/uuid';
+import { isNullOrUnDef } from '/@/utils/is';
+import { useAddNodes } from './useAddNodes';
+import { useAddEdges } from './useAddEdges';
+
+export function useBasicDataTransform() {
+  const nodeConfigMap = new Map<string, NodeData>();
+
+  function initNodeConfigMap() {
+    for (const key of Object.keys(allComponents)) {
+      const category = allComponents[key as RuleNodeTypeEnum];
+      for (const nodeConfig of category.components) {
+        const { clazz } = nodeConfig;
+        nodeConfigMap.set(clazz, { config: nodeConfig, category: category.category });
+      }
+    }
+  }
+
+  function mergeData(data: NodeData['data'], nodeData: NodeData, node: GraphNode) {
+    const { x: layoutX, y: layoutY } = node.computedPosition;
+
+    return {
+      debugMode: !!data?.debugMode,
+      name: data?.name,
+      type: nodeData.config?.clazz,
+      configuration: toRaw(unref(data?.configuration)),
+      additionalInfo: {
+        description: data?.description,
+        layoutX,
+        layoutY,
+      },
+    };
+  }
+
+  function deconstructionConnection(
+    ruleChain: Ref<RuleChainType> | RuleChainType,
+    inputNodeId: string
+  ) {
+    const { connections, nodes, firstNodeIndex } = unref(ruleChain);
+    const indexMap = new Map<number, BasicNodeBindData>();
+    const groupByConnections = new Map<string, string[]>();
+    const SOURCE_HANDLE = '__handle-right';
+    const TARGET_HANDLE = '__handle-left';
+    const SEPARATOR = ',';
+    const edges: Elements = [];
+    const { getAddedgesParams } = useAddEdges();
+
+    nodes.forEach((item, index) => indexMap.set(index, item));
+
+    (connections || []).forEach((item) => {
+      const { fromIndex, toIndex, type } = item;
+      const key = `${fromIndex}${SEPARATOR}${toIndex}`;
+      if (!groupByConnections.has(key)) groupByConnections.set(key, []);
+
+      const types = groupByConnections.get(key)!;
+      types.push(type);
+    });
+
+    for (const [key, types] of Array.from(groupByConnections.entries())) {
+      const [fromIndex, toIndex] = key.split(SEPARATOR);
+
+      const sourceNode = indexMap.get(Number(fromIndex));
+      const targetNode = indexMap.get(Number(toIndex));
+      const source = sourceNode!.id!.id;
+      const target = targetNode!.id!.id;
+      const sourceHandle = `${source}${SOURCE_HANDLE}`;
+      const targetHandle = `${target}${TARGET_HANDLE}`;
+
+      edges.push(
+        getAddedgesParams(
+          {
+            source,
+            target,
+            sourceHandle,
+            targetHandle,
+          },
+          { type: types }
+        )
+      );
+    }
+
+    if (!isNullOrUnDef(firstNodeIndex)) {
+      const targetNode = indexMap.get(firstNodeIndex);
+      const source = inputNodeId;
+      const target = targetNode!.id!.id;
+      const sourceHandle = `${source}$${SOURCE_HANDLE}`;
+      const targetHandle = `${target}${TARGET_HANDLE}`;
+      edges.push(
+        getAddedgesParams(
+          {
+            source,
+            target,
+            sourceHandle,
+            targetHandle,
+          },
+          {}
+        )
+      );
+    }
+
+    return edges;
+  }
+
+  function genNewNodeByData(node: BasicNodeBindData, config: NodeData) {
+    const { additionalInfo, configuration, debugMode, name, id } = node;
+    const { layoutX, layoutY, description } = additionalInfo || {};
+    const { getAddNodesParams } = useAddNodes();
+
+    return getAddNodesParams(
+      { x: layoutX!, y: layoutY! },
+      {
+        ...config,
+        data: {
+          configuration,
+          debugMode,
+          description,
+          name,
+        },
+        created: !!id?.id,
+      },
+      {
+        id: id?.id || buildUUID(),
+      }
+    );
+  }
+
+  function deconstructionNode(nodes: RuleChainType['nodes']) {
+    const addNodes: Elements = [];
+    for (const node of unref(nodes)) {
+      const { type } = node;
+      if (!type) continue;
+      const nodeConfig = nodeConfigMap.get(type);
+
+      if (!nodeConfig) {
+        throw `No component configuration of type '${type}' was found`;
+      }
+
+      const newNode = genNewNodeByData(node, nodeConfig);
+
+      addNodes.push(newNode);
+    }
+    return addNodes;
+  }
+
+  function deconstructionData(
+    ruleChain: RuleChainType | Ref<RuleChainType | undefined>,
+    inputNodeId: string
+  ) {
+    if (!ruleChain || !unref(ruleChain)) return;
+    ruleChain = toRaw(unref(ruleChain))!;
+
+    const nodes = deconstructionNode(ruleChain?.nodes || []);
+
+    const edges = deconstructionConnection(ruleChain!, inputNodeId);
+
+    return {
+      nodes,
+      edges,
+    };
+  }
+
+  initNodeConfigMap();
+
+  return {
+    mergeData,
+    deconstructionData,
+  };
+}

+import { EdgeProps, useEdge } from '@vue-flow/core';
+import { computed, unref } from 'vue';
+import { MarkerArrowEnum } from '../enum';
+
+export const useConnectionFocus = (props: EdgeProps) => {
+  const { edge } = useEdge(props.id);
+
+  const getSelected = computed(() => unref(edge)?.selected);
+
+  const getMarkerEnd = computed(
+    () =>
+      `url(#${
+        unref(getSelected) ? MarkerArrowEnum.BASIC_ARROW_SELECTED : MarkerArrowEnum.BASIC_ARROW
+      })`
+  );
+
+  return {
+    getMarkerEnd,
+    getSelected,
+  };
+};

+import { GraphEdge, GraphNode, VueFlowStore } from '@vue-flow/core';
+import { getRuleNodeCache, setRuleNodeCache } from './useRuleCopyPaste';
+import { RuleContextMenuEnum } from './useRuleChainContextMenu';
+import { useAddNodes } from './useAddNodes';
+import { buildUUID } from '/@/utils/uuid';
+import { toRaw, unref } from 'vue';
+import { useSaveAndRedo } from './useSaveAndRedo';
+import { isUnDef } from '/@/utils/is';
+import { useAddEdges } from './useAddEdges';
+import { EdgeData } from '../types/node';
+
+interface HandleContextMenuActionParamsType {
+  menuType: RuleContextMenuEnum;
+  event?: Event;
+  flowActionType?: VueFlowStore;
+  node?: GraphNode;
+  edge?: GraphEdge;
+  useSaveAndRedoActionType?: ReturnType<typeof useSaveAndRedo>;
+}
+
+export const NODE_WIDTH = 176;
+export const NODE_HEIGHT = 48;
+
+function getElementsCenter(nodes: GraphNode[]) {
+  let leftTopX: number | undefined;
+  let leftTopY: number | undefined;
+  let rightBottomX: number | undefined;
+  let rightBottomY: number | undefined;
+
+  for (const node of nodes) {
+    const { position } = node;
+    const { x, y } = position;
+    if (isUnDef(leftTopX)) {
+      leftTopX = x;
+      leftTopY = y;
+      rightBottomX = x + NODE_WIDTH;
+      rightBottomY = y + NODE_HEIGHT;
+
+      continue;
+    }
+
+    if (x < leftTopX!) {
+      leftTopX = x;
+      if (y < leftTopY!) {
+        leftTopY = y;
+      }
+      continue;
+    }
+
+    if (x + NODE_WIDTH > rightBottomX!) {
+      rightBottomX = x + NODE_WIDTH;
+      if (y + NODE_HEIGHT > rightBottomY!) {
+        rightBottomY = y + NODE_HEIGHT;
+      }
+    }
+  }
+
+  return {
+    originX: (rightBottomX! - leftTopX!) / 2 + leftTopX!,
+    originY: (rightBottomY! - leftTopY!) / 2 + leftTopY!,
+  };
+}
+
+export function useContextMenuAction() {
+  const copy = (params: HandleContextMenuActionParamsType) => {
+    const { node } = params;
+    if (!node) return;
+    const { position, data } = node;
+    const { getAddNodesParams } = useAddNodes();
+    const { x, y } = position;
+
+    const value = getAddNodesParams(position, data, { id: buildUUID() });
+
+    setRuleNodeCache({
+      nodes: [value],
+      originX: x + NODE_WIDTH / 2 + x,
+      originY: y + NODE_HEIGHT / 2,
+    });
+  };
+
+  const paste = (params: HandleContextMenuActionParamsType) => {
+    const { event, flowActionType, useSaveAndRedoActionType } = params;
+    const { triggerChange } = useSaveAndRedoActionType || {};
+    const { getAddNodesParams } = useAddNodes();
+    const { getAddedgesParams } = useAddEdges();
+    const clientX = (event as MouseEvent).offsetX;
+    const clientY = (event as MouseEvent).offsetY;
+
+    const { edges = [], nodes = [], originX, originY } = getRuleNodeCache();
+
+    const newNode = nodes.map((node) => {
+      const { position, data, id } = node;
+      const { x, y } = position;
+
+      const newX = clientX - originX! + x + NODE_WIDTH / 2;
+      const newY = clientY - originY! + y + NODE_HEIGHT / 2;
+
+      return getAddNodesParams({ x: newX, y: newY }, { ...data, created: false }, { id });
+    });
+
+    const newEdges = edges.map((edge) => getAddedgesParams(edge, edge.data));
+
+    flowActionType?.addNodes(newNode);
+    flowActionType?.addEdges(newEdges);
+
+    triggerChange?.();
+
+    flowActionType?.removeSelectedElements();
+  };
+
+  const selectAll = (params: HandleContextMenuActionParamsType) => {
+    const { flowActionType } = params;
+    flowActionType?.addSelectedElements(unref(flowActionType.getElements));
+  };
+
+  const unselect = (params: HandleContextMenuActionParamsType) => {
+    const { flowActionType } = params;
+    flowActionType?.removeSelectedElements();
+  };
+
+  const deleteElement = (parmas: HandleContextMenuActionParamsType) => {
+    const { useSaveAndRedoActionType, flowActionType, node, edge } = parmas;
+    const { triggerChange } = useSaveAndRedoActionType || {};
+
+    node && flowActionType?.removeNodes(node);
+    edge && flowActionType?.removeEdges(edge);
+
+    triggerChange?.();
+  };
+
+  const deleteElements = (params: HandleContextMenuActionParamsType) => {
+    const { flowActionType, useSaveAndRedoActionType } = params;
+    flowActionType?.removeNodes(unref(flowActionType.getSelectedNodes));
+
+    useSaveAndRedoActionType?.triggerChange?.();
+  };
+
+  const selectCopy = (params: HandleContextMenuActionParamsType) => {
+    const { flowActionType } = params;
+    const { getAddNodesParams } = useAddNodes();
+    const { getAddedgesParams } = useAddEdges();
+
+    const edges = unref(flowActionType?.getSelectedEdges)?.map((edge) =>
+      getAddedgesParams(
+        {
+          source: edge.source,
+          target: edge.target,
+          sourceHandle: edge.sourceHandle,
+          targetHandle: edge.targetHandle,
+        },
+        toRaw(unref(edge.data as EdgeData)?.data)
+      )
+    );
+
+    const nodes = unref(flowActionType?.getSelectedNodes)?.map((node) => {
+      const { id: oldId } = node;
+      const newId = buildUUID();
+
+      for (const connection of edges || []) {
+        if (connection.source.includes(oldId)) {
+          connection.source = newId;
+          connection.sourceHandle = connection.sourceHandle?.replaceAll(oldId, newId);
+          continue;
+        }
+
+        if (connection.target.includes(oldId)) {
+          connection.target = newId;
+          connection.targetHandle = connection.targetHandle?.replaceAll(oldId, newId);
+        }
+      }
+
+      return getAddNodesParams(node.position, toRaw(unref(node.data)), { id: newId });
+    });
+
+    const originRect = getElementsCenter(unref(flowActionType?.getSelectedNodes) || []);
+
+    setRuleNodeCache({ nodes, edges, ...originRect });
+  };
+
+  const applyChange = (params: HandleContextMenuActionParamsType) => {
+    const { useSaveAndRedoActionType, flowActionType } = params;
+
+    useSaveAndRedoActionType?.handleApplyChange(flowActionType!);
+  };
+
+  const undoChange = (params: HandleContextMenuActionParamsType) => {
+    const { useSaveAndRedoActionType, flowActionType } = params;
+
+    useSaveAndRedoActionType?.handleRedoChange(flowActionType!);
+  };
+
+  const handleContextMenuAction = (params: HandleContextMenuActionParamsType) => {
+    const { menuType } = params;
+
+    const handlerMapping = {
+      [RuleContextMenuEnum.COPY]: copy,
+      [RuleContextMenuEnum.PASTE]: paste,
+      [RuleContextMenuEnum.SELECT_ALL]: selectAll,
+      [RuleContextMenuEnum.UNSELECTED]: unselect,
+      [RuleContextMenuEnum.DELETE]: deleteElement,
+      [RuleContextMenuEnum.DELETE_SELECT]: deleteElements,
+      [RuleContextMenuEnum.SELECT_COPY]: selectCopy,
+      [RuleContextMenuEnum.APPLY_CHANGE]: applyChange,
+      [RuleContextMenuEnum.UNDO_CHANGE]: undoChange,
+    };
+
+    if (handlerMapping[menuType]) {
+      handlerMapping[menuType]?.(params);
+    }
+  };
+
+  return {
+    handleContextMenuAction,
+  };
+}

+import type { NodeItemConfigType } from '../types/node';
+
+export function useCreateNodeKey(scope: string) {
+  return {
+    key: scope,
+    createComponentKey: `VC_CREATE_${scope}`,
+    connectionComponentKey: `VCC_CONNECTION_${scope}`,
+  } as NodeItemConfigType;
+}

+import { Ref, toRaw, unref } from 'vue';
+import { NodeData } from '../types/node';
+
+export function useDataTool() {
+  /**
+   * @description 通过NodeData获取默认配置信息
+   * @param nodeData
+   * @returns
+   */
+  function getDefaultConfigurationByNodeData<T = any>(nodeData: Ref<NodeData> | NodeData) {
+    nodeData = toRaw(unref(nodeData));
+
+    const { nodeDefinition } = nodeData.config?.configurationDescriptor || {};
+    const { defaultConfiguration } = nodeDefinition || {};
+
+    return { defaultConfiguration: defaultConfiguration as T };
+  }
+
+  /**
+   * @description 通过NodeData获取节点绑定信息
+   * @param nodeData
+   * @returns
+   */
+  function getBindDataByNodeData<T = any>(nodeData: Ref<NodeData> | NodeData) {
+    nodeData = toRaw(unref(nodeData));
+
+    const data = nodeData.data as T;
+
+    return { data };
+  }
+
+  return { getDefaultConfigurationByNodeData, getBindDataByNodeData };
+}

+import { Ref, toRaw, unref } from 'vue';
+import type { VueFlowStore } from '@vue-flow/core';
+import type { FlowElRef } from '../types/flow';
+import type { CreateNodeModal } from '../src/components/CreateNodeModal';
+import type { DragTransferData } from '../types/node';
+import { useAddNodes } from './useAddNodes';
+
+type EffectSymbol = DataTransfer['dropEffect'];
+
+export const TRANSFER_DATA_KEY = 'NODE_INFO';
+export const EFFECT_SYMBOL: EffectSymbol = 'move';
+
+interface UseDragCreateOptionsType {
+  el: Ref<Nullable<FlowElRef>>;
+  createNodeModalActionType: Ref<Nullable<InstanceType<typeof CreateNodeModal>>>;
+  flowActionType: VueFlowStore;
+  triggerChange: () => void;
+}
+
+export function useDragCreate(options: UseDragCreateOptionsType) {
+  const { el, createNodeModalActionType, flowActionType, triggerChange } = options;
+  const { project, addNodes } = flowActionType;
+  const { getAddNodesParams } = useAddNodes();
+
+  const handleOnDrop = async (event: DragEvent) => {
+    const value = event.dataTransfer?.getData(TRANSFER_DATA_KEY);
+    const transferData: DragTransferData = JSON.parse(value || '');
+    const { options: nodeData, offsetX, offsetY } = transferData;
+    const { flag, data } = (await unref(createNodeModalActionType)?.open(nodeData)) || {};
+    if (!flag) return;
+
+    const flowBounds = unref(el)?.$el.getBoundingClientRect() as DOMRect;
+
+    const position = project({
+      x: event.clientX - flowBounds.left - offsetX,
+      y: event.clientY - flowBounds.top - offsetY,
+    });
+
+    const newNode = getAddNodesParams(position, { ...toRaw(unref(nodeData)), data });
+    addNodes(newNode);
+
+    triggerChange();
+  };
+
+  const handleOnDragOver = (event: DragEvent) => {
+    event.preventDefault();
+
+    if (event.dataTransfer) event.dataTransfer.dropEffect = EFFECT_SYMBOL;
+  };
+
+  const handleOnDragStart = (event: DragEvent, options: object) => {
+    if (event.dataTransfer) {
+      event.dataTransfer.setData(TRANSFER_DATA_KEY, JSON.stringify(options));
+      event.dataTransfer.effectAllowed = EFFECT_SYMBOL;
+    }
+  };
+
+  return {
+    handleOnDrop,
+    handleOnDragOver,
+    handleOnDragStart,
+  };
+}

+import type { Ref } from 'vue';
+import { inject, provide } from 'vue';
+import type { VueFlowStore } from '@vue-flow/core';
+import type { CreateNodeModal } from '../src/components/CreateNodeModal';
+import type { CreateEdgeModal } from '../src/components/CreateEdgeModal';
+import { UpdateNodeDrawer } from '../src/components/UpdateNodeDrawer';
+import { UpdateEdgeDrawer } from '../src/components/UpdateEdgeDrawer';
+
+const SYMBOL = Symbol('flow-context');
+
+interface FlowContextOptionsType {
+  /**
+   * @description 节点 actions
+   */
+  createNodeModalActionType: Ref<Nullable<InstanceType<typeof CreateNodeModal>>>;
+
+  /**
+   * @description 连接线 actions
+   */
+  createEdgeModalActionType: Ref<Nullable<InstanceType<typeof CreateEdgeModal>>>;
+
+  /**
+   * @description 节点更新 actions
+   */
+  updateNodeDrawerActionType: Ref<Nullable<InstanceType<typeof UpdateNodeDrawer>>>;
+
+  /**
+   * @description 连接线更新 actions
+   */
+  updateEdgeDrawerActionType: Ref<Nullable<InstanceType<typeof UpdateEdgeDrawer>>>;
+
+  /**
+   * @description vue flow store
+   */
+  flowActionType: VueFlowStore;
+
+  /**
+   * @description 更新变化
+   */
+  triggerChange: () => void;
+}
+
+export const createFlowContext = (options: FlowContextOptionsType) => {
+  provide(SYMBOL, options);
+};
+
+export const useFlowContext = () => {
+  return inject(SYMBOL) as FlowContextOptionsType;
+};

+import { useFullscreen } from '@vueuse/core';
+import type { Ref } from 'vue';
+import { computed, unref } from 'vue';
+
+export function useFullScreen(el: Ref<Nullable<HTMLDivElement>>) {
+  const { toggle, isFullscreen } = useFullscreen(el);
+
+  const getFullScreenIcon = computed(() =>
+    unref(isFullscreen) ? 'bx:exit-fullscreen' : 'mdi:fullscreen'
+  );
+
+  return {
+    getFullScreenIcon,
+    handleFullScreen: toggle,
+  };
+}

+import { Config as InputConfig } from '../packages/Entry/Input/config';
+import { useAddNodes } from './useAddNodes';
+
+export function useInputNode() {
+  const getInputNodeConfig = (id?: string) => {
+    const { getAddNodesParams } = useAddNodes();
+
+    const newNode = getAddNodesParams(
+      { x: 80, y: 50 },
+      {
+        ...new InputConfig(),
+        data: {
+          name: '输入',
+          description: '规则链的逻辑输入,将传入消息转发到下一个相关规则节点。',
+        },
+      },
+      { id, draggable: false, selectable: false }
+    );
+
+    return newNode;
+  };
+
+  return { getInputNodeConfig };
+}

+import { NodeMouseEvent } from '@vue-flow/core';
+import { useContextMenu } from '../src/components/RuleChainContextMenu';
+import { RuleChainContextMenuItemType } from '../src/components/RuleChainContextMenu/index.type';
+import { ElementsTypeEnum } from '../enum';
+import { checkHasCacheRuleNode } from './useRuleCopyPaste';
+
+export enum RuleContextMenuEnum {
+  DETAIL = 'DETAIL',
+  COPY = 'COPY',
+  DELETE = 'DELETE',
+
+  SELECT_COPY = 'SELECT_COPY',
+  PASTE = 'PASTE',
+  UNSELECTED = 'UNSELECTED',
+  DELETE_SELECT = 'DELETE_SELECT',
+  APPLY_CHANGE = 'APPLY_CHANGE',
+  UNDO_CHANGE = 'UNDO_CHANGE',
+
+  SELECT_ALL = 'SELECT_ALL',
+}
+
+export enum RuleContextMenuNameEnum {
+  DETAIL = '详情',
+  COPY = '复制',
+  DELETE = '删除',
+
+  SELECT_COPY = '选择副本',
+  PASTE = '粘贴',
+  UNSELECTED = '取消选择',
+  DELETE_SELECT = '删除选定',
+  APPLY_CHANGE = '应用更改',
+  UNDO_CHANGE = '撤销更改',
+
+  SELECT_ALL = '选择全部',
+}
+
+export enum RuleChainContextMenuIconEnum {
+  DETAIL = 'material-symbols:menu',
+  COPY = 'material-symbols:content-copy',
+  DELETE = 'material-symbols:delete',
+
+  SELECT_COPY = 'material-symbols:content-copy',
+  PASTE = 'material-symbols:content-paste',
+  UNSELECTED = 'material-symbols:tab-unselected',
+  DELETE_SELECT = 'material-symbols:close',
+  APPLY_CHANGE = 'material-symbols:done',
+  UNDO_CHANGE = 'material-symbols:close',
+
+  SELECT_ALL = 'material-symbols:select-all',
+
+  // LINK = 'material-symbols:trending-flat',
+}
+
+export enum RuleChainContextMenuShortcutKeyEnum {
+  DELETE = 'Ctrl(⌘) X',
+
+  SELECT_COPY = 'Ctrl(⌘) C',
+  PASTE = 'Ctrl(⌘) V',
+  UNSELECTED = 'Esc',
+  DELETE_SELECT = 'Del',
+  APPLY_CHANGE = 'Ctrl(⌘) S',
+  UNDO_CHANGE = 'Ctrl(⌘) Z',
+
+  SELECT_ALL = 'Ctrl(⌘) A',
+}
+
+const getMenuItem = (key: RuleContextMenuEnum, handler: Fn, disabled = false) => {
+  return {
+    key,
+    label: RuleContextMenuNameEnum[key],
+    icon: RuleChainContextMenuIconEnum[key],
+    shortcutKey: RuleChainContextMenuShortcutKeyEnum[key],
+    handler: () => handler?.(key),
+    disabled,
+  } as RuleChainContextMenuItemType;
+};
+
+const getDivider = (): RuleChainContextMenuItemType => ({ divider: true });
+
+export function useCreateRuleChainContextMenu() {
+  const [createContextMenu] = useContextMenu();
+
+  const createNodeContextMenu = (params: NodeMouseEvent): Promise<RuleContextMenuEnum | ''> => {
+    return new Promise(async (resolve) => {
+      await createContextMenu(params, {
+        items: [
+          getMenuItem(RuleContextMenuEnum.DETAIL, resolve),
+          getMenuItem(RuleContextMenuEnum.COPY, resolve),
+          getMenuItem(RuleContextMenuEnum.DELETE, resolve),
+        ],
+      });
+      resolve('');
+    });
+  };
+
+  const createElementsSelectedContextMenu = (
+    params: NodeMouseEvent,
+    changeMarker: boolean,
+    elementsType: ElementsTypeEnum.NODE = ElementsTypeEnum.NODE
+  ): Promise<RuleContextMenuEnum | ''> => {
+    return new Promise(async (resolve) => {
+      await createContextMenu(params, {
+        items: [
+          ...(elementsType === ElementsTypeEnum.NODE
+            ? [getMenuItem(RuleContextMenuEnum.SELECT_COPY, resolve)]
+            : []),
+          getMenuItem(RuleContextMenuEnum.PASTE, resolve, !checkHasCacheRuleNode()),
+          getDivider(),
+          getMenuItem(RuleContextMenuEnum.UNSELECTED, resolve),
+          getMenuItem(RuleContextMenuEnum.DELETE_SELECT, resolve),
+          getDivider(),
+          getMenuItem(RuleContextMenuEnum.APPLY_CHANGE, resolve, !changeMarker),
+          getMenuItem(RuleContextMenuEnum.UNDO_CHANGE, resolve, !changeMarker),
+        ],
+      });
+      resolve('');
+    });
+  };
+
+  const createPanelContextMenu = (
+    params: NodeMouseEvent,
+    changeMarker: boolean
+  ): Promise<RuleContextMenuEnum | ''> => {
+    return new Promise(async (resolve) => {
+      await createContextMenu(params, {
+        items: [
+          getMenuItem(RuleContextMenuEnum.PASTE, resolve, !checkHasCacheRuleNode()),
+          getMenuItem(RuleContextMenuEnum.SELECT_ALL, resolve),
+          getMenuItem(RuleContextMenuEnum.APPLY_CHANGE, resolve, !changeMarker),
+          getMenuItem(RuleContextMenuEnum.UNDO_CHANGE, resolve, !changeMarker),
+        ],
+      });
+      resolve('');
+    });
+  };
+
+  const createEdgeContextMenu = (
+    params: NodeMouseEvent,
+    isInput = false
+  ): Promise<RuleContextMenuEnum | ''> => {
+    return new Promise(async (resolve) => {
+      await createContextMenu(params, {
+        items: [
+          ...(isInput ? [] : [getMenuItem(RuleContextMenuEnum.DETAIL, resolve)]),
+          getMenuItem(RuleContextMenuEnum.DELETE, resolve),
+        ],
+      });
+      resolve('');
+    });
+  };
+  return {
+    createNodeContextMenu,
+    createElementsSelectedContextMenu,
+    createPanelContextMenu,
+    createEdgeContextMenu,
+  };
+}

+import { Edge, Node } from '@vue-flow/core';
+import { RULE_NODE_KEY, RULE_NODE_LOCAL_CACHE_KEY } from '/@/enums/cacheEnum';
+import { createLocalStorage } from '/@/utils/cache';
+
+const ruleNodeStorage = createLocalStorage({ prefixKey: RULE_NODE_LOCAL_CACHE_KEY });
+
+interface RuleNodeCacheType {
+  nodes?: Node[];
+  edges?: Edge[];
+  originX?: number;
+  originY?: number;
+}
+
+export const setRuleNodeCache = ({
+  nodes = [],
+  edges = [],
+  originX,
+  originY,
+}: RuleNodeCacheType) => {
+  ruleNodeStorage.set(RULE_NODE_KEY, {
+    nodes,
+    edges,
+    originX,
+    originY,
+  });
+};
+
+export const getRuleNodeCache = (): RuleNodeCacheType => ruleNodeStorage.get(RULE_NODE_KEY);
+
+export const checkHasCacheRuleNode = () => !!getRuleNodeCache();
+
+function initRuleNodeStorage() {
+  const value = ruleNodeStorage.get(RULE_NODE_KEY);
+  value && ruleNodeStorage.set(RULE_NODE_KEY, value);
+}
+
+initRuleNodeStorage();

+import type {
+  Connection,
+  EdgeComponent,
+  NodeComponent,
+  ValidConnectionFunc,
+  GraphNode,
+  NodeMouseEvent,
+  GraphEdge,
+  EdgeMouseEvent,
+} from '@vue-flow/core';
+import type { Ref } from 'vue';
+import type { CreateNodeModal } from '../src/components/CreateNodeModal';
+import type { EdgeData, NodeData } from '../types/node';
+import type { CreateEdgeModal } from '../src/components/CreateEdgeModal';
+import { BasicEdge, BasicNode } from '../src/components';
+import { EdgeTypeEnum, ElementsTypeEnum, NodeTypeEnum } from '../enum';
+import { markRaw, toRaw, unref } from 'vue';
+import { isFunction } from 'lodash-es';
+import { ConnectionLineType, SelectionMode, useVueFlow } from '@vue-flow/core';
+import { isInputHandle, isOutputHandle } from '../utils';
+import { useAddEdges } from './useAddEdges';
+import { UpdateNodeDrawer } from '../src/components/UpdateNodeDrawer';
+import { UpdateEdgeDrawer } from '../src/components/UpdateEdgeDrawer';
+import { isNumber } from '/@/utils/is';
+import { RuleContextMenuEnum, useCreateRuleChainContextMenu } from './useRuleChainContextMenu';
+import { RuleChainDetail } from '../types/ruleNode';
+import { useContextMenuAction } from './useContextMenuAction';
+import { useSaveAndRedo } from './useSaveAndRedo';
+import { EntryCategoryComponentEnum } from '../enum/category';
+
+interface UseRuleFlowOptionsType {
+  id: string;
+  ruleChainDetail: Ref<RuleChainDetail | undefined>;
+  createNodeModalActionType: Ref<Nullable<InstanceType<typeof CreateNodeModal>>>;
+  createEdgeModalActionType: Ref<Nullable<InstanceType<typeof CreateEdgeModal>>>;
+  updateNodeDrawerActionType: Ref<Nullable<InstanceType<typeof UpdateNodeDrawer>>>;
+  updateEdgeDrawerActionType: Ref<Nullable<InstanceType<typeof UpdateEdgeDrawer>>>;
+  useSaveAndRedoActionType: ReturnType<typeof useSaveAndRedo>;
+}
+
+const validateInputAndOutput: ValidConnectionFunc = (connection: Connection) => {
+  const { sourceHandle, targetHandle, source, target } = connection;
+
+  return (
+    isOutputHandle(sourceHandle || '') && isInputHandle(targetHandle || '') && source !== target
+  );
+};
+
+export function useRuleFlow(options: UseRuleFlowOptionsType) {
+  const {
+    id,
+    ruleChainDetail,
+    createEdgeModalActionType,
+    updateEdgeDrawerActionType,
+    updateNodeDrawerActionType,
+    useSaveAndRedoActionType,
+  } = options;
+
+  const { triggerChange } = useSaveAndRedoActionType;
+
+  const flowActionType = useVueFlow({
+    id,
+    maxZoom: 1,
+    minZoom: 1,
+    panOnScroll: true,
+    selectionMode: SelectionMode.Partial,
+    nodeTypes: {
+      [NodeTypeEnum.CUSTOM]: markRaw(BasicNode) as NodeComponent,
+    },
+    edgeTypes: {
+      [EdgeTypeEnum.CUSTOM]: markRaw(BasicEdge) as EdgeComponent,
+    },
+    connectionLineOptions: {
+      type: ConnectionLineType.Bezier,
+    },
+    defaultViewport: {
+      x: 0,
+      y: 0,
+    },
+    isValidConnection(connection, elements) {
+      const validateList = [validateInputAndOutput];
+      const targetData = elements.targetNode.data as NodeData;
+
+      if (
+        targetData.category?.validateConnection &&
+        isFunction(targetData.category.validateConnection)
+      )
+        validateList.push(targetData.category?.validateConnection);
+
+      if (targetData.config?.validateConnection && isFunction(targetData.config.validateConnection))
+        validateList.push(targetData.config.validateConnection);
+
+      if (!validateList.every((item) => item(connection, elements))) return false;
+
+      return true;
+    },
+  });
+
+  const {
+    getEdges,
+    addEdges,
+    findEdge,
+    findNode,
+    setViewport,
+    removeEdges,
+    onConnect,
+    onPaneReady,
+    onNodeDoubleClick,
+    onEdgeDoubleClick,
+    onNodeDragStop,
+    onNodeContextMenu,
+    onEdgeContextMenu,
+    onPaneContextMenu,
+  } = flowActionType;
+
+  const { getAddedgesParams } = useAddEdges();
+
+  onConnect(async (params) => {
+    const { source } = params;
+    const sourceNode = findNode(source);
+    const sourceData = sourceNode?.data as NodeData;
+
+    let types: string[] = [];
+
+    if (sourceData && validateHasLabelConnection(sourceData)) {
+      const { flag, data } = (await unref(createEdgeModalActionType)?.open(sourceData)) || {};
+      if (!flag) return;
+      types = toRaw(unref(data));
+    }
+
+    handleMaxConnectionPoint(sourceNode);
+
+    addEdges(getAddedgesParams(params, types));
+
+    triggerChange();
+  });
+
+  onPaneReady(async () => {
+    setViewport({ x: 0, y: 0, zoom: 1 });
+  });
+
+  onNodeDoubleClick(async ({ node }) => {
+    handleUpdateNode(node);
+  });
+
+  onEdgeDoubleClick(async ({ edge }) => {
+    handleUpdateEdge(edge);
+  });
+
+  onNodeDragStop(() => {
+    triggerChange();
+  });
+
+  const {
+    createNodeContextMenu,
+    createElementsSelectedContextMenu,
+    createEdgeContextMenu,
+    createPanelContextMenu,
+  } = useCreateRuleChainContextMenu();
+
+  const { handleContextMenuAction } = useContextMenuAction();
+
+  onNodeContextMenu(async (params) => {
+    const menuType = params.node.selected
+      ? await createElementsSelectedContextMenu(
+          params,
+          unref(useSaveAndRedoActionType.changeMarker)
+        )
+      : await createNodeContextMenu(params);
+
+    if (menuType) {
+      if (menuType === RuleContextMenuEnum.DETAIL) {
+        handleUpdateNode(params.node);
+        return;
+      }
+
+      handleContextMenuAction({
+        menuType,
+        flowActionType,
+        event: params.event,
+        node: params.node,
+        useSaveAndRedoActionType,
+      });
+    }
+  });
+
+  onEdgeContextMenu(async (params) => {
+    const isInputNode =
+      (params.edge.sourceNode.data as NodeData).config?.key === EntryCategoryComponentEnum.INPUT;
+    const menuType = await createEdgeContextMenu(
+      getCreateEdgeContextMenuParams(params),
+      isInputNode
+    );
+
+    if (menuType) {
+      if (menuType === RuleContextMenuEnum.DETAIL) {
+        handleUpdateEdge(params.edge);
+        return;
+      }
+
+      handleContextMenuAction({
+        menuType,
+        flowActionType,
+        event: params.event,
+        useSaveAndRedoActionType,
+        edge: params.edge,
+      });
+    }
+  });
+
+  onPaneContextMenu(async (params) => {
+    const menuType = unref(flowActionType.getSelectedElements).length
+      ? await createElementsSelectedContextMenu(
+          getCreatePanelContextMenuParams(params),
+          unref(useSaveAndRedoActionType.changeMarker)
+        )
+      : await createPanelContextMenu(
+          getCreatePanelContextMenuParams(params),
+          unref(useSaveAndRedoActionType.changeMarker)
+        );
+
+    if (menuType) {
+      handleContextMenuAction({
+        menuType,
+        flowActionType,
+        event: params,
+        useSaveAndRedoActionType,
+      });
+    }
+  });
+
+  /**
+   * @description 验证是否有连接label
+   * @param sourceData
+   * @returns
+   */
+  function validateHasLabelConnection(sourceData: NodeData) {
+    return !!sourceData?.config?.configurationDescriptor.nodeDefinition?.relationTypes?.length;
+  }
+
+  function handleMaxConnectionPoint(sourceNode?: GraphNode) {
+    if (!sourceNode) return;
+
+    const maxConnectionPoint = unref(sourceNode).data?.config?.maxConnectionPoint;
+
+    if (!maxConnectionPoint || !isNumber(maxConnectionPoint)) return;
+
+    const sourceId = sourceNode.id;
+    const connectionPool = unref(getEdges).filter((item) => item.source === sourceId);
+    if (connectionPool.length >= maxConnectionPoint && connectionPool[0]) {
+      removeEdges(connectionPool[0].id);
+    }
+  }
+
+  async function handleUpdateNode(node: GraphNode) {
+    if ((node.data as NodeData).config?.disableAction) return;
+    const { flag, data } =
+      (await unref(updateNodeDrawerActionType)?.open(
+        toRaw((node as NodeData)?.data as unknown as NodeData),
+        void 0,
+        { id: node.id, type: ElementsTypeEnum.NODE }
+      )) || {};
+
+    if (!flag) return;
+
+    const currentNode = findNode(node.id);
+    (currentNode!.data as NodeData).data = data;
+    triggerChange();
+  }
+
+  async function handleUpdateEdge(edge: GraphEdge) {
+    if (!validateHasLabelConnection(edge.sourceNode.data)) return;
+
+    if ((edge.sourceNode.data as NodeData).config?.disableAction) return;
+
+    const { flag, data } =
+      (await unref(updateEdgeDrawerActionType)?.open(
+        toRaw(unref(edge.sourceNode?.data as unknown as NodeData)),
+        toRaw(unref(edge.data as EdgeData)),
+        { id: edge.id, type: ElementsTypeEnum.EDGE }
+      )) || {};
+
+    if (!flag) return;
+
+    const currentEdge = findEdge(edge.id);
+
+    (currentEdge!.data as EdgeData).data = toRaw(unref(data));
+
+    triggerChange?.();
+  }
+
+  function getCreatePanelContextMenuParams(params: Event) {
+    return {
+      event: params as MouseEvent,
+      node: {
+        data: {
+          data: { name: '规则链' },
+          config: {
+            name: unref(ruleChainDetail)?.name,
+            backgroundColor: '#aac7e4',
+            configurationDescriptor: {
+              nodeDefinition: {
+                icon: 'material-symbols:settings-ethernet',
+              },
+            },
+          },
+        },
+      },
+    } as NodeMouseEvent;
+  }
+
+  function getCreateEdgeContextMenuParams(params: EdgeMouseEvent) {
+    return {
+      event: params.event as MouseEvent,
+      node: {
+        data: {
+          data: { name: '链接' },
+          config: {
+            name: unref(params.edge.data as EdgeData)?.data?.type?.join(' / '),
+            backgroundColor: '#aac7e4',
+            configurationDescriptor: {
+              nodeDefinition: {
+                icon: 'material-symbols:trending-flat',
+              },
+            },
+          },
+        },
+      },
+    } as NodeMouseEvent;
+  }
+
+  return { flowActionType };
+}