Merge branch 'perf/linkedage-enum-type' into 'main_dev'

perf: 优化场景联动枚举类型选择

See merge request yunteng/thingskit-front!1180

+import { toRaw, unref } from 'vue';
 import { OperationType } from './type';
 import { OperationType } from './type';
+import { DeviceModelOfMatterAttrs } from '/@/api/device/model/deviceModel';
 import { FormSchema } from '/@/components/Form';
 import { FormSchema } from '/@/components/Form';
 import {
 import {
   BooleanOperationEnum,
   BooleanOperationEnum,
@@ -11,6 +13,7 @@ import {
   StringOperationNameEnum,
   StringOperationNameEnum,
   TriggerValueTypeEnum,
   TriggerValueTypeEnum,
 } from '/@/enums/linkedgeEnum';
 } from '/@/enums/linkedgeEnum';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
 
 
 export enum FormFieldsEnum {
 export enum FormFieldsEnum {
   CONDITION_OPERATION = 'operation',
   CONDITION_OPERATION = 'operation',
@@ -26,6 +29,7 @@ export enum FormFieldsNameEnum {
 
 
 interface GetFormSchemasParamsType {
 interface GetFormSchemasParamsType {
   triggerType: TriggerValueTypeEnum;
   triggerType: TriggerValueTypeEnum;
+  objectModel?: DeviceModelOfMatterAttrs;
 }
 }
 
 
 export interface ConditionFormRecordType {
 export interface ConditionFormRecordType {
@@ -58,7 +62,10 @@ const getOperation = (type: TriggerValueTypeEnum) => {
   return Object.keys(value).map((value) => ({ label: label[value], value }));
   return Object.keys(value).map((value) => ({ label: label[value], value }));
 };
 };
 
 
-const getOperationValueFormSchemas = (triggerType: TriggerValueTypeEnum): FormSchema[] => {
+const getOperationValueFormSchemas = ({
+  triggerType,
+  objectModel,
+}: GetFormSchemasParamsType): FormSchema[] => {
   const getNumberSchemas = (): FormSchema[] => {
   const getNumberSchemas = (): FormSchema[] => {
     return [
     return [
       {
       {
@@ -139,17 +146,43 @@ const getOperationValueFormSchemas = (triggerType: TriggerValueTypeEnum): FormSc
     ];
     ];
   };
   };
 
 
+  const getEnumsSchemas = (): FormSchema[] => {
+    return [
+      {
+        field: FormFieldsEnum.CONDITION_VALUE,
+        label: FormFieldsNameEnum.CONDITION_VALUE,
+        component: 'Select',
+        required: true,
+        componentProps: () => {
+          return {
+            options: toRaw(unref(objectModel?.detail?.dataType?.specsList))?.map((item) => ({
+              label: item.name,
+              value: item.value,
+            })),
+            placeholder: `请输入${FormFieldsNameEnum.CONDITION_VALUE}`,
+          };
+        },
+      },
+    ];
+  };
+
   const schemasMap = {
   const schemasMap = {
     [TriggerValueTypeEnum.BOOLEAN]: getBoolSchemas,
     [TriggerValueTypeEnum.BOOLEAN]: getBoolSchemas,
     [TriggerValueTypeEnum.DATE_TIME]: getDateSchemas,
     [TriggerValueTypeEnum.DATE_TIME]: getDateSchemas,
-    [TriggerValueTypeEnum.NUMERIC]: getNumberSchemas,
+    [TriggerValueTypeEnum.NUMERIC]:
+      objectModel?.detail?.dataType?.type === DataTypeEnum.ENUM
+        ? getEnumsSchemas
+        : getNumberSchemas,
     [TriggerValueTypeEnum.STRING]: getStringSchemas,
     [TriggerValueTypeEnum.STRING]: getStringSchemas,
   };
   };
 
 
   return schemasMap[triggerType]?.() || [];
   return schemasMap[triggerType]?.() || [];
 };
 };
 
 
-export const getFormSchemas = ({ triggerType }: GetFormSchemasParamsType): FormSchema[] => {
+export const getFormSchemas = ({
+  triggerType,
+  objectModel,
+}: GetFormSchemasParamsType): FormSchema[] => {
   return [
   return [
     {
     {
       field: FormFieldsEnum.CONDITION_OPERATION,
       field: FormFieldsEnum.CONDITION_OPERATION,
@@ -163,6 +196,6 @@ export const getFormSchemas = ({ triggerType }: GetFormSchemasParamsType): FormS
         };
         };
       },
       },
     },
     },
-    ...getOperationValueFormSchemas(triggerType),
+    ...getOperationValueFormSchemas({ triggerType, objectModel }),
   ];
   ];
 };
 };

-<script setup lang="ts">
+x<script setup lang="ts">
   import { ComponentPublicInstance, computed, ref, unref, watch } from 'vue';
   import { ComponentPublicInstance, computed, ref, unref, watch } from 'vue';
   import { Card, Tag, Button, Tooltip } from 'ant-design-vue';
   import { Card, Tag, Button, Tooltip } from 'ant-design-vue';
   import { Icon } from '/@/components/Icon';
   import { Icon } from '/@/components/Icon';
@@ -24,8 +24,8 @@
   });
   });
 
 
   const getSchemas = computed(() => {
   const getSchemas = computed(() => {
-    const { triggerType } = props;
-    return getFormSchemas({ triggerType });
+    const { triggerType, objectModel } = props;
+    return getFormSchemas({ triggerType, objectModel });
   });
   });
 
 
   const conditionListElRef = ref<ConditionListItemType[]>([getNewConditionFilterItem()]);
   const conditionListElRef = ref<ConditionListItemType[]>([getNewConditionFilterItem()]);
@@ -40,8 +40,8 @@
 
 
   const handleConditionFormValueChange = () => {
   const handleConditionFormValueChange = () => {
     const condition = getConditionFormValues();
     const condition = getConditionFormValues();
-    const { triggerType } = props;
-    const message = useConditionFilterMessage({ triggerType, condition });
+    const { triggerType, objectModel } = props;
+    const message = useConditionFilterMessage({ triggerType, condition, objectModel });
     conditionMessageList.value = message;
     conditionMessageList.value = message;
   };
   };
 
 
@@ -84,6 +84,13 @@
     await validate?.();
     await validate?.();
   };
   };
 
 
+  watch(
+    () => props.objectModel,
+    () => {
+      handleConditionFormValueChange();
+    }
+  );
+
   defineExpose({ getFieldsValue, setFieldsValue, validate });
   defineExpose({ getFieldsValue, setFieldsValue, validate });
 </script>
 </script>
 
 

 import { FormFieldsEnum, getOperationMap } from './config';
 import { FormFieldsEnum, getOperationMap } from './config';
+import { DeviceModelOfMatterAttrs } from '/@/api/device/model/deviceModel';
 import {
 import {
   BooleanOperationValueEnum,
   BooleanOperationValueEnum,
   BooleanOperationValueNameEnum,
   BooleanOperationValueNameEnum,
   TriggerValueTypeEnum,
   TriggerValueTypeEnum,
 } from '/@/enums/linkedgeEnum';
 } from '/@/enums/linkedgeEnum';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
+import { isNullOrUnDef } from '/@/utils/is';
 
 
 export type ConditionMessageItemType = Record<
 export type ConditionMessageItemType = Record<
   Exclude<FormFieldsEnum, FormFieldsEnum.CONDITION_VALUE_IGNORE_CASE>,
   Exclude<FormFieldsEnum, FormFieldsEnum.CONDITION_VALUE_IGNORE_CASE>,
@@ -13,24 +16,39 @@ export type ConditionMessageItemType = Record<
 interface UseConditionFilterMessageParamsType {
 interface UseConditionFilterMessageParamsType {
   triggerType: TriggerValueTypeEnum;
   triggerType: TriggerValueTypeEnum;
   condition: ConditionMessageItemType[];
   condition: ConditionMessageItemType[];
+  objectModel?: DeviceModelOfMatterAttrs;
 }
 }
 
 
 export function useConditionFilterMessage({
 export function useConditionFilterMessage({
   triggerType,
   triggerType,
   condition,
   condition,
+  objectModel,
 }: UseConditionFilterMessageParamsType) {
 }: UseConditionFilterMessageParamsType) {
   const { label } = getOperationMap(triggerType);
   const { label } = getOperationMap(triggerType);
   const list: ConditionMessageItemType[] = [];
   const list: ConditionMessageItemType[] = [];
+
+  const isEnumsType = objectModel?.detail.dataType?.type === DataTypeEnum.ENUM;
+
+  const enumsMap: Recordable = {};
+  if (isEnumsType) {
+    const maps = objectModel.detail.dataType?.specsList?.reduce(
+      (prev, next) => ({ ...prev, [next.value!]: next.name }),
+      {}
+    );
+    maps && Object.assign(enumsMap, maps);
+  }
+
   for (const item of condition) {
   for (const item of condition) {
     let { defaultValue, operation } = item;
     let { defaultValue, operation } = item;
-    if (!defaultValue || !operation) continue;
+    if (isNullOrUnDef(defaultValue) || isNullOrUnDef(operation)) continue;
     operation = label[operation];
     operation = label[operation];
     if (triggerType === TriggerValueTypeEnum.BOOLEAN)
     if (triggerType === TriggerValueTypeEnum.BOOLEAN)
       defaultValue =
       defaultValue =
         defaultValue === BooleanOperationValueEnum.TRUE
         defaultValue === BooleanOperationValueEnum.TRUE
           ? BooleanOperationValueNameEnum.TRUE
           ? BooleanOperationValueNameEnum.TRUE
           : BooleanOperationValueNameEnum.FALSE;
           : BooleanOperationValueNameEnum.FALSE;
-    list.push({ operation, defaultValue });
+
+    list.push({ operation, defaultValue: isEnumsType ? enumsMap[defaultValue] : defaultValue });
   }
   }
   return list;
   return list;
 }
 }

@@ -77,6 +77,7 @@ function getTriggerValueTypeByThingsModelType(type: DataTypeEnum) {
     [DataTypeEnum.NUMBER_INT]: TriggerValueTypeEnum.NUMERIC,
     [DataTypeEnum.NUMBER_INT]: TriggerValueTypeEnum.NUMERIC,
     [DataTypeEnum.STRING]: TriggerValueTypeEnum.STRING,
     [DataTypeEnum.STRING]: TriggerValueTypeEnum.STRING,
     [DataTypeEnum.STRUCT]: TriggerValueTypeEnum.STRING,
     [DataTypeEnum.STRUCT]: TriggerValueTypeEnum.STRING,
+    [DataTypeEnum.ENUM]: TriggerValueTypeEnum.NUMERIC,
   };
   };
 
 
   return map[type];
   return map[type];
@@ -419,6 +420,7 @@ export const getFormSchemas = (
       colProps: { span: 24, xxl: 24, xl: 24, lg: 24, md: 24, sm: 24, xs: 24 },
       colProps: { span: 24, xxl: 24, xl: 24, lg: 24, md: 24, sm: 24, xs: 24 },
       ifShow: ({ model }) =>
       ifShow: ({ model }) =>
         model[FormFieldEnum.CONDITION_TYPE] === DeviceTriggerTypeEum.TIME_SERIES &&
         model[FormFieldEnum.CONDITION_TYPE] === DeviceTriggerTypeEum.TIME_SERIES &&
+        // model[FormFieldEnum.CONDITION_KEY_DETAIL] &&
         model[FormFieldEnum.CONDITION_KEY] &&
         model[FormFieldEnum.CONDITION_KEY] &&
         model[FormFieldEnum.CONDITION_VALUE_TYPE],
         model[FormFieldEnum.CONDITION_VALUE_TYPE],
       colSlot: 'conditionFilter',
       colSlot: 'conditionFilter',