feat: 场景联动新增事件触发

@@ -99,10 +99,12 @@ export enum TriggerTypeNameEnum {
 
 export enum DeviceTriggerTypeEum {
   TIME_SERIES = 'TIME_SERIES',
+  DEVICE_EVENT = 'DEVICE_EVENT',
 }
 
 export enum DeviceTriggerTypeNameEum {
   TIME_SERIES = '属性触发',
+  DEVICE_EVENT = '事件触发',
 }
 
 export enum TriggerEntityTypeEnum {

@@ -7,7 +7,7 @@ import {
   DeviceTriggerTypeEum,
   FlipFlopTypeEnum,
   NumberOperationEnum,
-  StringOperationNameEnum,
+  StringOperationEnum,
   TriggerTypeEnum,
   TriggerValueTypeEnum,
 } from '/@/enums/linkedgeEnum';
@@ -37,7 +37,7 @@ export interface ConditionType {
   spec: { type: FlipFlopTypeEnum; unit?: string; predicate?: { defaultValue: any } };
 }
 
-export type OperationType = NumberOperationEnum | StringOperationNameEnum | BooleanOperationEnum;
+export type OperationType = NumberOperationEnum | StringOperationEnum | BooleanOperationEnum;
 
 export interface ConditionItemType {
   key: { type: DeviceTriggerTypeEum; key: string };

@@ -10,6 +10,7 @@
   import { useExecutionActionData } from './useExecutionActionData';
   import { createNewExecutionActionItem } from '.';
   import { useSceneLinkageDrawerContext } from '../SceneLinkageDrawer/sceneLinkageDrawerContext';
+  import { FlipFlopComponentTypeEnum } from '../FlipFlop/types';
 
   const { disabledDrawer } = useSceneLinkageDrawerContext();
 
@@ -103,6 +104,7 @@
             :disabled="disabledDrawer"
             addButtonName="新增清除告警"
             @delete="handleClearRuleDelete(executionActionItem)"
+            :type="FlipFlopComponentTypeEnum.ALARM_CLEAR"
           />
         </template>
 

@@ -23,9 +23,15 @@ import {
   TriggerUnitEnum,
   TriggerUnitNameEnum,
 } from '/@/enums/linkedgeEnum';
-import { DeviceModelOfMatterAttrs } from '/@/api/device/model/deviceModel';
+import { DeviceModelOfMatterAttrs, DeviceProfileModel } from '/@/api/device/model/deviceModel';
 import TriggerDurationInput from './TriggerDurationInput.vue';
 import { DataTypeEnum } from '/@/enums/objectModelEnum';
+import { getModelTsl } from '/@/api/device/modelOfMatter';
+import { FunctionType } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
+import { GetModelTslParams } from '/@/api/device/model/modelOfMatterModel';
+import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
+import { FlipFlopComponentTypeEnum } from './types';
+import { OptionsType } from 'ant-design-vue/es/vc-select/interface';
 
 export enum FormFieldEnum {
   FLIP_FLOP_TYPE = 'flipFlopType',
@@ -42,6 +48,8 @@ export enum FormFieldEnum {
   TRIGGER_REPEAT_COUNT = 'triggerRepeatCount',
 
   CONDITION_KEY_DETAIL = 'conditionKeyDetail',
+  TRANSPORT_TYPE = 'transportType',
+  DEVICE_EVENT_TRIGGER_KEY = 'deviceEventTriggerKey',
 }
 
 export enum FormFieldNameEnum {
@@ -56,6 +64,8 @@ export enum FormFieldNameEnum {
   CONDITION_VALUE_TYPE = '比较类型',
   TRIGGER_DURATION_VALUE = '持续时长',
   TRIGGER_REPEAT_COUNT = '重复次数',
+
+  DEVICE_EVENT_TRIGGER_KEY = '事件',
 }
 
 useComponentRegister('TriggerDurationInput', TriggerDurationInput);
@@ -72,7 +82,9 @@ function getTriggerValueTypeByThingsModelType(type: DataTypeEnum) {
   return map[type];
 }
 
-export const getFormSchemas = (): FormSchema[] => {
+export const getFormSchemas = (
+  flipFlopComponentType: FlipFlopComponentTypeEnum = FlipFlopComponentTypeEnum.FLIP_FLOP
+): FormSchema[] => {
   const { organizationId } = useSceneLinkageDrawerContext();
 
   return [
@@ -119,6 +131,12 @@ export const getFormSchemas = (): FormSchema[] => {
       },
     },
     {
+      field: FormFieldEnum.TRANSPORT_TYPE,
+      label: '传输协议',
+      component: 'Input',
+      ifShow: false,
+    },
+    {
       field: FormFieldEnum.DEVICE_PROFILE_ID,
       label: '',
       component: 'ApiSelect',
@@ -134,11 +152,29 @@ export const getFormSchemas = (): FormSchema[] => {
           valueField: 'id',
           placeholder: `请选择${FormFieldNameEnum.DEVICE_PROFILE_ID}`,
           ...createPickerSearch(),
-          onChange() {
-            setFieldsValue({
+          onChange(value: string, option: DeviceProfileModel) {
+            const conditionType = formModel[FormFieldEnum.CONDITION_TYPE];
+            const deviceTyp = formModel[FormFieldEnum.DEVICE_TYPE];
+            const record = {
               [FormFieldEnum.ENTITY_ID]: [],
               [FormFieldEnum.CONDITION_KEY]: null,
-            });
+              [FormFieldEnum.TRANSPORT_TYPE]: value ? option.transportType : null,
+            };
+            // TCP网关子设备无物模型事件
+            if (
+              conditionType === DeviceTriggerTypeEum.DEVICE_EVENT &&
+              option.transportType === TransportTypeEnum.TCP &&
+              deviceTyp === DeviceTypeEnum.SENSOR
+            ) {
+              record[FormFieldEnum.CONDITION_TYPE] = null;
+            }
+            setFieldsValue(record);
+          },
+          onOptionsChange(options: (DeviceProfileModel & Record<'label' | 'value', string>)[]) {
+            const res = options.find(
+              (item) => item.value === formModel[FormFieldEnum.DEVICE_PROFILE_ID]
+            );
+            res && setFieldsValue({ [FormFieldEnum.TRANSPORT_TYPE]: res.transportType });
           },
         };
       },
@@ -256,14 +292,25 @@ export const getFormSchemas = (): FormSchema[] => {
       component: 'Select',
       rules: [{ required: true, message: `请选择${FormFieldNameEnum.CONDITION_TYPE}` }],
       defaultValue: DeviceTriggerTypeEum.TIME_SERIES,
-      componentProps: () => {
+      componentProps: ({ formModel }) => {
+        const options: OptionsType = [
+          {
+            label: DeviceTriggerTypeNameEum.TIME_SERIES,
+            value: DeviceTriggerTypeEum.TIME_SERIES,
+          },
+        ];
+
+        if (flipFlopComponentType === FlipFlopComponentTypeEnum.FLIP_FLOP) {
+          options.push({
+            label: DeviceTriggerTypeNameEum.DEVICE_EVENT,
+            value: DeviceTriggerTypeEum.DEVICE_EVENT,
+            disabled:
+              TransportTypeEnum.TCP === formModel[FormFieldEnum.TRANSPORT_TYPE] &&
+              formModel[FormFieldEnum.DEVICE_TYPE] === DeviceTypeEnum.SENSOR,
+          });
+        }
         return {
-          options: [
-            {
-              label: DeviceTriggerTypeNameEum.TIME_SERIES,
-              value: DeviceTriggerTypeEum.TIME_SERIES,
-            },
-          ],
+          options,
         };
       },
     },
@@ -278,6 +325,8 @@ export const getFormSchemas = (): FormSchema[] => {
       label: '',
       component: 'ApiSelect',
       rules: [{ required: true, message: `请选择${FormFieldNameEnum.CONDITION_KEY}` }],
+      ifShow: ({ model }) =>
+        model[FormFieldEnum.CONDITION_TYPE] === DeviceTriggerTypeEum.TIME_SERIES,
       componentProps: ({ formModel, formActionType }) => {
         const { setFieldsValue } = formActionType;
         return {
@@ -329,6 +378,8 @@ export const getFormSchemas = (): FormSchema[] => {
       label: '',
       component: 'Select',
       rules: [{ required: true, message: `请选择${FormFieldNameEnum.CONDITION_VALUE_TYPE}` }],
+      ifShow: ({ model }) =>
+        model[FormFieldEnum.CONDITION_TYPE] === DeviceTriggerTypeEum.TIME_SERIES,
       componentProps: () => {
         return {
           options: Object.keys(TriggerValueTypeEnum).map((value) => ({
@@ -340,12 +391,36 @@ export const getFormSchemas = (): FormSchema[] => {
       },
     },
     {
+      field: FormFieldEnum.DEVICE_EVENT_TRIGGER_KEY,
+      label: '',
+      component: 'ApiSelect',
+      ifShow: ({ model }) =>
+        model[FormFieldEnum.CONDITION_TYPE] === DeviceTriggerTypeEum.DEVICE_EVENT,
+      componentProps: ({ formModel }) => {
+        return {
+          api: async (params: GetModelTslParams) => {
+            if (!params.deviceProfileId) return [];
+            return await getModelTsl(params);
+          },
+          labelField: 'functionName',
+          valueField: 'identifier',
+          params: {
+            functionType: FunctionType.EVENTS,
+            deviceProfileId: formModel[FormFieldEnum.DEVICE_PROFILE_ID],
+          },
+          placeholder: `请选择${FormFieldNameEnum.DEVICE_EVENT_TRIGGER_KEY}`,
+        };
+      },
+    },
+    {
       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],
+        model[FormFieldEnum.CONDITION_TYPE] === DeviceTriggerTypeEum.TIME_SERIES &&
+        model[FormFieldEnum.CONDITION_KEY] &&
+        model[FormFieldEnum.CONDITION_VALUE_TYPE],
       colSlot: 'conditionFilter',
     },
   ];

@@ -3,7 +3,7 @@
   import { Tooltip, Button } from 'ant-design-vue';
   import { CollapseContainer } from '/@/components/Container';
   import { Icon } from '/@/components/Icon';
-  import { FlipFlopItemType, ScheduleOptionItemType } from './types';
+  import { FlipFlopItemType, FlipFlopComponentTypeEnum, ScheduleOptionItemType } from './types';
   import { BasicForm, FormActionType } from '/@/components/Form';
   import { getFormSchemas, FormFieldEnum } from './config';
   import { useSceneLinkageDrawerContext } from '../SceneLinkageDrawer/sceneLinkageDrawerContext';
@@ -27,6 +27,7 @@
       panelTitle?: (index: number) => string;
       showAddButton?: boolean;
       disabled?: boolean;
+      type?: FlipFlopComponentTypeEnum;
     }>(),
     {
       addButtonName: '触发器 (OR)',
@@ -34,10 +35,11 @@
       panelTitle: (index: number) => `触发器${index}`,
       showAddButton: true,
       disabled: false,
+      type: FlipFlopComponentTypeEnum.FLIP_FLOP,
     }
   );
 
-  const formSchemas = getFormSchemas();
+  const formSchemas = getFormSchemas(props.type);
 
   const [registerModal, { openModal }] = useModal();
 

@@ -14,6 +14,12 @@ import {
   TriggerValueTypeNameEnum,
 } from '/@/enums/linkedgeEnum';
 
+export enum FlipFlopComponentTypeEnum {
+  FLIP_FLOP,
+  EXECUTION_CONDITION,
+  ALARM_CLEAR,
+}
+
 export interface ScheduleOptionItemType {
   label: string;
   value: ScheduleTypeEnum;
@@ -48,4 +54,5 @@ export interface FlipFlopFormRecordType {
   [FormFieldEnum.TRIGGER_DURATION_VALUE]: number;
   [FormFieldEnum.TRIGGER_REPEAT_COUNT]: number;
   [FormFieldEnum.TRIGGER_DURATION_UNIT]: TriggerUnitEnum;
+  [FormFieldEnum.DEVICE_EVENT_TRIGGER_KEY]: string;
 }

@@ -2,13 +2,50 @@ import { Ref, nextTick, toRaw, unref } from 'vue';
 import { FlipFlopConditionType, FlipFlopFormRecordType, FlipFlopItemType } from './types';
 import { DefineComponentsBasicExpose } from '/#/utils';
 import { FormFieldEnum } from './config';
-import { FlipFlopTypeEnum } from '/@/enums/linkedgeEnum';
+import {
+  DeviceTriggerTypeEum,
+  FlipFlopTypeEnum,
+  StringOperationEnum,
+  TriggerValueTypeEnum,
+} from '/@/enums/linkedgeEnum';
 import { createNewFlipFlopItem } from '.';
+import { ConditionItemType } from '../ConditionFilter/type';
 
 export function useFlipFlopData(
   flipFlopListRef: Ref<FlipFlopItemType[]>
 ): DefineComponentsBasicExpose<FlipFlopConditionType[]> {
+  const getEventTriggerCOndition = (
+    basicRecord: FlipFlopFormRecordType,
+    _flipFlopItem: FlipFlopItemType
+  ): ConditionItemType[] => {
+    const { deviceEventTriggerKey } = basicRecord;
+    return [
+      {
+        key: {
+          type: DeviceTriggerTypeEum.DEVICE_EVENT,
+          key: deviceEventTriggerKey,
+        },
+        valueType: TriggerValueTypeEnum.STRING,
+        predicate: {
+          type: TriggerValueTypeEnum.STRING,
+          operation: StringOperationEnum.EQUAL,
+          value: {
+            defaultValue: deviceEventTriggerKey,
+          },
+        },
+      },
+    ];
+  };
+
+  const getCondition = (basicRecord: FlipFlopFormRecordType, flipFlopItem: FlipFlopItemType) => {
+    const { conditionType } = basicRecord;
+    return conditionType === DeviceTriggerTypeEum.TIME_SERIES
+      ? flipFlopItem.conditionRef?.getFieldsValue() || []
+      : getEventTriggerCOndition(basicRecord, flipFlopItem);
+  };
+
   const crateFlipFlopCondition = (flipFlopItem: FlipFlopItemType): FlipFlopConditionType => {
+    const basicRecord = flipFlopItem.ref?.getFieldsValue() as FlipFlopFormRecordType;
     const {
       deviceProfileId,
       deviceType,
@@ -19,9 +56,9 @@ export function useFlipFlopData(
       triggerDurationUnit,
       triggerRepeatCount,
       triggerDurationValue,
-    } = flipFlopItem.ref?.getFieldsValue() as FlipFlopFormRecordType;
+    } = basicRecord;
 
-    const condition = flipFlopItem.conditionRef?.getFieldsValue() || [];
+    const condition = getCondition(basicRecord, flipFlopItem);
 
     return {
       deviceProfileId,
@@ -70,17 +107,27 @@ export function useFlipFlopData(
         const { type, unit, predicate } = condition.spec;
         const { defaultValue } = predicate || {};
 
-        item.ref?.setFieldsValue({
+        const record = {
           ...data,
           [FormFieldEnum.FLIP_FLOP_TYPE]: type,
           [FormFieldEnum.CONDITION_KEY]: key.key,
+          [FormFieldEnum.CONDITION_TYPE]: key.type,
           [FormFieldEnum.CONDITION_VALUE_TYPE]: valueType,
           [FormFieldEnum.TRIGGER_DURATION_UNIT]: unit,
           [FormFieldEnum.TRIGGER_DURATION_VALUE]:
             type === FlipFlopTypeEnum.DURATION ? defaultValue : null,
           [FormFieldEnum.TRIGGER_REPEAT_COUNT]:
             type === FlipFlopTypeEnum.REPEATING ? defaultValue : null,
-        });
+        };
+
+        if (key.type === DeviceTriggerTypeEum.DEVICE_EVENT) {
+          Object.assign(record, {
+            [FormFieldEnum.DEVICE_EVENT_TRIGGER_KEY]: key.key,
+            [FormFieldEnum.CONDITION_KEY]: null,
+          });
+        }
+
+        item.ref?.setFieldsValue(record);
 
         const {
           daysOfWeek,

@@ -14,6 +14,7 @@
   import { screenLinkPageAddApi } from '/@/api/ruleengine/ruleengineApi';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { OrganizationListItem } from '/@/api/system/model/systemModel';
+  import { FlipFlopComponentTypeEnum } from '../FlipFlop/types';
 
   const emit = defineEmits(['success', 'register']);
 
@@ -127,7 +128,7 @@
             <Icon icon="ant-design:question-circle-outlined" class="ml-2" />
           </Tooltip>
         </Divider>
-        <FlipFlop ref="flipFlopElRef" />
+        <FlipFlop ref="flipFlopElRef" :type="FlipFlopComponentTypeEnum.FLIP_FLOP" />
       </template>
       <template #executionCondition>
         <Divider orientation="left">
@@ -142,6 +143,7 @@
           addButtonName="执行条件 (AND)"
           default-null
           :panel-title="(index) => `执行条件${index}`"
+          :type="FlipFlopComponentTypeEnum.EXECUTION_CONDITION"
         />
       </template>
       <template #executionAction>