Merge branch 'refactor/linkedge' into 'main_dev'

refactor: 重构场景联动

See merge request yunteng/thingskit-front!1020

@@ -25,7 +25,7 @@ module.exports = defineConfig({
     'plugin:jest/recommended',
     'plugin:jest/recommended',
   ],
   ],
   rules: {
   rules: {
-    'no-console': 'off',
+    'no-console': 'error',
     'vue/script-setup-uses-vars': 'error',
     'vue/script-setup-uses-vars': 'error',
     '@typescript-eslint/ban-ts-ignore': 'off',
     '@typescript-eslint/ban-ts-ignore': 'off',
     '@typescript-eslint/explicit-function-return-type': 'off',
     '@typescript-eslint/explicit-function-return-type': 'off',

 import { DataType } from '../../device/model/modelOfMatterModel';
 import { DataType } from '../../device/model/modelOfMatterModel';
-import { DataTypeEnum } from '/@/components/Form/src/externalCompns/components/StructForm/config';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
 import { DataSource } from '/@/views/visual/palette/types';
 import { DataSource } from '/@/views/visual/palette/types';
 
 
 export interface AddDataBoardParams {
 export interface AddDataBoardParams {

-import {
-  DataTypeEnum,
-  FunctionType,
-} from '/@/views/device/profiles/step/cpns/physical/cpns/config';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
+import { FunctionType } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
 
 
 export interface Specs {
 export interface Specs {
   min: string;
   min: string;
@@ -26,7 +24,7 @@ export interface DataType {
 
 
 export interface StructJSON {
 export interface StructJSON {
   functionName?: string;
   functionName?: string;
-  identifier?: string;
+  identifier: string;
   remark?: string;
   remark?: string;
   dataType?: DataType;
   dataType?: DataType;
   serviceCommand?: string;
   serviceCommand?: string;

 import { BasicPageParams } from '/@/api/model/baseModel';
 import { BasicPageParams } from '/@/api/model/baseModel';
+import { SceneLinkageDataType } from '/@/views/rule/linkedge/components/SceneLinkageDrawer/type';
 
 
 export type ScreenLinkPageQueryParam = BasicPageParams & ScreenParams;
 export type ScreenLinkPageQueryParam = BasicPageParams & ScreenParams;
 
 
@@ -14,97 +15,7 @@ export type ScreenByDeptIdParams = {
   // organizationId: '2f5c8f2a-196c-4941-8771-290f9da76219';
   // organizationId: '2f5c8f2a-196c-4941-8771-290f9da76219';
 };
 };
 
 
-export interface ScreenAddModel {
-  createTime?: string;
-  creator?: string;
-  defaultConfig?: string;
-  description?: string;
-  doAction?: [
-    {
-      command: string;
-      createTime: string;
-      creator: string;
-      defaultConfig: string;
-      description: string;
-      deviceId: string;
-      enabled: true;
-      icon: string;
-      id: string;
-      name: string;
-      outPut: string;
-      outTarget: string;
-      roleIds: [];
-      tenantCode: string;
-      tenantExpireTime: string;
-      tenantId: string;
-      tenantStatus: 'DISABLED';
-      updateTime: string;
-      updater: string;
-    }
-  ];
-  doCondition?: [
-    {
-      compare: 0;
-      createTime: string;
-      creator: string;
-      defaultConfig: string;
-      description: string;
-      deviceId: string;
-      enabled: true;
-      icon: string;
-      id: string;
-      name: string;
-      property: string;
-      roleIds: [];
-      status: string;
-      tenantCode: string;
-      tenantExpireTime: string;
-      tenantId: string;
-      tenantStatus: 'DISABLED';
-      updateTime: string;
-      updater: string;
-      value: string;
-    }
-  ];
-  enabled?: true;
-  icon?: string;
-  id?: string;
-  name?: string;
-  organizationId?: string;
-  roleIds?: [string];
-  status?: string;
-  tenantCode?: string;
-  tenantExpireTime?: string;
-  tenantId?: string;
-  tenantStatus?: 'DISABLED';
-  triggers?: [
-    {
-      attributeChoose?: string;
-      compare?: 0;
-      createTime?: string;
-      creator?: string;
-      defaultConfig?: string;
-      description?: string;
-      deviceId?: string;
-      enabled?: true;
-      icon?: string;
-      id?: string;
-      name?: string;
-      roleIds?: [];
-      tenantCode?: string;
-      tenantExpireTime?: string;
-      tenantId?: string;
-      tenantStatus?: 'DISABLED';
-      tiggerEvent?: string;
-      touchWay?: string;
-      updateTime?: string;
-      updater?: string;
-      value?: string;
-    }
-  ];
-  updateTime?: string;
-  updater?: string;
-}
+export type ScreenAddModel = SceneLinkageDataType;
 
 
 export interface IChangeStatus {
 export interface IChangeStatus {
   status?: number;
   status?: number;

@@ -6,6 +6,7 @@ import {
   ScreenByDeptIdParams,
   ScreenByDeptIdParams,
   IChangeStatus,
   IChangeStatus,
 } from '/@/api/ruleengine/model/ruleengineModel';
 } from '/@/api/ruleengine/model/ruleengineModel';
+import { DeviceModel } from '../device/model/deviceModel';
 
 
 enum ScreenManagerApi {
 enum ScreenManagerApi {
   /**
   /**
@@ -126,7 +127,7 @@ export const byOrganizationIdGetMasterDevice = (params: {
   deviceProfileId?: string;
   deviceProfileId?: string;
 }) => {
 }) => {
   const { organizationId, deviceProfileId } = params;
   const { organizationId, deviceProfileId } = params;
-  return defHttp.get({
+  return defHttp.get<DeviceModel[]>({
     url: `${ScreenManagerApi.MASTER_GET_DEVICE}`,
     url: `${ScreenManagerApi.MASTER_GET_DEVICE}`,
     params: { deviceProfileId, organizationId },
     params: { deviceProfileId, organizationId },
   });
   });

@@ -191,6 +191,10 @@
         <slot name="afterFullScreen"></slot>
         <slot name="afterFullScreen"></slot>
       </div>
       </div>
     </div>
     </div>
-    <div ref="jsonEditorElRef" class="flex-auto"></div>
+    <div
+      ref="jsonEditorElRef"
+      class="flex-auto"
+      :style="{ backgroundColor: disabled ? '#f0f0f0' : '' }"
+    ></div>
   </div>
   </div>
 </template>
 </template>

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

@@ -69,7 +69,7 @@
     name: 'BasicForm',
     name: 'BasicForm',
     components: { FormItem, Form, Row, FormAction },
     components: { FormItem, Form, Row, FormAction },
     props: basicProps,
     props: basicProps,
-    emits: ['advanced-change', 'reset', 'submit', 'register'],
+    emits: ['advanced-change', 'reset', 'submit', 'register', 'fieldValueChange'],
     setup(props, { emit, attrs }) {
     setup(props, { emit, attrs }) {
       const formModel = reactive<Recordable>({});
       const formModel = reactive<Recordable>({});
       const modalFn = useModalContext();
       const modalFn = useModalContext();
@@ -230,6 +230,7 @@
 
 
       function setFormModel(key: string, value: any) {
       function setFormModel(key: string, value: any) {
         formModel[key] = value;
         formModel[key] = value;
+        emit('fieldValueChange', key, value);
         const { validateTrigger } = unref(getBindValue);
         const { validateTrigger } = unref(getBindValue);
         if (!validateTrigger || validateTrigger === 'change') {
         if (!validateTrigger || validateTrigger === 'change') {
           validateFields([key]).catch((_) => {});
           validateFields([key]).catch((_) => {});

@@ -5,7 +5,8 @@
   import { BasicModal } from '/@/components/Modal';
   import { BasicModal } from '/@/components/Modal';
   import { PlusCircleOutlined } from '@ant-design/icons-vue';
   import { PlusCircleOutlined } from '@ant-design/icons-vue';
   import { FormFieldsEnum, formSchemas } from './config';
   import { FormFieldsEnum, formSchemas } from './config';
-  import { DataTypeEnum } from '../StructForm/config';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
+
   const show = ref(false);
   const show = ref(false);
 
 
   const props = withDefaults(
   const props = withDefaults(
@@ -50,7 +51,7 @@
       updateSchema([
       updateSchema([
         {
         {
           field: FormFieldsEnum.ZOOM_FACTOR,
           field: FormFieldsEnum.ZOOM_FACTOR,
-          ifShow: props.dataType == DataTypeEnum.IS_BOOL ? false : true,
+          ifShow: props.dataType == DataTypeEnum.BOOL ? false : true,
         },
         },
       ]);
       ]);
     }
     }

 <script lang="ts" setup>
 <script lang="ts" setup>
   import { Card } from 'ant-design-vue';
   import { Card } from 'ant-design-vue';
   import { computed, nextTick, onMounted, onUpdated, unref, watch } from 'vue';
   import { computed, nextTick, onMounted, onUpdated, unref, watch } from 'vue';
-  import { DataTypeEnum } from '../StructForm/config';
   import { BasicCreateFormParams } from './type';
   import { BasicCreateFormParams } from './type';
   import { DynamicProps } from '/#/utils';
   import { DynamicProps } from '/#/utils';
   import { Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
   import { Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
   import { BasicForm, FormProps, FormSchema, useForm } from '/@/components/Form';
   import { BasicForm, FormProps, FormSchema, useForm } from '/@/components/Form';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
   import { ReadAndWriteEnum } from '/@/enums/toolEnum';
   import { ReadAndWriteEnum } from '/@/enums/toolEnum';
 
 
   const props = withDefaults(
   const props = withDefaults(
@@ -86,7 +86,7 @@
         // step: step,
         // step: step,
         // formatter: (value: string) => value,
         // formatter: (value: string) => value,
         // parser: (string: string) => {
         // parser: (string: string) => {
-        //   if (dataType === DataTypeEnum.IS_NUMBER_INT) {
+        // if (dataType === DataTypeEnum.NUMBER_INT) {
         //     return Number(Number(string).toFixed());
         //     return Number(Number(string).toFixed());
         //   }
         //   }
         //   return Number(string);
         //   return Number(string);
@@ -188,19 +188,19 @@
         dataType: dataType! as unknown as DataTypeEnum,
         dataType: dataType! as unknown as DataTypeEnum,
         specs: specs as Partial<Specs>,
         specs: specs as Partial<Specs>,
       };
       };
-      if (type === DataTypeEnum.IS_NUMBER_INT || type === DataTypeEnum.IS_NUMBER_DOUBLE) {
+      if (type === DataTypeEnum.NUMBER_INT || type === DataTypeEnum.NUMBER_DOUBLE) {
         schemas.push(createInputNumber(params));
         schemas.push(createInputNumber(params));
       }
       }
 
 
-      if (type === DataTypeEnum.IS_BOOL) {
+      if (type === DataTypeEnum.BOOL) {
         schemas.push(createSelect(params));
         schemas.push(createSelect(params));
       }
       }
 
 
-      if (type === DataTypeEnum.IS_STRING) {
+      if (type === DataTypeEnum.STRING) {
         schemas.push(createInput(params));
         schemas.push(createInput(params));
       }
       }
 
 
-      if (type === DataTypeEnum.IS_STRUCT) {
+      if (type === DataTypeEnum.STRUCT) {
         schemas.push(createInputJson(params));
         schemas.push(createInputJson(params));
       }
       }
     }
     }

-import { DataTypeEnum } from '../StructForm/config';
 import { Specs } from '/@/api/device/model/modelOfMatterModel';
 import { Specs } from '/@/api/device/model/modelOfMatterModel';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
 
 
 export interface BasicCreateFormParams {
 export interface BasicCreateFormParams {
   identifier: string;
   identifier: string;

 import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
 import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
 import { findDictItemByCode } from '/@/api/system/dict';
 import { findDictItemByCode } from '/@/api/system/dict';
 import { FormSchema } from '/@/components/Table';
 import { FormSchema } from '/@/components/Table';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
 import { isNullOrUnDef } from '/@/utils/is';
 import { isNullOrUnDef } from '/@/utils/is';
 import { FormField } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
 import { FormField } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
 
 
-export enum DataTypeEnum {
-  IS_NUMBER_INT = 'INT',
-  IS_NUMBER_DOUBLE = 'DOUBLE',
-  IS_STRING = 'TEXT',
-  IS_STRUCT = 'STRUCT',
-  IS_BOOL = 'BOOL',
-}
-
 export const validateValueRange = (_rule, value: Record<'min' | 'max', number>, _callback) => {
 export const validateValueRange = (_rule, value: Record<'min' | 'max', number>, _callback) => {
   value = value || {};
   value = value || {};
   const { min, max } = value;
   const { min, max } = value;
@@ -77,10 +70,9 @@ export const formSchemas = (
             try {
             try {
               const record = await findDictItemByCode(params);
               const record = await findDictItemByCode(params);
               return hasStructForm
               return hasStructForm
-                ? record.filter((item) => item.itemValue !== DataTypeEnum.IS_STRUCT)
+                ? record.filter((item) => item.itemValue !== DataTypeEnum.STRUCT)
                 : record;
                 : record;
             } catch (error) {
             } catch (error) {
-              console.log(error);
               return [];
               return [];
             }
             }
           },
           },
@@ -91,7 +83,7 @@ export const formSchemas = (
           valueField: 'itemValue',
           valueField: 'itemValue',
           getPopupContainer: () => document.body,
           getPopupContainer: () => document.body,
           onChange: (value: string) => {
           onChange: (value: string) => {
-            if (value == DataTypeEnum.IS_STRUCT) {
+            if (value == DataTypeEnum.STRUCT) {
               updateSchema({
               updateSchema({
                 field: FormField.SPECS_LIST,
                 field: FormField.SPECS_LIST,
                 componentProps: {
                 componentProps: {
@@ -114,8 +106,8 @@ export const formSchemas = (
         span: 18,
         span: 18,
       },
       },
       ifShow: ({ values }) =>
       ifShow: ({ values }) =>
-        values[FormField.TYPE] === DataTypeEnum.IS_NUMBER_INT ||
-        values[FormField.TYPE] === DataTypeEnum.IS_NUMBER_DOUBLE,
+        values[FormField.TYPE] === DataTypeEnum.NUMBER_INT ||
+        values[FormField.TYPE] === DataTypeEnum.NUMBER_DOUBLE,
       rules: [{ validator: validateValueRange }],
       rules: [{ validator: validateValueRange }],
     },
     },
     {
     {
@@ -134,8 +126,8 @@ export const formSchemas = (
         },
         },
       },
       },
       ifShow: ({ values }) =>
       ifShow: ({ values }) =>
-        values[FormField.TYPE] === DataTypeEnum.IS_NUMBER_INT ||
-        values[FormField.TYPE] === DataTypeEnum.IS_NUMBER_DOUBLE,
+        values[FormField.TYPE] === DataTypeEnum.NUMBER_INT ||
+        values[FormField.TYPE] === DataTypeEnum.NUMBER_DOUBLE,
       dynamicRules: ({ model }) => {
       dynamicRules: ({ model }) => {
         const valueRange = model[FormField.VALUE_RANGE] || {};
         const valueRange = model[FormField.VALUE_RANGE] || {};
         const { min, max } = valueRange;
         const { min, max } = valueRange;
@@ -199,8 +191,8 @@ export const formSchemas = (
         };
         };
       },
       },
       ifShow: ({ values }) =>
       ifShow: ({ values }) =>
-        values[FormField.TYPE] === DataTypeEnum.IS_NUMBER_INT ||
-        values[FormField.TYPE] === DataTypeEnum.IS_NUMBER_DOUBLE,
+        values[FormField.TYPE] === DataTypeEnum.NUMBER_INT ||
+        values[FormField.TYPE] === DataTypeEnum.NUMBER_DOUBLE,
     },
     },
     {
     {
       field: FormField.BOOL_CLOSE,
       field: FormField.BOOL_CLOSE,
@@ -214,7 +206,7 @@ export const formSchemas = (
         placeholder: '如：关',
         placeholder: '如：关',
       },
       },
       defaultValue: '关',
       defaultValue: '关',
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.IS_BOOL,
+      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.BOOL,
       dynamicRules: ({ model }) => {
       dynamicRules: ({ model }) => {
         const close = model[FormField.BOOL_CLOSE];
         const close = model[FormField.BOOL_CLOSE];
         const open = model[FormField.BOOL_OPEN];
         const open = model[FormField.BOOL_OPEN];
@@ -243,7 +235,7 @@ export const formSchemas = (
         placeholder: '如：开',
         placeholder: '如：开',
       },
       },
       defaultValue: '开',
       defaultValue: '开',
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.IS_BOOL,
+      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.BOOL,
       dynamicRules: ({ model }) => {
       dynamicRules: ({ model }) => {
         const close = model[FormField.BOOL_CLOSE];
         const close = model[FormField.BOOL_CLOSE];
         const open = model[FormField.BOOL_OPEN];
         const open = model[FormField.BOOL_OPEN];
@@ -277,7 +269,7 @@ export const formSchemas = (
           suffix: () => '字节',
           suffix: () => '字节',
         };
         };
       },
       },
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.IS_STRING,
+      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.STRING,
     },
     },
     {
     {
       field: FormField.EXTENSION_DESC,
       field: FormField.EXTENSION_DESC,
@@ -322,7 +314,7 @@ export const formSchemas = (
       valueField: 'value',
       valueField: 'value',
       changeEvent: 'update:value',
       changeEvent: 'update:value',
       colProps: { span: 24 },
       colProps: { span: 24 },
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.IS_STRUCT,
+      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.STRUCT,
       rules: [{ required: true, validator: validateJSON }],
       rules: [{ required: true, validator: validateJSON }],
     },
     },
     {
     {

-import { DataTypeEnum } from './config';
 import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
 import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
 import { FormField } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
 import { FormField } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
 
 
 export enum OpenModalMode {
 export enum OpenModalMode {

 import { cloneDeep } from 'lodash-es';
 import { cloneDeep } from 'lodash-es';
-import { DataTypeEnum } from './config';
 import { StructFormValue } from './type';
 import { StructFormValue } from './type';
 import { DataType, ModelOfMatterParams, StructJSON } from '/@/api/device/model/modelOfMatterModel';
 import { DataType, ModelOfMatterParams, StructJSON } from '/@/api/device/model/modelOfMatterModel';
 import { isArray } from '/@/utils/is';
 import { isArray } from '/@/utils/is';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
 
 
 export function transfromToStructJSON(value: StructFormValue): StructJSON {
 export function transfromToStructJSON(value: StructFormValue): StructJSON {
   const {
   const {
@@ -24,21 +24,21 @@ export function transfromToStructJSON(value: StructFormValue): StructJSON {
   let dataType = {} as unknown as DataType;
   let dataType = {} as unknown as DataType;
 
 
   switch (type) {
   switch (type) {
-    case DataTypeEnum.IS_NUMBER_INT:
+    case DataTypeEnum.NUMBER_INT:
       dataType = {
       dataType = {
         type,
         type,
         specs: { valueRange, step, unit, unitName },
         specs: { valueRange, step, unit, unitName },
       };
       };
       break;
       break;
 
 
-    case DataTypeEnum.IS_NUMBER_DOUBLE:
+    case DataTypeEnum.NUMBER_DOUBLE:
       dataType = {
       dataType = {
         type,
         type,
         specs: { valueRange, step, unit, unitName },
         specs: { valueRange, step, unit, unitName },
       };
       };
       break;
       break;
 
 
-    case DataTypeEnum.IS_BOOL:
+    case DataTypeEnum.BOOL:
       dataType = {
       dataType = {
         type,
         type,
         specs: {
         specs: {
@@ -48,14 +48,14 @@ export function transfromToStructJSON(value: StructFormValue): StructJSON {
       };
       };
       break;
       break;
 
 
-    case DataTypeEnum.IS_STRING:
+    case DataTypeEnum.STRING:
       dataType = {
       dataType = {
         type,
         type,
         specs: { length },
         specs: { length },
       };
       };
       break;
       break;
 
 
-    case DataTypeEnum.IS_STRUCT:
+    case DataTypeEnum.STRUCT:
       dataType = {
       dataType = {
         type,
         type,
         specs: specs! as unknown as ModelOfMatterParams[],
         specs: specs! as unknown as ModelOfMatterParams[],

+<script setup lang="ts">
+  import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
+  import { JsonPreview } from '/@/components/CodeEditor';
+  import { BasicModal, useModalInner } from '/@/components/Modal';
+
+  defineProps<{
+    inputData?: StructJSON[];
+  }>();
+
+  defineEmits(['register']);
+
+  const data = {};
+
+  const [register] = useModalInner();
+</script>
+
+<template>
+  <BasicModal @register="register" title="">
+    <!--  -->
+    <JsonPreview :data="data" />
+  </BasicModal>
+</template>

+import { FormSchema } from '../../../types/form';
+import { Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
+import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
+
+export const getFormSchemas = ({
+  structJSON: structJson,
+  required,
+  transportType,
+}: {
+  structJSON: StructJSON[];
+  required?: boolean;
+  transportType?: string;
+}): FormSchema[] => {
+  const createInputNumber = ({ identifier, functionName, dataType }: StructJSON): FormSchema => {
+    const { specs } = dataType || {};
+    const { valueRange } = specs! as Specs;
+    const { max = 2147483647, min = -2147483648 } = valueRange || {};
+    return {
+      field: identifier,
+      label: functionName,
+      component: 'InputNumber',
+      rules: [
+        {
+          required,
+          message: `${functionName}是必填项`,
+        },
+        {
+          type: 'number',
+          trigger: 'change',
+          validator: (_rule, value) => {
+            const reg = /^[0-9]*$/;
+            if (!reg.test(value))
+              return Promise.reject(new Error(`${functionName}不是一个有效的数字`));
+            if (value < min || value > max)
+              return Promise.reject(new Error(`${functionName}取值范围在${min}~${max}之间`));
+
+            return Promise.resolve(value);
+          },
+        },
+      ],
+      componentProps: {
+        max,
+        min,
+        placeholder: `请输入${functionName}`,
+      },
+    } as FormSchema;
+  };
+
+  const createInput = ({ identifier, functionName, dataType }: StructJSON): FormSchema => {
+    const { specs } = dataType || {};
+    const { length = 10240 } = specs! as Partial<Specs>;
+    return {
+      field: identifier,
+      label: functionName,
+      component: 'Input',
+      rules: [
+        {
+          required,
+          message: `${functionName}是必填项`,
+        },
+        {
+          type: 'string',
+          trigger: 'change',
+          validator: (_rule, value) => {
+            if ((value?.length || 0) > length)
+              return Promise.reject(new Error(`${functionName}数据长度应该小于${length}`));
+
+            return Promise.resolve(value);
+          },
+        },
+      ],
+      componentProps: {
+        maxLength: length,
+        placeholder: `请输入${functionName}`,
+      },
+    } as FormSchema;
+  };
+
+  const createSelect = ({ identifier, functionName, dataType }: StructJSON): FormSchema => {
+    const { specs } = dataType || {};
+    const { boolClose, boolOpen } = specs! as Partial<Specs>;
+    return {
+      field: identifier,
+      label: functionName!,
+      component: 'Select',
+      rules: [
+        {
+          required,
+          message: `${functionName}是必填项`,
+          type: 'number',
+        },
+      ],
+      componentProps: {
+        options: [
+          { label: `${boolClose}-0`, value: 0 },
+          { label: `${boolOpen}-1`, value: 1 },
+        ],
+        placeholder: `请选择${functionName}`,
+      },
+    };
+  };
+
+  const createStructJson = ({ identifier, functionName, dataType }: StructJSON): FormSchema => {
+    return {
+      field: identifier,
+      label: functionName!,
+      component: 'Input',
+      changeEvent: 'update:value',
+      componentProps: () => {
+        return {
+          inputData: dataType?.specs || [],
+        };
+      },
+      colSlot: identifier,
+    };
+  };
+
+  const createTCPServiceCommandInput = ({
+    serviceCommand,
+    functionName,
+  }: StructJSON): FormSchema => {
+    return {
+      field: 'serviceCommand',
+      label: '服务命令',
+      component: 'Input',
+      required,
+      componentProps: {
+        defaultValue: serviceCommand,
+        placeholder: `请输入${functionName}`,
+      },
+    };
+  };
+
+  const schemas: FormSchema[] = [];
+
+  for (const item of structJson) {
+    const { dataType } = item;
+    const { type } = dataType || {};
+    if (transportType === TransportTypeEnum.TCP) {
+      item.serviceCommand && schemas.push(createTCPServiceCommandInput(item));
+      break;
+    }
+
+    if (type === DataTypeEnum.BOOL) schemas.push(createSelect(item));
+    else if (type === DataTypeEnum.NUMBER_INT) schemas.push(createInputNumber(item));
+    else if (type === DataTypeEnum.NUMBER_DOUBLE) schemas.push(createInputNumber(item));
+    else if (type === DataTypeEnum.STRING) schemas.push(createInput(item));
+    else if (type === DataTypeEnum.STRUCT) schemas.push(createStructJson(item));
+  }
+
+  return schemas;
+};

+import { ValidatorRule } from 'ant-design-vue/lib/form/interface';
+export { default as ThingsModelForm } from './index.vue';
+
+export const validateTCPCustomCommand: ValidatorRule['validator'] = (_rule, value) => {
+  const reg = /^[\s0-9a-fA-F]+$/;
+  if (reg.test(value)) return Promise.resolve();
+  return Promise.reject('请输入ASCII或HEX服务命令(0~9/A~F)');
+};
+
+export const trimBlankSpace = (string: string) => string.replace(/\s/g, '');

+<script setup lang="ts">
+  import { Card } from 'ant-design-vue';
+  import { ComponentPublicInstance, computed, nextTick, reactive, unref, watch } from 'vue';
+  import { getFormSchemas } from './config';
+  import { ThingsModelForm } from '.';
+  import { DefineComponentsBasicExpose } from '/#/utils';
+  import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
+  import { useForm } from '../../../hooks/useForm';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
+  import { BasicForm } from '/@/components/Form';
+
+  const props = withDefaults(
+    defineProps<{
+      value?: Recordable;
+      inputData?: StructJSON[];
+      required?: boolean;
+      title?: string;
+      transportType?: string;
+      disabled?: boolean;
+      identifier?: string;
+    }>(),
+    {
+      inputData: () => [],
+      required: true,
+    }
+  );
+
+  const thingsModelFormListElMap = reactive<
+    Record<string, { el: InstanceType<typeof ThingsModelForm>; structJSON: StructJSON }>
+  >({});
+
+  const [register, formActionType] = useForm({
+    schemas: getFormSchemas({
+      structJSON: props.inputData || [],
+      required: props.required,
+      transportType: props.transportType,
+    }),
+    showActionButtonGroup: false,
+    layout: 'inline',
+    labelWidth: 100,
+  });
+
+  const getStructFormItem = computed(() => {
+    const { inputData } = props;
+    return inputData.filter((item) => item.dataType?.type === DataTypeEnum.STRUCT);
+  });
+
+  const setFormElRef = (
+    el: Nullable<Element | ComponentPublicInstance>,
+    structJSON: StructJSON
+  ) => {
+    const _structJSON = unref(getStructFormItem).find(
+      (item) => item.identifier === structJSON.identifier
+    );
+
+    if (_structJSON)
+      thingsModelFormListElMap[structJSON.identifier!] = {
+        el: el as InstanceType<typeof ThingsModelForm>,
+        structJSON,
+      };
+  };
+
+  const getFieldsValue = () => {
+    const basicValue = formActionType.getFieldsValue();
+
+    const structValue: Recordable = {};
+    for (const key of Object.keys(thingsModelFormListElMap)) {
+      const item = thingsModelFormListElMap[key];
+      const { el } = item;
+      structValue[key] = el.getFieldsValue() || {};
+    }
+
+    return {
+      ...basicValue,
+      ...structValue,
+    };
+  };
+
+  const setFieldsValue = (value: Recordable) => {
+    formActionType.setFieldsValue(value);
+  };
+
+  const validate = async () => {
+    await formActionType.validate();
+    for (const key of Object.keys(thingsModelFormListElMap))
+      await thingsModelFormListElMap[key]?.el?.validate?.();
+  };
+
+  watch(
+    () => props.value,
+    async (value) => {
+      await nextTick();
+      formActionType.resetFields();
+      formActionType.setFieldsValue(value || {});
+    },
+    { immediate: true }
+  );
+
+  watch(
+    () => [props.inputData, props.identifier],
+    (value) => {
+      if (value && value.length) {
+        const schemas = getFormSchemas({
+          structJSON: props.inputData || [],
+          required: props.required,
+          transportType: props.transportType,
+        });
+        formActionType.setProps({ schemas });
+      }
+    }
+  );
+
+  watch(
+    () => props.disabled,
+    (value) => {
+      formActionType.setProps({ disabled: value });
+    }
+  );
+
+  defineExpose<DefineComponentsBasicExpose>({
+    getFieldsValue,
+    setFieldsValue,
+    validate,
+  });
+</script>
+
+<template>
+  <Card
+    class="!border-2 !border-dashed"
+    :title="title"
+    :style="{ backgroundColor: disabled ? '#f0f0f0' : '', borderColor: disabled ? '#e3e3e3' : '' }"
+  >
+    <BasicForm class="things-model-form" @register="register" :disabled="disabled">
+      <template
+        v-for="item in getStructFormItem"
+        #[item.identifier!]="{ model, field }"
+        :key="item.identifier"
+      >
+        <ThingsModelForm
+          class="!ml-10"
+          :ref="(el) => setFormElRef(el, item)"
+          v-model:value="model[field]"
+          :input-data="(item.dataType?.specs as StructJSON[]) || []"
+          :title="item.functionName"
+          :disabled="disabled"
+        />
+      </template>
+    </BasicForm>
+  </Card>
+</template>
+
+<style lang="less" scoped>
+  .things-model-form {
+    :deep(.ant-input-number) {
+      width: 100%;
+    }
+
+    :deep(.ant-form-item-label) {
+      label {
+        width: 100%;
+        display: block;
+        overflow: hidden;
+        text-overflow: ellipsis;
+      }
+    }
+  }
+
+  :deep(.ant-form-item-control) {
+    margin-left: 6px;
+  }
+</style>

@@ -123,6 +123,7 @@ export type ComponentType =
   | 'TransferModal'
   | 'TransferModal'
   | 'TransferTableModal'
   | 'TransferTableModal'
   | 'ObjectModelValidateForm'
   | 'ObjectModelValidateForm'
+  | 'ThingsModelForm'
   | 'DevicePicker'
   | 'DevicePicker'
   | 'ProductPicker'
   | 'ProductPicker'
   | 'PollCommandInput'
   | 'PollCommandInput'
@@ -138,4 +139,8 @@ export type ComponentType =
   | 'RelationsQuery'
   | 'RelationsQuery'
   | 'CredentialsCard'
   | 'CredentialsCard'
   | 'ApiComplete'
   | 'ApiComplete'
-  | 'DeviceProfileForm';
+  | 'DeviceProfileForm'
+  | 'ConditionFilter'
+  | 'TimeRangePicker'
+  | 'TriggerDurationInput'
+  | 'AlarmProfileSelect';

@@ -11,3 +11,19 @@ export enum AlarmStatusMean {
   CLEARED_ACK = '清除已确认',
   CLEARED_ACK = '清除已确认',
   ACTIVE_ACK = '激活已确认',
   ACTIVE_ACK = '激活已确认',
 }
 }
+
+export enum AlarmLevelEnum {
+  CRITICAL = 'CRITICAL',
+  MAJOR = 'MAJOR',
+  MINOR = 'MINOR',
+  WARNING = 'WARNING',
+  INDETERMINATE = 'INDETERMINATE',
+}
+
+export enum AlarmLevelNameEnum {
+  CRITICAL = '紧急',
+  MAJOR = '重要',
+  MINOR = '次要',
+  WARNING = '警告',
+  INDETERMINATE = '不确定',
+}

+/**
+ * 运算符枚举值
+ */
+
+// 数字运算符或者时间运算符
+export enum NumberOperationEnum {
+  EQUAL = 'EQUAL',
+  NOT_EQUAL = 'NOT_EQUAL',
+  LESS = 'LESS',
+  LESS_OR_EQUAL = 'LESS_OR_EQUAL',
+  GREATER = 'GREATER',
+  GREATER_OR_EQUAL = 'GREATER_OR_EQUAL',
+}
+
+export enum NumberOperationNameEnum {
+  EQUAL = '等于',
+  NOT_EQUAL = '不等于',
+  LESS = '小于',
+  LESS_OR_EQUAL = '小于等于',
+  GREATER = '大于',
+  GREATER_OR_EQUAL = '大于等于',
+}
+
+export enum StringOperationEnum {
+  EQUAL = 'EQUAL',
+  NOT_EQUAL = 'NOT_EQUAL',
+  STARTS_WITH = 'STARTS_WITH',
+  ENDS_WITH = 'ENDS_WITH',
+  CONTAINS = 'CONTAINS',
+  NOT_CONTAINS = 'NOT_CONTAINS',
+}
+
+export enum StringOperationNameEnum {
+  EQUAL = '等于',
+  NOT_EQUAL = '不等于',
+  STARTS_WITH = '开始于',
+  ENDS_WITH = '结束于',
+  CONTAINS = '包含',
+  NOT_CONTAINS = '不包含',
+}
+
+export enum BooleanOperationEnum {
+  EQUAL = 'EQUAL',
+  NOT_EQUAL = 'NOT_EQUAL',
+}
+
+export enum BooleanOperationNameEnum {
+  EQUAL = '等于',
+  NOT_EQUAL = '不等于',
+}
+
+export enum BooleanOperationValueEnum {
+  TRUE = 'true',
+  FALSE = 'false',
+}
+
+export enum BooleanOperationValueNameEnum {
+  TRUE = '真',
+  FALSE = '假',
+}
+
+export enum FlipFlopTypeEnum {
+  SIMPLE = 'SIMPLE',
+  DURATION = 'DURATION',
+  REPEATING = 'REPEATING',
+}
+
+export enum ScheduleTypeEnum {
+  ANY_TIME = 'ANY_TIME',
+  SPECIFIC_TIME = 'SPECIFIC_TIME',
+  CUSTOM = 'CUSTOM',
+}
+
+export enum ScheduleTypeNameEnum {
+  ANY_TIME = '始终启用',
+  SPECIFIC_TIME = '定时启用',
+  CUSTOM = '自定义启用',
+}
+
+export enum FlipFlopTypeNameEnum {
+  SIMPLE = '简单',
+  DURATION = '持续时长',
+  REPEATING = '重复次数',
+}
+
+export enum TriggerTypeEnum {
+  DEVICE_TRIGGER = 'DEVICE_TRIGGER',
+  SCHEDULE_TRIGGER = 'SCHEDULE_TRIGGER',
+  SCENE_TRIGGER = 'SCENE_TRIGGER',
+  HAND_ACT = 'HAND_ACT',
+}
+
+export enum TriggerTypeNameEnum {
+  DEVICE_TRIGGER = '设备触发',
+  SCHEDULE_TRIGGER = '定时触发',
+  SCENE_TRIGGER = '场景触发',
+  HAND_ACT = '手动触发',
+}
+
+export enum DeviceTriggerTypeEum {
+  TIME_SERIES = 'TIME_SERIES',
+}
+
+export enum DeviceTriggerTypeNameEum {
+  TIME_SERIES = '属性触发',
+}
+
+export enum TriggerEntityTypeEnum {
+  ALL = 'ALL',
+  PART = 'PART',
+}
+
+export enum TriggerEntityTypeNameEnum {
+  ALL = '全部',
+  PART = '部分',
+}
+
+export enum TriggerValueTypeEnum {
+  NUMERIC = 'NUMERIC',
+  BOOLEAN = 'BOOLEAN',
+  STRING = 'STRING',
+  DATE_TIME = 'DATE_TIME',
+}
+
+export enum TriggerValueTypeNameEnum {
+  NUMERIC = '数字',
+  BOOLEAN = '布尔值',
+  STRING = '字符串',
+  DATE_TIME = '时间',
+}
+
+export enum TriggerUnitEnum {
+  SECONDS = 'SECONDS',
+  MINUTES = 'MINUTES',
+  HOURS = 'HOURS',
+  DAYS = 'DAYS',
+}
+
+export enum TriggerUnitNameEnum {
+  SECONDS = '秒',
+  MINUTES = '分',
+  HOURS = '时',
+  DAYS = '天',
+}
+
+export enum ExecutionActionEnum {
+  DEVICE_OUT = 'DEVICE_OUT',
+  MSG_NOTIFY = 'MSG_NOTIFY',
+}
+
+export enum ExecutionActionNameEnum {
+  DEVICE_OUT = '设备输出',
+  MSG_NOTIFY = '告警输出',
+}
+
+export enum CommandTypeEnum {
+  CUSTOM = 0,
+  SERVICE = 1,
+  ATTRIBUTE = 2,
+  API = 'api',
+}
+
+export enum CommandTypeNameEnum {
+  CUSTOM = '自定义',
+  SERVICE = '服务',
+  ATTRIBUTE = '属性',
+}

+export enum DataTypeEnum {
+  NUMBER_INT = 'INT',
+  NUMBER_DOUBLE = 'DOUBLE',
+  STRING = 'TEXT',
+  STRUCT = 'STRUCT',
+  BOOL = 'BOOL',
+}

-/**
- * 运算符枚举值
- */
-
-// 数字运算符或者时间运算符
-export enum Number_Operation {
-  EQUAL = 'EQUAL',
-  NOT_EQUAL = 'NOT_EQUAL',
-  LESS = 'LESS',
-  LESS_OR_EQUAL = 'LESS_OR_EQUAL',
-  GREATER = 'GREATER',
-  GREATER_OR_EQUAL = 'GREATER_OR_EQUAL',
-}
-
-export enum String_Operation {
-  EQUAL = 'EQUAL',
-  NOT_EQUAL = 'NOT_EQUAL',
-  BEGAN_IN = 'STARTS_WITH',
-  END_IN = 'ENDS_WITH',
-  INCLUDE = 'CONTAINS',
-  NOT_INCLUDE = 'NOT_CONTAINS',
-}
-
-export enum Boolean_Operation {
-  EQUAL = 'EQUAL',
-  NOT_EQUAL = 'NOT_EQUAL',
-}

@@ -7,7 +7,7 @@ export enum DataActionModeEnum {
 }
 }
 
 
 export enum DataActionModeNameEnum {
 export enum DataActionModeNameEnum {
-  CREATE = '创建',
+  CREATE = '新增',
   READ = '查看',
   READ = '查看',
   UPDATE = '编辑',
   UPDATE = '编辑',
   DELETE = '删除',
   DELETE = '删除',
@@ -40,6 +40,11 @@ export enum ServiceCallTypeEnum {
   SYNC = 'SYNC',
   SYNC = 'SYNC',
 }
 }
 
 
+export enum ServiceCallTypeNameEnum {
+  ASYNC = '异步',
+  SYNC = '同步',
+}
+
 export enum CommandDeliveryWayEnum {
 export enum CommandDeliveryWayEnum {
   ONE_WAY = 'oneway',
   ONE_WAY = 'oneway',
   TWO_WAY = 'twoway',
   TWO_WAY = 'twoway',

@@ -16,15 +16,17 @@
       value?: string | string[];
       value?: string | string[];
       apiTreeSelectProps?: Recordable;
       apiTreeSelectProps?: Recordable;
       showCreate?: boolean;
       showCreate?: boolean;
+      disabled?: boolean;
     }>(),
     }>(),
     {
     {
       showCreate: true,
       showCreate: true,
+      disabled: false,
     }
     }
   );
   );
 
 
   const needReload = ref(true);
   const needReload = ref(true);
 
 
-  const emit = defineEmits(['change']);
+  const emit = defineEmits(['change', 'optionsChange']);
 
 
   const handleOpenCreate = () => {
   const handleOpenCreate = () => {
     openDrawer(true, { isUpdate: false });
     openDrawer(true, { isUpdate: false });
@@ -35,13 +37,14 @@
   const orgList = ref<Recordable[]>([]);
   const orgList = ref<Recordable[]>([]);
 
 
   const getBindProps = computed<Recordable>(() => {
   const getBindProps = computed<Recordable>(() => {
-    const { value, apiTreeSelectProps = {} } = props;
+    const { value, apiTreeSelectProps = {}, disabled } = props;
     const { params = {} } = apiTreeSelectProps;
     const { params = {} } = apiTreeSelectProps;
     return {
     return {
       replaceFields: { children: 'children', key: 'id', title: 'name', value: 'id' },
       replaceFields: { children: 'children', key: 'id', title: 'name', value: 'id' },
       getPopupContainer: () => document.body,
       getPopupContainer: () => document.body,
       placeholder: '请选择所属组织',
       placeholder: '请选择所属组织',
       maxLength: 250,
       maxLength: 250,
+      disabled,
       ...apiTreeSelectProps,
       ...apiTreeSelectProps,
       value,
       value,
       dropdownStyle: { maxHeight: '300px' },
       dropdownStyle: { maxHeight: '300px' },
@@ -63,6 +66,7 @@
       onChange: (...args: any[]) => {
       onChange: (...args: any[]) => {
         emit('change', ...args);
         emit('change', ...args);
       },
       },
+      onOptionsChange: (...args: any[]) => emit('optionsChange', ...args),
     };
     };
   });
   });
 
 
@@ -80,7 +84,9 @@
 <template>
 <template>
   <section class="flex">
   <section class="flex">
     <ApiTreeSelect v-bind="getBindProps" />
     <ApiTreeSelect v-bind="getBindProps" />
-    <Button v-if="getShowCreate" type="link" @click="handleOpenCreate">新增组织</Button>
+    <Button v-if="getShowCreate" type="link" @click="handleOpenCreate" :disabled="disabled"
+      >新增组织</Button
+    >
     <OrganizationDrawer v-if="getShowCreate" @register="registerDrawer" @success="handleReload" />
     <OrganizationDrawer v-if="getShowCreate" @register="registerDrawer" @success="handleReload" />
   </section>
   </section>
 </template>
 </template>

@@ -15,13 +15,13 @@
   import { useHistoryData } from '../../hook/useHistoryData';
   import { useHistoryData } from '../../hook/useHistoryData';
   import { formatToDateTime } from '/@/utils/dateUtil';
   import { formatToDateTime } from '/@/utils/dateUtil';
   import { useTable, BasicTable, BasicColumn } from '/@/components/Table';
   import { useTable, BasicTable, BasicColumn } from '/@/components/Table';
-  import { DataTypeEnum } from '/@/components/Form/src/externalCompns/components/StructForm/config';
   import {
   import {
     ModeSwitchButton,
     ModeSwitchButton,
     TABLE_CHART_MODE_LIST,
     TABLE_CHART_MODE_LIST,
     EnumTableChartMode,
     EnumTableChartMode,
   } from '/@/components/Widget';
   } from '/@/components/Widget';
   import { SchemaFiled } from '/@/views/visual/palette/components/HistoryTrendModal/config';
   import { SchemaFiled } from '/@/views/visual/palette/components/HistoryTrendModal/config';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
 
 
   interface DeviceDetail {
   interface DeviceDetail {
     tbDeviceId: string;
     tbDeviceId: string;
@@ -188,7 +188,7 @@
         method.setFieldsValue({ keys: props.attr });
         method.setFieldsValue({ keys: props.attr });
         const attrInfo = unref(deviceAttrs).find((item) => item.identifier === props.attr);
         const attrInfo = unref(deviceAttrs).find((item) => item.identifier === props.attr);
         if (
         if (
-          [DataTypeEnum.IS_STRING, DataTypeEnum.IS_STRUCT].includes(
+          [DataTypeEnum.STRING, DataTypeEnum.STRUCT].includes(
             attrInfo?.detail.dataType.type as unknown as DataTypeEnum
             attrInfo?.detail.dataType.type as unknown as DataTypeEnum
           )
           )
         ) {
         ) {

@@ -16,7 +16,6 @@
   import { DeviceModelOfMatterAttrs, DeviceRecord } from '/@/api/device/model/deviceModel';
   import { DeviceModelOfMatterAttrs, DeviceRecord } from '/@/api/device/model/deviceModel';
   import { Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
   import { Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
   import { isArray, isNull, isObject } from '/@/utils/is';
   import { isArray, isNull, isObject } from '/@/utils/is';
-  import { DataTypeEnum } from '/@/components/Form/src/externalCompns/components/StructForm/config';
   import { useGlobSetting } from '/@/hooks/setting';
   import { useGlobSetting } from '/@/hooks/setting';
   import { ModeSwitchButton, EnumTableCardMode } from '/@/components/Widget';
   import { ModeSwitchButton, EnumTableCardMode } from '/@/components/Widget';
   import { toRaw } from 'vue';
   import { toRaw } from 'vue';
@@ -25,6 +24,7 @@
   import { ModalParamsType } from '/#/utils';
   import { ModalParamsType } from '/#/utils';
   import { AreaChartOutlined } from '@ant-design/icons-vue';
   import { AreaChartOutlined } from '@ant-design/icons-vue';
   import { SvgIcon } from '/@/components/Icon';
   import { SvgIcon } from '/@/components/Icon';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
 
 
   interface ReceiveMessage {
   interface ReceiveMessage {
     data: {
     data: {
@@ -220,7 +220,7 @@
   };
   };
 
 
   const isStructAndTextType = (type: DataTypeEnum) => {
   const isStructAndTextType = (type: DataTypeEnum) => {
-    return [DataTypeEnum.IS_STRUCT, DataTypeEnum.IS_STRING].includes(type);
+    return [DataTypeEnum.STRUCT, DataTypeEnum.STRING].includes(type);
   };
   };
 
 
   const setDataSource = () => {
   const setDataSource = () => {
@@ -311,7 +311,7 @@
   });
   });
 
 
   const formatValue = (item: DataSource) => {
   const formatValue = (item: DataSource) => {
-    return item.type === DataTypeEnum.IS_BOOL
+    return item.type === DataTypeEnum.BOOL
       ? !isNull(item.value)
       ? !isNull(item.value)
         ? !!Number(item.value)
         ? !!Number(item.value)
           ? item.boolOpen
           ? item.boolOpen

@@ -6,7 +6,6 @@
   import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
   import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
   import { BasicForm, useForm } from '/@/components/Form';
   import { BasicForm, useForm } from '/@/components/Form';
   import { BasicModal, useModalInner } from '/@/components/Modal';
   import { BasicModal, useModalInner } from '/@/components/Modal';
-  import { DataTypeEnum } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
   import { sendCommandOneway } from '/@/api/dataBoard';
   import { sendCommandOneway } from '/@/api/dataBoard';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { unref } from 'vue';
   import { unref } from 'vue';
@@ -14,6 +13,7 @@
   import { TaskTypeEnum } from '/@/views/task/center/config';
   import { TaskTypeEnum } from '/@/views/task/center/config';
   import { SingleToHex, formSchemasConfig } from './config';
   import { SingleToHex, formSchemasConfig } from './config';
   import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
   import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
 
 
   defineEmits(['register']);
   defineEmits(['register']);
   const props = defineProps<{ deviceId: string; deviceName: string }>();
   const props = defineProps<{ deviceId: string; deviceName: string }>();
@@ -51,7 +51,7 @@
 
 
     let schemas = [{ dataType: dataType, identifier, functionName: name } as StructJSON];
     let schemas = [{ dataType: dataType, identifier, functionName: name } as StructJSON];
 
 
-    if (type === DataTypeEnum.IS_STRUCT) {
+    if (type === DataTypeEnum.STRUCT) {
       schemas = dataType?.specs as StructJSON[];
       schemas = dataType?.specs as StructJSON[];
     }
     }
 
 

 import { DataType, Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
 import { DataType, Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
 import { JSONEditor } from '/@/components/CodeEditor';
 import { JSONEditor } from '/@/components/CodeEditor';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
 import { useJsonParse } from '/@/hooks/business/useJsonParse';
 import { useJsonParse } from '/@/hooks/business/useJsonParse';
-import { DataTypeEnum } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
 
 
 export interface BasicCreateFormParams {
 export interface BasicCreateFormParams {
   identifier: string;
   identifier: string;
@@ -19,9 +19,9 @@ const validateDouble = (
   max?: number | string
   max?: number | string
 ) => {
 ) => {
   min =
   min =
-    Number(min) || type === DataTypeEnum.IS_NUMBER_INT ? Number.MIN_SAFE_INTEGER : Number.MIN_VALUE;
+    Number(min) || type === DataTypeEnum.NUMBER_INT ? Number.MIN_SAFE_INTEGER : Number.MIN_VALUE;
   max =
   max =
-    Number(max) || type === DataTypeEnum.IS_NUMBER_INT ? Number.MAX_SAFE_INTEGER : Number.MAX_VALUE;
+    Number(max) || type === DataTypeEnum.NUMBER_INT ? Number.MAX_SAFE_INTEGER : Number.MAX_VALUE;
 
 
   return {
   return {
     flag: value < min || value > max,
     flag: value < min || value > max,
@@ -56,13 +56,11 @@ export const useGenDynamicForm = () => {
         },
         },
       ],
       ],
       componentProps: {
       componentProps: {
-        max:
-          max ?? type === DataTypeEnum.IS_NUMBER_INT ? Number.MAX_SAFE_INTEGER : Number.MAX_VALUE,
-        min:
-          min ?? type === DataTypeEnum.IS_NUMBER_INT ? Number.MIN_SAFE_INTEGER : Number.MIN_VALUE,
+        max: max ?? type === DataTypeEnum.NUMBER_INT ? Number.MAX_SAFE_INTEGER : Number.MAX_VALUE,
+        min: min ?? type === DataTypeEnum.NUMBER_INT ? Number.MIN_SAFE_INTEGER : Number.MIN_VALUE,
         step,
         step,
         placeholder: `请输入${functionName}`,
         placeholder: `请输入${functionName}`,
-        precision: type === DataTypeEnum.IS_NUMBER_INT ? 0 : 2,
+        precision: type === DataTypeEnum.NUMBER_INT ? 0 : 2,
       },
       },
     } as FormSchema;
     } as FormSchema;
   };
   };
@@ -141,11 +139,11 @@ export const useGenDynamicForm = () => {
   };
   };
 
 
   const schemaMethod = {
   const schemaMethod = {
-    [DataTypeEnum.IS_BOOL]: createSelect,
-    [DataTypeEnum.IS_NUMBER_DOUBLE]: createInputNumber,
-    [DataTypeEnum.IS_NUMBER_INT]: createInputNumber,
-    [DataTypeEnum.IS_STRING]: createInput,
-    [DataTypeEnum.IS_STRUCT]: createInputJson,
+    [DataTypeEnum.BOOL]: createSelect,
+    [DataTypeEnum.NUMBER_DOUBLE]: createInputNumber,
+    [DataTypeEnum.NUMBER_INT]: createInputNumber,
+    [DataTypeEnum.STRING]: createInput,
+    [DataTypeEnum.STRUCT]: createInputJson,
   };
   };
 
 
   const fieldTypeMap = new Map<string, DataTypeEnum>();
   const fieldTypeMap = new Map<string, DataTypeEnum>();
@@ -176,7 +174,7 @@ export const useGenDynamicForm = () => {
       const dataType = fieldTypeMap.get(next)!;
       const dataType = fieldTypeMap.get(next)!;
 
 
       let itemValue = value[next];
       let itemValue = value[next];
-      if (dataType === DataTypeEnum.IS_STRUCT) {
+      if (dataType === DataTypeEnum.STRUCT) {
         const { value } = useJsonParse(itemValue);
         const { value } = useJsonParse(itemValue);
         itemValue = value;
         itemValue = value;
       }
       }

 import { FormSchema } from '/@/components/Table';
 import { FormSchema } from '/@/components/Table';
 import { findDictItemByCode } from '/@/api/system/dict';
 import { findDictItemByCode } from '/@/api/system/dict';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
 
 
 export enum FormField {
 export enum FormField {
   FUNCTION_NAME = 'functionName',
   FUNCTION_NAME = 'functionName',
@@ -40,30 +41,19 @@ export enum AssessMode {
   WRITE = 'w',
   WRITE = 'w',
 }
 }
 
 
-/**
- * 新增参数 动态显示表单
- */
-export enum DataTypeEnum {
-  IS_NUMBER_INT = 'INT',
-  IS_NUMBER_DOUBLE = 'DOUBLE',
-  IS_STRING = 'TEXT',
-  IS_STRUCT = 'STRUCT',
-  IS_BOOL = 'BOOL',
-}
-
 const isNumber = (type: string) => {
 const isNumber = (type: string) => {
-  return type === DataTypeEnum.IS_NUMBER_INT || type === DataTypeEnum.IS_NUMBER_DOUBLE;
+  return type === DataTypeEnum.NUMBER_INT || type === DataTypeEnum.NUMBER_DOUBLE;
 };
 };
 
 
 const isString = (type: string) => {
 const isString = (type: string) => {
-  return type === DataTypeEnum.IS_STRING;
+  return type === DataTypeEnum.STRING;
 };
 };
 const isStruct = (type: string) => {
 const isStruct = (type: string) => {
-  return type === DataTypeEnum.IS_STRUCT;
+  return type === DataTypeEnum.STRUCT;
 };
 };
 
 
 const isBool = (type: string) => {
 const isBool = (type: string) => {
-  return type === DataTypeEnum.IS_BOOL;
+  return type === DataTypeEnum.BOOL;
 };
 };
 
 
 export const serviceSchemas = (tcpDeviceFlag: boolean): FormSchema[] => {
 export const serviceSchemas = (tcpDeviceFlag: boolean): FormSchema[] => {

-<template>
-  <div>
-    <BasicDrawer
-      v-bind="$attrs"
-      @register="registerDrawer"
-      @ok="handleSubmit"
-      destroy-on-close
-      width="50%"
-      showFooter
-      @close="handleClose"
-      :title="title"
-    >
-      <div>
-        <!-- 基础表单 -->
-        <BasicForm @register="registerForm" />
-        <!-- 基础表单 -->
-        <!-- 触发器-begin -->
-        <!-- <Divider orientation="left">触发器</Divider> -->
-        <Divider orientation="left">
-          <a-tooltip>
-            <template #title>触发器不可为空，消息只要满足触发条件中任意一个即可触发。</template>
-            <label class="validate-dot"></label> 触发器
-            <QuestionCircleOutlined :style="{ fontSize: '14px', marginLeft: '5px' }" />
-          </a-tooltip>
-        </Divider>
-        <div>
-          <template v-for="(item, index) in triggerData" :key="item">
-            <TriggerOrCondition
-              class="mt-4"
-              title="触发器"
-              :index="index"
-              :provideOrgid="provideOrgid"
-              :ref="skipUnwrap.triggerItemRefs"
-              @delete="deleteTriggerOrCondition"
-            />
-          </template>
-          <!-- 按钮 -->
-          <a-button type="primary" class="mt-4" @click="addTrigger" v-if="isView">
-            <PlusOutlined />
-            触发器（OR）<span style="visibility: hidden">发</span>
-          </a-button>
-          <!-- 按钮 -->
-        </div>
-        <!-- 触发器-end -->
-
-        <!-- 执行条件-begin -->
-        <Divider orientation="left">
-          <a-tooltip>
-            <template #title>执行条件可为空，消息需要满足所有执行条件才会被处理。</template>
-            执行条件
-            <QuestionCircleOutlined :style="{ fontSize: '14px', marginLeft: '5px' }" />
-          </a-tooltip>
-        </Divider>
-        <div>
-          <template v-for="(item, index) in conditionData" :key="item">
-            <TriggerOrCondition
-              class="mt-4"
-              title="执行条件"
-              :index="index"
-              :provideOrgid="provideOrgid"
-              :ref="skipUnwrap.conditionItemRefs"
-              @delete="deleteTriggerOrCondition"
-            />
-          </template>
-          <!-- 按钮 -->
-          <a-button type="primary" class="mt-4" @click="addCondition" v-if="isView">
-            <PlusOutlined />
-            执行条件（AND）
-          </a-button>
-          <!-- 按钮 -->
-        </div>
-        <!-- 执行条件-end -->
-
-        <!-- 执行动作-begin -->
-        <Divider orientation="left">
-          <a-tooltip>
-            <template #title
-              >触发器和执行条件都满足时，场景联动会做什么，例如：设备联动、告警通知等。</template
-            >
-            <label class="validate-dot"></label> 执行动作
-            <QuestionCircleOutlined :style="{ fontSize: '14px', marginLeft: '5px' }" />
-          </a-tooltip>
-        </Divider>
-        <div>
-          <template v-for="(item, index) in actionData" :key="item">
-            <Action
-              class="mt-4"
-              :actionIndex="index"
-              :actionData="actionData"
-              :triggerData="triggerData"
-              :ref="skipUnwrap.actionItemRefs"
-              :provideOrgid="provideOrgid"
-              :deviceList="getMasterDeviceList"
-              :arr="arr"
-              @deleteAction="deleteAction"
-              @getActionFormArr="getActionFormArr"
-              @dynamicChangeAlarmConfig="handleDynamicChangeAlarmConfig"
-            />
-          </template>
-          <!-- 按钮 -->
-          <a-button type="primary" class="mt-4" @click="addAction" v-if="isView">
-            <PlusOutlined />
-            新增执行动作
-          </a-button>
-          <!-- 按钮 -->
-        </div>
-        <!-- 执行动作-end -->
-      </div>
-    </BasicDrawer>
-  </div>
-</template>
-<script lang="ts" setup>
-  import { ref, watch, unref, computed, nextTick } from 'vue';
-  import { BasicDrawer, useDrawerInner } from '/@/components/Drawer';
-  import { formSchema, organizationId as organizationIdRef } from './config/config.data';
-  import { BasicForm, useForm } from '/@/components/Form';
-  import { genTriggerOrConditionData, genActionData } from './config/formatData';
-  import { Divider } from 'ant-design-vue';
-  import { PlusOutlined, QuestionCircleOutlined } from '@ant-design/icons-vue';
-  import { useMessage } from '/@/hooks/web/useMessage';
-  import {
-    screenLinkPageAddApi,
-    screenLinkPageByDeptIdGetDevice,
-    getOrganizationAlarmConfig,
-  } from '/@/api/ruleengine/ruleengineApi';
-  import TriggerOrCondition from './cpns/Trigger-Condition.vue';
-  import Action from './cpns/Action.vue';
-  import { findOperation } from './config/formatData';
-  import { formatToDateTime } from '/@/utils/dateUtil';
-  import ObjectModelValidateForm from '/@/components/Form/src/externalCompns/components/ObjectModelValidateForm/ObjectModelValidateForm.vue';
-  import { isEmpty } from '/@/utils/is';
-  import { add } from '/@/components/Form/src/componentMap';
-
-  add('ObjectModelValidateForm', ObjectModelValidateForm);
-
-  const emit = defineEmits(['register', 'success']);
-  const provideOrgid = ref('');
-
-  const { createMessage } = useMessage();
-  const triggerData = ref<number[]>([]);
-  const conditionData = ref<number[]>([]);
-  const actionData = ref<number[]>([]);
-  const skipUnwrap = {
-    triggerItemRefs: ref<InstanceType<typeof TriggerOrCondition>[]>([]),
-    conditionItemRefs: ref<InstanceType<typeof TriggerOrCondition>[]>([]),
-    actionItemRefs: ref<InstanceType<typeof Action>[]>([]),
-  };
-  const title = computed(
-    () => `${isUpdate.value === 3 ? '查看' : isUpdate.value ? '编辑' : '新增'}场景联动`
-  );
-  let getTriggerFormValue = ref([]);
-  let getConditionFormValue = ref([]);
-  let getActionFormValue = ref([]);
-  const editEntryIdData = ref([]);
-  const editAlarmConfigData = ref([]);
-  const isUpdate = ref<boolean | number>(false);
-  const id = ref(undefined);
-  const tenantId = ref(undefined);
-  const isView = ref(true);
-  const [
-    registerForm,
-    { resetFields, validate, setFieldsValue, getFieldsValue, setProps, updateSchema },
-  ] = useForm({
-    labelWidth: 120,
-    schemas: formSchema,
-    showActionButtonGroup: false,
-  });
-  const [registerDrawer, { setDrawerProps, closeDrawer }] = useDrawerInner(async (data) => {
-    setDrawerProps({ confirmLoading: false, loading: true });
-    isUpdate.value = data.isUpdate;
-    getActionFormArr();
-    if (!unref(isUpdate)) {
-      resetFields();
-      //初始化执行动作
-      actionData.value = [Date.now()];
-    } else {
-      // 取值
-      const {
-        id: recordId,
-        tenantId: recordTenantId,
-        organizationId,
-        triggers,
-        doConditions,
-        doActions,
-      } = data.record;
-      organizationIdRef.value = organizationId;
-      // 赋值
-      await setFieldsValue(data.record);
-      id.value = recordId;
-      tenantId.value = recordTenantId;
-      //TODO-fengtao-把组织id传给子组件
-      provideOrgid.value = organizationId;
-      //TODO-fengtao获取当前执行动作下的设备(master那个接口)
-      // getMasterDeviceList.value = await byOrganizationIdGetMasterDevice(organizationId);
-      //TODO-fengtao
-      // 获取当前组织下的设备列表
-      const options = await screenLinkPageByDeptIdGetDevice({
-        organizationId,
-      });
-      // 获取当前组织下的告警配置
-      const alarmConfig = await getOrganizationAlarmConfig({ organizationId });
-
-      // 生成回显时对应得组件数量
-      triggerData.value = [...new Array(triggers.length).keys()];
-      conditionData.value = [...new Array(doConditions.length).keys()];
-      actionData.value = [...new Array(doActions.length).keys()];
-      // 回显设备列表
-      editEntryIdData.value = options.items.map((item) => {
-        return {
-          value: item.tbDeviceId,
-          label: item.name,
-        };
-      });
-      editAlarmConfigData.value = alarmConfig.map((item) => {
-        return {
-          value: item.id,
-          label: item.name,
-          status: item.status,
-        };
-      });
-      deviceList.value = editEntryIdData.value;
-      nextTick(() => {
-        setEditFields(skipUnwrap.triggerItemRefs, editEntryIdData);
-        setEditFields(skipUnwrap.conditionItemRefs, editEntryIdData);
-        setEditFields(skipUnwrap.actionItemRefs, getMasterDeviceList);
-        setEditAlarmConfig(skipUnwrap.actionItemRefs, editAlarmConfigData);
-      });
-
-      const map = {
-        ANY_TIME: 0,
-        SPECIFIC_TIME: 1,
-        CUSTOM: 2,
-      };
-      // 回显触发器数据---此处是个闭包!
-      triggers.forEach((trigger, index) => {
-        nextTick(async () => {
-          const selectProductId = ref('');
-          // 回显启用规则
-          unref(skipUnwrap.triggerItemRefs)[index].currentIndex =
-            map[trigger.triggerCondition.schedule.type];
-          unref(skipUnwrap.triggerItemRefs)[index].scheduleData = trigger.triggerCondition.schedule;
-          unref(skipUnwrap.triggerItemRefs)[index].isUpdate = true;
-          unref(skipUnwrap.triggerItemRefs)[index].alarmScheduleRef.scheduleData =
-            trigger.triggerCondition.schedule;
-          unref(skipUnwrap.triggerItemRefs)[index].setFieldsFormValueFun({
-            triggered: trigger?.triggerCondition?.condition?.spec?.type,
-            device: trigger?.entityType,
-            deviceType: trigger?.deviceType,
-            triggerType: trigger?.triggerType,
-            type1: trigger?.triggerCondition?.condition?.condition[0]?.key?.type,
-            type2: trigger?.triggerCondition?.condition?.condition[0]?.key?.key,
-            operationType: trigger?.triggerCondition?.condition?.condition[0]?.valueType,
-            detail: trigger?.triggerCondition?.alarmDetails,
-            entityId: trigger?.entityId,
-            deviceProfileId: trigger?.deviceProfileId,
-            replaceValue: trigger?.triggerCondition?.condition?.spec?.predicate?.defaultValue,
-            time: trigger?.triggerCondition?.condition?.spec?.predicate?.defaultValue,
-            timeUnit: trigger?.triggerCondition?.condition?.spec?.unit,
-          });
-          if (trigger.deviceProfileId != undefined) {
-            selectProductId.value = trigger?.deviceProfileId;
-          }
-          //fengtao-把设备id回传给子组件
-          unref(skipUnwrap.triggerItemRefs)[index].updateFieldAttributeFunc(selectProductId.value);
-          //fengtao
-          // 设置值operationType
-          unref(skipUnwrap.triggerItemRefs)[index].operationType =
-            trigger.triggerCondition?.condition.condition[0].valueType;
-
-          const ConditionScreeningForm = await unref(skipUnwrap.triggerItemRefs)[
-            index
-          ].getRefItemConditionScreeningRefs();
-
-          // 设置对应条件筛选的个数
-          unref(skipUnwrap.triggerItemRefs)[index].setConditionScreeningList([
-            ...new Array(trigger.triggerCondition.condition.condition.length).keys(),
-          ]);
-          // 操作符类型 NUMERIC|String|Boolean|DATE_TIME
-          const valueType = trigger.triggerCondition?.condition.condition[0].valueType;
-
-          // 循环设置条件筛选值。TODO:此处设置顺序有问题
-          nextTick(() => {
-            const richTextList = [];
-            trigger.triggerCondition.condition.condition.forEach((item, index) => {
-              const formItem = {
-                operation: item.predicate.operation,
-                value:
-                  valueType === 'DATE_TIME'
-                    ? formatToDateTime(
-                        Number(item.predicate.value.defaultValue),
-                        'YYYY-MM-DD HH:mm:ss'
-                      )
-                    : String(item.predicate.value.defaultValue),
-                ignoreCase: item.valueType === 'STRING' ? item.predicate.ignoreCase : undefined,
-              };
-              richTextList.push({
-                // 查询中文操作符
-                operation: findOperation(valueType, item.predicate.operation).label,
-                value:
-                  valueType === 'DATE_TIME'
-                    ? formatToDateTime(
-                        Number(item.predicate.value.defaultValue),
-                        'YYYY-MM-DD HH:mm:ss'
-                      )
-                    : String(item.predicate.value.defaultValue),
-                attribute: trigger.triggerCondition?.condition.condition[0]?.key?.key,
-              });
-              ConditionScreeningForm.value[index].setFieldsValue(formItem);
-            });
-            unref(skipUnwrap.triggerItemRefs)[index].setRichText(richTextList);
-          });
-        });
-      });
-
-      doConditions.forEach((condition, index) => {
-        nextTick(async () => {
-          const selectProductId = ref('');
-          // 回显启用规则
-          unref(skipUnwrap.conditionItemRefs)[index].currentIndex =
-            map[condition.triggerCondition.schedule.type];
-          unref(skipUnwrap.conditionItemRefs)[index].scheduleData =
-            condition.triggerCondition.schedule;
-          unref(skipUnwrap.conditionItemRefs)[index].isUpdate = true;
-          unref(skipUnwrap.conditionItemRefs)[index].alarmScheduleRef.scheduleData =
-            condition.triggerCondition.schedule;
-          unref(skipUnwrap.conditionItemRefs)[index].setFieldsFormValueFun({
-            triggered: condition?.triggerCondition?.condition?.spec?.type,
-            device: condition?.entityType,
-            triggerType: condition?.triggerType,
-            type1: condition?.triggerCondition?.condition?.condition[0]?.key?.type,
-            type2: condition?.triggerCondition?.condition?.condition[0]?.key?.key,
-            operationType: condition?.triggerCondition?.condition?.condition[0]?.valueType,
-            detail: condition?.triggerCondition?.alarmDetails,
-            entityId: condition?.entityId,
-            deviceProfileId: condition?.deviceProfileId,
-            deviceType: condition?.deviceType,
-            replaceValue: condition?.triggerCondition?.condition?.spec?.predicate?.defaultValue,
-            time: condition?.triggerCondition?.condition?.spec?.predicate?.defaultValue,
-            timeUnit: condition?.triggerCondition?.condition?.spec?.unit,
-          });
-          if (condition?.deviceProfileId != undefined) {
-            selectProductId.value = condition?.deviceProfileId;
-          }
-          //fengtao-把设备id回传给子组件
-          unref(skipUnwrap.conditionItemRefs)[index].updateFieldAttributeFunc(
-            selectProductId.value
-          );
-          //fengtao
-          // 设置值operationType
-          unref(skipUnwrap.conditionItemRefs)[index].operationType =
-            condition.triggerCondition?.condition.condition[0].valueType;
-
-          const ConditionScreeningForm = await unref(skipUnwrap.conditionItemRefs)[
-            index
-          ].getRefItemConditionScreeningRefs();
-
-          // 设置对应条件筛选的个数
-          unref(skipUnwrap.conditionItemRefs)[index].setConditionScreeningList([
-            ...new Array(condition.triggerCondition.condition.condition.length).keys(),
-          ]);
-          // 操作符类型 NUMERIC|String|Boolean|DATorganizeImportsE_TIME
-          const valueType = condition.triggerCondition?.condition.condition[0].valueType;
-
-          // 循环设置条件筛选值。TODO:此处设置顺序有问题
-          nextTick(() => {
-            const richTextList = [];
-            condition.triggerCondition.condition.condition.forEach((item, index) => {
-              const formItem = {
-                operation: item.predicate.operation,
-                value:
-                  valueType === 'DATE_TIME'
-                    ? formatToDateTime(
-                        Number(item.predicate.value.defaultValue),
-                        'YYYY-MM-DD HH:mm:ss'
-                      )
-                    : String(item.predicate.value.defaultValue),
-                ignoreCase: item.valueType === 'STRING' ? item.predicate.ignoreCase : undefined,
-              };
-              richTextList.push({
-                // 查询中文操作符
-                operation: findOperation(valueType, item.predicate.operation).label,
-                value:
-                  valueType === 'DATE_TIME'
-                    ? formatToDateTime(
-                        Number(item.predicate.value.defaultValue),
-                        'YYYY-MM-DD HH:mm:ss'
-                      )
-                    : String(item.predicate.value.defaultValue),
-                attribute: condition.triggerCondition?.condition.condition[0]?.key?.key,
-              });
-              ConditionScreeningForm.value[index].setFieldsValue(formItem);
-            });
-            unref(skipUnwrap.conditionItemRefs)[index].setRichText(richTextList);
-          });
-        });
-      });
-      doActions.forEach((action, index) => {
-        nextTick(() => {
-          const selectProductId = ref('');
-          // 设置执行动作外层值
-          unref(skipUnwrap.actionItemRefs)[index].setFieldsFormValueFun({
-            ...action,
-            outTarget: action.outTarget,
-            device: action.entityType,
-            deviceId: action.deviceId,
-            alarm_config: action.alarmProfileId,
-            alarm_level: action.doContext.alarmLevel,
-          });
-          // 如果是设备输出设置脚本值
-          if (action.outTarget === 'DEVICE_OUT') {
-            if (action.commandType.toString() === '0') {
-              unref(skipUnwrap.actionItemRefs)[index].setJsonValue(action.doContext.params);
-            }
-          }
-          // 清除告警有值?{数组}
-          if (action?.doContext?.clearRule?.length) {
-            unref(skipUnwrap.actionItemRefs)[index].checked = true;
-            // 生成对应清除告警的数组长度
-            unref(skipUnwrap.actionItemRefs)[index].clearRuleList = [
-              ...new Array(action?.doContext?.clearRule?.length).keys(),
-            ];
-            // 推迟执行时机-DOM渲染完毕在执行
-            nextTick(async () => {
-              unref(skipUnwrap.actionItemRefs)[index].refItem.clearRuleRefs.value.map(
-                (item, index) => {
-                  // 回显启用规则
-                  item.currentIndex =
-                    map[action.doContext.clearRule[index].triggerCondition.schedule.type];
-                  item.scheduleData = action.doContext.clearRule[index].triggerCondition.schedule;
-                  item.isUpdate = true;
-                  item.alarmScheduleRef.scheduleData =
-                    action.doContext.clearRule[index].triggerCondition.schedule;
-                  item.setFieldsFormValueFun({
-                    triggered:
-                      action.doContext.clearRule[index].triggerCondition.condition.spec.type,
-                    device: action.doContext.clearRule[index].entityType,
-                    deviceType: action.doContext.clearRule[index].deviceType,
-                    triggerType: action.doContext.clearRule[index].triggerType,
-                    type1:
-                      action.doContext.clearRule[index].triggerCondition.condition.condition[0].key
-                        .type,
-                    type2:
-                      action.doContext.clearRule[index].triggerCondition.condition.condition[0].key
-                        .key,
-                    operationType:
-                      action.doContext.clearRule[index].triggerCondition.condition.condition[0]
-                        .valueType,
-                    detail: action.doContext.clearRule[index].triggerCondition.alarmDetails,
-                    entityId: action.doContext.clearRule[index].entityId,
-                    deviceProfileId: action.doContext.clearRule[index]?.deviceProfileId,
-                    replaceValue:
-                      action.doContext.clearRule[index].triggerCondition.condition.spec.predicate
-                        .defaultValue,
-                    time: action.doContext.clearRule[index].triggerCondition.condition.spec
-                      .predicate.defaultValue,
-                    timeUnit:
-                      action.doContext.clearRule[index].triggerCondition.condition.spec.unit,
-                  });
-                  if (action.doContext.clearRule[index]?.deviceProfileId != undefined) {
-                    selectProductId.value = action.doContext.clearRule[index]?.deviceProfileId;
-                  }
-                  //fengtao-把设备id回传给子组件
-                  item.updateFieldAttributeFunc(selectProductId.value);
-                  item.updateFieldDeviceId(deviceList.value, provideOrgid.value, isUpdate.value);
-                  //fengtao
-                  // 单独设置operationType值 操作符类型 NUMERIC|String|Boolean|DATE_TIME
-                  item.operationType =
-                    action.doContext.clearRule[
-                      index
-                    ].triggerCondition.condition.condition[0].valueType;
-                }
-              );
-
-              const ConditionScreeningForm = await unref(skipUnwrap.actionItemRefs)[
-                index
-              ].getRefItemConditionScreeningRefs();
-
-              // 循环设置条件筛选值。TODO:此处设置顺序有问题
-              action.doContext.clearRule.map((rule, ruleIndex) => {
-                // 生成对应条件筛选的数组个数
-                unref(skipUnwrap.actionItemRefs)[index].setConditionScreeningList([
-                  ...new Array(
-                    action.doContext.clearRule[
-                      ruleIndex
-                    ].triggerCondition.condition.condition.length
-                  ).keys(),
-                ]);
-                nextTick(() => {
-                  const richTextList = [];
-                  rule.triggerCondition.condition.condition.forEach((item, conditionIndex) => {
-                    //TODO-fengtao之前是Number( item.predicate.value.defaultValue)-发现回显是Invalide Time
-                    const formItem = {
-                      operation: item.predicate.operation,
-                      value:
-                        item.valueType === 'DATE_TIME'
-                          ? formatToDateTime(
-                              Number(item.predicate.value.defaultValue),
-                              'YYYY-MM-DD HH:mm:ss'
-                            )
-                          : String(item.predicate.value.defaultValue),
-                      ignoreCase:
-                        item.valueType === 'STRING' ? item.predicate.ignoreCase : undefined,
-                    };
-                    //TODO-fengtao之前是Number( item.predicate.value.defaultValue)-发现回显是Invalide Time
-                    richTextList.push({
-                      // 查询中文操作符
-                      operation: findOperation(item.valueType, item.predicate.operation).label,
-                      value:
-                        item.valueType === 'DATE_TIME'
-                          ? formatToDateTime(
-                              item.predicate.value.defaultValue,
-                              'YYYY-MM-DD HH:mm:ss'
-                            )
-                          : String(item.predicate.value.defaultValue),
-                      attribute: item?.key?.key,
-                    });
-                    //TODO-fengtao之前是Number( item.predicate.value.defaultValue)-发现回显是Invalide Time
-                    ConditionScreeningForm[ruleIndex].value[conditionIndex].setFieldsValue(
-                      formItem
-                    );
-                  });
-                  unref(skipUnwrap.actionItemRefs)[index].setRichText(richTextList, ruleIndex);
-                });
-              });
-            });
-          }
-          nextTick(() => {
-            setEditFields(skipUnwrap.actionItemRefs, editEntryIdData);
-          });
-        });
-      });
-    }
-    if (unref(isUpdate) === 3) isView.value = false;
-    setDrawerProps({
-      showFooter: unref(isView),
-      loading: false,
-    });
-
-    if (isUpdate.value == 3) {
-      setProps({ disabled: true });
-      updateSchema({
-        field: 'organizationId',
-        componentProps: { apiTreeSelectProps: { disabled: true } },
-      });
-      await nextTick();
-      unref(skipUnwrap.triggerItemRefs)?.forEach((item) => {
-        item.setDisabledProps({ disabled: true });
-      });
-
-      unref(skipUnwrap.conditionItemRefs)?.forEach((item) => {
-        item.setDisabledProps({ disabled: true });
-      });
-
-      unref(skipUnwrap.actionItemRefs)?.forEach((item) => {
-        item.setDisabledProps({ disabled: true });
-      });
-    } else {
-      updateSchema({
-        field: 'organizationId',
-        componentProps: { apiTreeSelectProps: { disabled: false } },
-      });
-      unref(skipUnwrap.triggerItemRefs)?.forEach((item) => {
-        item.setCancelDisabled();
-      });
-      unref(skipUnwrap.conditionItemRefs)?.forEach((item) => {
-        item.setCancelDisabled();
-      });
-    }
-  });
-
-  // 设置设备的options
-  const setEditFields = (linkAge, deviceList) => {
-    unref(linkAge).map((item) => {
-      // TODO-fengtao
-      item.updateFieldDeviceId(deviceList, orgId, isUpdate);
-      // TODO-fengtao
-    });
-  };
-  // 设置告警配置options
-  const setEditAlarmConfig = (linkAge, alarmConfigList) => {
-    unref(linkAge).map((item) => {
-      item.updateEditFieldAlarmConfig(alarmConfigList);
-    });
-  };
-  // 监听组织变化更新设备列表
-  const deviceList = ref([]);
-  const getMasterDeviceList = ref([]);
-  const orgId = ref('');
-  const alarmConfigList = ref([]);
-  //FT add 2022-10-27
-  const addOrgId = ref('');
-  //FT add 2022-10-27
-  watch(organizationIdRef, async (newValue: string) => {
-    if (!newValue) return;
-    //FT add 2022-10-27
-    addOrgId.value = newValue;
-    //FT add 2022-10-27
-    const { items = [] } = await screenLinkPageByDeptIdGetDevice({ organizationId: newValue });
-    //TODO fengtao
-    // getMasterDeviceList.value = await byOrganizationIdGetMasterDevice(newValue);
-    //TODO fengtao
-    deviceList.value = (items || []).map((item) => ({
-      ...item,
-      label: item.name,
-      value: item.tbDeviceId,
-    }));
-    //TODO fengtao
-    orgId.value = newValue;
-    //TODO fengtao
-    setFields(skipUnwrap.triggerItemRefs, true);
-    setFields(skipUnwrap.conditionItemRefs, true);
-    setFields(skipUnwrap.actionItemRefs, true);
-    const data = await getOrganizationAlarmConfig({ organizationId: newValue });
-    alarmConfigList.value = data.map((item) => ({
-      label: item.name,
-      value: item.id,
-      status: item.status,
-    }));
-    setEditAlarmConfig(skipUnwrap.actionItemRefs, alarmConfigList);
-    // setFields(skipUnwrap.actionItemRefs, true);
-    // console.log(unref(organizationIdRef));
-    // setAlarmConfig(skipUnwrap.actionItemRefs, true);
-  });
-  //FT add 2022-10-27
-  const handleDynamicChangeAlarmConfig = async () => {
-    const data = await getOrganizationAlarmConfig({
-      organizationId: isUpdate.value ? provideOrgid.value : addOrgId.value,
-    });
-    const res = data.map((item) => ({ label: item.name, value: item.id, status: item.status }));
-    isUpdate.value ? (editAlarmConfigData.value = res) : (alarmConfigList.value = res);
-    unref(skipUnwrap.actionItemRefs)?.map((item: any) => {
-      if (isUpdate.value) {
-        item.updateEditFieldAlarmConfig(editAlarmConfigData);
-      } else {
-        item.updateFieldAlarmConfig(alarmConfigList);
-      }
-    });
-  };
-  //FT add 2022-10-27
-  // 根据上面组织变化动态改变触发器，执行条件,执行动作的设备值
-  function setFields(linkAge, isOrganizationChange = false) {
-    unref(linkAge).map((item) => {
-      isOrganizationChange && item.resetFieldsValueFunc();
-      //TODO fengtao
-      item.updateFieldDeviceId(deviceList, orgId, isUpdate);
-      if (isUpdate.value) {
-        item.updateEditFieldAlarmConfig(editAlarmConfigData);
-      } else {
-        item.updateFieldAlarmConfig(alarmConfigList);
-      }
-      //TODO fengtao
-    });
-  }
-  // function setAlarmConfig(linkAge, isOrganizationChange = false) {
-  //   unref(linkAge).map((item) => {
-  //     isOrganizationChange && item.resetFieldsValueFunc();
-  //     item.updateFieldAlarmConfig(alarmConfigList);
-  //   });
-  // }
-
-  const isEmptyThrowError = (obj) => {
-    if (isEmpty(obj)) {
-      createMessage.error('请选择组织');
-      throw Error('请选择组织');
-    }
-    if (!Reflect.get(obj, 'organizationId')) {
-      createMessage.error('请选择组织');
-      throw Error('请选择组织');
-    }
-  };
-
-  // 添加触发器
-  const addTrigger = () => {
-    unref(triggerData).push(Date.now());
-    nextTick(() => {
-      setFields(skipUnwrap.triggerItemRefs);
-    });
-    isEmptyThrowError(getFieldsValue());
-  };
-  // 添加执行条件
-  const addCondition = () => {
-    unref(conditionData).push(Date.now());
-    nextTick(() => {
-      setFields(skipUnwrap.conditionItemRefs);
-    });
-    isEmptyThrowError(getFieldsValue());
-  };
-  // 添加执行动作
-  const addAction = () => {
-    unref(actionData).push(Date.now());
-    nextTick(() => {
-      setFields(skipUnwrap.actionItemRefs);
-    });
-    isEmptyThrowError(getFieldsValue());
-  };
-
-  /**
-   * 获取触发器、执行条件、执行动作表单值--多个
-   */
-  const getFormValueFunc = () => {
-    getTriggerFormValue.value = unref(skipUnwrap.triggerItemRefs)?.map((item) =>
-      genTriggerOrConditionData(item.getFieldsValueFunc())
-    );
-    getConditionFormValue.value = unref(skipUnwrap.conditionItemRefs)?.map((item) =>
-      genTriggerOrConditionData(item.getFieldsValueFunc())
-    );
-    getActionFormValue.value = unref(skipUnwrap.actionItemRefs)?.map((item) =>
-      genActionData(item.getFieldsValueFunc())
-    );
-  };
-  const handleSubmit = async () => {
-    let basicFormValue = await validate();
-    if (!basicFormValue) return;
-    for (const item of unref(skipUnwrap.actionItemRefs)) {
-      const valid = await item.validateForm();
-      if (!valid) return;
-    }
-    try {
-      setDrawerProps({ confirmLoading: true });
-      getFormValueFunc();
-      //新增的代码2022-11-22
-      if (unref(getTriggerFormValue).length === 0 && unref(getConditionFormValue).length === 0) {
-        createMessage.error('请添加触发器或者执行条件');
-        throw '请添加触发器或者执行条件';
-      }
-
-      // return;
-      //新增的代码2022-11-22
-      const postAddOrEditData = {
-        ...basicFormValue,
-        triggers: !unref(getTriggerFormValue).length ? null : unref(getTriggerFormValue),
-        doConditions: !unref(getConditionFormValue).length ? null : unref(getConditionFormValue),
-        doActions: unref(getActionFormValue).flat(),
-        id: unref(id),
-        tenantId: unref(tenantId),
-      };
-      //FT change
-      let mustTriggerCondition = false;
-      let mustCondition = false;
-      if (postAddOrEditData?.triggers !== null && postAddOrEditData?.triggers.length > 0) {
-        postAddOrEditData?.triggers.some((s) => {
-          if (s.triggerCondition?.condition?.condition == undefined) {
-            mustTriggerCondition = true;
-          }
-        });
-      } else {
-        mustTriggerCondition = false;
-      }
-      if (postAddOrEditData?.doConditions !== null && postAddOrEditData?.doConditions.length > 0) {
-        postAddOrEditData?.doConditions.some((s) => {
-          if (s.triggerCondition?.condition?.condition == undefined) {
-            mustCondition = true;
-          }
-        });
-      } else {
-        mustCondition = false;
-      }
-      if (mustTriggerCondition) return;
-      if (mustCondition) return;
-      //FT change
-      await screenLinkPageAddApi(postAddOrEditData, unref(isUpdate));
-      createMessage.success(`${unref(isUpdate) ? '编辑' : '新增'}成功`);
-      closeDrawer();
-      handleClose();
-      emit('success');
-    } finally {
-      setDrawerProps({ confirmLoading: false });
-    }
-  };
-  // 删除
-  const deleteTriggerOrCondition = ({ index, title }) => {
-    if (title === '触发器') {
-      unref(triggerData).splice(index, 1);
-    } else if (title === '执行条件') {
-      unref(conditionData).splice(index, 1);
-    }
-  };
-  const deleteAction = (actionIndex) => {
-    unref(actionData).splice(actionIndex, 1);
-    unref(arr).splice(actionIndex, 1);
-  };
-  const arr = ref([]);
-  const getActionFormArr = () => {
-    arr.value = unref(skipUnwrap.actionItemRefs).map((item) => item.getFieldsValue());
-  };
-  const handleClose = () => {
-    id.value = undefined;
-    tenantId.value = undefined;
-    organizationIdRef.value = undefined;
-    isView.value = true;
-    getTriggerFormValue.value = [];
-    getConditionFormValue.value = [];
-    getActionFormValue.value = [];
-    triggerData.value = [];
-    conditionData.value = [];
-    actionData.value = [];
-    unref(skipUnwrap.triggerItemRefs).map((item) => {
-      item.resetFieldsValueFunc();
-    });
-    unref(skipUnwrap.conditionItemRefs).map((item) => {
-      item.resetFieldsValueFunc();
-    });
-    unref(skipUnwrap.actionItemRefs).map((item) => {
-      item.resetFieldsValueFunc();
-    });
-    window.localStorage.removeItem('isViewDisabledBtn');
-    // window.localStorage.setItem('isViewDisabledBtn', 'no')
-  };
-</script>
-
-<style lang="less" scoped>
-  //TODO-fengtao
-  ///移除选择框默认样式（24px）否则超出默认宽度会造成页面样式错乱
-  :deep(.ant-select-selector) {
-    padding-right: 0 !important;
-  }
-
-  :deep(.ant-select-selection-overflow) {
-    max-width: 10vw !important;
-  }
-
-  //TODO-fengtao
-
-  label.validate-dot::before {
-    display: inline-block;
-    color: #ff4d4f;
-    font-size: 14px;
-    font-family: SimSun, sans-serif;
-    line-height: 1;
-    content: '*';
-  }
-</style>

+import { OperationType } from './type';
+import { FormSchema } from '/@/components/Form';
+import {
+  BooleanOperationEnum,
+  BooleanOperationNameEnum,
+  BooleanOperationValueEnum,
+  BooleanOperationValueNameEnum,
+  NumberOperationEnum,
+  NumberOperationNameEnum,
+  StringOperationEnum,
+  StringOperationNameEnum,
+  TriggerValueTypeEnum,
+} from '/@/enums/linkedgeEnum';
+
+export enum FormFieldsEnum {
+  CONDITION_OPERATION = 'operation',
+  CONDITION_VALUE = 'defaultValue',
+  CONDITION_VALUE_IGNORE_CASE = 'ignoreCase',
+}
+
+export enum FormFieldsNameEnum {
+  CONDITION_OPERATION = '执行操作',
+  CONDITION_VALUE = '操作值',
+  CONDITION_VALUE_IGNORE_CASE = '忽略大小写',
+}
+
+interface GetFormSchemasParamsType {
+  triggerType: TriggerValueTypeEnum;
+}
+
+export interface ConditionFormRecordType {
+  [FormFieldsEnum.CONDITION_OPERATION]: OperationType;
+  [FormFieldsEnum.CONDITION_VALUE]: any;
+  [FormFieldsEnum.CONDITION_VALUE_IGNORE_CASE]?: boolean;
+}
+
+export const getOperationMap = (type: TriggerValueTypeEnum) => {
+  const keyMap = {
+    [TriggerValueTypeEnum.NUMERIC]: { value: NumberOperationEnum, label: NumberOperationNameEnum },
+    [TriggerValueTypeEnum.BOOLEAN]: {
+      value: BooleanOperationEnum,
+      label: BooleanOperationNameEnum,
+    },
+    [TriggerValueTypeEnum.STRING]: { value: StringOperationEnum, label: StringOperationNameEnum },
+    [TriggerValueTypeEnum.DATE_TIME]: {
+      value: NumberOperationEnum,
+      label: NumberOperationNameEnum,
+    },
+  };
+
+  return keyMap[type];
+};
+
+const getOperation = (type: TriggerValueTypeEnum) => {
+  const res = getOperationMap(type);
+
+  const { label, value } = res;
+  return Object.keys(value).map((value) => ({ label: label[value], value }));
+};
+
+const getOperationValueFormSchemas = (triggerType: TriggerValueTypeEnum): FormSchema[] => {
+  const getNumberSchemas = (): FormSchema[] => {
+    return [
+      {
+        field: FormFieldsEnum.CONDITION_VALUE,
+        label: FormFieldsNameEnum.CONDITION_VALUE,
+        component: 'InputNumber',
+        required: true,
+        componentProps: () => {
+          return {
+            placeholder: `请输入${FormFieldsNameEnum.CONDITION_VALUE}`,
+          };
+        },
+      },
+    ];
+  };
+
+  const getBoolSchemas = (): FormSchema[] => {
+    return [
+      {
+        field: FormFieldsEnum.CONDITION_VALUE,
+        label: FormFieldsNameEnum.CONDITION_VALUE,
+        component: 'Select',
+        required: true,
+        componentProps: () => {
+          return {
+            options: [
+              { label: BooleanOperationValueNameEnum.TRUE, value: BooleanOperationValueEnum.TRUE },
+              {
+                label: BooleanOperationValueNameEnum.FALSE,
+                value: BooleanOperationValueEnum.FALSE,
+              },
+            ],
+            placeholder: `请输入${FormFieldsNameEnum.CONDITION_VALUE}`,
+          };
+        },
+      },
+    ];
+  };
+
+  const getStringSchemas = (): FormSchema[] => {
+    return [
+      {
+        field: FormFieldsEnum.CONDITION_VALUE,
+        label: FormFieldsNameEnum.CONDITION_VALUE,
+        component: 'Input',
+        required: true,
+        componentProps: () => {
+          return {
+            placeholder: `请输入${FormFieldsNameEnum.CONDITION_VALUE}`,
+          };
+        },
+      },
+      {
+        field: FormFieldsEnum.CONDITION_VALUE_IGNORE_CASE,
+        label: ' ',
+        component: 'Checkbox',
+        renderComponentContent: () => ({
+          default: () => FormFieldsNameEnum.CONDITION_VALUE_IGNORE_CASE,
+        }),
+      },
+    ];
+  };
+
+  const getDateSchemas = (): FormSchema[] => {
+    return [
+      {
+        field: FormFieldsEnum.CONDITION_VALUE,
+        label: FormFieldsNameEnum.CONDITION_VALUE,
+        component: 'DatePicker',
+        required: true,
+        componentProps: () => {
+          return {
+            showTime: true,
+            placeholder: `请输入${FormFieldsNameEnum.CONDITION_VALUE}`,
+          };
+        },
+      },
+    ];
+  };
+
+  const schemasMap = {
+    [TriggerValueTypeEnum.BOOLEAN]: getBoolSchemas,
+    [TriggerValueTypeEnum.DATE_TIME]: getDateSchemas,
+    [TriggerValueTypeEnum.NUMERIC]: getNumberSchemas,
+    [TriggerValueTypeEnum.STRING]: getStringSchemas,
+  };
+
+  return schemasMap[triggerType]?.() || [];
+};
+
+export const getFormSchemas = ({ triggerType }: GetFormSchemasParamsType): FormSchema[] => {
+  return [
+    {
+      field: FormFieldsEnum.CONDITION_OPERATION,
+      label: FormFieldsNameEnum.CONDITION_OPERATION,
+      component: 'Select',
+      required: true,
+      componentProps: () => {
+        return {
+          options: getOperation(triggerType),
+          placeholder: `请选择${FormFieldsNameEnum.CONDITION_OPERATION}`,
+        };
+      },
+    },
+    ...getOperationValueFormSchemas(triggerType),
+  ];
+};

+import { ConditionListItemType } from './type';
+import { buildUUID } from '/@/utils/uuid';
+
+export { default as ConditionFilter } from './index.vue';
+
+export function getNewConditionFilterItem(value?: Recordable): ConditionListItemType {
+  return {
+    key: buildUUID(),
+    value,
+  };
+}

+<script setup lang="ts">
+  import { ComponentPublicInstance, computed, ref, unref, watch } from 'vue';
+  import { Card, Tag, Button } from 'ant-design-vue';
+  import { Icon } from '/@/components/Icon';
+  import { getFormSchemas, FormFieldsEnum } from './config';
+  import { CollapseContainer } from '/@/components/Container';
+  import { BasicForm, FormActionType } from '/@/components/Form';
+  import { TriggerValueTypeEnum } from '/@/enums/linkedgeEnum';
+  import { ConditionFilterProps, ConditionListItemType } from './type';
+  import { ConditionMessageItemType, useConditionFilterMessage } from './useConditionFilterMessage';
+  import { useConditionData } from './useConditionData';
+  import { getNewConditionFilterItem } from '.';
+  import { useSceneLinkageDrawerContext } from '../SceneLinkageDrawer/sceneLinkageDrawerContext';
+
+  const { disabledDrawer } = useSceneLinkageDrawerContext();
+
+  const props = withDefaults(defineProps<ConditionFilterProps>(), {
+    triggerType: TriggerValueTypeEnum.BOOLEAN,
+  });
+
+  const getSchemas = computed(() => {
+    const { triggerType } = props;
+    return getFormSchemas({ triggerType });
+  });
+
+  const conditionListElRef = ref<ConditionListItemType[]>([getNewConditionFilterItem()]);
+
+  const getConditionFormValues = (): Record<FormFieldsEnum, string>[] => {
+    return unref(conditionListElRef).map(
+      (conditionForm) => conditionForm.ref?.getFieldsValue() as Record<FormFieldsEnum, string>
+    );
+  };
+
+  const conditionMessageList = ref<ConditionMessageItemType[]>([]);
+
+  const handleConditionFormValueChange = () => {
+    const condition = getConditionFormValues();
+    const { triggerType } = props;
+    const message = useConditionFilterMessage({ triggerType, condition });
+    conditionMessageList.value = message;
+  };
+
+  const setConditionRef = (
+    conditionItem: ConditionListItemType,
+    el: Element | ComponentPublicInstance | null
+  ) => {
+    conditionItem.ref = el as unknown as FormActionType;
+  };
+
+  const handleDelete = (conditionItem: ConditionListItemType) => {
+    const { key } = conditionItem;
+
+    const index = unref(conditionListElRef).findIndex((item) => item.key === key);
+
+    ~index && unref(conditionListElRef).splice(index, 1);
+  };
+
+  const handleAdd = () => {
+    conditionListElRef.value.push(getNewConditionFilterItem());
+  };
+
+  watch(
+    () => props.triggerType,
+    () => {
+      conditionListElRef.value = [getNewConditionFilterItem()];
+      conditionMessageList.value = [];
+    }
+  );
+
+  const { getFieldsValue, setFieldsValue, validate } = useConditionData(
+    props,
+    conditionListElRef,
+    handleConditionFormValueChange
+  );
+
+  const handelValidate = async () => {
+    await validate?.();
+  };
+
+  defineExpose({ getFieldsValue, setFieldsValue, validate });
+</script>
+
+<template>
+  <Card class="condition-filter-card !border-dashed !border-2 !border-gray-200 !rounded-lg">
+    <CollapseContainer class="rounded-lg" :is-close="!disabledDrawer">
+      <template #title>
+        <section class="flex !p-2">
+          <div class="w-20 flex-grow-0 flex-shrink-0"> 条件筛选 </div>
+          <div class="flex flex-wrap">
+            <template v-for="(item, index) in conditionMessageList" :key="index">
+              <Tag class="!rounded-md !m-0 !text-sky-700"> {{ objectModel?.name }} </Tag>
+              <span class="mx-2">{{ item.operation }}</span>
+              <Tag class="!rounded-md !m-0 !text-orange-300">
+                {{ item.defaultValue }}
+              </Tag>
+              <span class="mx-2" v-if="conditionMessageList.length - 1 !== index">和</span>
+            </template>
+          </div>
+        </section>
+      </template>
+      <!--  -->
+      <main
+        class="flex gap-4 items-center mb-2"
+        v-for="(conditionItem, index) in conditionListElRef"
+        :key="conditionItem.key"
+      >
+        <section class="border-2 border-dashed border-gray-200 rounded-lg px-4 py-2 flex-1">
+          <!--  -->
+          <BasicForm
+            :ref="(el) => setConditionRef(conditionItem, el)"
+            :show-action-button-group="false"
+            layout="horizontal"
+            :disabled="disabledDrawer"
+            :label-width="80"
+            :schemas="getSchemas"
+            :base-col-props="{ span: 24 / getSchemas.length, xl: 8, lg: 12, sm: 24 }"
+            @field-value-change="handleConditionFormValueChange"
+          />
+        </section>
+        <span
+          class="w-5"
+          :style="{ visibility: conditionListElRef.length - 1 !== index ? 'visible' : 'hidden' }"
+        >
+          和
+        </span>
+        <Icon
+          v-if="!disabledDrawer"
+          icon="fluent:delete-off-20-regular"
+          size="24"
+          class="cursor-pointer"
+          @click="handleDelete(conditionItem)"
+        />
+      </main>
+      <section class="flex mt-4 items-center justify-between">
+        <Button v-if="!disabledDrawer" type="primary" @click="handleAdd">
+          <Icon icon="ant-design:plus-outlined" />
+          新增条件筛选
+        </Button>
+        <Button v-if="!disabledDrawer" type="primary" @click="handelValidate">添加</Button>
+      </section>
+    </CollapseContainer>
+  </Card>
+</template>
+
+<style lang="less" scoped>
+  .condition-filter-card {
+    :deep(.ant-card-body) {
+      @apply p-3;
+
+      .vben-collapse-container__header {
+        height: fit-content;
+      }
+
+      .ant-calendar-picker {
+        min-width: auto !important;
+        width: 100%;
+      }
+
+      .ant-input-number {
+        min-width: auto !important;
+      }
+    }
+  }
+</style>
+./type

+import { ScheduleType } from '../EnablingRule/type';
+import { DeviceModelOfMatterAttrs } from '/@/api/device/model/deviceModel';
+import { FormActionType } from '/@/components/Form';
+import {
+  BooleanOperationEnum,
+  DeviceTriggerTypeEum,
+  FlipFlopTypeEnum,
+  NumberOperationEnum,
+  StringOperationNameEnum,
+  TriggerTypeEnum,
+  TriggerValueTypeEnum,
+} from '/@/enums/linkedgeEnum';
+
+export interface ConditionListItemType {
+  key: string;
+  value?: Recordable;
+  ref?: FormActionType;
+}
+
+export interface ConditionFilterProps {
+  triggerType?: TriggerValueTypeEnum;
+  objectModel?: DeviceModelOfMatterAttrs;
+  conditionType?: DeviceTriggerTypeEum;
+}
+
+export interface TriggerCondition {
+  condition: ConditionType;
+  alarmDetails?: Nullable<any>;
+  dashboardId?: Nullable<any>;
+  schedule: ScheduleType;
+  triggerType?: TriggerTypeEnum;
+}
+
+export interface ConditionType {
+  condition: ConditionItemType[];
+  spec: { type: FlipFlopTypeEnum; unit?: string; predicate?: { defaultValue: any } };
+}
+
+export type OperationType = NumberOperationEnum | StringOperationNameEnum | BooleanOperationEnum;
+
+export interface ConditionItemType {
+  key: { type: DeviceTriggerTypeEum; key: string };
+  predicate: {
+    type: TriggerValueTypeEnum;
+    operation: OperationType;
+    ignoreCase?: boolean;
+    value: {
+      defaultValue: number | string | boolean;
+      userValue?: Nullable<number | string | boolean>;
+      dynamicValue?: Nullable<number | string | boolean>;
+    };
+  };
+  valueType: TriggerValueTypeEnum;
+  value?: Nullable<any>;
+}

+import { Ref, nextTick, unref } from 'vue';
+import { ConditionFilterProps, ConditionItemType, ConditionListItemType } from './type';
+import { DefineComponentsBasicExpose } from '/#/utils';
+import { DeviceTriggerTypeEum, TriggerValueTypeEnum } from '/@/enums/linkedgeEnum';
+import { ConditionFormRecordType, FormFieldsEnum } from './config';
+import { getNewConditionFilterItem } from '.';
+import { dateUtil } from '/@/utils/dateUtil';
+
+function getPredicateType(triggerType: TriggerValueTypeEnum) {
+  const map = {
+    [TriggerValueTypeEnum.BOOLEAN]: TriggerValueTypeEnum.BOOLEAN,
+    [TriggerValueTypeEnum.STRING]: TriggerValueTypeEnum.STRING,
+    [TriggerValueTypeEnum.NUMERIC]: TriggerValueTypeEnum.NUMERIC,
+    [TriggerValueTypeEnum.DATE_TIME]: TriggerValueTypeEnum.NUMERIC,
+  };
+
+  return map[triggerType];
+}
+
+export function useConditionData(
+  props: ConditionFilterProps,
+  conditionItemRef: Ref<ConditionListItemType[]>,
+  handleConditionFormValueChange: Fn
+): DefineComponentsBasicExpose<ConditionItemType[]> {
+  const createConditionItem = ({
+    operation,
+    defaultValue,
+    ignoreCase,
+  }: ConditionFormRecordType): ConditionItemType => {
+    const { triggerType, objectModel } = props;
+    const { identifier } = objectModel || {};
+    return {
+      key: { key: identifier!, type: DeviceTriggerTypeEum.TIME_SERIES },
+      predicate: {
+        ...(ignoreCase ? { ignoreCase } : {}),
+        operation,
+        type: getPredicateType(triggerType!),
+        value: {
+          defaultValue:
+            triggerType === TriggerValueTypeEnum.DATE_TIME
+              ? Number(dateUtil(defaultValue).format('x'))
+              : defaultValue,
+        },
+      },
+      valueType: triggerType!,
+    };
+  };
+
+  const getFieldsValue = (): ConditionItemType[] => {
+    return unref(conditionItemRef).map((conditionItem) => {
+      const value = conditionItem.ref?.getFieldsValue() as ConditionFormRecordType;
+      return createConditionItem(value);
+    });
+  };
+
+  const setFieldsValue = (condition: ConditionItemType[]) => {
+    conditionItemRef.value = Array.from({ length: condition.length }, () =>
+      getNewConditionFilterItem()
+    );
+
+    nextTick(() => {
+      unref(conditionItemRef).forEach((conditionItem, index) => {
+        const result = condition[index] || {};
+
+        const { operation, value, ignoreCase, type } = result.predicate || {};
+
+        conditionItem.ref?.setFieldsValue({
+          [FormFieldsEnum.CONDITION_OPERATION]: operation,
+          [FormFieldsEnum.CONDITION_VALUE]:
+            type === TriggerValueTypeEnum.BOOLEAN
+              ? value.defaultValue.toString()
+              : value.defaultValue,
+          [FormFieldsEnum.CONDITION_VALUE_IGNORE_CASE]: ignoreCase,
+        });
+      });
+      handleConditionFormValueChange();
+    });
+  };
+
+  const validate = async () => {
+    for (const conditionItem of unref(conditionItemRef)) {
+      await conditionItem.ref?.validate();
+    }
+  };
+  return {
+    getFieldsValue,
+    setFieldsValue,
+    validate,
+  };
+}

+import { FormFieldsEnum, getOperationMap } from './config';
+import {
+  BooleanOperationValueEnum,
+  BooleanOperationValueNameEnum,
+  TriggerValueTypeEnum,
+} from '/@/enums/linkedgeEnum';
+
+export type ConditionMessageItemType = Record<
+  Exclude<FormFieldsEnum, FormFieldsEnum.CONDITION_VALUE_IGNORE_CASE>,
+  string
+>;
+
+interface UseConditionFilterMessageParamsType {
+  triggerType: TriggerValueTypeEnum;
+  condition: ConditionMessageItemType[];
+}
+
+export function useConditionFilterMessage({
+  triggerType,
+  condition,
+}: UseConditionFilterMessageParamsType) {
+  const { label } = getOperationMap(triggerType);
+  const list: ConditionMessageItemType[] = [];
+  for (const item of condition) {
+    let { defaultValue, operation } = item;
+    if (!defaultValue || !operation) continue;
+    operation = label[operation];
+    if (triggerType === TriggerValueTypeEnum.BOOLEAN)
+      defaultValue =
+        defaultValue === BooleanOperationValueEnum.TRUE
+          ? BooleanOperationValueNameEnum.TRUE
+          : BooleanOperationValueNameEnum.FALSE;
+    list.push({ operation, defaultValue });
+  }
+  return list;
+}

+import TimeRangePicker from './TimeRangePicker.vue';
+import { WeekName } from './config';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
+
+enum FormFieldsEnum {
+  DAY_OF_WEEK = 'dayOfWeek',
+  ENABLED = 'enabled',
+  ENDS_ON = 'endsOn',
+  STARTS_ON = 'startsOn',
+  TIME_RANGE = 'timeRange',
+}
+
+export interface RuleFormRecordItem {
+  [FormFieldsEnum.DAY_OF_WEEK]: number;
+  [FormFieldsEnum.ENABLED]: boolean;
+  [FormFieldsEnum.TIME_RANGE]: {
+    [FormFieldsEnum.STARTS_ON]: number;
+    [FormFieldsEnum.ENDS_ON]: number;
+  };
+}
+
+useComponentRegister('TimeRangePicker', TimeRangePicker);
+
+export const getFormSchemas = (index: number): FormSchema[] => {
+  return [
+    {
+      field: FormFieldsEnum.DAY_OF_WEEK,
+      label: '',
+      component: 'InputNumber',
+      defaultValue: index + 1,
+      ifShow: false,
+    },
+    {
+      field: FormFieldsEnum.ENABLED,
+      label: '',
+      component: 'Checkbox',
+      defaultValue: false,
+      renderComponentContent: () => ({
+        default: () => `星期${WeekName[index]}`,
+      }),
+      colProps: { span: 5 },
+    },
+    {
+      field: FormFieldsEnum.TIME_RANGE,
+      label: '',
+      changeEvent: 'update:value',
+      valueField: 'value',
+      component: 'TimeRangePicker',
+      dynamicDisabled: ({ model }) => !model[FormFieldsEnum.ENABLED],
+      colProps: { span: 16 },
+      defaultValue: { startsOn: 0, endsOn: 0 },
+      dynamicRules: ({ model }) => {
+        return [
+          {
+            required: model[FormFieldsEnum.ENABLED],
+            validator(_rule, value: Record<'startsOn' | 'endsOn', number>, _callback) {
+              if (!model[FormFieldsEnum.ENABLED]) return Promise.resolve();
+              if (!value?.endsOn) return Promise.reject('请选择结束时间');
+              if (!value?.startsOn) return Promise.reject('请选择开始时间');
+              return Promise.resolve();
+            },
+          },
+        ];
+      },
+    },
+  ];
+};

+<script setup lang="ts">
+  import { CustomRuleItemType } from './type';
+  import { ComponentPublicInstance, nextTick, ref, unref, watch } from 'vue';
+  import { BasicForm, FormActionType } from '/@/components/Form';
+  import { getFormSchemas, RuleFormRecordItem } from './CustomRule.config';
+  import { buildUUID } from '/@/utils/uuid';
+  import { DefineComponentsBasicExpose } from '/#/utils';
+
+  interface CustomRuleItemRefType {
+    key: string;
+    ref?: FormActionType;
+    value?: CustomRuleItemType;
+  }
+
+  const props = withDefaults(
+    defineProps<{
+      value?: CustomRuleItemType[];
+    }>(),
+    {
+      value: () => [],
+    }
+  );
+
+  const customRuleListRef = ref<CustomRuleItemRefType[]>(
+    Array.from({ length: 7 }, () => ({ key: buildUUID() }))
+  );
+
+  const setRuleItemRef = (
+    el: Nullable<Element | ComponentPublicInstance>,
+    ruleItem: CustomRuleItemRefType
+  ) => {
+    ruleItem.ref = el as unknown as FormActionType;
+  };
+
+  const validate = async () => {
+    for (const item of unref(customRuleListRef)) {
+      await item.ref?.validate?.();
+    }
+  };
+
+  const getFieldsValue = (): CustomRuleItemType[] => {
+    return unref(customRuleListRef).map((item) => {
+      const { dayOfWeek, enabled, timeRange } = item.ref?.getFieldsValue() as RuleFormRecordItem;
+      return {
+        dayOfWeek,
+        enabled,
+        ...timeRange,
+      };
+    });
+  };
+
+  const setFieldsValue = async (ruleList: CustomRuleItemType[]) => {
+    if (!ruleList.length) return;
+    await nextTick();
+
+    ruleList.forEach((value, index) => {
+      const refEl = unref(customRuleListRef)[index];
+      refEl.ref?.setFieldsValue({
+        ...value,
+        timeRange: {
+          startsOn: value.startsOn,
+          endsOn: value.endsOn,
+        },
+      } as RuleFormRecordItem);
+    });
+  };
+
+  watch(
+    () => props.value,
+    () => {
+      setFieldsValue(props.value);
+    },
+    { immediate: true }
+  );
+
+  defineExpose<DefineComponentsBasicExpose<CustomRuleItemType[]>>({
+    getFieldsValue,
+    setFieldsValue,
+    validate,
+  });
+</script>
+
+<template>
+  <section>
+    <template v-for="(item, index) in customRuleListRef" :key="index">
+      <BasicForm
+        :ref="(el) => setRuleItemRef(el, item)"
+        :show-action-button-group="false"
+        :schemas="getFormSchemas(index)"
+        class="h-14"
+      />
+    </template>
+  </section>
+</template>

+<script setup lang="ts">
+  import { TimePicker } from 'ant-design-vue';
+  import { Moment } from 'moment';
+  import { computed, unref } from 'vue';
+  import { dateUtil } from '/@/utils/dateUtil';
+
+  interface TimeRangePickerProps {
+    timestampToNumber?: boolean;
+    value?: Record<string, number>;
+    startValue?: number;
+    endValue?: number;
+    startField?: string;
+    endField?: string;
+    disabled?: boolean;
+  }
+
+  enum TimePickerTypeEnum {
+    START = 'START',
+    END = 'END',
+  }
+
+  const emit = defineEmits(['update:value', 'update:startValue', 'update:endValue', 'change']);
+
+  const props = withDefaults(defineProps<TimeRangePickerProps>(), {
+    value: () => ({}),
+    startField: 'startsOn',
+    endField: 'endsOn',
+  });
+
+  const getTimeMoment = (value: number) => {
+    value = value / 1000;
+    const hour = Math.floor(value / 60 / 60);
+    const minute = Math.floor((value - hour * 60 * 60) / 60);
+    const second = value - hour * 60 * 60 - minute * 60;
+
+    return dateUtil({ hour, minute, second });
+  };
+
+  const getRangeValue = computed(() => {
+    const { value, startValue, endValue, startField, endField } = props;
+
+    let startTs = startValue || value[startField];
+
+    let endTs = endValue || value[endField];
+
+    return {
+      startTs: startTs ? getTimeMoment(startTs) : null,
+      endTs: endTs ? getTimeMoment(endTs) : null,
+    };
+  });
+
+  const getTimestamp = (moment: Moment | null) => {
+    if (!moment) return null;
+    const { hours, minutes, seconds } = moment.toObject();
+    return (hours * 60 * 60 + minutes * 60 + seconds) * 1000;
+  };
+
+  const handleTimeChange = (time: Moment, type: TimePickerTypeEnum) => {
+    const { value, startField, endField } = props;
+    const { startTs, endTs } = unref(getRangeValue);
+
+    const rangeValue = {
+      [startField]: getTimestamp(startTs),
+      [endField]: getTimestamp(endTs),
+    };
+
+    Reflect.set(
+      rangeValue,
+      type === TimePickerTypeEnum.START ? startField : endField,
+      getTimestamp(time)
+    );
+
+    if (
+      rangeValue[startField] &&
+      rangeValue[endField] &&
+      rangeValue[startField]! > rangeValue[endField]!
+    ) {
+      Reflect.set(rangeValue, type === TimePickerTypeEnum.START ? startField : endField, null);
+    }
+
+    emit('update:startValue', rangeValue[startField]);
+    emit('update:endValue', rangeValue[endField]);
+    emit('update:value', rangeValue);
+    emit('change', value);
+  };
+
+  const handleBasicDisabledHours = (type: TimePickerTypeEnum) => {
+    return () => {
+      const { startTs, endTs } = unref(getRangeValue);
+
+      if (type === TimePickerTypeEnum.START && !endTs) return [];
+      if (type === TimePickerTypeEnum.END && !startTs) return [];
+
+      const selectedHour = type === TimePickerTypeEnum.END ? startTs!.hour() : endTs!.hour();
+
+      return type === TimePickerTypeEnum.START
+        ? Array.from({ length: 24 - selectedHour }, (_, index) => selectedHour + index + 1)
+        : Array.from({ length: selectedHour }, (_, index) => index);
+    };
+  };
+
+  const handleBasicDisabledMinutes = (type: TimePickerTypeEnum) => {
+    return (currentSelectedHour: number) => {
+      const { startTs, endTs } = unref(getRangeValue);
+
+      if (type === TimePickerTypeEnum.START && !endTs) return [];
+      if (type === TimePickerTypeEnum.END && !startTs) return [];
+
+      const selectedTime = type === TimePickerTypeEnum.END ? startTs : endTs;
+      const selectedHour = selectedTime!.hour();
+      const selectedMinute = selectedTime!.minute();
+
+      if (type == TimePickerTypeEnum.START) {
+        return selectedHour > currentSelectedHour
+          ? []
+          : Array.from({ length: 60 - selectedMinute }, (_, index) => selectedMinute + index + 1);
+      } else {
+        return selectedHour < currentSelectedHour
+          ? []
+          : Array.from({ length: selectedMinute }, (_, index) => index);
+      }
+    };
+  };
+
+  const handleBasicDisabledSeconds = (type: TimePickerTypeEnum) => {
+    return (currentSelectedHour: number, currentSelectedMinute: number) => {
+      const { startTs, endTs } = unref(getRangeValue);
+
+      if (type === TimePickerTypeEnum.START && !endTs) return [];
+      if (type === TimePickerTypeEnum.END && !startTs) return [];
+
+      const selectedTime = type === TimePickerTypeEnum.END ? startTs : endTs;
+      const selectedHour = selectedTime!.hour();
+      const selectedMinute = selectedTime!.minute();
+      const selectedSeconds = selectedTime!.seconds();
+
+      if (type === TimePickerTypeEnum.START) {
+        return selectedHour >= currentSelectedHour && selectedMinute > currentSelectedMinute
+          ? []
+          : Array.from({ length: 60 - selectedSeconds }, (_, index) => selectedSeconds + index + 1);
+      } else {
+        return selectedHour <= currentSelectedHour && selectedMinute < currentSelectedMinute
+          ? []
+          : Array.from({ length: selectedSeconds }, (_, index) => index);
+      }
+    };
+  };
+</script>
+
+<template>
+  <main class="time-range-picker flex items-center">
+    <TimePicker
+      :value="getRangeValue.startTs"
+      format="HH:mm"
+      :disabled="disabled"
+      @change="(time) => handleTimeChange(time, TimePickerTypeEnum.START)"
+      :disabled-hours="handleBasicDisabledHours(TimePickerTypeEnum.START)"
+      :disabled-minutes="handleBasicDisabledMinutes(TimePickerTypeEnum.START)"
+      :disabled-seconds="handleBasicDisabledSeconds(TimePickerTypeEnum.START)"
+    />
+    <slot v-if="$slots?.separator" name="separator"></slot>
+    <span v-else class="mx-4">~</span>
+    <TimePicker
+      :value="getRangeValue.endTs"
+      format="HH:mm"
+      :disabled="disabled"
+      @change="(time) => handleTimeChange(time, TimePickerTypeEnum.END)"
+      :disabled-hours="handleBasicDisabledHours(TimePickerTypeEnum.END)"
+      :disabled-minutes="handleBasicDisabledMinutes(TimePickerTypeEnum.END)"
+      :disabled-seconds="handleBasicDisabledSeconds(TimePickerTypeEnum.END)"
+    />
+  </main>
+</template>
+
+<style scoped lang="less">
+  .time-range-picker {
+    :deep(.ant-time-picker) {
+      width: auto;
+    }
+  }
+</style>

+import TimeRangePicker from './TimeRangePicker.vue';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
+import { ScheduleTypeEnum, ScheduleTypeNameEnum } from '/@/enums/linkedgeEnum';
+
+export enum FormFieldsEnum {
+  SCHEDULE_TYPE = 'type',
+  TIMEZONE = 'timezone',
+  STARTS_ON = 'startsOn',
+  ENDS_ON = 'endsOn',
+  DAYS_OF_WEEK = 'daysOfWeek',
+  SCHEDULE_ITEMS = 'items',
+  TIME_RANGE = 'timeRange',
+}
+
+export enum FormFieldsNameEnum {
+  SCHEDULE_TYPE = '启用类型',
+  TIMEZONE = '时区',
+  DAYS_OF_WEEK = '启用日',
+  TIME_RANGE = '启用时间',
+}
+
+export interface EnableRuleFormType {
+  [FormFieldsEnum.DAYS_OF_WEEK]: number[];
+  [FormFieldsEnum.SCHEDULE_TYPE]: ScheduleTypeEnum;
+  [FormFieldsEnum.TIMEZONE]: string;
+  [FormFieldsEnum.TIME_RANGE]: {
+    [FormFieldsEnum.STARTS_ON]: number;
+    [FormFieldsEnum.ENDS_ON]: number;
+  };
+}
+
+useComponentRegister('TimeRangePicker', TimeRangePicker);
+
+export const WeekName = ['一', '二', '三', '四', '五', '六', '日'];
+
+enum TimezoneEnum {
+  SHANG_HAI = 'Asia/Shanghai',
+}
+
+export const getFormSchemas = (): FormSchema[] => {
+  return [
+    {
+      field: FormFieldsEnum.SCHEDULE_TYPE,
+      label: FormFieldsNameEnum.SCHEDULE_TYPE,
+      component: 'Select',
+      required: true,
+      defaultValue: ScheduleTypeEnum.ANY_TIME,
+      componentProps: () => {
+        return {
+          options: Object.keys(ScheduleTypeEnum).map((value) => ({
+            label: ScheduleTypeNameEnum[value],
+            value,
+          })),
+          allowClear: false,
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.TIMEZONE,
+      label: FormFieldsNameEnum.TIMEZONE,
+      component: 'Select',
+      required: true,
+      defaultValue: TimezoneEnum.SHANG_HAI,
+      ifShow: ({ model }) => model[FormFieldsEnum.SCHEDULE_TYPE] !== ScheduleTypeEnum.ANY_TIME,
+      componentProps: () => {
+        return {
+          options: [{ label: TimezoneEnum.SHANG_HAI, value: TimezoneEnum.SHANG_HAI }],
+          allowClear: false,
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.SCHEDULE_ITEMS,
+      label: '规则',
+      component: 'Input',
+      ifShow: ({ model }) => model[FormFieldsEnum.SCHEDULE_TYPE] === ScheduleTypeEnum.CUSTOM,
+      slot: 'custom',
+    },
+    {
+      field: FormFieldsEnum.DAYS_OF_WEEK,
+      label: FormFieldsNameEnum.DAYS_OF_WEEK,
+      component: 'CheckboxGroup',
+      ifShow: ({ model }) => model[FormFieldsEnum.SCHEDULE_TYPE] === ScheduleTypeEnum.SPECIFIC_TIME,
+      rules: [{ required: true, type: 'array' }],
+      componentProps: () => {
+        return {
+          options: Array.from({ length: 7 }, (_, index) => ({
+            label: `星期${WeekName[index]}`,
+            value: index + 1,
+          })),
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.TIME_RANGE,
+      label: FormFieldsNameEnum.TIME_RANGE,
+      component: 'TimeRangePicker',
+      changeEvent: 'update:value',
+      valueField: 'value',
+      ifShow: ({ model }) => model[FormFieldsEnum.SCHEDULE_TYPE] === ScheduleTypeEnum.SPECIFIC_TIME,
+      rules: [
+        {
+          required: true,
+          validator(_rule, value: Record<'startsOn' | 'endsOn', number>, _callback) {
+            if (!value?.endsOn) return Promise.reject('请选择结束时间');
+            if (!value?.startsOn) return Promise.reject('请选择开始时间');
+            return Promise.resolve();
+          },
+        },
+      ],
+    },
+  ];
+};

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

+<script setup lang="ts">
+  import { BasicModal, useModalInner } from '/@/components/Modal';
+  import { BasicForm, useForm } from '/@/components/Form';
+  import { EnableRuleFormType, getFormSchemas } from './config';
+  import { nextTick, ref, unref } from 'vue';
+  import CustomRule from './CustomRule.vue';
+  import { ScheduleTypeEnum } from '/@/enums/linkedgeEnum';
+  import { EnableRuleFormModalParamsType, ScheduleType } from './type';
+  import { useSceneLinkageDrawerContext } from '../SceneLinkageDrawer/sceneLinkageDrawerContext';
+
+  const { disabledDrawer } = useSceneLinkageDrawerContext();
+
+  const emit = defineEmits(['register', 'settingComplete']);
+
+  const scheduleItemKey = ref<string>();
+  const [registerModal, { closeModal }] = useModalInner(
+    ({ record }: EnableRuleFormModalParamsType) => {
+      resetFields();
+      const { type, schedule, key } = record;
+      scheduleItemKey.value = key;
+      handleSetFieldsValue({ ...schedule, type });
+      clearValidate();
+    }
+  );
+
+  const [register, { getFieldsValue, validate, setFieldsValue, resetFields, clearValidate }] =
+    useForm({
+      schemas: getFormSchemas(),
+      showActionButtonGroup: false,
+      layout: 'vertical',
+    });
+
+  const customRuleElRef = ref<Nullable<InstanceType<typeof CustomRule>>>();
+
+  const handleGetFieldsValue = async (): Promise<ScheduleType> => {
+    await unref(customRuleElRef)?.validate?.();
+    await validate();
+    const { type, timeRange, timezone, daysOfWeek } = getFieldsValue() as EnableRuleFormType;
+    const customValue = unref(customRuleElRef)?.getFieldsValue();
+
+    if (type === ScheduleTypeEnum.ANY_TIME) return { type };
+
+    if (type === ScheduleTypeEnum.SPECIFIC_TIME)
+      return {
+        type,
+        timezone,
+        daysOfWeek,
+        ...timeRange,
+      };
+
+    return {
+      type,
+      timezone,
+      items: customValue,
+    };
+  };
+
+  const handleSetFieldsValue = async (schedule: ScheduleType) => {
+    const { type, startsOn, endsOn, timezone, daysOfWeek } = schedule;
+
+    if (type === ScheduleTypeEnum.ANY_TIME) return setFieldsValue({ type });
+
+    if (type === ScheduleTypeEnum.SPECIFIC_TIME)
+      return setFieldsValue({ type, timezone, daysOfWeek, timeRange: { startsOn, endsOn } });
+
+    setFieldsValue(schedule);
+    await nextTick();
+    unref(customRuleElRef)?.setFieldsValue(schedule.items || []);
+  };
+
+  const handleOk = async () => {
+    const result = await handleGetFieldsValue();
+    emit('settingComplete', result, unref(scheduleItemKey));
+    closeModal();
+  };
+</script>
+
+<template>
+  <BasicModal @register="registerModal" title="启用规则" :width="600" @ok="handleOk">
+    <BasicForm @register="register" :disabled="disabledDrawer">
+      <template #custom="{ model, field }">
+        <CustomRule ref="customRuleElRef" v-model:value="model[field]" />
+      </template>
+    </BasicForm>
+  </BasicModal>
+</template>

+import { ScheduleTypeEnum } from '/@/enums/linkedgeEnum';
+
+export interface CustomRuleItemType {
+  dayOfWeek: number;
+  enabled: boolean;
+  endsOn: number;
+  startsOn: number;
+}
+
+export interface ScheduleType {
+  type: ScheduleTypeEnum;
+  timezone?: string;
+  items?: CustomRuleItemType[];
+  daysOfWeek?: number[];
+  endsOn?: number;
+  startsOn?: number;
+}
+
+interface EnableRuleFormModalParams {
+  type: ScheduleTypeEnum;
+  schedule: ScheduleType;
+  key: string;
+}
+
+export type EnableRuleFormModalParamsType = ModalParamsType<EnableRuleFormModalParams>;

+<script setup lang="ts">
+  import { ApiSelect } from '/@/components/Form';
+  import { Divider } from 'ant-design-vue';
+  import { Icon } from '/@/components/Icon';
+  import { VNode } from 'vue';
+  import AlarmConfigDrawer from '/@/views/alarm/config/ContactDrawer.vue';
+  import { useDrawer } from '/@/components/Drawer';
+
+  const [registerAlarmContactDrawer, { openDrawer }] = useDrawer();
+
+  const Options = (props: { menuNode: VNode }) => {
+    return props.menuNode;
+  };
+
+  const handleOpenAlarmConfig = () => {
+    openDrawer();
+  };
+
+  const handleSuccess = () => {};
+</script>
+
+<template>
+  <section>
+    <ApiSelect v-bind="$attrs">
+      <template #dropdownRender="{ menuNode }">
+        <Options :menuNode="menuNode" />
+        <Divider class="!my-2" />
+        <div class="cursor-pointer text-gray-500" @click="handleOpenAlarmConfig">
+          <Icon icon="ant-design:plus-outlined" class="mx-2" />
+          <span>新增告警配置</span>
+        </div>
+      </template>
+    </ApiSelect>
+    <AlarmConfigDrawer
+      @register="registerAlarmContactDrawer"
+      default-enable
+      @success="handleSuccess"
+    />
+  </section>
+</template>

+import { FormSchema, useComponentRegister } from '/@/components/Form';
+import {
+  CommandTypeEnum,
+  CommandTypeNameEnum,
+  ExecutionActionEnum,
+  ExecutionActionNameEnum,
+  TriggerEntityTypeEnum,
+  TriggerEntityTypeNameEnum,
+} from '/@/enums/linkedgeEnum';
+import AlarmProfileSelect from './AlarmProfileSelect.vue';
+import {
+  byOrganizationIdGetMasterDevice,
+  getOrganizationAlarmConfig,
+} from '/@/api/ruleengine/ruleengineApi';
+import { useSceneLinkageDrawerContext } from '../SceneLinkageDrawer/sceneLinkageDrawerContext';
+import { Ref, h, toRaw, unref } from 'vue';
+import { AlarmLevelEnum, AlarmLevelNameEnum } from '/@/enums/alarmEnum';
+import Icon from '/@/components/Icon';
+import { Tooltip } from 'ant-design-vue';
+import { findDictItemByCode } from '/@/api/system/dict';
+import { DictEnum } from '/@/enums/dictEnum';
+import { getDeviceProfile } from '/@/api/alarm/position';
+import { createPickerSearch } from '/@/utils/pickerSearch';
+import { ServiceCallTypeEnum, ServiceCallTypeNameEnum } from '/@/enums/toolEnum';
+import { DeviceTypeEnum } from '../../../dataFlow/cpns/config';
+import { getModelServices } from '/@/api/device/modelOfMatter';
+import { ModelOfMatterParams, StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { DeviceProfileModel } from '/@/api/device/model/deviceModel';
+import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
+import { JSONEditor } from '/@/components/CodeEditor';
+import { useJsonParse } from '/@/hooks/business/useJsonParse';
+import { validateTCPCustomCommand } from '/@/components/Form/src/externalCompns/components/ThingsModelForm';
+
+export enum FormFieldsEnum {
+  OUT_TARGET = 'outTarget',
+  ALARM_PROFILED = 'alarmProfileId',
+  ALARM_LEVEL = 'alarmLevel',
+  DEVICE_TYPE = 'deviceType',
+  DEVICE_PROFILE_ID = 'deviceProfileId',
+  ENTITY_TYPE = 'entityType',
+  ENTITY_ID = 'entityId',
+  COMMAND_TYPE = 'commandType',
+  CALL_TYPE = 'callType',
+  CALL_SERVICE_IDENTIFIER = 'callServiceIdentifier',
+
+  TCP_CUSTOM_COMMAND = 'tcpCustomCommand',
+  CUSTOM_COMMAND = 'customCommand',
+  CALL_SERVICE = 'callService',
+  SERVICE_COMMAND = 'serviceCommand',
+  SERVICE_ID = 'serviceId',
+  TRANSPORT_TYPE = 'transportType',
+  ENABLE_CLEAR_RULE = 'enableClearRule',
+  CLEAR_RULE = 'clearRule',
+}
+
+export enum FormFieldsNameEnum {
+  OUT_TARGET = '执行动作',
+  ALARM_PROFILED = '告警配置',
+  ALARM_LEVEL = '告警等级',
+  DEVICE_TYPE = '设备类型',
+  DEVICE_PROFILE_ID = '产品',
+  ENTITY_TYPE = '触发设备类型',
+  ENTITY_ID = '设备',
+  COMMAND_TYPE = '类型',
+  CALL_TYPE = '命令下发类型',
+  CALL_SERVICE_IDENTIFIER = '服务',
+
+  ENABLE_CLEAR_RULE = '清除告警',
+  TCP_CUSTOM_COMMAND = '自定义命令',
+  CUSTOM_COMMAND = '自定义命令',
+}
+
+useComponentRegister('AlarmProfileSelect', AlarmProfileSelect);
+useComponentRegister('JSONEditor', JSONEditor);
+
+export const getFormSchemas = (hasAlarmNotify: Ref<boolean>): FormSchema[] => {
+  const { organizationId } = useSceneLinkageDrawerContext();
+  return [
+    {
+      field: FormFieldsEnum.OUT_TARGET,
+      label: '',
+      component: 'Select',
+      rules: [{ required: true, message: `请选择${FormFieldsNameEnum.OUT_TARGET}` }],
+      defaultValue: ExecutionActionEnum.DEVICE_OUT,
+      componentProps: () => {
+        return {
+          options: [
+            { label: ExecutionActionNameEnum.DEVICE_OUT, value: ExecutionActionEnum.DEVICE_OUT },
+            {
+              label: ExecutionActionNameEnum.MSG_NOTIFY,
+              value: ExecutionActionEnum.MSG_NOTIFY,
+              disabled: unref(hasAlarmNotify),
+            },
+          ],
+          labelField: 'name',
+          valueField: 'id',
+          placeholder: `请选择${FormFieldsNameEnum.OUT_TARGET}`,
+          onChange(value: ExecutionActionEnum) {
+            hasAlarmNotify.value = value === ExecutionActionEnum.MSG_NOTIFY;
+          },
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.ALARM_PROFILED,
+      label: '',
+      component: 'AlarmProfileSelect',
+      rules: [{ required: true, message: `请选择${FormFieldsEnum.ALARM_PROFILED}` }],
+      ifShow: ({ model }) => model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.MSG_NOTIFY,
+      componentProps: () => {
+        return {
+          api: async () => {
+            if (!unref(organizationId)) return [];
+            return await getOrganizationAlarmConfig({ organizationId: unref(organizationId) });
+          },
+          labelField: 'name',
+          valueField: 'id',
+          placeholder: `请选择${FormFieldsNameEnum.ALARM_PROFILED}`,
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.ALARM_LEVEL,
+      label: '',
+      component: 'Select',
+      ifShow: ({ model }) => model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.MSG_NOTIFY,
+      rules: [{ required: true, message: `请选择${FormFieldsEnum.ALARM_LEVEL}` }],
+      componentProps: () => {
+        return {
+          options: Object.keys(AlarmLevelEnum).map((value) => ({
+            label: AlarmLevelNameEnum[value],
+            value,
+          })),
+          placeholder: `请选择${FormFieldsNameEnum.ALARM_LEVEL}`,
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.ENABLE_CLEAR_RULE,
+      label: '',
+      component: 'Checkbox',
+      ifShow: ({ model }) => model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.MSG_NOTIFY,
+      renderComponentContent: () => ({
+        default: () => [
+          h('span', FormFieldsNameEnum.ENABLE_CLEAR_RULE),
+          h(Tooltip, { title: '清除告警与触发器一一对应' }, () =>
+            h(Icon, {
+              icon: 'ant-design:question-circle-outlined',
+              class: ' cursor-pointer ml-1',
+            })
+          ),
+        ],
+      }),
+    },
+    {
+      field: FormFieldsEnum.CLEAR_RULE,
+      label: '',
+      component: 'Input',
+      colProps: { span: 24, xxl: 24, xl: 24, lg: 24, md: 24, sm: 24, xs: 24 },
+      slot: 'alarmClearRule',
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.ENABLE_CLEAR_RULE] &&
+        model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.MSG_NOTIFY,
+    },
+    {
+      field: FormFieldsEnum.DEVICE_TYPE,
+      label: '',
+      component: 'ApiSelect',
+      rules: [{ required: true, message: `请选择${FormFieldsNameEnum.DEVICE_TYPE}` }],
+      ifShow: ({ model }) => model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.DEVICE_OUT,
+      defaultValue: DeviceTypeEnum.SENSOR,
+      componentProps: ({ formActionType }) => {
+        return {
+          api: findDictItemByCode,
+          params: {
+            dictCode: DictEnum.DEVICE_TYPE,
+          },
+          labelField: 'itemText',
+          valueField: 'itemValue',
+          placeholder: `请选择${FormFieldsNameEnum.DEVICE_TYPE}`,
+          onChange() {
+            const { setFieldsValue } = formActionType;
+            setFieldsValue({
+              [FormFieldsEnum.DEVICE_PROFILE_ID]: null,
+              [FormFieldsEnum.ENTITY_ID]: [],
+              [FormFieldsEnum.CALL_SERVICE_IDENTIFIER]: null,
+              [FormFieldsEnum.SERVICE_COMMAND]: null,
+              [FormFieldsEnum.CALL_SERVICE]: null,
+              [FormFieldsEnum.TRANSPORT_TYPE]: null,
+            });
+          },
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.TRANSPORT_TYPE,
+      label: '传输协议',
+      component: 'Input',
+      ifShow: false,
+    },
+    {
+      field: FormFieldsEnum.DEVICE_PROFILE_ID,
+      label: '',
+      component: 'ApiSelect',
+      rules: [{ required: true, message: `请选择${FormFieldsNameEnum.DEVICE_PROFILE_ID}` }],
+      ifShow: ({ model }) => model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.DEVICE_OUT,
+      componentProps: ({ formModel, formActionType }) => {
+        const deviceType = formModel[FormFieldsEnum.DEVICE_TYPE];
+        const { setFieldsValue } = formActionType;
+        return {
+          api: async () => {
+            return await getDeviceProfile(deviceType);
+          },
+          labelField: 'name',
+          valueField: 'id',
+          placeholder: `请选择${FormFieldsNameEnum.DEVICE_PROFILE_ID}`,
+          ...createPickerSearch(),
+          onChange(_value: string, option: DeviceProfileModel) {
+            setFieldsValue({
+              [FormFieldsEnum.ENTITY_ID]: [],
+              [FormFieldsEnum.TRANSPORT_TYPE]: option?.transportType,
+            });
+          },
+          onOptionsChange(options: (DeviceProfileModel & Record<'label' | 'value', string>)[]) {
+            const deviceProfileId = formModel[FormFieldsEnum.DEVICE_PROFILE_ID];
+            const res = options.find((item) => item.value === deviceProfileId);
+            res &&
+              setFieldsValue({
+                [FormFieldsEnum.TRANSPORT_TYPE]: res.transportType,
+              });
+          },
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.ENTITY_TYPE,
+      label: '',
+      component: 'Select',
+      rules: [{ required: true, message: `请选择${FormFieldsNameEnum.ENTITY_TYPE}` }],
+      ifShow: ({ model }) => model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.DEVICE_OUT,
+      componentProps: () => {
+        return {
+          options: Object.keys(TriggerEntityTypeEnum).map((value) => ({
+            label: TriggerEntityTypeNameEnum[value],
+            value,
+          })),
+          placeholder: `请选择${FormFieldsNameEnum.ENTITY_TYPE}`,
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.ENTITY_ID,
+      label: '',
+      component: 'ApiSelect',
+      rules: [{ required: true, type: 'array', message: `请选择${FormFieldsNameEnum.ENTITY_ID}` }],
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.DEVICE_OUT &&
+        model[FormFieldsEnum.ENTITY_TYPE] === TriggerEntityTypeEnum.PART,
+      componentProps: ({ formModel }) => {
+        return {
+          api: async (params: Record<'organizationId' | 'deviceProfileId', string>) => {
+            if (params.deviceProfileId && params.organizationId) {
+              const result = await byOrganizationIdGetMasterDevice(params);
+              if (result) {
+                return result.map((item) => ({
+                  ...item,
+                  label: item.alias || item.name,
+                  value: item.tbDeviceId,
+                }));
+              }
+            }
+            return [];
+          },
+          mode: 'multiple',
+          maxTagCount: 3,
+          params: {
+            organizationId: unref(organizationId),
+            deviceProfileId: formModel[FormFieldsEnum.DEVICE_PROFILE_ID],
+          },
+          placeholder: `请选择${FormFieldsNameEnum.ENTITY_ID}`,
+          ...createPickerSearch(),
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.COMMAND_TYPE,
+      label: '',
+      component: 'Select',
+      rules: [
+        { required: true, message: `请选择${FormFieldsNameEnum.COMMAND_TYPE}`, type: 'number' },
+      ],
+      defaultValue: CommandTypeEnum.CUSTOM,
+      ifShow: ({ model }) => model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.DEVICE_OUT,
+      componentProps: ({ formActionType }) => {
+        return {
+          options: [
+            { label: CommandTypeNameEnum.CUSTOM, value: CommandTypeEnum.CUSTOM },
+            { label: CommandTypeNameEnum.SERVICE, value: CommandTypeEnum.SERVICE },
+          ],
+          placeholder: `请选择${FormFieldsNameEnum.COMMAND_TYPE}`,
+          onChange() {
+            const { setFieldsValue } = formActionType;
+            setFieldsValue({
+              [FormFieldsEnum.CALL_SERVICE]: null,
+              [FormFieldsEnum.CALL_SERVICE_IDENTIFIER]: null,
+              [FormFieldsEnum.SERVICE_COMMAND]: null,
+            });
+          },
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.CALL_TYPE,
+      label: '',
+      component: 'Select',
+      defaultValue: ServiceCallTypeEnum.ASYNC,
+      rules: [{ required: true, message: `请选择${FormFieldsNameEnum.CALL_TYPE}` }],
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.DEVICE_OUT &&
+        model[FormFieldsEnum.COMMAND_TYPE] === CommandTypeEnum.CUSTOM,
+      componentProps: () => {
+        return {
+          options: [
+            { label: ServiceCallTypeNameEnum.ASYNC, value: ServiceCallTypeEnum.ASYNC },
+            { label: ServiceCallTypeNameEnum.SYNC, value: ServiceCallTypeEnum.SYNC },
+          ],
+          placeholder: `请选择${FormFieldsNameEnum.CALL_TYPE}`,
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.SERVICE_ID,
+      label: '',
+      component: 'ApiSelect',
+      rules: [{ required: true, message: `请选择${FormFieldsNameEnum.CALL_SERVICE_IDENTIFIER}` }],
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.DEVICE_OUT &&
+        model[FormFieldsEnum.COMMAND_TYPE] === CommandTypeEnum.SERVICE,
+      componentProps: ({ formModel, formActionType }) => {
+        return {
+          api: async () => {
+            const deviceProfileId = formModel[FormFieldsEnum.DEVICE_PROFILE_ID];
+            if (!deviceProfileId) return [];
+            return await getModelServices({ deviceProfileId });
+          },
+          labelField: 'functionName',
+          valueField: 'id',
+          placeholder: `请选择${FormFieldsNameEnum.CALL_SERVICE_IDENTIFIER}`,
+          onChange(
+            value: string,
+            option: ModelOfMatterParams & Record<'label' | 'value' | 'id', string>
+          ) {
+            const { setFieldsValue } = formActionType;
+            setFieldsValue({
+              [FormFieldsEnum.CALL_TYPE]: value ? option.callType : null,
+              [FormFieldsEnum.CALL_SERVICE_IDENTIFIER]: value ? option.identifier : null,
+              [FormFieldsEnum.CALL_SERVICE]: value
+                ? { ...toRaw(option), id: option?.value, functionName: option?.label }
+                : null,
+              [FormFieldsEnum.SERVICE_COMMAND]: {},
+            });
+          },
+          onOptionsChange(options: (StructJSON & Record<'label' | 'value' | 'id', string>)[]) {
+            const { setFieldsValue } = formActionType;
+            const serviceId = formModel[FormFieldsEnum.SERVICE_ID];
+            const res = options.find((item) => item.value === serviceId);
+            res &&
+              setFieldsValue({
+                [FormFieldsEnum.CALL_SERVICE_IDENTIFIER]: res.identifier,
+                [FormFieldsEnum.CALL_SERVICE]: {
+                  ...toRaw(res),
+                  id: res?.value,
+                  functionName: res?.label,
+                },
+              });
+          },
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.CALL_SERVICE_IDENTIFIER,
+      label: '服务标识符',
+      component: 'Input',
+      ifShow: false,
+    },
+    {
+      field: FormFieldsEnum.CALL_SERVICE,
+      label: '服务详情',
+      component: 'Input',
+      ifShow: false,
+    },
+    {
+      field: FormFieldsEnum.SERVICE_COMMAND,
+      label: '',
+      component: 'Input',
+      colProps: { span: 24, xxl: 24, xl: 24, lg: 24, md: 24, sm: 24, xs: 24 },
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.DEVICE_OUT &&
+        model[FormFieldsEnum.COMMAND_TYPE] === CommandTypeEnum.SERVICE &&
+        model[FormFieldsEnum.CALL_SERVICE],
+      colSlot: 'serviceCommand',
+    },
+    {
+      field: FormFieldsEnum.CUSTOM_COMMAND,
+      label: '',
+      component: 'JSONEditor',
+      valueField: 'value',
+      changeEvent: 'update:value',
+      colProps: { span: 24, xxl: 24, xl: 24, lg: 24, md: 24, sm: 24, xs: 24 },
+      rules: [
+        {
+          required: true,
+          validator(_rule, value: string) {
+            const { flag } = useJsonParse(value);
+            return flag ? Promise.resolve() : Promise.reject('请检查自定义命令');
+          },
+        },
+      ],
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.DEVICE_OUT &&
+        model[FormFieldsEnum.TRANSPORT_TYPE] !== TransportTypeEnum.TCP &&
+        model[FormFieldsEnum.COMMAND_TYPE] === CommandTypeEnum.CUSTOM,
+      componentProps: () => {
+        return {
+          title: FormFieldsNameEnum.CUSTOM_COMMAND,
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.TCP_CUSTOM_COMMAND,
+      label: FormFieldsNameEnum.TCP_CUSTOM_COMMAND,
+      component: 'Input',
+      colProps: { span: 24, xxl: 24, xl: 24, lg: 24, md: 24, sm: 24, xs: 24 },
+      rules: [
+        { required: true, message: `请输入${FormFieldsNameEnum.TCP_CUSTOM_COMMAND}` },
+        { validator: validateTCPCustomCommand },
+      ],
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.OUT_TARGET] === ExecutionActionEnum.DEVICE_OUT &&
+        model[FormFieldsEnum.TRANSPORT_TYPE] === TransportTypeEnum.TCP &&
+        model[FormFieldsEnum.COMMAND_TYPE] === CommandTypeEnum.CUSTOM,
+      componentProps: () => {
+        return {
+          placeholder: `请输入${FormFieldsNameEnum.TCP_CUSTOM_COMMAND}`,
+        };
+      },
+      // labelWidth: 120,
+    },
+  ];
+};

+import { ExecutionActionListRefItemType } from './type';
+import { buildUUID } from '/@/utils/uuid';
+
+export { default as ExecutionAction } from './index.vue';
+
+export function createNewExecutionActionItem(): ExecutionActionListRefItemType {
+  return { key: buildUUID() };
+}

+<script setup lang="ts">
+  import { CollapseContainer } from '/@/components/Container';
+  import { Icon } from '/@/components/Icon';
+  import { Tooltip, Button } from 'ant-design-vue';
+  import { BasicForm, FormActionType, ThingsModelForm } from '/@/components/Form';
+  import { getFormSchemas, FormFieldsEnum } from './config';
+  import { FlipFlop } from '../FlipFlop';
+  import { ComponentPublicInstance, ref, unref } from 'vue';
+  import { ExecutionActionListRefItemType } from './type';
+  import { useExecutionActionData } from './useExecutionActionData';
+  import { createNewExecutionActionItem } from '.';
+  import { useSceneLinkageDrawerContext } from '../SceneLinkageDrawer/sceneLinkageDrawerContext';
+
+  const { disabledDrawer } = useSceneLinkageDrawerContext();
+
+  const hasAlarmNotify = ref(false);
+
+  const formSchemas = getFormSchemas(hasAlarmNotify);
+
+  const executionActionListRef = ref<ExecutionActionListRefItemType[]>([
+    createNewExecutionActionItem(),
+  ]);
+
+  const handleAdd = () => {
+    executionActionListRef.value.push(createNewExecutionActionItem());
+  };
+
+  const handleDelete = (executionActionItem: ExecutionActionListRefItemType) => {
+    const index = unref(executionActionListRef).findIndex(
+      (item) => item.key === executionActionItem.key
+    );
+    ~index && unref(executionActionListRef).splice(index, 1);
+  };
+
+  const setExecutionActionRef = (
+    el: Nullable<Element | ComponentPublicInstance>,
+    executionActionItem: ExecutionActionListRefItemType
+  ) => {
+    executionActionItem.ref = el as unknown as FormActionType;
+  };
+
+  const setAlarmClearRuleRef = (
+    el: Nullable<Element | ComponentPublicInstance>,
+    executionActionItem: ExecutionActionListRefItemType
+  ) => {
+    executionActionItem.alarmClearRuleElRef = el as unknown as InstanceType<typeof FlipFlop>;
+  };
+
+  const handleClearRuleDelete = (_executionActionItem: ExecutionActionListRefItemType) => {
+    //
+  };
+
+  const setThingsModelFormRef = (
+    el: Nullable<Element | ComponentPublicInstance>,
+    executionActionItem: ExecutionActionListRefItemType
+  ) => {
+    executionActionItem.thingsModelFormRefl = el as unknown as InstanceType<typeof ThingsModelForm>;
+  };
+
+  const { getFieldsValue, setFieldsValue, validate, resetFieldsValue } = useExecutionActionData(
+    executionActionListRef,
+    hasAlarmNotify
+  );
+
+  defineExpose({
+    getFieldsValue,
+    setFieldsValue,
+    validate,
+    resetFieldsValue,
+  });
+</script>
+
+<template>
+  <section>
+    <CollapseContainer
+      class="mb-4"
+      v-for="(executionActionItem, index) in executionActionListRef"
+      :title="`执行动作${index + 1}`"
+      :key="executionActionItem.key"
+    >
+      <template #action>
+        <Tooltip title="删除">
+          <Icon
+            v-if="!disabledDrawer"
+            class="ml-2 cursor-pointer"
+            icon="fluent:delete-off-20-regular"
+            size="20"
+            @click="handleDelete(executionActionItem)"
+          />
+        </Tooltip>
+      </template>
+      <BasicForm
+        :ref="(el) => setExecutionActionRef(el, executionActionItem)"
+        :disabled="disabledDrawer"
+        :show-action-button-group="false"
+        :baseColProps="{ span: 6, xxl: 6, xl: 8, lg: 12, sm: 24 }"
+        :schemas="formSchemas"
+      >
+        <template #alarmClearRule>
+          <FlipFlop
+            :ref="(el) => setAlarmClearRuleRef(el, executionActionItem)"
+            :panel-title="(index) => `清除告警${index}`"
+            :disabled="disabledDrawer"
+            addButtonName="新增清除告警"
+            @delete="handleClearRuleDelete(executionActionItem)"
+          />
+        </template>
+
+        <template #serviceCommand="{ field, model }">
+          <ThingsModelForm
+            :ref="(el) => setThingsModelFormRef(el, executionActionItem)"
+            :value="model[field]"
+            :identifier="model[FormFieldsEnum.CALL_SERVICE_IDENTIFIER]"
+            :input-data="model[FormFieldsEnum.CALL_SERVICE]?.functionJson?.inputData"
+            :title="model[FormFieldsEnum.CALL_SERVICE]?.functionName"
+            :disabled="disabledDrawer"
+            :transport-type="model[FormFieldsEnum.TRANSPORT_TYPE]"
+          />
+        </template>
+      </BasicForm>
+    </CollapseContainer>
+    <Button v-if="!disabledDrawer" class="w-full" type="primary" @click="handleAdd">
+      <Icon icon="ant-design:plus-outlined" />
+      执行动作
+    </Button>
+  </section>
+</template>

+export { default as ExecutionAction } from './index.vue';
+import { FlipFlop } from '../FlipFlop';
+import { FormFieldsEnum } from './config';
+import { FlipFlopConditionType } from '../FlipFlop/types';
+import { DeviceModelOfMatterAttrs, DeviceTypeEnum } from '/@/api/device/model/deviceModel';
+import { FormActionType, ThingsModelForm } from '/@/components/Form';
+import { AlarmLevelEnum } from '/@/enums/alarmEnum';
+import { CommandTypeEnum, ExecutionActionEnum, TriggerEntityTypeEnum } from '/@/enums/linkedgeEnum';
+import { ServiceCallTypeEnum } from '/@/enums/toolEnum';
+import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
+
+export interface ExecutionActionListRefItemType {
+  key: string;
+  alarmClearRuleElRef?: InstanceType<typeof FlipFlop>;
+  ref?: FormActionType;
+  thingsModelFormRefl?: InstanceType<typeof ThingsModelForm>;
+}
+
+export interface ExecutionActionDataItemType {
+  callType: ServiceCallTypeEnum;
+  commandType: CommandTypeEnum;
+  deviceProfileId: string;
+  deviceType: DeviceTypeEnum;
+  entityType: TriggerEntityTypeEnum;
+  outTarget: ExecutionActionEnum;
+  deviceId?: string[];
+  thingsModelId?: string;
+  doContext: DoContextType | DoContextAlarmType;
+  alarmProfileId: string;
+}
+
+export interface DoContextType {
+  method?: string;
+  additionalInfo?: { cmdType: string | number };
+  params?: string | Recordable;
+}
+
+export interface DoContextAlarmType {
+  alarmLevel: AlarmLevelEnum;
+  clearRule: FlipFlopConditionType[];
+}
+
+export interface ExecutionActionFormItemRecordType {
+  [FormFieldsEnum.ALARM_LEVEL]?: AlarmLevelEnum;
+  [FormFieldsEnum.ALARM_PROFILED]?: string;
+  [FormFieldsEnum.CALL_TYPE]?: ServiceCallTypeEnum;
+  [FormFieldsEnum.COMMAND_TYPE]?: CommandTypeEnum;
+  [FormFieldsEnum.DEVICE_TYPE]?: DeviceTypeEnum;
+  [FormFieldsEnum.DEVICE_PROFILE_ID]?: string;
+  [FormFieldsEnum.OUT_TARGET]?: ExecutionActionEnum;
+  [FormFieldsEnum.TCP_CUSTOM_COMMAND]?: string;
+  [FormFieldsEnum.CUSTOM_COMMAND]?: string;
+  [FormFieldsEnum.TRANSPORT_TYPE]?: TransportTypeEnum;
+  [FormFieldsEnum.ENTITY_TYPE]?: TriggerEntityTypeEnum;
+  [FormFieldsEnum.ENTITY_ID]?: string[];
+  [FormFieldsEnum.CALL_SERVICE_IDENTIFIER]?: string;
+  [FormFieldsEnum.CALL_SERVICE]?: DeviceModelOfMatterAttrs;
+  [FormFieldsEnum.SERVICE_ID]?: string;
+}

+import { Ref, unref, nextTick, toRaw } from 'vue';
+import { DefineComponentsBasicExpose } from '/#/utils';
+import {
+  DoContextAlarmType,
+  DoContextType,
+  ExecutionActionDataItemType,
+  ExecutionActionFormItemRecordType,
+  ExecutionActionListRefItemType,
+} from './type';
+import { CommandTypeEnum, ExecutionActionEnum } from '/@/enums/linkedgeEnum';
+import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
+import { useJsonParse } from '/@/hooks/business/useJsonParse';
+import { createNewExecutionActionItem } from '.';
+import { FormFieldsEnum } from './config';
+import { isObject, isString } from '/@/utils/is';
+
+export function useExecutionActionData(
+  executionActionListRef: Ref<ExecutionActionListRefItemType[]>,
+  hasAlarmNotify: Ref<boolean>
+): DefineComponentsBasicExpose<ExecutionActionDataItemType[]> {
+  const getExecutionActionItemData = (executionActionItem: ExecutionActionListRefItemType) => {
+    const { ref, alarmClearRuleElRef, thingsModelFormRefl } = executionActionItem;
+    const {
+      callType,
+      commandType,
+      deviceType,
+      deviceProfileId,
+      entityType,
+      entityId,
+      outTarget,
+      transportType,
+      alarmLevel,
+      callServiceIdentifier,
+      serviceId,
+      tcpCustomCommand,
+      customCommand,
+      alarmProfileId,
+    } = (ref?.getFieldsValue?.() || {}) as Required<ExecutionActionFormItemRecordType>;
+
+    const thingsModelFormRecord = thingsModelFormRefl?.getFieldsValue?.();
+
+    const clearRule = alarmClearRuleElRef?.getFieldsValue();
+
+    const record: ExecutionActionDataItemType = {
+      callType,
+      commandType,
+      alarmProfileId,
+      deviceType,
+      deviceProfileId,
+      entityType,
+      deviceId: entityId,
+      outTarget,
+      thingsModelId: serviceId,
+      doContext: {},
+    };
+
+    if (outTarget === ExecutionActionEnum.DEVICE_OUT) {
+      record.doContext = {
+        method: 'methodThingskit',
+        additionalInfo: { cmdType: commandType },
+        params:
+          commandType === CommandTypeEnum.CUSTOM
+            ? transportType === TransportTypeEnum.TCP
+              ? tcpCustomCommand
+              : useJsonParse(customCommand).value
+            : {
+                [callServiceIdentifier]: thingsModelFormRecord,
+              },
+      };
+    } else {
+      record.doContext = {
+        alarmLevel,
+        clearRule: clearRule || [],
+      };
+    }
+
+    return record;
+  };
+
+  const getFieldsValue = () => {
+    const dataList: ExecutionActionDataItemType[] = [];
+    for (const executionActionItem of unref(executionActionListRef)) {
+      dataList.push(getExecutionActionItemData(executionActionItem));
+    }
+
+    return dataList;
+  };
+
+  const setFieldsValue = (executionActionData: ExecutionActionDataItemType[]) => {
+    executionActionListRef.value = Array.from({ length: executionActionData.length }, () =>
+      createNewExecutionActionItem()
+    );
+
+    nextTick(() => {
+      unref(executionActionListRef).forEach((executionActionItem, index) => {
+        const result = executionActionData[index];
+
+        const { doContext, outTarget, commandType } = result;
+
+        const { thingsModelId, deviceId } = result;
+
+        const record = {
+          ...result,
+          [FormFieldsEnum.SERVICE_ID]: thingsModelId,
+          [FormFieldsEnum.ENTITY_ID]: deviceId,
+        };
+
+        if (outTarget === ExecutionActionEnum.MSG_NOTIFY) {
+          const { alarmLevel, clearRule } = doContext as DoContextAlarmType;
+          Object.assign(record, {
+            [FormFieldsEnum.ALARM_LEVEL]: alarmLevel,
+            [FormFieldsEnum.ENABLE_CLEAR_RULE]: !!(clearRule && clearRule.length),
+          });
+          hasAlarmNotify.value = true;
+        }
+
+        if (outTarget == ExecutionActionEnum.DEVICE_OUT && (doContext as DoContextType)?.params) {
+          const { params } = doContext as DoContextType;
+          Object.assign(record, {
+            [isString(params) ? FormFieldsEnum.TCP_CUSTOM_COMMAND : FormFieldsEnum.CUSTOM_COMMAND]:
+              params,
+          });
+        }
+
+        if (
+          outTarget === ExecutionActionEnum.DEVICE_OUT &&
+          commandType === CommandTypeEnum.SERVICE
+        ) {
+          const { params } = doContext as DoContextType;
+          if (isObject(params)) {
+            const [identifier] = Object.keys(params);
+            const result = params[identifier];
+            Object.assign(record, { [FormFieldsEnum.SERVICE_COMMAND]: toRaw(result || {}) });
+            executionActionItem.thingsModelFormRefl?.setFieldsValue(result || {});
+          }
+        }
+
+        executionActionItem.ref?.setFieldsValue(record);
+
+        if (
+          outTarget === ExecutionActionEnum.MSG_NOTIFY &&
+          (doContext as DoContextAlarmType).clearRule &&
+          (doContext as DoContextAlarmType).clearRule.length
+        ) {
+          nextTick(() => {
+            executionActionItem.alarmClearRuleElRef?.setFieldsValue(
+              (result.doContext as DoContextAlarmType).clearRule
+            );
+          });
+        }
+      });
+    });
+  };
+
+  const validate = async () => {
+    for (const executionActionItem of unref(executionActionListRef)) {
+      const { ref, alarmClearRuleElRef, thingsModelFormRefl } = executionActionItem;
+      await ref?.validate?.();
+      await alarmClearRuleElRef?.validate?.();
+      await thingsModelFormRefl?.validate?.();
+    }
+  };
+
+  const resetFieldsValue = () => {
+    executionActionListRef.value = [createNewExecutionActionItem()];
+    hasAlarmNotify.value = false;
+  };
+
+  return {
+    getFieldsValue,
+    setFieldsValue,
+    validate,
+    resetFieldsValue,
+  };
+}

+<script setup lang="ts">
+  import { InputGroup, InputNumber, Select } from 'ant-design-vue';
+  import { TriggerUnitEnum } from '/@/enums/linkedgeEnum';
+
+  withDefaults(
+    defineProps<{
+      value?: number;
+      unit?: TriggerUnitEnum;
+      unitOptions: Record<'label' | 'value', any>[];
+      disabled?: boolean;
+    }>(),
+    {
+      value: undefined,
+      unit: TriggerUnitEnum.SECONDS,
+      unitOptions: () => [],
+    }
+  );
+  const emit = defineEmits(['unitChange', 'update:unit', 'update:value']);
+
+  const handleUnitChange = (value: TriggerUnitEnum) => {
+    emit('update:unit', value);
+    emit('unitChange', value);
+  };
+</script>
+
+<template>
+  <InputGroup class="!flex" compact>
+    <InputNumber
+      :disabled="disabled"
+      :value="value"
+      :min="0"
+      @change="$emit('update:value', $event)"
+      v-bind="$attrs"
+    />
+    <Select
+      :disabled="disabled"
+      :value="unit"
+      :options="unitOptions"
+      :allow-clear="false"
+      @change="handleUnitChange"
+    />
+  </InputGroup>
+</template>

+import { unref } from 'vue';
+import { useSceneLinkageDrawerContext } from '../SceneLinkageDrawer/sceneLinkageDrawerContext';
+import { getDeviceProfile } from '/@/api/alarm/position';
+import { byOrganizationIdGetMasterDevice } from '/@/api/ruleengine/ruleengineApi';
+import { findDictItemByCode } from '/@/api/system/dict';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
+import { DictEnum } from '/@/enums/dictEnum';
+import { createPickerSearch } from '/@/utils/pickerSearch';
+import { DeviceTypeEnum } from '../../../dataFlow/cpns/config';
+import { getDeviceAttributes } from '/@/api/dataBoard';
+import { DeviceAttributeParams } from '/@/api/dataBoard/model';
+import {
+  TriggerValueTypeEnum,
+  TriggerValueTypeNameEnum,
+  TriggerEntityTypeEnum,
+  TriggerEntityTypeNameEnum,
+  TriggerTypeEnum,
+  TriggerTypeNameEnum,
+  DeviceTriggerTypeEum,
+  DeviceTriggerTypeNameEum,
+  FlipFlopTypeEnum,
+  FlipFlopTypeNameEnum,
+  TriggerUnitEnum,
+  TriggerUnitNameEnum,
+} from '/@/enums/linkedgeEnum';
+import { DeviceModelOfMatterAttrs } from '/@/api/device/model/deviceModel';
+import TriggerDurationInput from './TriggerDurationInput.vue';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
+
+export enum FormFieldEnum {
+  FLIP_FLOP_TYPE = 'flipFlopType',
+  DEVICE_TYPE = 'deviceType',
+  DEVICE_PROFILE_ID = 'deviceProfileId',
+  ENTITY_TYPE = 'entityType',
+  ENTITY_ID = 'entityId',
+  TRIGGER_TYPE = 'triggerType',
+  CONDITION_TYPE = 'conditionType',
+  CONDITION_KEY = 'conditionKey',
+  CONDITION_VALUE_TYPE = 'conditionValueType',
+  TRIGGER_DURATION_UNIT = 'triggerDurationUnit',
+  TRIGGER_DURATION_VALUE = 'triggerDurationValue',
+  TRIGGER_REPEAT_COUNT = 'triggerRepeatCount',
+
+  CONDITION_KEY_DETAIL = 'conditionKeyDetail',
+}
+
+export enum FormFieldNameEnum {
+  FLIP_FLOP_TYPE = '触发类型',
+  DEVICE_TYPE = '设备类型',
+  DEVICE_PROFILE_ID = '产品',
+  ENTITY_TYPE = '触发设备类型',
+  ENTITY_ID = '设备',
+  TRIGGER_TYPE = '触发方式',
+  CONDITION_TYPE = '触发条件',
+  CONDITION_KEY = '属性',
+  CONDITION_VALUE_TYPE = '比较类型',
+  TRIGGER_DURATION_VALUE = '持续时长',
+  TRIGGER_REPEAT_COUNT = '重复次数',
+}
+
+useComponentRegister('TriggerDurationInput', TriggerDurationInput);
+
+function getTriggerValueTypeByThingsModelType(type: DataTypeEnum) {
+  const map = {
+    [DataTypeEnum.BOOL]: TriggerValueTypeEnum.BOOLEAN,
+    [DataTypeEnum.NUMBER_DOUBLE]: TriggerValueTypeEnum.NUMERIC,
+    [DataTypeEnum.NUMBER_INT]: TriggerValueTypeEnum.NUMERIC,
+    [DataTypeEnum.STRING]: TriggerValueTypeEnum.STRING,
+    [DataTypeEnum.STRUCT]: TriggerValueTypeEnum.STRING,
+  };
+
+  return map[type];
+}
+
+export const getFormSchemas = (): FormSchema[] => {
+  const { organizationId } = useSceneLinkageDrawerContext();
+
+  return [
+    {
+      field: FormFieldEnum.FLIP_FLOP_TYPE,
+      label: '',
+      component: 'Select',
+      rules: [{ required: true, message: `请选择${FormFieldNameEnum.FLIP_FLOP_TYPE}` }],
+      defaultValue: FlipFlopTypeEnum.SIMPLE,
+      componentProps: () => {
+        return {
+          options: Object.keys(FlipFlopTypeEnum).map((value) => ({
+            label: FlipFlopTypeNameEnum[value],
+            value,
+          })),
+          placeholder: `请选择${FormFieldNameEnum.FLIP_FLOP_TYPE}`,
+        };
+      },
+    },
+    {
+      field: FormFieldEnum.DEVICE_TYPE,
+      label: '',
+      component: 'ApiSelect',
+      defaultValue: DeviceTypeEnum.SENSOR,
+      rules: [{ required: true, message: `请选择${FormFieldNameEnum.DEVICE_TYPE}` }],
+      componentProps: ({ formActionType }) => {
+        const { setFieldsValue } = formActionType;
+        return {
+          api: findDictItemByCode,
+          params: {
+            dictCode: DictEnum.DEVICE_TYPE,
+          },
+          labelField: 'itemText',
+          valueField: 'itemValue',
+          placeholder: `请选择${FormFieldNameEnum.DEVICE_TYPE}`,
+          onChange() {
+            setFieldsValue({
+              [FormFieldEnum.DEVICE_PROFILE_ID]: null,
+              [FormFieldEnum.ENTITY_ID]: [],
+              [FormFieldEnum.CONDITION_KEY]: null,
+            });
+          },
+        };
+      },
+    },
+    {
+      field: FormFieldEnum.DEVICE_PROFILE_ID,
+      label: '',
+      component: 'ApiSelect',
+      rules: [{ required: true, message: `请选择${FormFieldNameEnum.DEVICE_PROFILE_ID}` }],
+      componentProps: ({ formModel, formActionType }) => {
+        const deviceType = formModel[FormFieldEnum.DEVICE_TYPE];
+        const { setFieldsValue } = formActionType;
+        return {
+          api: async () => {
+            return await getDeviceProfile(deviceType);
+          },
+          labelField: 'name',
+          valueField: 'id',
+          placeholder: `请选择${FormFieldNameEnum.DEVICE_PROFILE_ID}`,
+          ...createPickerSearch(),
+          onChange() {
+            setFieldsValue({
+              [FormFieldEnum.ENTITY_ID]: [],
+              [FormFieldEnum.CONDITION_KEY]: null,
+            });
+          },
+        };
+      },
+    },
+    {
+      field: FormFieldEnum.ENTITY_TYPE,
+      label: '',
+      component: 'Select',
+      rules: [{ required: true, message: `请选择${FormFieldNameEnum.ENTITY_TYPE}` }],
+      componentProps: () => {
+        return {
+          options: Object.keys(TriggerEntityTypeEnum).map((value) => ({
+            label: TriggerEntityTypeNameEnum[value],
+            value,
+          })),
+          placeholder: `请选择${FormFieldNameEnum.ENTITY_TYPE}`,
+        };
+      },
+    },
+    {
+      field: FormFieldEnum.TRIGGER_DURATION_UNIT,
+      label: '',
+      component: 'Input',
+      ifShow: false,
+      defaultValue: TriggerUnitEnum.SECONDS,
+    },
+    {
+      field: FormFieldEnum.TRIGGER_DURATION_VALUE,
+      label: '',
+      component: 'TriggerDurationInput',
+      rules: [
+        {
+          required: true,
+          message: `请输入${FormFieldNameEnum.TRIGGER_DURATION_VALUE}`,
+          type: 'number',
+        },
+      ],
+      changeEvent: 'update:value',
+      ifShow: ({ model }) => model[FormFieldEnum.FLIP_FLOP_TYPE] === FlipFlopTypeEnum.DURATION,
+      componentProps: ({ formActionType, formModel }) => {
+        const { setFieldsValue } = formActionType;
+        return {
+          placeholder: `请输入${FormFieldNameEnum.TRIGGER_DURATION_VALUE}`,
+          unit: formModel[FormFieldEnum.TRIGGER_DURATION_UNIT],
+          unitOptions: Object.values(TriggerUnitEnum).map((value) => ({
+            label: TriggerUnitNameEnum[value],
+            value,
+          })),
+          onUnitChange(value: TriggerUnitEnum) {
+            setFieldsValue({ [FormFieldEnum.TRIGGER_DURATION_UNIT]: value });
+          },
+        };
+      },
+    },
+    {
+      field: FormFieldEnum.TRIGGER_REPEAT_COUNT,
+      label: '',
+      component: 'InputNumber',
+      rules: [{ required: true, message: `请输入${FormFieldNameEnum.TRIGGER_REPEAT_COUNT}` }],
+      ifShow: ({ model }) => model[FormFieldEnum.FLIP_FLOP_TYPE] === FlipFlopTypeEnum.REPEATING,
+      componentProps: {
+        placeholder: `请输入${FormFieldNameEnum.TRIGGER_REPEAT_COUNT}`,
+        min: 0,
+      },
+    },
+    {
+      field: FormFieldEnum.ENTITY_ID,
+      label: '',
+      component: 'ApiSelect',
+      rules: [{ required: true, type: 'array', message: `请选择${FormFieldNameEnum.ENTITY_ID}` }],
+      ifShow: ({ model }) => model[FormFieldEnum.ENTITY_TYPE] === TriggerEntityTypeEnum.PART,
+      componentProps: ({ formModel }) => {
+        return {
+          api: async (params: Record<'organizationId' | 'deviceProfileId', string>) => {
+            if (params.deviceProfileId && params.organizationId) {
+              const result = await byOrganizationIdGetMasterDevice(params);
+              if (result) {
+                return result.map((item) => ({
+                  ...item,
+                  label: item.alias || item.name,
+                  value: item.tbDeviceId,
+                }));
+              }
+            }
+            return [];
+          },
+          mode: 'multiple',
+          maxTagCount: 3,
+          params: {
+            organizationId: unref(organizationId),
+            deviceProfileId: formModel[FormFieldEnum.DEVICE_PROFILE_ID],
+          },
+          placeholder: `请选择${FormFieldNameEnum.ENTITY_ID}`,
+          ...createPickerSearch(),
+        };
+      },
+    },
+    {
+      field: FormFieldEnum.TRIGGER_TYPE,
+      label: '',
+      component: 'Select',
+      rules: [{ required: true, message: `请选择${FormFieldNameEnum.TRIGGER_TYPE}` }],
+      defaultValue: TriggerTypeEnum.DEVICE_TRIGGER,
+      componentProps: () => {
+        return {
+          options: [
+            { label: TriggerTypeNameEnum.DEVICE_TRIGGER, value: TriggerTypeEnum.DEVICE_TRIGGER },
+          ],
+        };
+      },
+    },
+    {
+      field: FormFieldEnum.CONDITION_TYPE,
+      label: '',
+      component: 'Select',
+      rules: [{ required: true, message: `请选择${FormFieldNameEnum.CONDITION_TYPE}` }],
+      defaultValue: DeviceTriggerTypeEum.TIME_SERIES,
+      componentProps: () => {
+        return {
+          options: [
+            {
+              label: DeviceTriggerTypeNameEum.TIME_SERIES,
+              value: DeviceTriggerTypeEum.TIME_SERIES,
+            },
+          ],
+        };
+      },
+    },
+    {
+      field: FormFieldEnum.CONDITION_KEY_DETAIL,
+      label: '',
+      component: 'Input',
+      ifShow: false,
+    },
+    {
+      field: FormFieldEnum.CONDITION_KEY,
+      label: '',
+      component: 'ApiSelect',
+      rules: [{ required: true, message: `请选择${FormFieldNameEnum.CONDITION_KEY}` }],
+      componentProps: ({ formModel, formActionType }) => {
+        const { setFieldsValue } = formActionType;
+        return {
+          api: async (params: DeviceAttributeParams) => {
+            if (params.deviceProfileId) {
+              return await getDeviceAttributes(params);
+            }
+            return [];
+          },
+          labelField: 'name',
+          valueField: 'identifier',
+          params: {
+            deviceProfileId: formModel[FormFieldEnum.DEVICE_PROFILE_ID],
+          },
+          placeholder: `请选择${FormFieldNameEnum.CONDITION_KEY}`,
+          onChange(
+            value: string,
+            option: DeviceModelOfMatterAttrs & Record<'label' | 'value', string>
+          ) {
+            setFieldsValue({
+              [FormFieldEnum.CONDITION_KEY_DETAIL]: value
+                ? { ...option, identifier: option?.value, name: option?.label }
+                : {},
+              [FormFieldEnum.CONDITION_VALUE_TYPE]:
+                value && option?.detail?.dataType?.type
+                  ? getTriggerValueTypeByThingsModelType(option.detail.dataType?.type)
+                  : null,
+            });
+          },
+          onOptionsChange(
+            options: (DeviceModelOfMatterAttrs & Record<'label' | 'value', string>)[]
+          ) {
+            const conditionKey = formModel[FormFieldEnum.CONDITION_KEY];
+            const res = options.find((item) => item.value === conditionKey);
+            res &&
+              setFieldsValue({
+                [FormFieldEnum.CONDITION_KEY_DETAIL]: {
+                  ...res,
+                  identifier: res?.value,
+                  name: res?.label,
+                },
+              });
+          },
+        };
+      },
+    },
+    {
+      field: FormFieldEnum.CONDITION_VALUE_TYPE,
+      label: '',
+      component: 'Select',
+      rules: [{ required: true, message: `请选择${FormFieldNameEnum.CONDITION_VALUE_TYPE}` }],
+      componentProps: () => {
+        return {
+          options: Object.keys(TriggerValueTypeEnum).map((value) => ({
+            label: TriggerValueTypeNameEnum[value],
+            value,
+          })),
+          placeholder: `请选择${FormFieldNameEnum.CONDITION_VALUE_TYPE}`,
+        };
+      },
+    },
+    {
+      field: 'conditionFilter',
+      label: '',
+      component: 'Input',
+      colProps: { span: 24, xxl: 24, xl: 24, lg: 24, md: 24, sm: 24, xs: 24 },
+      ifShow: ({ model }) =>
+        model[FormFieldEnum.CONDITION_KEY] && model[FormFieldEnum.CONDITION_VALUE_TYPE],
+      colSlot: 'conditionFilter',
+    },
+  ];
+};

+import { FlipFlopItemType } from './types';
+import { ScheduleTypeEnum } from '/@/enums/linkedgeEnum';
+import { buildUUID } from '/@/utils/uuid';
+
+export { default as FlipFlop } from './index.vue';
+
+export function createNewFlipFlopItem(): FlipFlopItemType {
+  return { key: buildUUID(), schedule: { type: ScheduleTypeEnum.ANY_TIME } };
+}

+<script setup lang="ts">
+  import { ComponentPublicInstance, ref, unref, watch } from 'vue';
+  import { Tooltip, Button } from 'ant-design-vue';
+  import { CollapseContainer } from '/@/components/Container';
+  import { Icon } from '/@/components/Icon';
+  import { FlipFlopItemType, ScheduleOptionItemType } from './types';
+  import { BasicForm, FormActionType } from '/@/components/Form';
+  import { getFormSchemas, FormFieldEnum } from './config';
+  import { useSceneLinkageDrawerContext } from '../SceneLinkageDrawer/sceneLinkageDrawerContext';
+  import { ScheduleTypeEnum, ScheduleTypeNameEnum } from '/@/enums/linkedgeEnum';
+  import { ConditionFilter } from '../ConditionFilter';
+  import { EnablingRule } from '../EnablingRule';
+  import { useModal } from '/@/components/Modal';
+  import { DataActionModeEnum } from '/@/enums/toolEnum';
+  import { EnableRuleFormModalParamsType, ScheduleType } from '../EnablingRule/type';
+  import { useFlipFlopData } from './useFlipFlopData';
+  import { createNewFlipFlopItem } from '.';
+
+  const { disabledDrawer } = useSceneLinkageDrawerContext();
+
+  const emit = defineEmits(['delete']);
+
+  const props = withDefaults(
+    defineProps<{
+      addButtonName?: string;
+      defaultNull?: boolean;
+      panelTitle?: (index: number) => string;
+      showAddButton?: boolean;
+      disabled?: boolean;
+    }>(),
+    {
+      addButtonName: '触发器 (OR)',
+      defaultNull: false,
+      panelTitle: (index: number) => `触发器${index}`,
+      showAddButton: true,
+      disabled: false,
+    }
+  );
+
+  const formSchemas = getFormSchemas();
+
+  const [registerModal, { openModal }] = useModal();
+
+  const handleOpenModal = (type: ScheduleTypeEnum, flipFlopItem: FlipFlopItemType) => {
+    if (unref(disabledDrawer) && type !== flipFlopItem.schedule.type) return;
+
+    if (type === ScheduleTypeEnum.ANY_TIME) {
+      flipFlopItem.schedule = { type };
+      return;
+    }
+
+    openModal(true, {
+      mode: DataActionModeEnum.CREATE,
+      record: {
+        type,
+        schedule: flipFlopItem.schedule,
+        key: flipFlopItem.key,
+      },
+    } as EnableRuleFormModalParamsType);
+  };
+
+  const handleRuleSetting = (params: ScheduleType, key: string) => {
+    const index = unref(flipFlopListElRef).findIndex((flipFlopItem) => flipFlopItem.key === key);
+
+    ~index && (unref(flipFlopListElRef)[index].schedule = params);
+  };
+
+  const scheduleOptions: ScheduleOptionItemType[] = Object.keys(ScheduleTypeEnum).map((value) => ({
+    label: ScheduleTypeNameEnum[value],
+    value: value as ScheduleTypeEnum,
+  }));
+
+  const { organizationId } = useSceneLinkageDrawerContext();
+
+  const flipFlopListElRef = ref<FlipFlopItemType[]>(
+    props.defaultNull ? [] : [createNewFlipFlopItem()]
+  );
+
+  /**
+   * @description on organization change
+   */
+  watch(organizationId, () => {
+    unref(flipFlopListElRef).forEach((flipFlopItem) =>
+      flipFlopItem.ref?.setFieldsValue({ [FormFieldEnum.ENTITY_ID]: [] })
+    );
+  });
+
+  const setFlopFlipFormRef = (
+    flipFlopItem: FlipFlopItemType,
+    el: Nullable<Element | ComponentPublicInstance>
+  ) => {
+    flipFlopItem.ref = el as unknown as FormActionType;
+  };
+
+  const setFlopFlipConditionRef = (
+    flipFlopItem: FlipFlopItemType,
+    el: Nullable<Element | ComponentPublicInstance>
+  ) => {
+    flipFlopItem.conditionRef = el as unknown as InstanceType<typeof ConditionFilter>;
+  };
+
+  const handleDelete = (flipFlopItem: FlipFlopItemType) => {
+    const index = unref(flipFlopListElRef).findIndex((item) => item.key === flipFlopItem.key);
+    ~index && unref(flipFlopListElRef).splice(index, 1);
+    emit('delete');
+  };
+
+  const handleAdd = () => {
+    flipFlopListElRef.value.push(createNewFlipFlopItem());
+  };
+
+  const { getFieldsValue, setFieldsValue, validate, resetFieldsValue } =
+    useFlipFlopData(flipFlopListElRef);
+
+  defineExpose({ getFieldsValue, setFieldsValue, validate, resetFieldsValue });
+</script>
+
+<template>
+  <section>
+    <CollapseContainer
+      v-for="(flipFlopItem, index) in flipFlopListElRef"
+      :key="flipFlopItem.key"
+      :title="panelTitle(index + 1)"
+      class="mb-4"
+    >
+      <template #action>
+        <header class="flex items-center justify-between">
+          <div class="flex items-center">
+            <div class="flex">
+              <span class="mr-2">启用规则:</span>
+              <div
+                class="px-1 cursor-pointer"
+                v-for="schedule in scheduleOptions"
+                :key="schedule.value"
+                type="text"
+                :class="flipFlopItem.schedule.type === schedule.value ? 'text-blue-400' : ''"
+                @click="handleOpenModal(schedule.value, flipFlopItem)"
+              >
+                {{ schedule.label }}
+              </div>
+            </div>
+            <Tooltip title="删除">
+              <Icon
+                v-if="!disabledDrawer"
+                class="ml-2 cursor-pointer"
+                icon="fluent:delete-off-20-regular"
+                size="20"
+                @click="handleDelete(flipFlopItem)"
+              />
+            </Tooltip>
+          </div>
+        </header>
+      </template>
+      <BasicForm
+        :ref="(el) => setFlopFlipFormRef(flipFlopItem, el)"
+        :key="flipFlopItem.key"
+        class="trigger-form"
+        layout="horizontal"
+        :disabled="disabledDrawer"
+        :schemas="formSchemas"
+        :showActionButtonGroup="false"
+        :baseColProps="{ span: 6, xxl: 6, xl: 8, lg: 12, sm: 24 }"
+      >
+        <template #conditionFilter="{ model }">
+          <ConditionFilter
+            :ref="(el) => setFlopFlipConditionRef(flipFlopItem, el)"
+            :triggerType="model[FormFieldEnum.CONDITION_VALUE_TYPE]"
+            :object-model="model[FormFieldEnum.CONDITION_KEY_DETAIL]"
+            :condition-type="model[FormFieldEnum.CONDITION_TYPE]"
+          />
+        </template>
+      </BasicForm>
+    </CollapseContainer>
+    <Button
+      v-if="showAddButton && !disabledDrawer"
+      type="primary"
+      class="w-full"
+      @click="handleAdd"
+    >
+      <Icon icon="ant-design:plus-outlined" />
+      {{ addButtonName }}
+    </Button>
+
+    <EnablingRule @register="registerModal" @setting-complete="handleRuleSetting" />
+  </section>
+</template>
+
+<style lang="less" scoped>
+  .trigger-form {
+    :deep(.ant-form-item-control-input-content) {
+      width: 100%;
+
+      > div > div {
+        width: 100%;
+      }
+
+      .ant-input-number {
+        width: 100% !important;
+      }
+      // .ant-col {
+      //   .ant-row{
+      //     .ant-col {
+      //       .
+      //     }
+      //   }
+      // }
+    }
+  }
+</style>

+import { ConditionFilter } from '../ConditionFilter';
+import { TriggerCondition } from '../ConditionFilter/type';
+import { ScheduleType } from '../EnablingRule/type';
+import { FormFieldEnum } from './config';
+import { DeviceTypeEnum } from '/@/api/device/model/deviceModel';
+import { FormActionType } from '/@/components/Form';
+import {
+  DeviceTriggerTypeEum,
+  FlipFlopTypeEnum,
+  ScheduleTypeEnum,
+  TriggerEntityTypeEnum,
+  TriggerTypeEnum,
+  TriggerUnitEnum,
+  TriggerValueTypeNameEnum,
+} from '/@/enums/linkedgeEnum';
+
+export interface ScheduleOptionItemType {
+  label: string;
+  value: ScheduleTypeEnum;
+}
+
+export interface FlipFlopItemType {
+  key: string;
+  ref?: FormActionType;
+  schedule: ScheduleType;
+  conditionRef?: InstanceType<typeof ConditionFilter>;
+}
+
+export interface FlipFlopConditionType {
+  deviceProfileId: string;
+  deviceType: DeviceTypeEnum;
+  entityId: string[];
+  entityType: TriggerEntityTypeEnum;
+  triggerCondition: TriggerCondition;
+  triggerType: TriggerTypeEnum;
+}
+
+export interface FlipFlopFormRecordType {
+  [FormFieldEnum.FLIP_FLOP_TYPE]: FlipFlopTypeEnum;
+  [FormFieldEnum.DEVICE_TYPE]: DeviceTypeEnum;
+  [FormFieldEnum.DEVICE_PROFILE_ID]: string;
+  [FormFieldEnum.ENTITY_TYPE]: TriggerEntityTypeEnum;
+  [FormFieldEnum.ENTITY_ID]: string[];
+  [FormFieldEnum.TRIGGER_TYPE]: TriggerTypeEnum;
+  [FormFieldEnum.CONDITION_TYPE]: DeviceTriggerTypeEum;
+  [FormFieldEnum.CONDITION_KEY]: string;
+  [FormFieldEnum.CONDITION_VALUE_TYPE]: TriggerValueTypeNameEnum;
+  [FormFieldEnum.TRIGGER_DURATION_VALUE]: number;
+  [FormFieldEnum.TRIGGER_REPEAT_COUNT]: number;
+  [FormFieldEnum.TRIGGER_DURATION_UNIT]: TriggerUnitEnum;
+}