Merge branch 'main_dev' into fengtao

@@ -6,6 +6,7 @@
   ],
   "cSpell.words": [
     "ACKS",
+    "Cascader",
     "clazz",
     "Cmds",
     "COAP",

 import { DeviceProfileModel } from '../../device/model/deviceModel';
-import { HistoryData } from './model';
+import { DeviceAttributeItemType, HistoryData } from './model';
 import { defHttp } from '/@/utils/http/axios';
 import { isString } from '/@/utils/is';
 import { OrderByEnum } from '/@/views/device/localtion/cpns/TimePeriodForm/config';
@@ -17,7 +17,7 @@ export const getDeviceHistoryInfo = (params: Recordable, orderBy = OrderByEnum.D
   return defHttp.get<HistoryData>(
     {
       url: `/plugins/telemetry/DEVICE/${params.entityId}/values/timeseries`,
-      params: { orderBy, ...params, entityId: null },
+      params: { ...params, entityId: null, orderBy },
     },
     {
       joinPrefix: false,
@@ -38,7 +38,7 @@ export const getDeviceDataKeys = (id: string) => {
 };
 // 获取设备状态，在线 or 离线时间
 export const getDeviceActiveTime = (entityId: string) => {
-  return defHttp.get(
+  return defHttp.get<DeviceAttributeItemType[]>(
     {
       url: `/plugins/telemetry/DEVICE/${entityId}/values/attributes?keys=active`,
     },

 export interface HistoryData {
   [key: string]: { ts: number; value: string }[];
 }
+
+export interface DeviceAttributeItemType {
+  key: string;
+  value: boolean;
+  lastUpdateTs: number;
+}

@@ -13,7 +13,7 @@ import { ChildDeviceParams } from './model/deviceModel';
 import { PaginationResult } from '/#/axios';
 import { AlarmLogItem } from './model/deviceConfigModel';
 import { omit } from 'lodash-es';
-import { CommandDeliveryWayEnum } from '/@/enums/toolEnum';
+import { CommandDeliveryWayEnum } from '/@/enums/deviceEnum';
 enum DeviceManagerApi {
   /**
    * 设备URL
@@ -137,7 +137,7 @@ export const createOrEditDevice = (data) => {
 
 // 查询设备详情
 export const getDeviceDetail = (id: string) => {
-  return defHttp.get({
+  return defHttp.get<DeviceRecord>({
     url: DeviceManagerApi.DEVICE_URL + `/${id}`,
   });
 };

 import { BasicPageParams } from '/@/api/model/baseModel';
+import { CommandTypeEnum, RPCCommandMethodEnum } from '/@/enums/deviceEnum';
 
 export type TDeviceConfigPageQueryParam = BasicPageParams & TDeviceConfigParams;
 
@@ -184,3 +185,10 @@ export interface Configuration {
 export interface TransportConfiguration {
   type: string;
 }
+
+export interface RpcCommandType {
+  additionalInfo: { cmdType: CommandTypeEnum };
+  method: RPCCommandMethodEnum;
+  params: Recordable | string | number;
+  persistent: boolean;
+}

 import { DataTypeEnum } from '/@/enums/objectModelEnum';
-import { FunctionType } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
+import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
 
 export interface Specs {
-  min: string;
-  max: string;
+  min: number;
+  max: number;
   unit: string;
   unitName: string;
 
   dataType?: string;
   name?: string;
-  value?: string;
-  step: string;
-  length: string;
+  value?: string | number;
+  step: number;
+  length: number;
   boolOpen: string;
   boolClose: string;
   valueRange?: {
-    min: string;
-    max: string;
+    min: number;
+    max: number;
   };
 }
 
@@ -26,17 +26,23 @@ export interface DataType {
   specsList?: Specs[];
 }
 
+export interface ExtensionDesc {
+  zoomFactor?: number;
+  actionType?: string;
+  dataType: string;
+  registerAddress: number;
+}
+
 export interface StructJSON {
-  functionName?: string;
+  functionName: string;
   identifier: string;
-  remark?: string;
   dataType?: DataType;
+  remark?: string;
   serviceCommand?: string;
-  accessMode?: string;
 }
 
 export interface FunctionJson {
-  dataType?: DataType | DataType[];
+  dataType?: DataType;
   inputData?: StructJSON[];
   outputData?: StructJSON[];
   serviceCommand?: string;
@@ -46,19 +52,19 @@ export interface ModelOfMatterParams {
   deviceProfileId?: string;
   functionJson: FunctionJson;
   functionName: string;
-  functionType: FunctionType;
+  functionType: FunctionTypeEnum;
   identifier: string;
-  remark: string;
+  remark?: string;
   id?: string;
   categoryId?: string;
   callType?: string;
   eventType?: string;
   accessMode?: string;
-  extensionDesc?: Recordable;
+  extensionDesc?: ExtensionDesc;
 }
 
 export interface GetModelTslParams {
-  functionType: FunctionType;
+  functionType: FunctionTypeEnum;
   deviceProfileId: string;
   ifShowClass?: string | Boolean;
 }
@@ -85,3 +91,26 @@ export interface ModelOfMatterItemRecordType {
   status: number;
   deviceProfileId: string;
 }
+
+export interface BatchGetObjectModelItemType {
+  id: string;
+  name: string;
+  transportType: string;
+  deviceType: string;
+  tsl: Tsl[];
+}
+
+export interface Tsl {
+  functionName: string;
+  identifier: string;
+  functionType: string;
+  accessMode?: string;
+  specs?: {
+    dataType: DataType;
+  };
+  extensionDesc: ExtensionDesc;
+  eventType?: string;
+  outputData?: StructJSON[];
+  callType?: string;
+  inputData?: StructJSON[];
+}

 import { BasicPageParams } from '../model/baseModel';
 import {
+  BatchGetObjectModelItemType,
   GetModelTslParams,
   ImportModelOfMatterType,
   ModelOfMatterItemRecordType,
   ModelOfMatterParams,
 } from './model/modelOfMatterModel';
+import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
 import { defHttp } from '/@/utils/http/axios';
-import { FunctionType } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
 
 enum ModelOfMatter {
   CREATE = '/things_model',
@@ -26,12 +27,14 @@ enum ModelOfMatter {
 
   IMPORT_CSV = '/things_model/csvImport',
   EXCEL_EXPORT = '/things_model/downloadTemplate',
+
+  BATCH_GET_TSL_BY_DEVICE_PROFILES = '/things_model/batch/get_tsl',
 }
 
 export const getModelList = (
   params: BasicPageParams & {
     deviceProfileId?: string;
-    functionTyp?: FunctionType;
+    functionTyp?: FunctionTypeEnum;
     nameOrIdentifier?: string;
     selectType?: string | undefined;
     id?: string;
@@ -181,3 +184,16 @@ export const excelExport = () => {
     responseType: 'blob',
   });
 };
+
+export const batchGetObjectModel = ({
+  deviceProfileIds,
+  functionTypeEnum = 'all',
+}: {
+  deviceProfileIds: string[];
+  functionTypeEnum?: FunctionTypeEnum | 'all';
+}) => {
+  return defHttp.post<BatchGetObjectModelItemType[]>({
+    url: ModelOfMatter.BATCH_GET_TSL_BY_DEVICE_PROFILES,
+    data: { deviceProfileIds, functionTypeEnum },
+  });
+};

@@ -59,7 +59,7 @@ export interface GenModbusCommandType {
   crc: string;
   deviceCode: string;
   method: string;
-  registerAddress: string;
+  registerAddress: number;
   registerNumber?: number;
   registerValues?: number[];
 }

@@ -2,7 +2,7 @@ import { withInstall } from '/@/utils';
 // @ts-ignore
 import codeEditor from './src/CodeEditor.vue';
 import jsonPreview from './src/json-preview/JsonPreview.vue';
-export { JSONEditor } from './src/JSONEditor';
+export { JSONEditor, JSONEditorValidator, parseStringToJSON } from './src/JSONEditor';
 
 export const CodeEditor = withInstall(codeEditor);
 export const JsonPreview = withInstall(jsonPreview);

@@ -11,18 +11,18 @@ export { default as RadioButtonGroup } from './src/components/RadioButtonGroup.v
 export { default as ApiTreeSelect } from './src/components/ApiTreeSelect.vue';
 export { default as ApiRadioGroup } from './src/components/ApiRadioGroup.vue';
 export { default as ApiUpload } from './src/components/ApiUpload.vue';
+export { default as ApiCascader } from './src/components/ApiCascader.vue';
 
-export { default as StructForm } from './src/externalCompns/components/StructForm/StructForm.vue';
 export { default as JavaScriptFunctionEditor } from './src/components/JavaScriptFunctionEditor.vue';
 
-export { ThingsModelForm } from './src/externalCompns/components/ThingsModelForm';
+export { ThingsModelForm } from './src/components/ThingsModelForm';
 
 //注册自定义组件
 export {
   JEasyCron,
   JEasyCronInner,
   JEasyCronModal,
-} from '/@/components/Form/src/externalCompns/components/JEasyCron';
+} from '/@/components/Form/src/components/JEasyCron';
 // Jeecg自定义校验
-export { JCronValidator } from '/@/components/Form/src/externalCompns/components/JEasyCron';
+export { JCronValidator } from '/@/components/Form/src/components/JEasyCron';
 // export { BasicForm };

@@ -29,20 +29,18 @@ import { IconPicker } from '/@/components/Icon';
 import { CountdownInput } from '/@/components/CountDown';
 import ApiRadioGroup from './components/ApiRadioGroup.vue';
 //自定义组件
-import JAddInput from './externalCompns/components/JAddInput.vue';
-import { JEasyCron } from './externalCompns/components/JEasyCron';
+import JAddInput from './components/JAddInput.vue';
+import { JEasyCron } from './components/JEasyCron';
 import ColorPicker from './components/ColorPicker.vue';
 import IconDrawer from './components/IconDrawer.vue';
 import ApiUpload from './components/ApiUpload.vue';
 import ApiSearchSelect from './components/ApiSearchSelect.vue';
-import CustomMinMaxInput from './externalCompns/components/CustomMinMaxInput.vue';
-import StructForm from './externalCompns/components/StructForm/StructForm.vue';
+import CustomMinMaxInput from './components/CustomMinMaxInput.vue';
 import ApiSelectScrollLoad from './components/ApiSelectScrollLoad.vue';
 import InputGroup from './components/InputGroup.vue';
 import RegisterAddressInput from '/@/views/task/center/components/PollCommandInput/RegisterAddressInput.vue';
-import ExtendDesc from '/@/components/Form/src/externalCompns/components/ExtendDesc/index.vue';
-import DeviceProfileForm from '/@/components/Form/src/externalCompns/components/DeviceProfileForm/index.vue';
-import EnumList from './externalCompns/components/StructForm/EnumList.vue';
+import DeviceProfileForm from '/@/components/Form/src/components/DeviceProfileForm/index.vue';
+import { Segmented } from './components/Segmented';
 
 const componentMap = new Map<ComponentType, Component>();
 
@@ -76,6 +74,7 @@ componentMap.set('TimePicker', TimePicker);
 componentMap.set('StrengthMeter', StrengthMeter);
 componentMap.set('IconPicker', IconPicker);
 componentMap.set('InputCountDown', CountdownInput);
+componentMap.set('Segmented', Segmented);
 
 componentMap.set('Upload', BasicUpload);
 //注册自定义组件
@@ -86,12 +85,9 @@ componentMap.set('IconDrawer', IconDrawer);
 componentMap.set('ApiUpload', ApiUpload);
 componentMap.set('ApiSearchSelect', ApiSearchSelect);
 componentMap.set('CustomMinMaxInput', CustomMinMaxInput);
-componentMap.set('StructForm', StructForm);
 componentMap.set('ApiSelectScrollLoad', ApiSelectScrollLoad);
 componentMap.set('InputGroup', InputGroup);
 componentMap.set('RegisterAddressInput', RegisterAddressInput);
-componentMap.set('ExtendDesc', ExtendDesc);
-componentMap.set('EnumList', EnumList);
 componentMap.set('DeviceProfileForm', DeviceProfileForm);
 
 export function add(compName: ComponentType, component: Component) {

+<script setup lang="ts">
+  import { Cascader } from 'ant-design-vue';
+  import { LoadingOutlined } from '@ant-design/icons-vue';
+  import { CascaderOptionType } from 'ant-design-vue/lib/cascader';
+  import { get } from 'lodash';
+  import { ref, unref, watch, watchEffect } from 'vue';
+  import { useRuleFormItem } from '/@/hooks/component/useFormItem';
+  import { useI18n } from '/@/hooks/web/useI18n';
+  import { isFunction } from '/@/utils/is';
+
+  const { t } = useI18n();
+
+  const props = withDefaults(
+    defineProps<{
+      value?: (string | number)[];
+      immediate?: boolean;
+      params?: any;
+      api?: Fn<any, Promise<any>>;
+      options?: CascaderOptionType[];
+      resultField?: string;
+      fieldNames?: Record<'label' | 'value' | 'children', string>;
+    }>(),
+    {
+      value: () => [],
+      immediate: true,
+      fieldNames: () => ({ label: 'label', value: 'value', children: 'children' }),
+    }
+  );
+
+  const emit = defineEmits(['change', 'options-change', 'update:value']);
+
+  const options = ref<CascaderOptionType[]>([]);
+  const loading = ref(false);
+  const isFirstLoad = ref(true);
+  const emitData = ref<any[]>([]);
+
+  // Embedded in the form, just use the hook binding to perform form verification
+  const [state] = useRuleFormItem(props, 'value', 'update:value', emitData);
+
+  watchEffect(() => {
+    props.immediate && fetch();
+  });
+
+  watch(
+    () => props.params,
+    () => {
+      !unref(isFirstLoad) && fetch();
+    },
+    { deep: true }
+  );
+
+  async function fetch() {
+    const api = props.api;
+    if (!api || !isFunction(api)) return;
+    options.value = [];
+    try {
+      loading.value = true;
+      const res = await api(props.params);
+      if (Array.isArray(res)) {
+        options.value = res;
+        emitChange();
+        return;
+      }
+      if (props.resultField) {
+        options.value = get(res, props.resultField) || [];
+      }
+      emitChange();
+    } catch (error) {
+      console.warn(error);
+    } finally {
+      loading.value = false;
+    }
+  }
+
+  async function handleFetch(open) {
+    if (open) {
+      await fetch();
+    }
+  }
+
+  function emitChange() {
+    emit('options-change', options);
+  }
+
+  function handleChange(_, ...args) {
+    emitData.value = args;
+  }
+</script>
+
+<template>
+  <Cascader
+    v-bind="$attrs"
+    @change="handleChange"
+    :fieldNames="fieldNames"
+    :options="options"
+    v-model:value="state"
+    @popupVisibleChange="handleFetch"
+  >
+    <template #notFoundContent v-if="loading">
+      <span>
+        <LoadingOutlined spin class="mr-1" />
+        {{ t('component.form.apiSelectNotFound') }}
+      </span>
+    </template>
+  </Cascader>
+</template>

@@ -4,17 +4,13 @@
       placeholder="最小值"
       :disabled="$props.disabled"
       :value="getValue.min!"
-      style="width: 38%"
       @change="(value) => emitChange(value, 'min')"
     />
-    <span style="width: 8px"></span>
-    <span>~</span>
-    <span style="width: 8px"></span>
+    <div class="text-center flex-shrink-0 w-6">~</div>
     <InputNumber
       placeholder="最大值"
       :disabled="$props.disabled"
       :value="getValue.max!"
-      style="width: 38%"
       @change="(value) => emitChange(value, 'max')"
     />
   </div>

+<script setup lang="ts">
+  import {
+    computed,
+    CSSProperties,
+    nextTick,
+    onBeforeUnmount,
+    ref,
+    TransitionProps,
+    unref,
+    watch,
+  } from 'vue';
+  import { addClass } from './styleClass';
+  import { ThumbReact } from './type';
+  import { removeClass } from '/@/utils/domUtils';
+
+  const calcThumbStyle = (targetElement: HTMLElement | null | undefined): ThumbReact =>
+    targetElement
+      ? {
+          left: targetElement.offsetLeft,
+          right:
+            (targetElement.parentElement!.clientWidth as number) -
+            targetElement.clientWidth -
+            targetElement.offsetLeft,
+          width: targetElement.clientWidth,
+        }
+      : null;
+
+  const toPX = (value?: number) => (value !== undefined ? `${value}px` : undefined);
+
+  const props = defineProps<{
+    value?: string | number;
+    getValueIndex: (value: string | number) => number;
+    containerRef?: HTMLDivElement;
+    prefixCls: string;
+    direction?: 'rtl' | 'ltr';
+    motionName: string;
+  }>();
+
+  const emits = defineEmits(['motionStart', 'motionEnd']);
+
+  const thumbRef = ref<HTMLDivElement>();
+
+  const findValueElement = (val: string | number) => {
+    const { getValueIndex, prefixCls } = props;
+    const index = getValueIndex(val);
+    const ele = unref(props.containerRef)?.querySelectorAll<HTMLDivElement>(`.${prefixCls}-item`)?.[
+      index
+    ];
+
+    return ele?.offsetParent && ele;
+  };
+
+  const prevStyle = ref<ThumbReact>(null);
+  const nextStyle = ref<ThumbReact>(null);
+
+  watch(
+    () => props.value,
+    (value, prevValue) => {
+      const prev = findValueElement(prevValue as number);
+      const next = findValueElement(value as number);
+
+      const calcPrevStyle = calcThumbStyle(prev);
+      const calcNextStyle = calcThumbStyle(next);
+
+      prevStyle.value = calcPrevStyle;
+      nextStyle.value = calcNextStyle;
+
+      prev && next ? emits('motionStart') : emits('motionEnd');
+    },
+    { flush: 'post' }
+  );
+
+  const thumbStart = computed(() => {
+    const { direction } = props;
+
+    return direction === 'rtl'
+      ? toPX(-(prevStyle.value?.right as number))
+      : toPX(prevStyle.value?.left as number);
+  });
+
+  const thumbActive = computed(() => {
+    const { direction } = props;
+
+    return direction === 'rtl'
+      ? toPX(-(nextStyle.value?.right as number))
+      : toPX(nextStyle.value?.left as number);
+  });
+
+  let timeId: any;
+  const onAppearStart: TransitionProps['onBeforeEnter'] = (el: HTMLDivElement) => {
+    clearTimeout(timeId);
+    nextTick(() => {
+      if (el) {
+        el.style.transform = `translateX(var(--thumb-start-left))`;
+        el.style.width = `var(--thumb-start-width)`;
+      }
+    });
+  };
+
+  const onAppearActive: TransitionProps['onEnter'] = (el: HTMLDivElement) => {
+    timeId = setTimeout(() => {
+      if (el) {
+        addClass(el, `${props.motionName}-appear-active`);
+        el.style.transform = `translateX(var(--thumb-active-left))`;
+        el.style.width = `var(--thumb-active-width)`;
+      }
+    });
+  };
+
+  const onAppearEnd: TransitionProps['onAfterEnter'] = (el: HTMLDivElement) => {
+    prevStyle.value = null;
+    nextStyle.value = null;
+    if (el) {
+      el.style.transform = '';
+      el.style.width = '';
+      removeClass(el, `${props.motionName}-appear-active`);
+    }
+    emits('motionEnd');
+  };
+
+  const mergedStyle = computed(
+    () =>
+      ({
+        '--thumb-start-left': thumbStart.value,
+        '--thumb-start-width': toPX(prevStyle.value?.width),
+        '--thumb-active-left': thumbActive.value,
+        '--thumb-active-width': toPX(nextStyle.value?.width),
+      } as CSSProperties)
+  );
+
+  onBeforeUnmount(() => {
+    clearTimeout(timeId);
+  });
+
+  const motionProps = computed(() => {
+    return {
+      ref: thumbRef,
+      style: mergedStyle.value,
+      class: `${props.prefixCls}-thumb`,
+    };
+  });
+</script>
+
+<template>
+  <Transition
+    appear
+    @before-enter="onAppearStart"
+    @enter="onAppearActive"
+    @after-enter="onAppearEnd"
+  >
+    <div v-if="prevStyle && nextStyle" v-bind="motionProps"></div>
+  </Transition>
+</template>

+<script setup lang="ts">
+  import { computed, ref } from 'vue';
+  import MotionThumb from './MotionThumb.vue';
+  import { SegmentedBaseOption, SegmentedOption } from './type';
+
+  const props = withDefaults(
+    defineProps<{
+      block?: boolean;
+      disabled?: boolean;
+      options?: string[] | number[] | SegmentedOption[];
+      value?: string | number;
+      motionName?: string;
+    }>(),
+    {
+      options: () => [],
+      motionName: 'thumb-motion',
+    }
+  );
+
+  const slots = defineSlots<{ label?(props: SegmentedBaseOption): any }>();
+
+  const prefixCls = 'segmented';
+
+  const thumbShow = ref(false);
+
+  const rootRef = ref<HTMLDivElement>();
+
+  const getOptions = computed<SegmentedBaseOption[]>(() => {
+    const { options } = props;
+    return (options as SegmentedOption[]).map((item) => {
+      return {
+        value: item?.value || item,
+        disabled: item?.disabled || false,
+        payload: item?.payload || {},
+        title: item?.title || item,
+        className: item?.className || '',
+      } as SegmentedBaseOption;
+    });
+  });
+
+  const emits = defineEmits(['change', 'update:value']);
+
+  const handleChange = (value: string | number) => {
+    emits('update:value', value);
+    emits('change', value);
+  };
+</script>
+
+<template>
+  <div :class="prefixCls" ref="rootRef">
+    <div :class="`${prefixCls}-group`">
+      <MotionThumb
+        :containerRef="rootRef"
+        :prefix-cls="prefixCls"
+        :value="value"
+        :motion-name="`${prefixCls}-${motionName}`"
+        direction="ltr"
+        :get-value-index="(val) => getOptions.findIndex((item) => item.value === val)"
+        @motion-start="thumbShow = true"
+        @motion-end="thumbShow = false"
+      />
+      <label
+        v-for="item in getOptions"
+        :key="item.value"
+        :class="[
+          `${prefixCls}-item`,
+          value === item.value && !thumbShow && `${prefixCls}-item-selected`,
+          (disabled || item.disabled) && `${prefixCls}-item-disabled`,
+        ]"
+        @click="!disabled && !item.disabled && handleChange(item.value)"
+      >
+        <input type="radio" class="absolute pointer-events-none w-0 h-0 opacity-0" />
+        <slot v-if="slots.label" name="label" v-bind="item"></slot>
+        <template v-else>
+          <div :class="`${prefixCls}-item-label`"> {{ item.title }}</div>
+        </template>
+      </label>
+    </div>
+  </div>
+</template>
+
+<style lang="less">
+  .segmented {
+    box-sizing: border-box;
+    padding: 2px;
+    color: #000000a6;
+    font-size: 14px;
+    display: inline-block;
+    border-radius: 4px;
+    background-color: #f5f5f5;
+    transition: all 0.2s cubic-bezier(0.645, 0.045, 0.355, 1);
+
+    &-block {
+      display: flex;
+    }
+
+    &-block.segmented-item {
+      flex: 1;
+    }
+
+    &-group {
+      position: relative;
+      display: flex;
+      align-items: stretch;
+      justify-content: flex-start;
+      width: 100%;
+      border-radius: inherit;
+      transition: color 0.2s cubic-bezier(0.645, 0.045, 0.355, 1);
+    }
+
+    &-item {
+      position: relative;
+      cursor: pointer;
+      border-radius: inherit;
+      text-align: center;
+      transition: color 0.2s cubic-bezier(0.645, 0.045, 0.355, 1);
+
+      &-label {
+        min-height: 28px;
+        line-height: 28px;
+        padding: 0 11px;
+        overflow: hidden;
+        white-space: nowrap;
+        text-overflow: ellipsis;
+      }
+
+      &::after {
+        content: '';
+        position: absolute;
+        width: 100%;
+        height: 100%;
+        top: 0;
+        inset-inline-start: 0;
+        border-radius: inherit;
+        transition: background-color 0.2s;
+      }
+
+      &:hover:not(.segmented-item-selected):not(.segmented-item-disabled) {
+        color: #000000e0;
+
+        &::after {
+          background-color: rgba(0, 0, 0, 0.06);
+        }
+      }
+
+      &-disabled {
+        cursor: not-allowed;
+        color: rgba(0, 0, 0, 0.25);
+      }
+
+      &-selected {
+        background-color: #fff;
+
+        ::after {
+          box-shadow: 0 1px 2px 0 rgba(0, 0, 0, 0.03), 0 1px 6px -1px rgba(0, 0, 0, 0.02),
+            0 2px 4px 0 rgba(0, 0, 0, 0.02);
+        }
+      }
+
+      &-selected:not(.segmented-item-disabled) {
+        color: rgba(0, 0, 0, 0.88);
+      }
+    }
+
+    &-thumb {
+      position: absolute;
+      inset-block-start: 0;
+      inset-inline-start: 0;
+      width: 0;
+      height: 100%;
+      background-color: #fff;
+
+      &-motion-appear-active {
+        transition: transform 0.3s cubic-bezier(0.645, 0.045, 0.355, 1),
+          width 0.3s cubic-bezier(0.645, 0.045, 0.355, 1);
+        will-change: transform, width;
+      }
+
+      & ~ .segmented-item:not(.segmented-item-selected):not(.segmented-item-disabled)::after {
+        background-color: transparent;
+      }
+    }
+  }
+</style>

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

+export function hasClass(node: HTMLElement, className: string) {
+  if (node.classList) {
+    return node.classList.contains(className);
+  }
+  const originClass = node.className;
+  return ` ${originClass} `.indexOf(` ${className} `) > -1;
+}
+
+export function addClass(node: HTMLElement, className: string) {
+  if (node.classList) {
+    node.classList.add(className);
+  } else {
+    if (!hasClass(node, className)) {
+      node.className = `${node.className} ${className}`;
+    }
+  }
+}

+export interface SegmentedBaseOption {
+  value: string | number;
+  disabled?: boolean;
+  payload?: any;
+  title?: string;
+  className?: string;
+}
+
+export interface SegmentedOption extends SegmentedBaseOption {
+  label?: VueNode | ((option: SegmentedBaseOption) => VueNode);
+}
+
+export type ThumbReact = {
+  left: number;
+  right: number;
+  width: number;
+} | null;

-import { FormSchema } from '../../../types/form';
+import { FormSchema } from '/@/components/Form';
 import { Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
 import { DataTypeEnum } from '/@/enums/objectModelEnum';
-import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
+import { validateTCPCustomCommand } from '.';
 
 export const getFormSchemas = ({
   structJSON: structJson,
@@ -127,6 +128,7 @@ export const getFormSchemas = ({
       label: functionName!,
       component: 'Input',
       changeEvent: 'update:value',
+      rules: [{ required: required, validator: () => Promise.resolve() }],
       componentProps: () => {
         return {
           inputData: dataType?.specs || [],
@@ -143,6 +145,7 @@ export const getFormSchemas = ({
       component: 'Input',
       required,
       defaultValue: serviceCommand,
+      rules: [{ validator: validateTCPCustomCommand }],
       componentProps: {
         placeholder: `请输入服务命令`,
       },

 <script setup lang="ts">
+  import {
+    ComponentPublicInstance,
+    computed,
+    nextTick,
+    reactive,
+    ref,
+    toRaw,
+    unref,
+    watch,
+  } from 'vue';
   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 { 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,
-    }
-  );
+  import { BasicForm, FormProps } from '/@/components/Form';
+  import { deepMerge } from '/@/utils';
+
+  interface ThingsModelFormPropsType {
+    value?: Recordable;
+    inputData?: StructJSON[];
+    required?: boolean;
+    title?: string;
+    transportType?: string;
+    disabled?: boolean;
+    identifier?: string;
+    formProps?: FormProps;
+  }
+
+  const props = withDefaults(defineProps<ThingsModelFormPropsType>(), {
+    inputData: () => [],
+    required: true,
+    formProps: () => ({}),
+  });
 
   const thingsModelFormListElMap = reactive<
     Record<string, { el: InstanceType<typeof ThingsModelForm>; structJSON: StructJSON }>
   >({});
 
+  const propsRef = ref<Partial<ThingsModelFormPropsType>>({});
+
+  const getProps = computed<ThingsModelFormPropsType>(
+    () => ({ ...props, ...unref(propsRef) } as ThingsModelFormPropsType)
+  );
+
   const [register, formActionType] = useForm({
-    schemas: getFormSchemas({
-      structJSON: props.inputData || [],
-      required: props.required,
-      transportType: props.transportType,
-    }),
-    showActionButtonGroup: false,
     layout: 'inline',
     labelWidth: 100,
+    ...toRaw(unref(getProps)),
+    schemas: getFormSchemasByProps(),
+    showActionButtonGroup: false,
   });
 
   const getStructFormItem = computed(() => {
-    const { inputData } = props;
-    return inputData.filter((item) => item.dataType?.type === DataTypeEnum.STRUCT);
+    const { inputData } = unref(getProps);
+    return (inputData || []).filter((item) => item.dataType?.type === DataTypeEnum.STRUCT);
   });
 
   const setFormElRef = (
@@ -87,7 +100,7 @@
   };
 
   watch(
-    () => props.value,
+    () => unref(getProps).value,
     async (value) => {
       await nextTick();
       formActionType.resetFields();
@@ -97,30 +110,36 @@
   );
 
   watch(
-    () => [props.inputData, props.identifier],
+    () => [unref(getProps).inputData, unref(getProps).identifier],
     (value) => {
-      if (value && value.length) {
-        const schemas = getFormSchemas({
-          structJSON: props.inputData || [],
-          required: props.required,
-          transportType: props.transportType,
-        });
-        formActionType.setProps({ schemas });
-      }
+      if (value && value.length) formActionType.setProps({ schemas: getFormSchemasByProps() });
     }
   );
 
   watch(
-    () => props.disabled,
+    () => unref(getProps).disabled,
     (value) => {
       formActionType.setProps({ disabled: value });
     }
   );
 
-  defineExpose<DefineComponentsBasicExpose>({
+  function getFormSchemasByProps() {
+    return getFormSchemas({
+      structJSON: unref(getProps).inputData || [],
+      required: unref(getProps).required,
+      transportType: unref(getProps).transportType,
+    });
+  }
+
+  function setProps(props: Partial<ThingsModelFormPropsType>) {
+    propsRef.value = deepMerge(unref(propsRef) || {}, props);
+  }
+
+  defineExpose({
     getFieldsValue,
     setFieldsValue,
     validate,
+    setProps,
   });
 </script>
 
@@ -155,6 +174,10 @@
       width: 100%;
     }
 
+    :deep(.ant-col.ant-form-item-control) {
+      min-height: auto;
+    }
+
     :deep(.ant-input-number) {
       width: 100%;
     }

-<script lang="ts" setup>
-  import { Card } from 'ant-design-vue';
-  import { computed, nextTick, onMounted, onUpdated, unref, watch } from 'vue';
-  import { BasicCreateFormParams } from './type';
-  import { DynamicProps } from '/#/utils';
-  import { Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
-  import { BasicForm, FormProps, FormSchema, useForm } from '/@/components/Form';
-  import { DataTypeEnum } from '/@/enums/objectModelEnum';
-  import { ReadAndWriteEnum } from '/@/enums/toolEnum';
-
-  const props = withDefaults(
-    defineProps<{
-      inputData?: StructJSON[];
-      formProps?: FormProps;
-      value?: Recordable;
-      required?: boolean;
-    }>(),
-    {
-      inputData: () => [] as StructJSON[],
-      formProps: () => ({}),
-      value: () => ({}),
-    }
-  );
-
-  const emit = defineEmits(['update:value']);
-
-  const getCurrentKeys = computed(() => {
-    const { inputData } = props;
-    return (inputData || []).map((item) => item.identifier);
-  });
-
-  const [register, { setProps, getFieldsValue, setFieldsValue }] = useForm({
-    schemas: [],
-    showActionButtonGroup: false,
-    layout: 'inline',
-    labelWidth: 80,
-    wrapperCol: { span: 12 },
-    ...(props.formProps || ({} as unknown as Partial<DynamicProps<FormProps>>)),
-  });
-
-  const syncValue = (key: string, value: any) => {
-    let record = getFieldsValue();
-    record = { ...record, [key]: value };
-    const setValues = {};
-    Object.keys(record).forEach((key) => {
-      const hasKey = unref(getCurrentKeys).includes(key);
-      if (hasKey) {
-        setValues[key] = record[key];
-      }
-    });
-    emit('update:value', setValues);
-  };
-
-  const createInputNumber = ({
-    identifier,
-    functionName,
-    specs,
-  }: BasicCreateFormParams): FormSchema => {
-    const { valueRange } = specs! as Partial<Specs>;
-    const { max = 2147483647, min = -2147483648 } = valueRange || {};
-    return {
-      field: identifier,
-      label: functionName,
-      component: 'InputNumber',
-      rules: [
-        {
-          required: props.required,
-          message: `${functionName}是必填项`,
-        },
-        {
-          type: 'number',
-          trigger: 'change',
-          validator: (_rule, value) => {
-            const reg = /^[0-9]*$/;
-            if (!reg.test(value)) return Promise.reject(`${functionName}不是一个有效的数字`);
-            if (value < min || value > max) {
-              return Promise.reject(`${functionName}取值范围在${min}~${max}之间`);
-            }
-            return Promise.resolve(value);
-          },
-        },
-      ],
-      componentProps: {
-        max,
-        min,
-        // step: step,
-        // formatter: (value: string) => value,
-        // parser: (string: string) => {
-        // if (dataType === DataTypeEnum.NUMBER_INT) {
-        //     return Number(Number(string).toFixed());
-        //   }
-        //   return Number(string);
-        // },
-        onChange: (value: string) => {
-          syncValue(identifier, value);
-        },
-      },
-    } as FormSchema;
-  };
-
-  const createInput = ({ identifier, functionName, specs }: BasicCreateFormParams): FormSchema => {
-    const { length = 10240 } = specs! as Partial<Specs>;
-    return {
-      field: identifier,
-      label: functionName,
-      component: 'Input',
-      rules: [
-        {
-          required: props.required,
-          message: `${functionName}是必填项`,
-        },
-        {
-          type: 'string',
-          trigger: 'change',
-          validator: (_rule, value) => {
-            if (value.length > length) {
-              return Promise.reject(`${functionName}数据长度应该小于${length}`);
-            }
-            return Promise.resolve(value);
-          },
-        },
-      ],
-      componentProps: {
-        maxLength: length,
-        onChange: (value: InputEvent) => {
-          syncValue(identifier, (value.target as HTMLInputElement).value);
-        },
-      },
-    } as FormSchema;
-  };
-
-  const createSelect = ({ identifier, functionName, specs }: BasicCreateFormParams): FormSchema => {
-    const { boolClose, boolOpen } = specs! as Partial<Specs>;
-    return {
-      field: identifier,
-      label: functionName,
-      component: 'Select',
-      rules: [
-        {
-          required: props.required,
-          message: `${functionName}是必填项`,
-          type: 'number',
-        },
-      ],
-      componentProps: {
-        options: [
-          { label: `${boolClose}-0`, value: 0 },
-          { label: `${boolOpen}-1`, value: 1 },
-        ],
-        onChange: (value: string) => {
-          syncValue(identifier, value);
-        },
-      },
-    };
-  };
-
-  const createInputJson = ({ identifier, functionName }: BasicCreateFormParams): FormSchema => {
-    return {
-      field: identifier,
-      label: functionName,
-      component: 'InputTextArea',
-      rules: [
-        {
-          required: props.required,
-          message: `${functionName}是必填项`,
-        },
-      ],
-      componentProps: {
-        onChange: (value: InputEvent) => {
-          syncValue(identifier, (value.target as HTMLInputElement).value);
-        },
-      },
-    };
-  };
-
-  const transformToFormSchema = (inputData: StructJSON[]) => {
-    const schemas: FormSchema[] = [];
-    for (const item of inputData) {
-      const { dataType, identifier, functionName, accessMode } = item;
-      if (accessMode === ReadAndWriteEnum.READ) {
-        continue;
-      }
-      const { type, specs } = dataType! || {};
-
-      const params: BasicCreateFormParams = {
-        identifier: identifier!,
-        functionName: functionName!,
-        dataType: dataType! as unknown as DataTypeEnum,
-        specs: specs as Partial<Specs>,
-      };
-      if (type === DataTypeEnum.NUMBER_INT || type === DataTypeEnum.NUMBER_DOUBLE) {
-        schemas.push(createInputNumber(params));
-      }
-
-      if (type === DataTypeEnum.BOOL) {
-        schemas.push(createSelect(params));
-      }
-
-      if (type === DataTypeEnum.STRING) {
-        schemas.push(createInput(params));
-      }
-
-      if (type === DataTypeEnum.STRUCT) {
-        schemas.push(createInputJson(params));
-      }
-    }
-
-    return schemas;
-  };
-
-  const generateSchemas = (value: StructJSON[]) => {
-    if (value && value.length) {
-      const schemas = transformToFormSchema(value);
-      setProps({ schemas });
-    }
-  };
-
-  onMounted(() => {
-    generateSchemas(props.inputData);
-  });
-
-  onUpdated(async () => {
-    if (props.inputData && props.inputData.length) {
-      await nextTick();
-      setFieldsValue(props.value || {});
-    }
-  });
-
-  watch(
-    () => props.inputData,
-    (value) => {
-      generateSchemas(value);
-    }
-  );
-
-  watch(
-    () => props.formProps,
-    (value) => {
-      setProps(value);
-    }
-  );
-</script>
-
-<template>
-  <Card bordered class="!border-dashed !rounded-lg !border-2px">
-    <!-- <Alert class="!mb-4 w-32" message="服务参数配置" type="info" /> -->
-    <BasicForm class="object-model-validate-form" @register="register" />
-  </Card>
-</template>
-
-<style lang="less">
-  .object-model-validate-form {
-    .ant-input-number {
-      width: 100% !important;
-    }
-  }
-</style>

-import { Specs } from '/@/api/device/model/modelOfMatterModel';
-import { DataTypeEnum } from '/@/enums/objectModelEnum';
-
-export interface BasicCreateFormParams {
-  identifier: string;
-  functionName: string;
-  dataType: DataTypeEnum;
-  specs: Partial<Specs>;
-}

-<script lang="ts">
-  export default {
-    inheritAttrs: false,
-  };
-</script>
-<script lang="ts" setup>
-  import StructFormModel from './StructFormModel.vue';
-  import { useModal } from '/@/components/Modal';
-  import { PlusOutlined } from '@ant-design/icons-vue';
-  import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
-  import { computed, unref } from 'vue';
-  import { buildUUID } from '/@/utils/uuid';
-  import { Divider, Button } from 'ant-design-vue';
-  import { OpenModalMode, OpenModalParams, StructRecord } from './type';
-  import { cloneDeep } from 'lodash-es';
-  import { isArray } from '/@/utils/is';
-  import { FormField } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
-  import { DataTypeEnum } from '/@/enums/objectModelEnum';
-
-  const emit = defineEmits(['update:value']);
-
-  const props = withDefaults(
-    defineProps<{
-      value: ModelOfMatterParams[];
-      disabled: boolean;
-      hasStructForm?: boolean;
-      hiddenAccessMode?: boolean;
-    }>(),
-    {
-      value: () => [],
-      hiddenAccessMode: false,
-      hasStructForm: false,
-    }
-  );
-
-  const getValue = computed<StructRecord[]>(() => {
-    const { value } = props;
-
-    return (isArray(value) ? value : []).map((item) => {
-      return {
-        ...(item as StructRecord),
-        ...((item as StructRecord).id ? {} : { id: buildUUID() }),
-      };
-    });
-  });
-
-  const [registerModal, { openModal }] = useModal();
-
-  const handleCreateParams = () => {
-    openModal(true, {
-      mode: OpenModalMode.CREATE,
-    } as OpenModalParams);
-  };
-
-  const handleUpdate = (value: StructRecord) => {
-    openModal(true, {
-      mode: OpenModalMode.UPDATE,
-      record: {
-        ...value,
-        [FormField.HAS_STRUCT_FROM]: value?.dataType?.type === DataTypeEnum.STRUCT,
-      },
-    } as OpenModalParams);
-  };
-
-  const handleDelete = (value: StructRecord) => {
-    const index = unref(getValue).findIndex((item) => item.id === value.id);
-    const _value = cloneDeep(unref(getValue));
-    _value.splice(index, 1);
-    emit('update:value', _value);
-  };
-
-  const handleSaveStruct = (mode: OpenModalMode, value: StructRecord) => {
-    const _value = cloneDeep(unref(getValue));
-
-    if (mode === OpenModalMode.UPDATE) {
-      const index = unref(getValue).findIndex((item) => item.id === value.id);
-      ~index && _value.splice(index, 1, value);
-    } else {
-      _value.push(value);
-    }
-
-    emit('update:value', _value);
-  };
-</script>
-
-<template>
-  <section>
-    <div class="text-blue-500 cursor-pointer">
-      <section>
-        <div
-          class="flex bg-blue-50 mb-2 p-2 text-gray-500 justify-between items-center"
-          v-for="item in getValue"
-          :key="item.id"
-        >
-          <div>参数名称: {{ item.functionName }}</div>
-          <div class="flex">
-            <Button class="!p-0" type="link" @click="handleUpdate(item)">
-              <span>{{ disabled ? '查看' : '编辑' }}</span>
-            </Button>
-            <Divider type="vertical" />
-            <Button :disabled="disabled" class="!p-0" type="link" @click="handleDelete(item)">
-              <span>删除</span>
-            </Button>
-          </div>
-        </div>
-      </section>
-      <div :class="$props.disabled && 'text-gray-400'">
-        <span class="mr-2">
-          <PlusOutlined />
-        </span>
-        <span @click="!disabled && handleCreateParams()">增加参数</span>
-      </div>
-    </div>
-    <StructFormModel
-      :has-struct-form="hasStructForm!"
-      :hidden-access-mode="hiddenAccessMode"
-      :disabled="disabled"
-      :value-list="getValue"
-      @register="registerModal"
-      @submit="handleSaveStruct"
-    />
-  </section>
-</template>
-
-<style lang="less" scoped></style>

-<script lang="ts">
-  export default {
-    inheritAttrs: false,
-  };
-</script>
-<script lang="ts" setup>
-  import { BasicForm, useForm } from '/@/components/Form';
-  import { formSchemas } from './config';
-  import { BasicModal, useModalInner } from '/@/components/Modal';
-  import { OpenModalMode, OpenModalParams, StructRecord } from './type';
-  import { computed, ref, unref } from 'vue';
-  import { transfromToStructJSON } from './util';
-  import { cloneDeep } from 'lodash-es';
-  import { DataType, StructJSON } from '/@/api/device/model/modelOfMatterModel';
-  import { isArray } from '/@/utils/is';
-  import { useMessage } from '/@/hooks/web/useMessage';
-  import EnumList from './EnumList.vue';
-  import { DataTypeEnum } from '/@/enums/objectModelEnum';
-
-  const modalReceiveRecord = ref<OpenModalParams>({
-    mode: OpenModalMode.CREATE,
-  });
-
-  const props = defineProps<{
-    disabled: boolean;
-    hasStructForm: boolean;
-    valueList: StructRecord[];
-    hiddenAccessMode: boolean;
-  }>();
-
-  const enumListRef = ref<InstanceType<typeof EnumList>>();
-
-  const emit = defineEmits(['register', 'submit']);
-
-  const { createMessage } = useMessage();
-
-  const [register, { validate, setFieldsValue, setProps }] = useForm({
-    labelWidth: 100,
-    actionColOptions: {
-      span: 14,
-    },
-    disabled: props.disabled,
-    showResetButton: false,
-    submitOnReset: false,
-    showActionButtonGroup: false,
-  });
-
-  const getFormSchemas = computed(() => {
-    const { hasStructForm, hiddenAccessMode } = props;
-    return formSchemas({
-      hasStructForm,
-      hiddenAccessMode,
-    });
-  });
-
-  const [registerModal, { closeModal }] = useModalInner((record: OpenModalParams) => {
-    modalReceiveRecord.value = record;
-    const data = record.record || {};
-    const { dataType = {} } = data! as StructJSON;
-    const { specs = {}, type, specsList } = dataType as DataType;
-
-    if (record.record) {
-      const value = {
-        type,
-        ...data,
-        ...(isArray(specs) ? { specs } : { ...specs }),
-        enumList: type === DataTypeEnum.ENUM ? specsList : [],
-      };
-
-      setFieldsValue(value);
-    }
-    setProps({ disabled: props.disabled });
-  });
-
-  const validateRepeat = (value: StructRecord, valueList: StructRecord[]) => {
-    return valueList.filter((item) => item.identifier === value.identifier).length >= 1;
-  };
-
-  const handleSubmit = async () => {
-    try {
-      const _value = await validate();
-      await unref(enumListRef)?.validate?.();
-      let structJSON = transfromToStructJSON(_value, unref(enumListRef)?.getFieldsValue?.() || []);
-      const value = {
-        ...structJSON,
-        ...(unref(modalReceiveRecord)?.record?.id
-          ? { id: unref(modalReceiveRecord)?.record?.id }
-          : {}),
-      };
-
-      if (
-        unref(modalReceiveRecord).mode === OpenModalMode.CREATE &&
-        validateRepeat(_value, props.valueList)
-      ) {
-        createMessage.error('存在一致的标识符');
-        return;
-      }
-      emit('submit', unref(modalReceiveRecord).mode, cloneDeep(value));
-      closeModal();
-    } catch (error) {}
-  };
-</script>
-
-<template>
-  <BasicModal
-    @register="registerModal"
-    :title="modalReceiveRecord.mode === OpenModalMode.CREATE ? '创建参数' : '编辑参数'"
-    :width="800"
-    @ok="handleSubmit"
-    destroy-on-close
-    :show-ok-btn="!$props.disabled"
-  >
-    <BasicForm @register="register" :schemas="getFormSchemas">
-      <template #EnumList="{ field, model }">
-        <EnumList ref="enumListRef" :value="model[field]" :disabled="disabled" />
-      </template>
-    </BasicForm>
-  </BasicModal>
-</template>
-
-<style lang="less" scoped></style>

-import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
-import { findDictItemByCode } from '/@/api/system/dict';
-import { Rule } from '/@/components/Form';
-import { FormSchema } from '/@/components/Table';
-import { DataTypeEnum } from '/@/enums/objectModelEnum';
-import { isNullOrUnDef } from '/@/utils/is';
-import { FormField } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
-
-export const validateValueRange = (_rule, value: Record<'min' | 'max', number>, _callback) => {
-  value = value || {};
-  const { min, max } = value;
-  if (min > max) {
-    return Promise.reject('最大值小于最小值');
-  }
-  return Promise.resolve();
-};
-
-export const validateJSON = (_rule, value = [] as ModelOfMatterParams[], _callback) => {
-  if (value.length) {
-    return Promise.resolve();
-  }
-  return Promise.reject('JSON对象不能为空');
-};
-
-interface StructFormSchemasParmasType {
-  hasStructForm: boolean;
-  hiddenAccessMode: boolean;
-  isTcp?: boolean;
-}
-
-//功能名称和标识符 输入框不能包含逗号
-const validateExcludeComma = (field: string, errorName: string): Rule[] => {
-  return [
-    {
-      required: true,
-      trigger: 'blur',
-      validator: () => {
-        const reg = /[,，]+/;
-        if (reg.test(field)) {
-          return Promise.reject(`${errorName}不能包含逗号`);
-        }
-        return Promise.resolve();
-      },
-    },
-  ];
-};
-
-export const formSchemas = ({
-  hasStructForm,
-  hiddenAccessMode,
-  isTcp = false,
-}: StructFormSchemasParmasType): FormSchema[] => {
-  return [
-    {
-      field: FormField.FUNCTION_NAME,
-      label: '功能名称',
-      required: true,
-      component: 'Input',
-      colProps: {
-        span: 18,
-      },
-      componentProps: {
-        maxLength: 32,
-        placeholder: '请输入功能名称',
-      },
-      dynamicRules: ({ values }) => {
-        return [
-          { required: true, message: '请输入功能名称' },
-          ...validateExcludeComma(values[FormField.FUNCTION_NAME], '功能名称'),
-        ];
-      },
-    },
-    {
-      field: FormField.IDENTIFIER,
-      label: '标识符',
-      required: true,
-      component: 'Input',
-      colProps: {
-        span: 18,
-      },
-      componentProps: {
-        maxLength: 128,
-        placeholder: '请输入标识符',
-      },
-      dynamicRules: ({ values }) => {
-        return [
-          { required: true, message: '请输入标识符' },
-          ...validateExcludeComma(values[FormField.IDENTIFIER], '标识符'),
-        ];
-      },
-    },
-    {
-      field: FormField.HAS_STRUCT_FROM,
-      label: '是否已存在结构体',
-      component: 'Input',
-      ifShow: false,
-    },
-    {
-      field: FormField.TYPE,
-      label: '数据类型',
-      required: true,
-      component: 'ApiSelect',
-      colProps: {
-        span: 9,
-      },
-      defaultValue: 'INT',
-      componentProps: ({ formActionType }) => {
-        const { setFieldsValue } = formActionType;
-        return {
-          placeholder: '请选择数据类型',
-          api: async (params: Recordable) => {
-            try {
-              const record = await findDictItemByCode(params);
-
-              if (isTcp) {
-                // TCP 产品 属性可创建范围
-                return record.filter((item) =>
-                  [
-                    DataTypeEnum.BOOL,
-                    DataTypeEnum.NUMBER_DOUBLE,
-                    DataTypeEnum.NUMBER_INT,
-                    DataTypeEnum.STRING,
-                  ].includes(item.itemValue as DataTypeEnum)
-                );
-              }
-
-              return hasStructForm
-                ? record.filter((item) => item.itemValue !== DataTypeEnum.STRUCT)
-                : record;
-            } catch (error) {
-              return [];
-            }
-          },
-          params: {
-            dictCode: 'data_type',
-          },
-          labelField: 'itemText',
-          valueField: 'itemValue',
-          getPopupContainer: () => document.body,
-          onChange: (value: string) => {
-            if (value == DataTypeEnum.STRUCT) {
-              setFieldsValue({ [FormField.SPECS_LIST]: [], [FormField.HAS_STRUCT_FROM]: true });
-            }
-          },
-        };
-      },
-    },
-    {
-      field: FormField.ENUM_LIST,
-      component: 'Input',
-      label: '枚举',
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.ENUM,
-      slot: 'EnumList',
-      colProps: {
-        span: 24,
-      },
-    },
-    {
-      field: FormField.VALUE_RANGE,
-      label: '取值范围',
-      component: 'CustomMinMaxInput',
-      valueField: 'value',
-      changeEvent: 'update:value',
-      colProps: {
-        span: 18,
-      },
-      ifShow: ({ values }) =>
-        values[FormField.TYPE] === DataTypeEnum.NUMBER_INT ||
-        values[FormField.TYPE] === DataTypeEnum.NUMBER_DOUBLE,
-      rules: [{ validator: validateValueRange }],
-    },
-    {
-      field: FormField.STEP,
-      label: '步长',
-      component: 'InputNumber',
-      colProps: {
-        span: 18,
-      },
-      componentProps: {
-        maxLength: 255,
-        placeholder: '请输入步长',
-        min: 1,
-        formatter: (value: number | string) => {
-          return value ? Math.floor(Number(value)) : value;
-        },
-      },
-      ifShow: ({ values }) =>
-        values[FormField.TYPE] === DataTypeEnum.NUMBER_INT ||
-        values[FormField.TYPE] === DataTypeEnum.NUMBER_DOUBLE,
-      dynamicRules: ({ model }) => {
-        const valueRange = model[FormField.VALUE_RANGE] || {};
-        const { min, max } = valueRange;
-        const step = model[FormField.STEP];
-        return [
-          {
-            validator: () => {
-              if ([min, max].every(isNullOrUnDef)) return Promise.resolve();
-              if (step > max - min) {
-                return Promise.reject('步长不能大于取值范围的差值');
-              }
-              return Promise.resolve();
-            },
-          },
-        ];
-      },
-    },
-    {
-      field: FormField.UNIT_NAME,
-      label: '单位名称',
-      component: 'Input',
-      show: false,
-    },
-    {
-      field: FormField.UNIT,
-      label: '单位',
-      component: 'ApiSelect',
-      colProps: {
-        span: 9,
-      },
-      componentProps: ({ formActionType }) => {
-        const { setFieldsValue } = formActionType;
-        return {
-          placeholder: '请选择单位',
-          api: async (params) => {
-            const list = await findDictItemByCode(params);
-            list.map((item) => (item.itemText = `${item.itemText} / ${item.itemValue}`));
-            return list;
-          },
-          params: {
-            dictCode: 'attribute_unit',
-          },
-          labelInValue: true,
-          labelField: 'itemText',
-          valueField: 'itemValue',
-          onChange(_, record: Record<'label' | 'value', string>) {
-            if (record) {
-              const { label } = record;
-              setFieldsValue({ [FormField.UNIT_NAME]: label });
-            }
-          },
-          getPopupContainer: () => document.body,
-          showSearch: true,
-          filterOption: (inputValue: string, option: Record<'label' | 'value', string>) => {
-            let { label, value } = option;
-            label = label.toLowerCase();
-            value = value.toLowerCase();
-            inputValue = inputValue.toLowerCase();
-            return label.includes(inputValue) || value.includes(inputValue);
-          },
-        };
-      },
-      ifShow: ({ values }) =>
-        values[FormField.TYPE] === DataTypeEnum.NUMBER_INT ||
-        values[FormField.TYPE] === DataTypeEnum.NUMBER_DOUBLE,
-    },
-    {
-      field: FormField.BOOL_CLOSE,
-      component: 'Input',
-      required: true,
-      label: '0 -',
-      colProps: {
-        span: 18,
-      },
-      componentProps: {
-        placeholder: '如：关',
-      },
-      defaultValue: '关',
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.BOOL,
-      dynamicRules: ({ model }) => {
-        const close = model[FormField.BOOL_CLOSE];
-        const open = model[FormField.BOOL_OPEN];
-        return [
-          {
-            required: true,
-          },
-          {
-            validator() {
-              if (open === close) return Promise.reject('布尔值不能相同');
-              return Promise.resolve();
-            },
-          },
-        ];
-      },
-    },
-    {
-      field: FormField.BOOL_OPEN,
-      component: 'Input',
-      required: true,
-      label: '1 -',
-      colProps: {
-        span: 18,
-      },
-      componentProps: {
-        placeholder: '如：开',
-      },
-      defaultValue: '开',
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.BOOL,
-      dynamicRules: ({ model }) => {
-        const close = model[FormField.BOOL_CLOSE];
-        const open = model[FormField.BOOL_OPEN];
-        return [
-          {
-            required: true,
-          },
-          {
-            validator() {
-              if (open === close) return Promise.reject('布尔值不能相同');
-              return Promise.resolve();
-            },
-          },
-        ];
-      },
-    },
-    {
-      field: FormField.LENGTH,
-      component: 'Input',
-      required: true,
-      label: '数据长度',
-      defaultValue: '10240',
-      colProps: {
-        span: 8,
-      },
-      componentProps: {
-        placeholder: '请输入数据长度',
-      },
-      renderComponentContent: () => {
-        return {
-          suffix: () => '字节',
-        };
-      },
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.STRING,
-    },
-    {
-      field: FormField.EXTENSION_DESC,
-      component: 'ExtendDesc',
-      label: '扩展描述',
-      valueField: 'value',
-      changeEvent: 'update:value',
-      ifShow: isTcp,
-      colProps: {
-        span: 16,
-      },
-      componentProps: ({ formModel }) => {
-        return {
-          dataType: formModel[FormField.TYPE],
-        };
-      },
-    },
-    {
-      field: FormField.ACCESS_MODE,
-      component: 'ApiRadioGroup',
-      label: '读写类型',
-      required: true,
-      colProps: {
-        span: 24,
-      },
-      ifShow: () => !hiddenAccessMode && !hasStructForm,
-      defaultValue: 'r',
-      componentProps: {
-        placeholder: '请选择读写类型',
-        api: findDictItemByCode,
-        params: {
-          dictCode: 'read_write_type',
-        },
-        labelField: 'itemText',
-        valueField: 'itemValue',
-      },
-    },
-    {
-      field: FormField.SPECS_LIST,
-      label: 'JSON对象',
-      component: 'StructForm',
-      valueField: 'value',
-      changeEvent: 'update:value',
-      colProps: { span: 24 },
-      ifShow: ({ values }) => values[FormField.TYPE] === DataTypeEnum.STRUCT,
-      rules: [{ required: true, validator: validateJSON }],
-      componentProps: ({ formModel }) => {
-        return {
-          hasStructForm: formModel[FormField.HAS_STRUCT_FROM],
-        };
-      },
-    },
-    {
-      field: FormField.REFARK,
-      label: '备注',
-      component: 'InputTextArea',
-      componentProps: {
-        rows: 4,
-        maxLength: 100,
-        placeholder: '请输入描述',
-      },
-    },
-  ];
-};

-import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
-import { DataTypeEnum } from '/@/enums/objectModelEnum';
-import { FormField } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
-
-export enum OpenModalMode {
-  CREATE = 'create',
-  UPDATE = 'update',
-}
-
-export interface OpenModalParams {
-  mode: OpenModalMode;
-  record?: StructRecord;
-}
-
-export interface StructFormValue
-  extends Partial<Record<Exclude<FormField, FormField.VALUE_RANGE | FormField.STRUCT>, string>> {
-  [FormField.TYPE]: DataTypeEnum;
-  [FormField.VALUE_RANGE]?: {
-    [FormField.MIN]: string;
-    [FormField.MAX]: string;
-  };
-  [FormField.STRUCT]: StructRecord[];
-}
-
-export interface StructRecord extends StructJSON {
-  id: string;
-}

-import { cloneDeep } from 'lodash-es';
-import { StructFormValue } from './type';
-import {
-  DataType,
-  ModelOfMatterParams,
-  Specs,
-  StructJSON,
-} from '/@/api/device/model/modelOfMatterModel';
-import { isArray } from '/@/utils/is';
-import { DataTypeEnum } from '/@/enums/objectModelEnum';
-
-export function transfromToStructJSON(value: StructFormValue, enumList: Specs[] = []): StructJSON {
-  const {
-    type,
-    valueRange,
-    step,
-    length = '',
-    boolClose,
-    boolOpen,
-    unit,
-    unitName,
-    functionName,
-    identifier,
-    remark,
-    specs,
-    accessMode,
-  } = value;
-  const basic = { functionName, identifier, remark, accessMode };
-  let dataType = {} as unknown as DataType;
-
-  switch (type) {
-    case DataTypeEnum.NUMBER_INT:
-      dataType = {
-        type,
-        specs: { valueRange, step, unit, unitName },
-      };
-      break;
-
-    case DataTypeEnum.NUMBER_DOUBLE:
-      dataType = {
-        type,
-        specs: { valueRange, step, unit, unitName },
-      };
-      break;
-
-    case DataTypeEnum.BOOL:
-      dataType = {
-        type,
-        specs: {
-          boolOpen: boolOpen,
-          boolClose: boolClose,
-        },
-      };
-      break;
-
-    case DataTypeEnum.STRING:
-      dataType = {
-        type,
-        specs: { length },
-      };
-      break;
-
-    case DataTypeEnum.ENUM:
-      dataType = {
-        type,
-        specsList: enumList,
-      };
-      break;
-
-    case DataTypeEnum.STRUCT:
-      dataType = {
-        type,
-        specs: specs! as unknown as ModelOfMatterParams[],
-      };
-      break;
-  }
-  return { ...basic, dataType } as StructJSON;
-}
-
-export const excludeIdInStructJSON = (struct: DataType) => {
-  const _value = cloneDeep(struct);
-  const { specs } = _value;
-  if (!specs) return _value;
-  const list = [specs];
-
-  while (list.length) {
-    for (const item of list) {
-      if (isArray(item)) {
-        (item as StructJSON[]).forEach((temp) => {
-          if (temp.dataType?.specs) {
-            list.push(temp.dataType.specs);
-          }
-          Reflect.has(temp, 'id') && Reflect.deleteProperty(temp, 'id');
-        });
-      } else {
-        Reflect.has(item as Recordable, 'id') && Reflect.deleteProperty(item as Recordable, 'id');
-      }
-      list.shift();
-    }
-  }
-
-  return _value;
-};

@@ -117,12 +117,12 @@ export type ComponentType =
   | 'ColorPicker'
   | 'IconDrawer'
   | 'ApiUpload'
+  | 'ApiCascader'
   | 'ApiSearchSelect'
   | 'StructForm'
   | 'ApiSelectScrollLoad'
   | 'TransferModal'
   | 'TransferTableModal'
-  | 'ObjectModelValidateForm'
   | 'ThingsModelForm'
   | 'DevicePicker'
   | 'ProductPicker'
@@ -145,4 +145,6 @@ export type ComponentType =
   | 'TriggerDurationInput'
   | 'AlarmProfileSelect'
   | 'LockControlGroup'
-  | 'EnumList';
+  | 'EnumList'
+  | 'Segmented'
+  | 'StructFormItem';

+export enum TransportTypeEnum {
+  DEFAULT = 'DEFAULT',
+  MQTT = 'MQTT',
+  COAP = 'COAP',
+  LWM2M = 'LWM2M',
+  SNMP = 'SNMP',
+  TCP = 'TCP',
+}
+
+export enum ReadAndWriteEnum {
+  READ = 'r',
+  READ_AND_WRITE = 'rw',
+}
+
+export enum ServiceCallTypeEnum {
+  ASYNC = 'ASYNC',
+  SYNC = 'SYNC',
+}
+
+export enum ServiceCallTypeNameEnum {
+  ASYNC = '异步',
+  SYNC = '同步',
+}
+
+export enum CommandDeliveryWayEnum {
+  ONE_WAY = 'oneway',
+  TWO_WAY = 'twoway',
+}
+
+export enum CommandDeliveryWayNameEnum {
+  ONE_WAY = '单向',
+  TWO_WAY = '双向',
+}
+
+export enum CommandTypeEnum {
+  CUSTOM = 0,
+  SERVICE = 1,
+  ATTRIBUTE = 2,
+  API = 'api',
+}
+
+export enum CommandTypeNameEnum {
+  CUSTOM = '自定义',
+  SERVICE = '服务',
+  ATTRIBUTE = '属性',
+}
+
+export enum RPCCommandMethodEnum {
+  THINGSKIT = 'methodThingskit',
+}

 export enum DictEnum {
+  // 物模型数据类型
+  DATA_TYPE = 'data_type',
+
+  // 事件类型
+  EVENT_TYPE = 'event_type',
+  // 物模型单位
+  ATTRIBUTE_UNIT = 'attribute_unit',
+  // 物模型读写类型
+  READ_WRITE_TYP = 'read_write_type',
   // 从机地址
   SLAVE_ADDRESS = 'slave_address',
   // 功能码

@@ -154,16 +154,3 @@ export enum ExecutionActionNameEnum {
   DEVICE_OUT = '设备输出',
   MSG_NOTIFY = '告警输出',
 }
-
-export enum CommandTypeEnum {
-  CUSTOM = 0,
-  SERVICE = 1,
-  ATTRIBUTE = 2,
-  API = 'api',
-}
-
-export enum CommandTypeNameEnum {
-  CUSTOM = '自定义',
-  SERVICE = '服务',
-  ATTRIBUTE = '属性',
-}

@@ -7,6 +7,30 @@ export enum DataTypeEnum {
   ENUM = 'ENUM',
 }
 
+export enum FunctionTypeEnum {
+  PROPERTIES = 'properties',
+  SERVICE = 'services',
+  EVENTS = 'events',
+}
+
+export enum FunctionTypeNameEnum {
+  PROPERTIES = '属性',
+  SERVICE = '服务',
+  EVENTS = '事件',
+}
+
+export enum ObjectEventTypeEnum {
+  INFO = 'INFO',
+  ALERT = 'ALERT',
+  ERROR = 'ERROR',
+}
+
+export enum ObjectEventTypeNameEnum {
+  INFO = '信息',
+  ALERT = '告警',
+  ERROR = '故障',
+}
+
 export enum RegisterDataTypeEnum {
   UN_SHORT = 'unshort',
 }
@@ -26,3 +50,12 @@ export enum RegisterActionTypeNameEnum {
   INT = '06写入单个保持寄存器',
   DOUBLE = '16写入多个保持寄存器',
 }
+
+export enum ObjectModelAccessModeEnum {
+  READ = 'r',
+  READ_AND_WRITE = 'rw',
+}
+
+export enum ModbusCRCEnum {
+  CRC_16_LOWER = 'CRC_16_LOWER',
+}

@@ -29,23 +29,3 @@ export enum BooleanStringEnum {
   TRUE = 'true',
   FALSE = 'false',
 }
-
-export enum ReadAndWriteEnum {
-  READ = 'r',
-  READ_AND_WRITE = 'rw',
-}
-
-export enum ServiceCallTypeEnum {
-  ASYNC = 'ASYNC',
-  SYNC = 'SYNC',
-}
-
-export enum ServiceCallTypeNameEnum {
-  ASYNC = '异步',
-  SYNC = '同步',
-}
-
-export enum CommandDeliveryWayEnum {
-  ONE_WAY = 'oneway',
-  TWO_WAY = 'twoway',
-}

@@ -6,6 +6,7 @@
     :title="getTitle"
     width="30%"
     @ok="handleSubmit"
+    wrapClassName="camera-configration-drawer"
   >
     <BasicForm @register="registerForm">
       <template #videoPlatformIdSlot="{ model, field }">
@@ -125,7 +126,11 @@
             });
           }
 
-          setFieldsValue({ ...record, videoType: record.videoPlatformDTO?.type });
+          setFieldsValue({
+            ...record,
+            videoType: record.videoPlatformDTO?.type,
+            ...(record?.params || {}),
+          });
         } else {
           editId.value = '';
         }
@@ -157,6 +162,7 @@
           ) {
             values.streamType = values.articulation;
             values.playProtocol = values.videoFormat;
+            values.params = values.channelNo ? { channelNo: values.channelNo } : null;
           }
 
           await createOrEditCameraManage(values);
@@ -190,3 +196,11 @@
     },
   });
 </script>
+
+<style lang="less">
+  .camera-configration-drawer {
+    .ant-input-number {
+      width: 100% !important;
+    }
+  }
+</style>

@@ -21,11 +21,6 @@ export enum CameraPermission {
   DELETE = 'api:yt:video:delete',
 }
 
-export enum VideoPlatformEnum {
-  HAIKANG = 0,
-  FLUORITE = 1,
-}
-
 export enum AccessMode {
   ManuallyEnter = 0,
   Streaming = 1,
@@ -250,16 +245,28 @@ export const formSchema: QFormSchema[] = [
     required: true,
     defaultValue: VideoPlatformEnum.SCI,
     ifShow: ({ values }) => values.accessMode === AccessMode.Streaming,
-    componentProps: {
-      api: async (params) => {
-        const values = await findDictItemByCode(params);
-        return values.map((item) => ({ label: item.itemText, value: Number(item.itemValue) }));
-      },
-      params: {
-        dictCode: DictEnum.STREAMING_MEDIA_TYPE,
-      },
-      getPopupContainer: () => document.body,
-      placeholder: `请选择平台类型`,
+    componentProps: ({ formActionType }) => {
+      return {
+        api: async (params) => {
+          const values = await findDictItemByCode(params);
+          return values.map((item) => ({ label: item.itemText, value: Number(item.itemValue) }));
+        },
+        params: {
+          dictCode: DictEnum.STREAMING_MEDIA_TYPE,
+        },
+        getPopupContainer: () => document.body,
+        placeholder: `请选择平台类型`,
+        onChange() {
+          const { setFieldsValue } = formActionType;
+          setFieldsValue({
+            articulation: ArticulationEnumType.HIGH_DEFINITION,
+            playProtocol: PlayProtocol.HTTP,
+            sn: null,
+            channelNo: null,
+            videoPlatformId: null,
+          });
+        },
+      };
     },
   },
   {
@@ -384,4 +391,22 @@ export const formSchema: QFormSchema[] = [
       placeholder: '请输入监控点编号',
     },
   },
+  {
+    field: 'channelNo',
+    label: '通道号',
+    component: 'InputNumber',
+    ifShow({ values }) {
+      return (
+        values.accessMode === AccessMode.Streaming &&
+        values.videoType === VideoPlatformEnum.FLUORITE
+      );
+    },
+    componentProps: {
+      min: 1,
+      max: 10000,
+      step: 1,
+      placeholder: '请输入通道号',
+      precision: 0,
+    },
+  },
 ];

-import { FormProps, FormSchema, useComponentRegister } from '/@/components/Form';
+import { FormSchema, useComponentRegister } from '/@/components/Form';
 import { findDictItemByCode } from '/@/api/system/dict';
 import { getGatewayDevice, queryDeviceProfileBy } from '/@/api/device/deviceManager';
-import { TransportTypeEnum } from '../../profiles/components/TransportDescript/const';
-import { JSONEditorValidator } from '/@/components/CodeEditor/src/JSONEditor';
 import { JSONEditor } from '/@/components/CodeEditor';
 import { DeviceRecord, DeviceTypeEnum } from '/@/api/device/model/deviceModel';
-import { getModelServices } from '/@/api/device/modelOfMatter';
-import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
-import { h, toRaw, unref } from 'vue';
-import ObjectModelValidateForm from '/@/components/Form/src/externalCompns/components/ObjectModelValidateForm/ObjectModelValidateForm.vue';
-import { CommandDeliveryWayEnum, ServiceCallTypeEnum } from '/@/enums/toolEnum';
+import { h } from 'vue';
 import { TaskTypeEnum } from '/@/views/task/center/config';
 import { AddressTypeEnum } from '/@/views/task/center/components/PollCommandInput';
 import { FileItem } from '/@/components/Form/src/components/ApiUpload.vue';
@@ -17,9 +11,9 @@ import { createImgPreview } from '/@/components/Preview';
 import { uploadThumbnail } from '/@/api/configuration/center/configurationCenter';
 import LockControlGroup from '/@/components/Form/src/components/LockControlGroup.vue';
 import { OrgTreeSelect } from '/@/views/common/OrgTreeSelect';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
 
 useComponentRegister('JSONEditor', JSONEditor);
-useComponentRegister('ObjectModelValidateForm', ObjectModelValidateForm);
 useComponentRegister('LockControlGroup', LockControlGroup);
 useComponentRegister('OrgTreeSelect', OrgTreeSelect);
 
@@ -910,214 +904,3 @@ export const TokenSchemas: FormSchema[] = [
     },
   },
 ];
-
-export enum ValueType {
-  JSON = 'json',
-  STRING = 'string',
-}
-
-export enum CommandFieldsEnum {
-  COMMAND_TYPE = 'commandType',
-  VALUE_TYPE = 'valueType',
-  COMMAND_TEXT = 'commandText',
-  COMAND_VALUE = 'commandValue',
-  SERVICE = 'service',
-  SERVICE_TYPE = 'service_type',
-  TCP_SERVICE = 'tcpService',
-  MODEL_INPUT = 'modelInput',
-  CUSTOM_TYPE = 'customType',
-}
-
-export enum CommandType {
-  CUSTOM = 'custom',
-  SERVICE = 'service',
-}
-
-export const CommandSchemas = (
-  transportType: TransportTypeEnum,
-  deviceProfileId: string
-): FormSchema[] => {
-  return [
-    {
-      field: CommandFieldsEnum.COMMAND_TYPE,
-      component: 'RadioGroup',
-      label: '下发类型',
-      defaultValue: CommandType.CUSTOM,
-      componentProps: ({ formActionType }) => {
-        const { setFieldsValue } = formActionType;
-        return {
-          options: [
-            { label: '自定义', value: CommandType.CUSTOM },
-            { label: '服务', value: CommandType.SERVICE },
-          ],
-          onChange() {
-            setFieldsValue({
-              [CommandFieldsEnum.SERVICE]: null,
-              [CommandFieldsEnum.MODEL_INPUT]: null,
-              [CommandFieldsEnum.COMAND_VALUE]: null,
-              [CommandFieldsEnum.COMMAND_TEXT]: null,
-            });
-          },
-        };
-      },
-    },
-    {
-      field: CommandFieldsEnum.CUSTOM_TYPE,
-      component: 'RadioGroup',
-      label: '单向/双向',
-      defaultValue: CommandDeliveryWayEnum.ONE_WAY,
-      ifShow: ({ model }) => model[CommandFieldsEnum.COMMAND_TYPE] === CommandType.CUSTOM,
-      componentProps: {
-        options: [
-          {
-            label: '单向',
-            value: CommandDeliveryWayEnum.ONE_WAY,
-          },
-          {
-            label: '双向',
-            value: CommandDeliveryWayEnum.TWO_WAY,
-          },
-        ],
-      },
-    },
-    {
-      field: CommandFieldsEnum.VALUE_TYPE,
-      label: '命令类型',
-      component: 'RadioGroup',
-      ifShow: ({ model }) => model[CommandFieldsEnum.COMMAND_TYPE] === CommandType.CUSTOM,
-      defaultValue: transportType === TransportTypeEnum.TCP ? ValueType.STRING : ValueType.JSON,
-      componentProps: () => {
-        const options: Record<'label' | 'value', string>[] = [];
-        if (transportType === TransportTypeEnum.TCP) {
-          options.push({ label: '字符串', value: ValueType.STRING });
-        } else {
-          options.push({ label: 'JSON', value: ValueType.JSON });
-        }
-        return {
-          options,
-        };
-      },
-    },
-    {
-      field: CommandFieldsEnum.COMMAND_TEXT,
-      label: '命令',
-      ifShow: ({ model }) =>
-        model[CommandFieldsEnum.VALUE_TYPE] === ValueType.STRING &&
-        model[CommandFieldsEnum.COMMAND_TYPE] === CommandType.CUSTOM,
-      component: 'InputTextArea',
-      componentProps: {
-        autoSize: {
-          minRows: 3,
-        },
-        placeholder: '请输入命令内容',
-      },
-      dynamicRules: () => {
-        return [
-          {
-            required: false,
-            validator: (_, value) => {
-              const zg = /^[0-9a-zA-Z]*$/;
-              if (!zg.test(value)) {
-                return Promise.reject('输入的内容只能是字母和数字的组合');
-              } else {
-                return Promise.resolve();
-              }
-            },
-          },
-        ];
-      },
-    },
-    {
-      field: CommandFieldsEnum.COMAND_VALUE,
-      label: '命令',
-      component: 'JSONEditor',
-      colProps: { span: 20 },
-      changeEvent: 'update:value',
-      valueField: 'value',
-      rules: [...JSONEditorValidator()],
-      ifShow: ({ model }) =>
-        model[CommandFieldsEnum.VALUE_TYPE] === ValueType.JSON &&
-        model[CommandFieldsEnum.COMMAND_TYPE] === CommandType.CUSTOM,
-
-      componentProps: {
-        height: 250,
-      },
-    },
-    {
-      field: CommandFieldsEnum.SERVICE,
-      label: '服务',
-      component: 'ApiSelect',
-      ifShow: ({ model }) => model[CommandFieldsEnum.COMMAND_TYPE] !== CommandType.CUSTOM,
-      rules: [{ required: true, message: '请选择服务' }],
-      componentProps: ({ formActionType }) => {
-        const { setFieldsValue, updateSchema } = formActionType;
-        return {
-          api: async () => {
-            try {
-              const result = await getModelServices({ deviceProfileId });
-              return result || [];
-            } catch (error) {
-              return [];
-            }
-          },
-          valueField: 'identifier',
-          labelField: 'functionName',
-          getPopupContainer: () => document.body,
-          onChange(value: string, options: ModelOfMatterParams) {
-            if (!value) return;
-
-            const setValues = {
-              [CommandFieldsEnum.CUSTOM_TYPE]:
-                options.callType === ServiceCallTypeEnum.ASYNC
-                  ? CommandDeliveryWayEnum.ONE_WAY
-                  : CommandDeliveryWayEnum.TWO_WAY,
-              [CommandFieldsEnum.MODEL_INPUT]: null,
-            };
-
-            if (transportType !== TransportTypeEnum.TCP) {
-              updateSchema({
-                field: CommandFieldsEnum.MODEL_INPUT,
-                componentProps: {
-                  inputData: toRaw(unref(options.functionJson.inputData)),
-                },
-              });
-            } else {
-              Object.assign(setValues, {
-                [CommandFieldsEnum.TCP_SERVICE]:
-                  options.functionJson?.inputData?.[0]?.serviceCommand,
-              });
-            }
-
-            setFieldsValue(setValues);
-          },
-        };
-      },
-    },
-    {
-      field: CommandFieldsEnum.TCP_SERVICE,
-      component: 'Input',
-      label: '命令',
-      dynamicDisabled: true,
-      ifShow: ({ model }) =>
-        model[CommandFieldsEnum.SERVICE] &&
-        transportType === TransportTypeEnum.TCP &&
-        model[CommandFieldsEnum.COMMAND_TYPE] !== CommandType.CUSTOM,
-    },
-    {
-      field: CommandFieldsEnum.MODEL_INPUT,
-      component: 'ObjectModelValidateForm',
-      label: '输入参数',
-      changeEvent: 'update:value',
-      valueField: 'value',
-      ifShow: ({ model }) =>
-        model[CommandFieldsEnum.SERVICE] &&
-        transportType !== TransportTypeEnum.TCP &&
-        model[CommandFieldsEnum.COMMAND_TYPE] !== CommandType.CUSTOM,
-      componentProps: {
-        formProps: {
-          wrapperCol: { span: 24 },
-        } as FormProps,
-      },
-    },
-  ];
-};

@@ -5,8 +5,8 @@ import { DeviceRecord, DeviceTypeEnum } from '/@/api/device/model/deviceModel';
 import { findDictItemByCode } from '/@/api/system/dict';
 import { FormSchema, useComponentRegister } from '/@/components/Form';
 import { BasicColumn } from '/@/components/Table';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
 import { OrgTreeSelect } from '/@/views/common/OrgTreeSelect';
-import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
 import XLSX, { CellObject } from 'xlsx';
 
 useComponentRegister('OrgTreeSelect', OrgTreeSelect);

+import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
+import { getModelServices } from '/@/api/device/modelOfMatter';
+import { FormProps, FormSchema, useComponentRegister } from '/@/components/Form';
+import { validateTCPCustomCommand } from '/@/components/Form/src/components/ThingsModelForm';
+import { JSONEditor, JSONEditorValidator } from '/@/components/CodeEditor';
+import {
+  TransportTypeEnum,
+  CommandTypeNameEnum,
+  CommandTypeEnum,
+  ServiceCallTypeEnum,
+  CommandDeliveryWayEnum,
+  CommandDeliveryWayNameEnum,
+} from '/@/enums/deviceEnum';
+
+export interface CommandDeliveryFormFieldType {
+  [CommandFieldsEnum.COMMAND_TYPE]: CommandTypeEnum;
+  [CommandFieldsEnum.TCP_COMMAND_VALUE]?: string;
+  [CommandFieldsEnum.COMAND_VALUE]?: string;
+  [CommandFieldsEnum.SERVICE]?: string;
+  [CommandFieldsEnum.MODEL_INPUT]?: ModelOfMatterParams;
+  [CommandFieldsEnum.CALL_TYPE]: CommandDeliveryWayEnum;
+}
+
+export enum CommandFieldsEnum {
+  COMMAND_TYPE = 'commandType',
+  TCP_COMMAND_VALUE = 'tcpCommandValue',
+  COMAND_VALUE = 'commandValue',
+  SERVICE = 'service',
+  MODEL_INPUT = 'modelInput',
+  CALL_TYPE = 'callType',
+
+  SERVICE_COMMAND = 'serviceCommand',
+
+  SERVICE_OBJECT_MODEL = 'serviceObjectModel',
+}
+
+useComponentRegister('JSONEditor', JSONEditor);
+
+export const CommandSchemas = (
+  transportType: TransportTypeEnum,
+  deviceProfileId: string
+): FormSchema[] => {
+  return [
+    {
+      field: CommandFieldsEnum.COMMAND_TYPE,
+      component: 'RadioGroup',
+      label: '下发类型',
+      defaultValue: CommandTypeEnum.CUSTOM,
+      required: true,
+      componentProps: ({ formActionType }) => {
+        const { setFieldsValue } = formActionType;
+        return {
+          options: [
+            { label: CommandTypeNameEnum.CUSTOM, value: CommandTypeEnum.CUSTOM },
+            { label: CommandTypeNameEnum.SERVICE, value: CommandTypeEnum.SERVICE },
+          ],
+          onChange() {
+            setFieldsValue({
+              [CommandFieldsEnum.SERVICE]: null,
+              [CommandFieldsEnum.MODEL_INPUT]: null,
+              [CommandFieldsEnum.COMAND_VALUE]: null,
+              [CommandFieldsEnum.TCP_COMMAND_VALUE]: null,
+            });
+          },
+        };
+      },
+    },
+    {
+      field: CommandFieldsEnum.CALL_TYPE,
+      component: 'RadioGroup',
+      label: '单向/双向',
+      required: true,
+      defaultValue: CommandDeliveryWayEnum.ONE_WAY,
+      ifShow: ({ model }) => model[CommandFieldsEnum.COMMAND_TYPE] === CommandTypeEnum.CUSTOM,
+      componentProps: {
+        options: Object.keys(CommandDeliveryWayEnum).map((key) => ({
+          label: CommandDeliveryWayNameEnum[key],
+          value: CommandDeliveryWayEnum[key],
+        })),
+      },
+    },
+    {
+      field: CommandFieldsEnum.TCP_COMMAND_VALUE,
+      label: '命令',
+      required: true,
+      ifShow: ({ model }) =>
+        transportType === TransportTypeEnum.TCP &&
+        model[CommandFieldsEnum.COMMAND_TYPE] === CommandTypeEnum.CUSTOM,
+      component: 'Input',
+      rules: [{ validator: validateTCPCustomCommand }],
+      componentProps: {
+        placeholder: '请输入命令',
+      },
+    },
+    {
+      field: CommandFieldsEnum.COMAND_VALUE,
+      label: '命令',
+      component: 'JSONEditor',
+      colProps: { span: 20 },
+      changeEvent: 'update:value',
+      valueField: 'value',
+      required: true,
+      rules: JSONEditorValidator(),
+      ifShow: ({ model }) =>
+        transportType !== TransportTypeEnum.TCP &&
+        model[CommandFieldsEnum.COMMAND_TYPE] === CommandTypeEnum.CUSTOM,
+      componentProps: {
+        height: 250,
+      },
+    },
+    {
+      field: CommandFieldsEnum.SERVICE,
+      label: '服务',
+      component: 'ApiSelect',
+      required: true,
+      ifShow: ({ model }) => model[CommandFieldsEnum.COMMAND_TYPE] !== CommandTypeEnum.CUSTOM,
+      rules: [{ required: true, message: '请选择服务' }],
+      componentProps: ({ formActionType }) => {
+        const { setFieldsValue } = formActionType;
+        return {
+          api: getModelServices,
+          params: {
+            deviceProfileId,
+          },
+          valueField: 'identifier',
+          labelField: 'functionName',
+          getPopupContainer: () => document.body,
+          placeholder: '请选择服务',
+          onChange(
+            value: string,
+            options: ModelOfMatterParams & Record<'label' | 'value', string>
+          ) {
+            if (!value) return;
+            setFieldsValue({
+              [CommandFieldsEnum.CALL_TYPE]:
+                options.callType === ServiceCallTypeEnum.ASYNC
+                  ? CommandDeliveryWayEnum.ONE_WAY
+                  : CommandDeliveryWayEnum.TWO_WAY,
+              [CommandFieldsEnum.MODEL_INPUT]: null,
+              [CommandFieldsEnum.SERVICE_OBJECT_MODEL]: Object.assign(options, {
+                functionName: options.label,
+                identifier: options.value,
+              }),
+            });
+          },
+        };
+      },
+    },
+    {
+      field: CommandFieldsEnum.SERVICE_OBJECT_MODEL,
+      label: '服务物模型',
+      component: 'Input',
+      ifShow: false,
+    },
+    {
+      field: CommandFieldsEnum.MODEL_INPUT,
+      component: 'Input',
+      label: '输入参数',
+      changeEvent: 'update:value',
+      valueField: 'value',
+      ifShow: ({ model }) =>
+        model[CommandFieldsEnum.SERVICE] &&
+        model[CommandFieldsEnum.SERVICE_OBJECT_MODEL] &&
+        model[CommandFieldsEnum.COMMAND_TYPE] !== CommandTypeEnum.CUSTOM,
+      componentProps: {
+        formProps: {
+          wrapperCol: { span: 24 },
+        } as FormProps,
+      },
+      slot: 'serviceCommand',
+    },
+  ];
+};

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

+<template>
+  <BasicModal
+    title="命令下发"
+    :width="650"
+    @register="registerModal"
+    @ok="handleOk"
+    @cancel="handleCancel"
+  >
+    <BasicForm @register="registerForm">
+      <template #serviceCommand="{ field, model }">
+        <ThingsModelForm
+          :disabled="deviceDetail?.transportType === TransportTypeEnum.TCP"
+          ref="thingsModelFormRef"
+          v-model:value="model[field]"
+          :key="model[CommandFieldsEnum.SERVICE_OBJECT_MODEL]?.identifier"
+          :inputData="model[CommandFieldsEnum.SERVICE_OBJECT_MODEL]?.functionJson?.inputData"
+          :transportType="deviceDetail?.transportType"
+        />
+      </template>
+    </BasicForm>
+  </BasicModal>
+</template>
+<script lang="ts" setup>
+  import { nextTick, ref, unref } from 'vue';
+  import { BasicForm, ThingsModelForm, useForm } from '/@/components/Form';
+  import { CommandDeliveryFormFieldType, CommandFieldsEnum, CommandSchemas } from './config';
+  import { useMessage } from '/@/hooks/web/useMessage';
+  import { DeviceRecord } from '/@/api/device/model/deviceModel';
+  import { CommandDeliveryWayEnum } from '/@/enums/deviceEnum';
+  import { CommandTypeEnum, RPCCommandMethodEnum, TransportTypeEnum } from '/@/enums/deviceEnum';
+  import { BasicModal, useModalInner } from '/@/components/Modal';
+  import { getDeviceActiveTime } from '/@/api/alarm/position';
+  import { RpcCommandType } from '/@/api/device/model/deviceConfigModel';
+  import { parseStringToJSON } from '/@/components/CodeEditor';
+  import { commandIssuanceApi } from '/@/api/device/deviceManager';
+
+  defineEmits(['register']);
+
+  const thingsModelFormRef = ref<InstanceType<typeof ThingsModelForm>>();
+  const deviceDetail = ref<DeviceRecord>();
+
+  const [registerModal, { setModalProps }] = useModalInner(
+    (params: ModalParamsType<DeviceRecord>) => {
+      const { record } = params;
+      deviceDetail.value = record;
+      setProps({
+        schemas: CommandSchemas(record.transportType as TransportTypeEnum, record.deviceProfileId),
+      });
+    }
+  );
+
+  const { createMessage } = useMessage();
+
+  const [registerForm, { setProps, getFieldsValue, validate, resetFields, clearValidate }] =
+    useForm({
+      labelWidth: 120,
+      baseColProps: { span: 20 },
+      labelAlign: 'right',
+      showSubmitButton: false,
+      showResetButton: false,
+    });
+
+  const handleCancel = async () => {
+    await resetFields();
+    await nextTick();
+    await clearValidate();
+  };
+
+  const handleValidate = async () => {
+    await validate();
+    await unref(thingsModelFormRef)?.validate?.();
+  };
+
+  const handleValidateDeviceActive = async (): Promise<boolean> => {
+    const result = await getDeviceActiveTime(unref(deviceDetail)!.tbDeviceId);
+    const [firstItem] = result;
+    return !!firstItem.value;
+  };
+
+  const handleCommandParams = (
+    values: CommandDeliveryFormFieldType,
+    serviceCommand: Recordable
+  ) => {
+    const { commandType, service } = values;
+
+    const isTcpDevice = unref(deviceDetail)?.transportType === TransportTypeEnum.TCP;
+    if (commandType === CommandTypeEnum.CUSTOM) {
+      if (isTcpDevice) {
+        return values.tcpCommandValue;
+      }
+      return parseStringToJSON(values.commandValue!).json;
+    } else {
+      if (isTcpDevice) return Reflect.get(serviceCommand, CommandFieldsEnum.SERVICE_COMMAND);
+      return {
+        [service!]: serviceCommand,
+      };
+    }
+  };
+
+  const handleOk = async () => {
+    await handleValidate();
+
+    try {
+      setModalProps({ loading: true, confirmLoading: true });
+
+      const values = getFieldsValue() as CommandDeliveryFormFieldType;
+      const { callType, commandType } = values;
+      const serviceCommand = unref(thingsModelFormRef)?.getFieldsValue() || {};
+
+      if (callType === CommandDeliveryWayEnum.TWO_WAY && !(await handleValidateDeviceActive())) {
+        createMessage.warn('当前设备不在线');
+        return;
+      }
+
+      const rpcCommands: RpcCommandType = {
+        additionalInfo: {
+          cmdType:
+            commandType === CommandTypeEnum.CUSTOM
+              ? CommandTypeEnum.CUSTOM
+              : CommandTypeEnum.SERVICE,
+        },
+        method: RPCCommandMethodEnum.THINGSKIT,
+        persistent: true,
+        params: handleCommandParams(values, serviceCommand),
+      };
+
+      await commandIssuanceApi(callType, unref(deviceDetail)!.tbDeviceId, rpcCommands);
+
+      createMessage.success('命令下发成功');
+    } finally {
+      setModalProps({ loading: false, confirmLoading: false });
+    }
+  };
+</script>
+<style scoped lang="less"></style>

-<template>
-  <div class="tabs-detail">
-    <div>
-      <BasicForm @register="registerForm" />
-      <Space class="w-full justify-end py-2" justify="end">
-        <Button :loading="loading" type="primary" @click="handleOk" class="mr-2">确定</Button>
-        <Button type="default" @click="handleCancel" class="mr-2">重置</Button>
-      </Space>
-    </div>
-  </div>
-</template>
-<script lang="ts">
-  import { defineComponent, nextTick, ref } from 'vue';
-  import { BasicForm, useForm } from '/@/components/Form';
-  import { CommandFieldsEnum, CommandSchemas, CommandType, ValueType } from '../../config/data';
-  import { commandIssuanceApi } from '/@/api/device/deviceManager';
-  import { useMessage } from '/@/hooks/web/useMessage';
-  import { Button } from '/@/components/Button';
-  import { Space } from 'ant-design-vue';
-  import { DeviceRecord } from '/@/api/device/model/deviceModel';
-  import { TransportTypeEnum } from '../../../profiles/components/TransportDescript/const';
-  import { parseStringToJSON } from '/@/components/CodeEditor/src/JSONEditor';
-  import { CommandDeliveryWayEnum } from '/@/enums/toolEnum';
-
-  export default defineComponent({
-    components: { BasicForm, Button, Space },
-    props: {
-      deviceDetail: {
-        type: Object as PropType<DeviceRecord>,
-        required: true,
-      },
-    },
-    emits: ['register'],
-    setup(props) {
-      const { createMessage } = useMessage();
-      const loading = ref(false);
-
-      const [registerForm, { getFieldsValue, validate, resetFields, clearValidate }] = useForm({
-        labelWidth: 120,
-        schemas: CommandSchemas(
-          props.deviceDetail.deviceProfile.transportType as TransportTypeEnum,
-          props.deviceDetail.deviceProfileId
-        ),
-        baseColProps: { span: 20 },
-        labelAlign: 'right',
-        showSubmitButton: false,
-        showResetButton: false,
-      });
-
-      const handleCancel = async () => {
-        await resetFields();
-        await nextTick();
-        await clearValidate();
-      };
-
-      const handleOk = async () => {
-        loading.value = true;
-        try {
-          // 验证
-          const valid = await validate();
-          if (!valid) return;
-          // 收集表单数据
-          const field = getFieldsValue();
-          let command: Recordable = {
-            persistent: true,
-            method: 'methodThingskit',
-            params: field[CommandFieldsEnum.COMMAND_TEXT],
-          };
-
-          if (field[CommandFieldsEnum.COMMAND_TYPE] === CommandType.CUSTOM) {
-            if (field[CommandFieldsEnum.VALUE_TYPE] === ValueType.JSON) {
-              const { json } = parseStringToJSON(field.commandValue);
-              command.params = json;
-            }
-          } else {
-            const { transportType } = props.deviceDetail.deviceProfile;
-            command.params =
-              transportType === TransportTypeEnum.TCP
-                ? field[CommandFieldsEnum.TCP_SERVICE]
-                : {
-                    [field[CommandFieldsEnum.SERVICE]]: field[CommandFieldsEnum.MODEL_INPUT],
-                  };
-            command.additionalInfo = { cmdType: 1 };
-          }
-          commandIssuanceApi(
-            field[CommandFieldsEnum.CUSTOM_TYPE] as CommandDeliveryWayEnum,
-            props.deviceDetail.tbDeviceId,
-            command
-          )
-            .then((res) => {
-              if (!res) return;
-              createMessage.success('命令下发成功');
-              loading.value = true;
-              // 请求
-              handleCancel();
-            })
-            .catch((e) => {
-              if (e?.message) {
-                createMessage.error(e?.message);
-              }
-              handleCancel();
-            })
-            .finally(() => {
-              setTimeout(() => {
-                loading.value = false;
-              }, 300);
-            });
-        } catch (e) {
-          throw e;
-        } finally {
-          loading.value = false;
-        }
-      };
-      return {
-        registerForm,
-        handleCancel,
-        handleOk,
-        loading,
-      };
-    },
-  });
-</script>
-<style scoped lang="less">
-  .jsoneditor-transform {
-    background-position: -144px -96px;
-    display: none !important;
-  }
-
-  .tabs-detail:deep(.object-model-validate-form) {
-    > .ant-row {
-      @apply w-full;
-    }
-  }
-</style>

@@ -14,7 +14,7 @@
   import { ColEx } from '/@/components/Form/src/types';
   import { useHistoryData } from '../../hook/useHistoryData';
   import { formatToDateTime } from '/@/utils/dateUtil';
-  import { useTable, BasicTable, BasicColumn } from '/@/components/Table';
+  import { useTable, BasicTable, BasicColumn, SorterResult } from '/@/components/Table';
   import {
     ModeSwitchButton,
     TABLE_CHART_MODE_LIST,
@@ -64,7 +64,7 @@
   }
 
   const sortOrder = ref<any>('descend');
-  const columns: BasicColumn[] | any = computed(() => {
+  const columns = computed<BasicColumn[]>(() => {
     return [
       {
         title: '属性',
@@ -119,7 +119,7 @@
     loading.value = false;
   };
 
-  const handleTableChange = async (_pag, _filters, sorter: any) => {
+  const handleTableChange = async (_pag, _filters, sorter: SorterResult) => {
     sortOrder.value = sorter.order;
     await setColumns(unref(columns));
     if (sorter.field == 'ts') {

@@ -18,7 +18,8 @@
   import { useGlobSetting } from '/@/hooks/setting';
   import { ModeSwitchButton, EnumTableCardMode } from '/@/components/Widget';
   import { toRaw } from 'vue';
-  import { DataActionModeEnum, ReadAndWriteEnum } from '/@/enums/toolEnum';
+  import { DataActionModeEnum } from '/@/enums/toolEnum';
+  import { ReadAndWriteEnum } from '/@/enums/deviceEnum';
   import { ObjectModelCommandDeliveryModal } from './ObjectModelCommandDeliveryModal';
   import { ModalParamsType } from '/#/utils';
   import { AreaChartOutlined } from '@ant-design/icons-vue';

 import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
 import { FormSchema } from '/@/components/Form';
-import { validateTCPCustomCommand } from '/@/components/Form/src/externalCompns/components/ThingsModelForm';
+import { validateTCPCustomCommand } from '/@/components/Form/src/components/ThingsModelForm';
 import { DataTypeEnum } from '/@/enums/objectModelEnum';
 
 const InsertString = (t, c, n) => {

@@ -12,8 +12,8 @@
   import { genModbusCommand } from '/@/api/task';
   import { TaskTypeEnum } from '/@/views/task/center/config';
   import { SingleToHex, formSchemasConfig } from './config';
-  import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
   import { DataTypeEnum } from '/@/enums/objectModelEnum';
+  import { TransportTypeEnum } from '/@/enums/deviceEnum';
 
   defineEmits(['register']);
   const props = defineProps<{ deviceId: string; deviceName: string }>();

@@ -97,7 +97,7 @@
 
   const handleControl = (action: number, direction: string) => {
     const organizationId = getId();
-    controlling({ cameralndexCode: organizationId, action, command: direction });
+    controlling({ cameraIndexCode: organizationId, action, command: direction });
   };
 
   const isPlay = ref<Boolean | null | undefined>(false);

@@ -6,7 +6,7 @@
     <template #toolbar>
       <Space>
         <Authority value="api:yt:device:rpc">
-          <Button type="primary" @click="openModal(true)">命令下发</Button>
+          <Button type="primary" @click="handleOpenModal">命令下发</Button>
         </Authority>
       </Space>
     </template>
@@ -24,16 +24,7 @@
     </template>
   </BasicTable>
 
-  <BasicModal
-    @register="registerCommandIssuanceModal"
-    width="700px"
-    title="命令下发"
-    :showOkBtn="false"
-    cancelText="关闭"
-    :footer="null"
-  >
-    <CommandIssuance :deviceDetail="deviceDetail" />
-  </BasicModal>
+  <CommandDeliveryModal @register="registerCommandDeliverModal" :deviceDetail="deviceDetail" />
 </template>
 <script lang="ts" setup>
   import { h } from 'vue';
@@ -43,9 +34,10 @@
   import { Button, Modal, Space } from 'ant-design-vue';
   import { JsonPreview } from '/@/components/CodeEditor';
   import { DeviceRecord } from '/@/api/device/model/deviceModel';
-  import { BasicModal, useModal } from '/@/components/Modal';
-  import CommandIssuance from '../CommandIssuance.vue';
+  import { useModal } from '/@/components/Modal';
+  import { CommandDeliveryModal } from '../CommandDeliveryModal';
   import { Authority } from '/@/components/Authority';
+  import { DataActionModeEnum } from '/@/enums/toolEnum';
 
   const props = defineProps({
     fromId: {
@@ -58,7 +50,7 @@
     },
   });
 
-  const [registerCommandIssuanceModal, { openModal }] = useModal();
+  const [registerCommandDeliverModal, { openModal }] = useModal();
 
   const [registerTable] = useTable({
     api: deviceCommandRecordGetQuery,
@@ -79,6 +71,7 @@
     },
     useSearchForm: true,
   });
+
   const commonModalInfo = (title, value) => {
     Modal.info({
       title,
@@ -86,14 +79,23 @@
       content: h(JsonPreview, { data: value }),
     });
   };
+
   const handleRecordContent = (record) => {
     if (!record?.request?.body) return;
     if (Object.prototype.toString.call(record?.request?.body) !== '[object Object]') return;
     const jsonParams = record?.request?.body?.params;
     commonModalInfo('命令下发内容', jsonParams);
   };
+
   const handleRecordResponseContent = (record) => {
     const jsonParams = record?.response;
     commonModalInfo('响应内容', jsonParams);
   };
+
+  function handleOpenModal() {
+    openModal(true, {
+      mode: DataActionModeEnum.READ,
+      record: props.deviceDetail,
+    } as ModalParamsType<DeviceRecord>);
+  }
 </script>

@@ -287,6 +287,7 @@ export function getPacketIntervalByRange(
         break;
       }
     }
+    if (!options.length) options = rangeIntervalOption[rangeIntervalOption.length - 1].linkage;
     return options;
   }
   return [];

+import { unref } from 'vue';
+import { FormFieldsEnum, FormFieldsNameEnum } from '../config';
+import { useObjectModelFormContext } from '../useObjectModelFormContext';
+import { Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { findDictItemByCode } from '/@/api/system/dict';
+import { FormSchema } from '/@/components/Form';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
+import { DictEnum } from '/@/enums/dictEnum';
+import { DataTypeEnum, FunctionTypeEnum } from '/@/enums/objectModelEnum';
+import { isNullOrUnDef } from '/@/utils/is';
+import { ValidatorRule } from 'ant-design-vue/lib/form/interface';
+
+export interface DataTypeFormGetFieldsValueType {
+  [FormFieldsEnum.FUNCTION_NAME]: string;
+  [FormFieldsEnum.IDENTIFIER]: string;
+  [FormFieldsEnum.DATA_TYPE]: DataTypeEnum;
+  [FormFieldsEnum.VALUE_RANGE]?: Record<'min' | 'max', number>;
+  [FormFieldsEnum.STEP]?: number;
+  [FormFieldsEnum.UNIT]?: string;
+  [FormFieldsEnum.UNIT_NAME]?: string;
+  [FormFieldsEnum.BOOL_CLOSE]?: string;
+  [FormFieldsEnum.BOOL_OPEN]?: string;
+  [FormFieldsEnum.LENGTH]?: number;
+  [FormFieldsEnum.ENUMS_DATA]?: Specs[];
+  [FormFieldsEnum.STRUCT_DATA]?: StructJSON[];
+  [FormFieldsEnum.REMARK]?: string;
+}
+
+export const validateValueRange: ValidatorRule['validator'] = (
+  _rule,
+  value: Record<'min' | 'max', number>,
+  _callback
+) => {
+  value = value || {};
+  const { min, max } = value;
+  if (min > max) {
+    return Promise.reject('最大值小于最小值');
+  }
+  return Promise.resolve();
+};
+
+export const validateFunctionName: ValidatorRule['validator'] = (_rule, value: any) => {
+  if (/^[a-zA-Z0-9_\-\u4e00-\u9fa5]+$/.test(value)) return Promise.resolve();
+  return Promise.reject('支持中文、大小写字母、数字、短划线、下划线.');
+};
+
+export const validateIdentifier: ValidatorRule['validator'] = (_rule, value: any) => {
+  if (/^[a-zA-Z0-9_]+$/.test(value)) {
+    return Promise.resolve();
+  }
+  return Promise.reject('支持大小写字母、数字和下划线.');
+};
+
+export const createFunctionNameFormItem = (params: Partial<FormSchema> = {}): FormSchema => {
+  return {
+    field: FormFieldsEnum.FUNCTION_NAME,
+    label: FormFieldsNameEnum.FUNCTION_NAME,
+    component: 'Input',
+    required: true,
+    helpMessage: '支持中文、大小写字母、数字、短划线、下划线。',
+    rules: [
+      {
+        required: true,
+        validator: validateFunctionName,
+      },
+    ],
+    componentProps: {
+      placeholder: `请输入${FormFieldsNameEnum.FUNCTION_NAME}`,
+    },
+    ...params,
+  };
+};
+
+export const createIdentifierFormItem = (params: Partial<FormSchema> = {}): FormSchema => {
+  return {
+    field: FormFieldsEnum.IDENTIFIER,
+    label: FormFieldsNameEnum.IDENTIFIER,
+    required: true,
+    component: 'Input',
+    helpMessage: '支持大小写字母、数字和下划线.',
+    componentProps: {
+      maxLength: 128,
+      placeholder: '请输入标识符',
+    },
+    rules: [
+      {
+        required: true,
+        validator: validateIdentifier,
+      },
+    ],
+    ...params,
+  };
+};
+
+export const getFormSchemas = (dataType: DataTypeEnum[], showRemark: boolean): FormSchema[] => {
+  const { getTransportType } = useObjectModelFormContext();
+  return [
+    createFunctionNameFormItem(),
+    createIdentifierFormItem(),
+    {
+      field: FormFieldsEnum.DATA_TYPE,
+      label: FormFieldsNameEnum.DATA_TYPE,
+      required: true,
+      component: 'ApiSelect',
+      defaultValue: DataTypeEnum.NUMBER_INT,
+      ifShow: () => !!dataType.length,
+      componentProps: () => {
+        return {
+          placeholder: '请选择数据类型',
+          api: async (params: Recordable) => {
+            let result = await findDictItemByCode(params);
+            if (unref(getTransportType) === TransportTypeEnum.TCP) {
+              result = result.filter(
+                (item) =>
+                  ![DataTypeEnum.STRUCT, DataTypeEnum.ENUM].includes(item.itemValue as DataTypeEnum)
+              );
+            }
+            return result.filter((item) => dataType.includes(item.itemValue as DataTypeEnum));
+          },
+          params: {
+            dictCode: DictEnum.DATA_TYPE,
+          },
+          allowClear: false,
+          labelField: 'itemText',
+          valueField: 'itemValue',
+          getPopupContainer: () => document.body,
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.VALUE_RANGE,
+      label: FormFieldsNameEnum.VALUE_RANGE,
+      component: 'CustomMinMaxInput',
+      valueField: 'value',
+      changeEvent: 'update:value',
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) &&
+        (model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_INT ||
+          model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_DOUBLE),
+      dynamicRules: ({ model }) => [
+        {
+          required:
+            model[FormFieldsEnum.VALUE_RANGE]?.min || model[FormFieldsEnum.VALUE_RANGE]?.max,
+          validator: validateValueRange,
+        },
+      ],
+    },
+    {
+      field: FormFieldsEnum.STEP,
+      label: FormFieldsNameEnum.STEP,
+      component: 'InputNumber',
+      componentProps: {
+        maxLength: 255,
+        placeholder: '请输入步长',
+        min: 1,
+        formatter: (value: number | string) => {
+          return value ? Math.floor(Number(value)) : value;
+        },
+      },
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) &&
+        (model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_INT ||
+          model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_DOUBLE),
+      dynamicRules: ({ model }) => {
+        const valueRange = model[FormFieldsEnum.VALUE_RANGE] || {};
+        const { min, max } = valueRange;
+        const step = model[FormFieldsEnum.STEP];
+        return [
+          {
+            validator: () => {
+              if ([min, max].every(isNullOrUnDef)) return Promise.resolve();
+              if (step > max - min) {
+                return Promise.reject('步长不能大于取值范围的差值');
+              }
+              return Promise.resolve();
+            },
+          },
+        ];
+      },
+    },
+    {
+      field: FormFieldsEnum.UNIT_NAME,
+      label: FormFieldsNameEnum.UNIT_NAME,
+      component: 'Input',
+      show: false,
+    },
+    {
+      field: FormFieldsEnum.UNIT,
+      label: FormFieldsNameEnum.UNIT,
+      component: 'ApiSelect',
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) &&
+        (model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_INT ||
+          model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_DOUBLE),
+      componentProps: ({ formActionType }) => {
+        const { setFieldsValue } = formActionType;
+        return {
+          placeholder: '请选择单位',
+          api: async (params: Recordable) => {
+            const list = await findDictItemByCode(params);
+            list.map((item) => (item.itemText = `${item.itemText} / ${item.itemValue}`));
+            return list;
+          },
+          params: {
+            dictCode: DictEnum.ATTRIBUTE_UNIT,
+          },
+          labelField: 'itemText',
+          valueField: 'itemValue',
+          onChange(_, record: Record<'label' | 'value', string>) {
+            if (record) {
+              const { label } = record;
+              setFieldsValue({ [FormFieldsEnum.UNIT_NAME]: label });
+            }
+          },
+          getPopupContainer: () => document.body,
+          showSearch: true,
+          filterOption: (inputValue: string, option: Record<'label' | 'value', string>) => {
+            let { label, value } = option;
+            label = label.toLowerCase();
+            value = value.toLowerCase();
+            inputValue = inputValue.toLowerCase();
+            return label.includes(inputValue) || value.includes(inputValue);
+          },
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.BOOL_CLOSE,
+      component: 'Input',
+      required: true,
+      label: FormFieldsNameEnum.BOOL_CLOSE,
+      componentProps: {
+        placeholder: '如：关',
+      },
+      defaultValue: '关',
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) && model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.BOOL,
+      dynamicRules: ({ model }) => {
+        const close = model[FormFieldsEnum.BOOL_CLOSE];
+        const open = model[FormFieldsEnum.BOOL_OPEN];
+        return [
+          {
+            required: true,
+            message: `布尔值不能为空`,
+          },
+          {
+            validator() {
+              if (open === close) return Promise.reject('布尔值不能相同');
+              return Promise.resolve();
+            },
+          },
+        ];
+      },
+    },
+    {
+      field: FormFieldsEnum.BOOL_OPEN,
+      component: 'Input',
+      required: true,
+      label: FormFieldsNameEnum.BOOL_OPEN,
+      componentProps: {
+        placeholder: '如：开',
+      },
+      defaultValue: '开',
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) && model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.BOOL,
+      dynamicRules: ({ model }) => {
+        const close = model[FormFieldsEnum.BOOL_CLOSE];
+        const open = model[FormFieldsEnum.BOOL_OPEN];
+        return [
+          {
+            required: true,
+            message: `布尔值不能为空`,
+          },
+          {
+            validator() {
+              if (open === close) return Promise.reject('布尔值不能相同');
+              return Promise.resolve();
+            },
+          },
+        ];
+      },
+    },
+    {
+      field: FormFieldsEnum.LENGTH,
+      component: 'InputNumber',
+      required: true,
+      label: FormFieldsNameEnum.LENGTH,
+      defaultValue: 1024,
+      componentProps: {
+        placeholder: '请输入数据长度',
+      },
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) && model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.STRING,
+    },
+    {
+      field: FormFieldsEnum.ENUMS_DATA,
+      label: FormFieldsNameEnum.ENUMS_DATA,
+      component: 'Input',
+      slot: FormFieldsEnum.ENUMS_DATA,
+      changeEvent: 'update:value',
+      valueField: 'value',
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) && model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.ENUM,
+    },
+    {
+      field: FormFieldsEnum.STRUCT_DATA,
+      label: FormFieldsNameEnum.STRUCT_DATA,
+      component: 'Input',
+      slot: FormFieldsEnum.STRUCT_DATA,
+      changeEvent: 'update:value',
+      valueField: 'value',
+      required: true,
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.STRUCT &&
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ),
+    },
+
+    {
+      field: FormFieldsEnum.REMARK,
+      label: FormFieldsNameEnum.REMARK,
+      component: 'InputTextArea',
+      ifShow: showRemark,
+      componentProps: {
+        rows: 4,
+        maxLength: 100,
+        placeholder: '请输入描述',
+      },
+    },
+  ];
+};

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

+<script setup lang="ts">
+  import { useForm, BasicForm } from '/@/components/Form';
+  import { getFormSchemas } from './config';
+  import { EnumList } from '../EnumList';
+  import { ref } from 'vue';
+  import { StructFormItem } from '../StructFormItem';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
+  import { useDataTypeFormData } from './useDataTypeFormData';
+  import { DataActionModeEnum } from '/@/enums/toolEnum';
+
+  const props = withDefaults(
+    defineProps<{
+      dataType?: DataTypeEnum[];
+      mode?: DataActionModeEnum;
+      showRemark?: boolean;
+    }>(),
+    {
+      dataType: () => Object.values(DataTypeEnum),
+      showRemark: false,
+    }
+  );
+
+  defineEmits<{
+    (event: 'field-value-change', field: string, value: any): void;
+  }>();
+
+  const [register, formActionType] = useForm({
+    schemas: getFormSchemas(props.dataType, props.showRemark),
+    layout: 'vertical',
+    showActionButtonGroup: false,
+  });
+
+  const enumListRef = ref<InstanceType<typeof EnumList>>();
+
+  const { getFieldsValue, setFieldsValue, validate, resetFieldsValue } = useDataTypeFormData({
+    formActionType,
+    enumListRef,
+  });
+
+  defineExpose({ getFieldsValue, setFieldsValue, validate, resetFieldsValue });
+</script>
+
+<template>
+  <BasicForm
+    @register="register"
+    class="data-type-form"
+    :disabled="mode === DataActionModeEnum.READ"
+    @field-value-change="(field, value) => $emit('field-value-change', field, value)"
+  >
+    <template #enumsData="{ model, field }">
+      <EnumList
+        ref="enumListRef"
+        v-model:value="model[field]"
+        :disabled="mode === DataActionModeEnum.READ"
+      />
+    </template>
+    <template #structData="{ model, field }">
+      <StructFormItem
+        v-model:value="model[field]"
+        :mode="mode"
+        :dataType="[
+          DataTypeEnum.BOOL,
+          DataTypeEnum.ENUM,
+          DataTypeEnum.NUMBER_DOUBLE,
+          DataTypeEnum.NUMBER_INT,
+          DataTypeEnum.STRING,
+        ]"
+      />
+    </template>
+  </BasicForm>
+</template>
+
+<style lang="less" scoped>
+  .data-type-form {
+    :deep(.ant-input-number) {
+      width: 100%;
+    }
+  }
+</style>
+./config

+import { Ref, unref } from 'vue';
+import { FormActionType } from '/@/components/Form';
+import EnumList from './EnumList.vue';
+import { DefineComponentsBasicExpose } from '/#/utils';
+import { DataTypeFormGetFieldsValueType } from './config';
+import { DataType, Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
+import { isObject } from '/@/utils/is';
+
+interface UseDataTypeFormDataParams {
+  formActionType: FormActionType;
+  enumListRef: Ref<InstanceType<typeof EnumList> | undefined>;
+}
+
+function getDataType(value: DataTypeFormGetFieldsValueType, enumListFormValue?: Specs[]): DataType {
+  const { dataType, valueRange, unit, unitName, step, length, boolClose, boolOpen, structData } =
+    value;
+
+  const basic: DataType = { type: dataType };
+
+  if (dataType === DataTypeEnum.BOOL) {
+    basic.specs = {
+      boolClose,
+      boolOpen,
+    };
+  } else if (dataType === DataTypeEnum.ENUM) {
+    basic.specsList = enumListFormValue;
+  } else if ([DataTypeEnum.NUMBER_DOUBLE, DataTypeEnum.NUMBER_INT].includes(dataType)) {
+    basic.specs = {
+      valueRange,
+      unit,
+      unitName,
+      step,
+    };
+  } else if (dataType === DataTypeEnum.STRING) {
+    basic.specs = {
+      length,
+    };
+  } else if (dataType === DataTypeEnum.STRUCT) {
+    basic.specs = structData || [];
+  }
+
+  return basic;
+}
+
+export function useDataTypeFormData({
+  formActionType,
+  enumListRef,
+}: UseDataTypeFormDataParams): DefineComponentsBasicExpose<StructJSON> {
+  const getFieldsValue = (): StructJSON => {
+    const value = formActionType.getFieldsValue() as DataTypeFormGetFieldsValueType;
+    const enumListFormValue = unref(enumListRef)?.getFieldsValue();
+    const { functionName, identifier, remark } = value;
+
+    return {
+      functionName,
+      identifier,
+      remark,
+      dataType: getDataType(value, enumListFormValue),
+    };
+  };
+
+  const setFieldsValue = (record: StructJSON) => {
+    const { dataType, identifier, functionName, remark } = record;
+    const { type, specs, specsList = [] } = dataType || {};
+
+    // 兼容处理 unit
+    if (isObject(specs) && isObject((specs as Specs).unit)) {
+      (specs as Specs).unit = ((specs as Specs).unit as unknown as Record<'value', string>)?.value;
+    }
+
+    // 兼容处理 length 数据长度类型
+    if (isObject(specs) && isObject((specs as Specs).length)) {
+      (specs as Specs).length = Number((specs as Specs).length);
+    }
+
+    formActionType.setFieldsValue({
+      dataType: type,
+      identifier,
+      functionName,
+      remark,
+      ...(isObject(specs) ? specs : {}),
+      structData: type === DataTypeEnum.STRUCT ? specs : [],
+      enumsData: type === DataTypeEnum.ENUM ? specsList : [],
+    } as DataTypeFormGetFieldsValueType);
+  };
+
+  const validate = async () => {
+    await formActionType.validate();
+    await unref(enumListRef)?.validate?.();
+  };
+
+  const resetFieldsValue = () => {
+    formActionType.resetFields();
+  };
+
+  return {
+    validate,
+    getFieldsValue,
+    setFieldsValue,
+    resetFieldsValue,
+  };
+}

-import { FormSchema } from '/@/components/Table';
+import { FormSchema } from '/@/components/Form';
 
 export enum FormFieldsEnum {
   VALUE = 'value',
@@ -41,14 +41,7 @@ export const getFormSchemas = (): FormSchema[] => {
       field: FormFieldsEnum.NAME,
       label: '',
       component: 'Input',
-      rules: [
-        {
-          required: true,
-          message: `支持中文、英文大小写、数字、下划线和短划线，必须以中文、英文或数字开头，不超过20个字符`,
-          type: 'string',
-          pattern: /^[a-zA-Z0-9\u4e00-\u9fa5a][\u4e00-\u9fa5a-zA-Z0-9_-]*$/,
-        },
-      ],
+      rules: [{ required: true, message: `参数描述不能为空`, type: 'string' }],
       componentProps: () => {
         return {
           placeholder: '对该枚举项的描述',

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

 <script setup lang="ts">
   import { Button, Tooltip } from 'ant-design-vue';
   import { computed, nextTick, ref, unref, watch } from 'vue';
-  import { useForm, BasicForm } from '/@/components/Form';
+  import { useForm, BasicForm, FormActionType } from '/@/components/Form';
   import { Specs } from '/@/api/device/model/modelOfMatterModel';
   import { Icon } from '/@/components/Icon';
-  import { getFormSchemas } from './EnumList.config';
-  import { FormActionType } from '../../../types/form';
+  import { getFormSchemas } from './config';
   import { buildUUID } from '/@/utils/uuid';
   import { DataTypeEnum } from '/@/enums/objectModelEnum';
   import { isNullOrUnDef } from '/@/utils/is';
@@ -65,7 +64,6 @@
 
   const setFieldsValue = (spaceList: Specs[]) => {
     enumsListElRef.value = spaceList.map((item) => ({ uuid: buildUUID(), dataSource: item }));
-
     nextTick(() => {
       unref(enumsListElRef).forEach((item) =>
         item.formActionType?.setFieldsValue?.(item.dataSource)
@@ -76,10 +74,7 @@
   const handleDeleteEnums = (item: EnumElItemType) => {
     const index = unref(enumsListElRef).findIndex((temp) => item.uuid === temp.uuid);
 
-    if (~index) {
-      enumsListElRef.value.splice(index, 1);
-      validateSameEnum();
-    }
+    ~index && enumsListElRef.value.splice(index, 1);
   };
 
   const handleAddEnums = () => {
@@ -107,15 +102,17 @@
   <section class="w-full">
     <header class="flex h-8 items-center">
       <div class="w-1/2">
-        <span>参考值</span>
+        <span class="mr-1 text-red-400">*</span>
+        <span> 参考值 </span>
         <Tooltip title="支持整型，取值范围：-2147483648 ~ 2147483647">
           <Icon icon="ant-design:question-circle-outlined" class="cursor-pointer ml-1" />
         </Tooltip>
       </div>
       <div class="w-1/2">
-        <span>参考描述</span>
+        <span class="mr-1 text-red-400">*</span>
+        <span> 参考描述 </span>
         <Tooltip
-          title="支持中文、英文大小写、数字、下划线和短划线，必须以中文、英文或数字开头，不超过20个字符"
+          title="支持中文、英文大小写、日文、数字、下划线和短划线，必须以中文、英文或数字开头，不超过20个字符"
         >
           <Icon icon="ant-design:question-circle-outlined" class="cursor-pointer ml-1" />
         </Tooltip>

+import { unref } from 'vue';
+import { useObjectModelFormContext } from '../useObjectModelFormContext';
 import { findDictItemByCode } from '/@/api/system/dict';
 import { FormSchema } from '/@/components/Table';
 import { DictEnum } from '/@/enums/dictEnum';
@@ -37,66 +39,62 @@ function getActionTypeByObjectModelType(dataType: DataTypeEnum) {
   return list;
 }
 
-export const formSchemas: FormSchema[] = [
-  {
-    field: FormFieldsEnum.OBJECT_MODEL_TYPE,
-    component: 'Input',
-    label: '物模型数据类型',
-    ifShow: false,
-  },
-  {
-    field: FormFieldsEnum.REGISTER_ADDRESS,
-    component: 'RegisterAddressInput',
-    label: '寄存器地址',
-    changeEvent: 'update:value',
-    valueField: 'value',
-    rules: [{ message: '请输入寄存器地址', required: true, type: 'number' }],
-    componentProps: {
-      placeholder: '请输入寄存器地址',
-    },
-  },
-  {
-    field: FormFieldsEnum.DATA_TYPE,
-    component: 'ApiSelect',
-    label: '数据格式',
-    rules: [{ message: '请选择数据格式', required: true }],
-    defaultValue: RegisterDataTypeEnum.UN_SHORT,
-    componentProps: {
-      api: findDictItemByCode,
-      params: {
-        dictCode: DictEnum.REGISTER_DATA_FORMAT,
+export const getFormSchemas = (): FormSchema[] => {
+  const { getDataType } = useObjectModelFormContext();
+  return [
+    {
+      field: FormFieldsEnum.REGISTER_ADDRESS,
+      component: 'RegisterAddressInput',
+      label: '寄存器地址',
+      changeEvent: 'update:value',
+      valueField: 'value',
+      rules: [{ message: '请输入寄存器地址', required: true, type: 'number' }],
+      componentProps: {
+        placeholder: '请输入寄存器地址',
       },
-      labelField: 'itemText',
-      valueField: 'itemValue',
-      placeholder: '请选择数据格式',
-      getPopupContainer: () => document.body,
     },
-  },
-  {
-    field: FormFieldsEnum.ACTION_TYPE,
-    component: 'Select',
-    label: '操作类型',
-    rules: [{ message: '请选择操作类型', required: true }],
-    componentProps: ({ formModel }) => {
-      const objectModelType = formModel[FormFieldsEnum.OBJECT_MODEL_TYPE];
-      return {
-        options: getActionTypeByObjectModelType(objectModelType),
-        placeholder: '请选择操作类型',
+    {
+      field: FormFieldsEnum.DATA_TYPE,
+      component: 'ApiSelect',
+      label: '数据格式',
+      rules: [{ message: '请选择数据格式', required: true }],
+      defaultValue: RegisterDataTypeEnum.UN_SHORT,
+      componentProps: {
+        api: findDictItemByCode,
+        params: {
+          dictCode: DictEnum.REGISTER_DATA_FORMAT,
+        },
+        labelField: 'itemText',
+        valueField: 'itemValue',
+        placeholder: '请选择数据格式',
         getPopupContainer: () => document.body,
-      };
+      },
     },
-  },
-  {
-    field: FormFieldsEnum.ZOOM_FACTOR,
-    component: 'InputNumber',
-    label: '缩放因子',
-    helpMessage: ['缩放因子不能为0,默认为1'],
-    defaultValue: 1,
-    ifShow: ({ model }) =>
-      ![DataTypeEnum.BOOL, DataTypeEnum.STRING].includes(model[FormFieldsEnum.OBJECT_MODEL_TYPE]),
-    componentProps: {
-      min: 1,
-      placeholder: '请输入缩放因子',
+    {
+      field: FormFieldsEnum.ACTION_TYPE,
+      component: 'Select',
+      label: '操作类型',
+      rules: [{ message: '请选择操作类型', required: true }],
+      componentProps: () => {
+        return {
+          options: getActionTypeByObjectModelType(unref(getDataType)),
+          placeholder: '请选择操作类型',
+          getPopupContainer: () => document.body,
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.ZOOM_FACTOR,
+      component: 'InputNumber',
+      label: '缩放因子',
+      helpMessage: ['缩放因子不能为0,默认为1'],
+      defaultValue: 1,
+      ifShow: ({ model }) =>
+        ![DataTypeEnum.BOOL, DataTypeEnum.STRING].includes(model[FormFieldsEnum.OBJECT_MODEL_TYPE]),
+      componentProps: {
+        min: 1,
+        placeholder: '请输入缩放因子',
+      },
     },
-  },
-];
+  ];
+};

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

@@ -4,19 +4,18 @@
   import { BasicForm, useForm } from '/@/components/Form';
   import { BasicModal } from '/@/components/Modal';
   import { PlusCircleOutlined } from '@ant-design/icons-vue';
-  import { FormFieldsEnum, formSchemas } from './config';
-  import { DataTypeEnum } from '/@/enums/objectModelEnum';
+  import { getFormSchemas } from './config';
+  import { ExtensionDesc } from '/@/api/device/model/modelOfMatterModel';
 
   const show = ref(false);
 
   const props = withDefaults(
     defineProps<{
-      value?: object;
+      value?: ExtensionDesc;
       disabled?: boolean;
-      dataType?: DataTypeEnum;
     }>(),
     {
-      value: () => ({}),
+      value: () => ({} as ExtensionDesc),
     }
   );
 
@@ -24,7 +23,7 @@
 
   const [registerForm, { setFieldsValue, getFieldsValue, setProps, validate, resetFields }] =
     useForm({
-      schemas: formSchemas,
+      schemas: getFormSchemas(),
       showActionButtonGroup: false,
     });
 
@@ -39,7 +38,6 @@
   const handleSubmit = async () => {
     await validate();
     const value = getFieldsValue();
-    Reflect.deleteProperty(value, FormFieldsEnum.OBJECT_MODEL_TYPE);
     emit('update:value', value);
     show.value = false;
   };
@@ -47,22 +45,15 @@
   watch(show, async (value) => {
     if (value) {
       await nextTick();
-      setFieldsValue({ [FormFieldsEnum.OBJECT_MODEL_TYPE]: props.dataType });
+      setFieldsValue({ ...props.value });
     }
   });
-
-  watch(
-    () => props.value,
-    (value) => {
-      setFieldsValue(value);
-    }
-  );
 </script>
 
 <template>
   <section>
     <Button type="link" @click="handleClick"><PlusCircleOutlined />新增扩展描述</Button>
-    <BasicModal title="扩展描述" v-model:visible="show" @ok="handleSubmit">
+    <BasicModal title="扩展描述" v-model:visible="show" @ok="handleSubmit" :show-ok-btn="!disabled">
       <BasicForm class="extension-form" @register="registerForm" />
     </BasicModal>
   </section>

+<script setup lang="ts">
+  import { BasicModal, useModalInner } from '/@/components/Modal';
+  import { ref, unref } from 'vue';
+  import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
+  import { DataActionModeEnum } from '/@/enums/toolEnum';
+  import { DataTypeForm } from '../DataTypeForm';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
+  import { useMessage } from '/@/hooks/web/useMessage';
+
+  const props = withDefaults(
+    defineProps<{ value?: StructJSON[]; dataType?: DataTypeEnum[]; mode?: DataActionModeEnum }>(),
+    {
+      value: () => [],
+      dataType: () => Object.values(DataTypeEnum),
+    }
+  );
+
+  const dataTypeFormRef = ref<InstanceType<typeof DataTypeForm>>();
+
+  const emits = defineEmits(['register', 'complete']);
+
+  const currentMode = ref(DataActionModeEnum.CREATE);
+  const [registerModal] = useModalInner(({ mode, record }: ModalParamsType<StructJSON>) => {
+    unref(dataTypeFormRef)?.resetFieldsValue?.();
+    currentMode.value = mode;
+    if (mode === DataActionModeEnum.UPDATE) {
+      unref(dataTypeFormRef)?.setFieldsValue?.(record);
+    }
+  });
+
+  const { createMessage } = useMessage();
+
+  const handleValidateHasSameIdentifier = (formValue?: StructJSON) => {
+    const { identifier } = formValue || {};
+    if (
+      unref(currentMode) === DataActionModeEnum.CREATE &&
+      props.value.filter((item) => item.identifier === identifier).length >= 1
+    ) {
+      const message = '存在一致的标识符';
+      createMessage.warn(message);
+      return Promise.reject(message);
+    }
+
+    return Promise.resolve();
+  };
+
+  const handleOk = async () => {
+    await unref(dataTypeFormRef)?.validate?.();
+    const value = unref(dataTypeFormRef)?.getFieldsValue?.();
+    await handleValidateHasSameIdentifier(value);
+    emits('complete', value);
+  };
+</script>
+
+<template>
+  <BasicModal
+    @register="registerModal"
+    title="新增参数"
+    @ok="handleOk"
+    :width="480"
+    :show-ok-btn="mode !== DataActionModeEnum.READ"
+  >
+    <DataTypeForm ref="dataTypeFormRef" :data-type="dataType" show-remark :mode="mode" />
+  </BasicModal>
+</template>

+import { FormFieldsEnum, FormFieldsNameEnum } from '../config';
+import { findDictItemByCode } from '/@/api/system/dict';
+import { FormSchema } from '/@/components/Form';
+import { DictEnum } from '/@/enums/dictEnum';
+import { DataTypeEnum, FunctionTypeEnum, FunctionTypeNameEnum } from '/@/enums/objectModelEnum';
+import { isNullOrUnDef } from '/@/utils/is';
+
+export const validateValueRange = (_rule, value: Record<'min' | 'max', number>, _callback) => {
+  value = value || {};
+  const { min, max } = value;
+  if (min > max) {
+    return Promise.reject('最大值小于最小值');
+  }
+  return Promise.resolve();
+};
+
+export const getFormSchemas = (): FormSchema[] => {
+  return [
+    {
+      field: FormFieldsEnum.FUNCTION_TYPE,
+      label: FormFieldsNameEnum.FUNCTION_TYPE,
+      component: 'Segmented',
+      defaultValue: FunctionTypeEnum.PROPERTIES,
+      required: true,
+      componentProps: ({ formActionType }) => {
+        return {
+          options: Object.keys(FunctionTypeEnum).map((key) => ({
+            title: FunctionTypeNameEnum[key],
+            value: FunctionTypeEnum[key],
+          })),
+          onChange() {
+            const { setFieldsValue, clearValidate } = formActionType;
+            setFieldsValue({
+              [FormFieldsEnum.INPUT_DATA]: [],
+              [FormFieldsEnum.OUTPUT_DATA]: [],
+              [FormFieldsEnum.STRUCT_DATA]: [],
+              [FormFieldsEnum.SERVICE_COMMAND]: null,
+            });
+            clearValidate();
+          },
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.FUNCTION_NAME,
+      label: FormFieldsNameEnum.FUNCTION_NAME,
+      component: 'Input',
+      required: true,
+      dynamicRules: ({ values }) => {
+        return [
+          { required: true, message: '请输入功能名称' },
+          {
+            validator: () => {
+              const reg = /[,，]+/;
+              if (reg.test(values?.[FormFieldsEnum.FUNCTION_NAME])) {
+                return Promise.reject(`${FormFieldsNameEnum.FUNCTION_NAME}不能包含逗号`);
+              }
+              return Promise.resolve();
+            },
+          },
+        ];
+      },
+      componentProps: {
+        placeholder: `请输入${FormFieldsNameEnum.FUNCTION_NAME}`,
+      },
+    },
+    {
+      field: FormFieldsEnum.IDENTIFIER,
+      label: FormFieldsNameEnum.IDENTIFIER,
+      required: true,
+      component: 'Input',
+      componentProps: {
+        maxLength: 128,
+        placeholder: '请输入标识符',
+      },
+      dynamicRules: ({ values }) => {
+        return [
+          { required: true, message: '请输入标识符' },
+          {
+            validator: () => {
+              const reg = /[,，]+/;
+              if (reg.test(values?.[FormFieldsEnum.IDENTIFIER])) {
+                return Promise.reject(`${FormFieldsNameEnum.IDENTIFIER}不能包含逗号`);
+              }
+              return Promise.resolve();
+            },
+          },
+        ];
+      },
+    },
+    {
+      field: FormFieldsEnum.DATA_TYPE,
+      label: FormFieldsNameEnum.DATA_TYPE,
+      required: true,
+      component: 'ApiSelect',
+      defaultValue: DataTypeEnum.NUMBER_INT,
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ),
+      componentProps: () => {
+        return {
+          placeholder: '请选择数据类型',
+          api: async (params: Recordable) => {
+            const result = await findDictItemByCode(params);
+            return result;
+          },
+          params: {
+            dictCode: DictEnum.DATA_TYPE,
+          },
+          labelField: 'itemText',
+          valueField: 'itemValue',
+          getPopupContainer: () => document.body,
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.VALUE_RANGE,
+      label: FormFieldsNameEnum.VALUE_RANGE,
+      component: 'CustomMinMaxInput',
+      valueField: 'value',
+      changeEvent: 'update:value',
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) &&
+        (model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_INT ||
+          model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_DOUBLE),
+      rules: [{ validator: validateValueRange }],
+    },
+    {
+      field: FormFieldsEnum.STEP,
+      label: FormFieldsNameEnum.STEP,
+      component: 'InputNumber',
+      componentProps: {
+        maxLength: 255,
+        placeholder: '请输入步长',
+        min: 1,
+        formatter: (value: number | string) => {
+          return value ? Math.floor(Number(value)) : value;
+        },
+      },
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) &&
+        (model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_INT ||
+          model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_DOUBLE),
+      dynamicRules: ({ model }) => {
+        const valueRange = model[FormFieldsEnum.VALUE_RANGE] || {};
+        const { min, max } = valueRange;
+        const step = model[FormFieldsEnum.STEP];
+        return [
+          {
+            validator: () => {
+              if ([min, max].every(isNullOrUnDef)) return Promise.resolve();
+              if (step > max - min) {
+                return Promise.reject('步长不能大于取值范围的差值');
+              }
+              return Promise.resolve();
+            },
+          },
+        ];
+      },
+    },
+    {
+      field: FormFieldsEnum.UNIT_NAME,
+      label: FormFieldsNameEnum.UNIT_NAME,
+      component: 'Input',
+      show: false,
+    },
+    {
+      field: FormFieldsEnum.UNIT,
+      label: FormFieldsNameEnum.UNIT,
+      component: 'ApiSelect',
+      componentProps: ({ formActionType }) => {
+        const { setFieldsValue } = formActionType;
+        return {
+          placeholder: '请选择单位',
+          api: async (params: Recordable) => {
+            const list = await findDictItemByCode(params);
+            list.map((item) => (item.itemText = `${item.itemText} / ${item.itemValue}`));
+            return list;
+          },
+          params: {
+            dictCode: DictEnum.ATTRIBUTE_UNIT,
+          },
+          labelInValue: true,
+          labelField: 'itemText',
+          valueField: 'itemValue',
+          onChange(_, record: Record<'label' | 'value', string>) {
+            if (record) {
+              const { label } = record;
+              setFieldsValue({ [FormFieldsEnum.UNIT_NAME]: label });
+            }
+          },
+          getPopupContainer: () => document.body,
+          showSearch: true,
+          filterOption: (inputValue: string, option: Record<'label' | 'value', string>) => {
+            let { label, value } = option;
+            label = label.toLowerCase();
+            value = value.toLowerCase();
+            inputValue = inputValue.toLowerCase();
+            return label.includes(inputValue) || value.includes(inputValue);
+          },
+        };
+      },
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) &&
+        (model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_INT ||
+          model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.NUMBER_DOUBLE),
+    },
+    {
+      field: FormFieldsEnum.BOOL_CLOSE,
+      component: 'Input',
+      required: true,
+      label: FormFieldsNameEnum.BOOL_CLOSE,
+      componentProps: {
+        placeholder: '如：关',
+      },
+      defaultValue: '关',
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) && model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.BOOL,
+      dynamicRules: ({ model }) => {
+        const close = model[FormFieldsEnum.BOOL_CLOSE];
+        const open = model[FormFieldsEnum.BOOL_OPEN];
+        return [
+          {
+            required: true,
+            message: `布尔值不能为空`,
+          },
+          {
+            validator() {
+              if (open === close) return Promise.reject('布尔值不能相同');
+              return Promise.resolve();
+            },
+          },
+        ];
+      },
+    },
+    {
+      field: FormFieldsEnum.BOOL_OPEN,
+      component: 'Input',
+      required: true,
+      label: FormFieldsNameEnum.BOOL_OPEN,
+      componentProps: {
+        placeholder: '如：开',
+      },
+      defaultValue: '开',
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) && model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.BOOL,
+      dynamicRules: ({ model }) => {
+        const close = model[FormFieldsEnum.BOOL_CLOSE];
+        const open = model[FormFieldsEnum.BOOL_OPEN];
+        return [
+          {
+            required: true,
+            message: `布尔值不能为空`,
+          },
+          {
+            validator() {
+              if (open === close) return Promise.reject('布尔值不能相同');
+              return Promise.resolve();
+            },
+          },
+        ];
+      },
+    },
+    {
+      field: FormFieldsEnum.LENGTH,
+      component: 'Input',
+      required: true,
+      label: FormFieldsNameEnum.LENGTH,
+      defaultValue: '10240',
+      colProps: {
+        span: 8,
+      },
+      componentProps: {
+        placeholder: '请输入数据长度',
+      },
+      renderComponentContent: () => {
+        return {
+          suffix: () => '字节',
+        };
+      },
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) && model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.STRING,
+    },
+    {
+      field: FormFieldsEnum.ENUMS_DATA,
+      label: FormFieldsNameEnum.ENUMS_DATA,
+      component: 'Input',
+      slot: FormFieldsEnum.ENUMS_DATA,
+      changeEvent: 'update:value',
+      valueField: 'value',
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ) && model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.ENUM,
+    },
+    {
+      field: FormFieldsEnum.STRUCT_DATA,
+      label: FormFieldsNameEnum.STRUCT_DATA,
+      component: 'Input',
+      slot: FormFieldsEnum.STRUCT_DATA,
+      changeEvent: 'update:value',
+      valueField: 'value',
+      required: true,
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.DATA_TYPE] === DataTypeEnum.STRUCT &&
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ),
+    },
+  ];
+};

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

+<script setup lang="ts">
+  import { Button, Divider } from 'ant-design-vue';
+  import { cloneDeep } from 'lodash';
+  import { toRaw, unref } from 'vue';
+  import CreateStructModal from './CreateStructModal.vue';
+  import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
+  import { useModal } from '/@/components/Modal';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
+  import { DataActionModeEnum } from '/@/enums/toolEnum';
+
+  const props = withDefaults(
+    defineProps<{
+      buttonName?: string;
+      disabled?: boolean;
+      value?: StructJSON[];
+      dataType?: DataTypeEnum[];
+      mode?: DataActionModeEnum;
+    }>(),
+    {
+      buttonName: '+ 新增参数',
+      value: () => [],
+      dataType: () => Object.values(DataTypeEnum),
+    }
+  );
+
+  const emits = defineEmits(['update:value']);
+
+  const [registerModal, { openModal, closeModal }] = useModal();
+
+  const handleOpenCreateModal = () => {
+    openModal(true, {
+      mode: DataActionModeEnum.CREATE,
+    } as ModalParamsType);
+  };
+
+  const handleEdit = (item: StructJSON) => {
+    openModal(true, {
+      mode: DataActionModeEnum.UPDATE,
+      record: cloneDeep(item),
+    } as ModalParamsType);
+  };
+
+  const handleDelete = (item: StructJSON) => {
+    const index = props.value.findIndex((temp) => item.identifier === temp.identifier);
+
+    if (~index) {
+      const _values = cloneDeep(props.value);
+      _values.splice(index, 1);
+      emits('update:value', _values);
+    }
+  };
+
+  const handleEditComplete = (value: StructJSON) => {
+    const _value = cloneDeep(toRaw(unref(props.value)));
+    const index = _value.findIndex((item) => item.identifier === value.identifier);
+    ~index ? _value.splice(index, 1, value) : _value.push(value);
+    emits('update:value', _value);
+    closeModal();
+  };
+</script>
+
+<template>
+  <section>
+    <main>
+      <div
+        v-for="item in value"
+        :key="item.identifier"
+        class="flex items-center justify-between px-2 py-1 mb-2 bg-blue-50 text-gray-600"
+      >
+        <div>
+          <span>参数名称:</span>
+          <span class="ml-1">{{ item.functionName }}</span>
+        </div>
+        <div>
+          <Button type="link" @click="handleEdit(item)">
+            {{ mode === DataActionModeEnum.READ ? '查看' : '编辑' }}
+          </Button>
+          <Divider type="vertical" />
+          <Button
+            type="link"
+            @click="handleDelete(item)"
+            :disabled="mode === DataActionModeEnum.READ"
+          >
+            删除
+          </Button>
+        </div>
+      </div>
+    </main>
+    <Button type="link" @click="handleOpenCreateModal" :disabled="mode === DataActionModeEnum.READ">
+      {{ buttonName }}
+    </Button>
+    <CreateStructModal
+      :value="value"
+      @register="registerModal"
+      @complete="handleEditComplete"
+      :dataType="dataType"
+      :mode="mode"
+    />
+  </section>
+</template>
+./index.config

+import { unref } from 'vue';
+import { createHexCommandRuleValidator } from '.';
+import { createFunctionNameFormItem, createIdentifierFormItem } from './DataTypeForm/config';
+import { useObjectModelFormContext } from './useObjectModelFormContext';
+import { findDictItemByCode } from '/@/api/system/dict';
+import { FormSchema } from '/@/components/Form';
+import {
+  ServiceCallTypeEnum,
+  ServiceCallTypeNameEnum,
+  TransportTypeEnum,
+} from '/@/enums/deviceEnum';
+import { DictEnum } from '/@/enums/dictEnum';
+import {
+  ObjectModelAccessModeEnum,
+  FunctionTypeEnum,
+  FunctionTypeNameEnum,
+  ObjectEventTypeEnum,
+} from '/@/enums/objectModelEnum';
+import { DataActionModeEnum } from '/@/enums/toolEnum';
+
+export enum FormFieldsEnum {
+  FUNCTION_TYPE = 'functionType',
+  FUNCTION_NAME = 'functionName',
+  IDENTIFIER = 'identifier',
+  DATA_TYPE = 'dataType',
+  ACCESS_MODE = 'accessMode',
+  VALUE_RANGE = 'valueRange',
+  STEP = 'step',
+  UNIT = 'unit',
+  UNIT_NAME = 'unitName',
+  REMARK = 'remark',
+  BOOL_CLOSE = 'boolClose',
+  BOOL_OPEN = 'boolOpen',
+  LENGTH = 'length',
+  EXTENSION_DESC = 'extensionDesc',
+  ENUMS_DATA = 'enumsData',
+  STRUCT_DATA = 'structData',
+
+  CALL_TYPE = 'callType',
+  SERVICE_COMMAND = 'serviceCommand',
+  INPUT_DATA = 'inputData',
+  OUTPUT_DATA = 'outputData',
+
+  EVENT_TYPE = 'eventType',
+
+  DATA_TYPE_FORM = 'dataTypeForm',
+}
+
+export enum FormFieldsNameEnum {
+  FUNCTION_TYPE = '功能类型',
+  FUNCTION_NAME = '功能名称',
+  IDENTIFIER = '功能标识符',
+  DATA_TYPE = '数据类型',
+  ACCESS_MODE = '读写类型',
+  VALUE_RANGE = '取值范围',
+  STEP = '步长',
+  UNIT = '单位',
+  UNIT_NAME = '单位名称',
+  REMARK = '备注',
+  BOOL_CLOSE = '0 - 关',
+  BOOL_OPEN = '1 - 开',
+  LENGTH = '数据长度(字节)',
+  EXTENSION_DESC = '拓展描述符',
+  ENUMS_DATA = '枚举项',
+  STRUCT_DATA = 'JSON对象',
+
+  CALL_TYPE = '调用方式',
+  SERVICE_COMMAND = '输入参数',
+  INPUT_DATA = '输入参数',
+  OUTPUT_DATA = '输出参数',
+
+  EVENT_TYPE = '事件类型',
+}
+
+export const getFormSchemas = ({
+  transportType,
+}: {
+  transportType?: string;
+  mode?: DataActionModeEnum;
+}): FormSchema[] => {
+  return [
+    {
+      field: FormFieldsEnum.FUNCTION_TYPE,
+      label: FormFieldsNameEnum.FUNCTION_TYPE,
+      component: 'Segmented',
+      defaultValue: FunctionTypeEnum.PROPERTIES,
+      required: true,
+      dynamicDisabled: () => {
+        const { getModalMode } = useObjectModelFormContext();
+        return unref(getModalMode) !== DataActionModeEnum.CREATE;
+      },
+      componentProps: ({ formActionType }) => {
+        return {
+          options: Object.keys(FunctionTypeEnum).map((key) => ({
+            title: FunctionTypeNameEnum[key],
+            value: FunctionTypeEnum[key],
+          })),
+          onChange() {
+            const { setFieldsValue, clearValidate } = formActionType;
+            setFieldsValue({
+              [FormFieldsEnum.INPUT_DATA]: [],
+              [FormFieldsEnum.OUTPUT_DATA]: [],
+              [FormFieldsEnum.STRUCT_DATA]: [],
+              [FormFieldsEnum.SERVICE_COMMAND]: null,
+            });
+            clearValidate();
+          },
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.DATA_TYPE_FORM,
+      component: 'Input',
+      label: '',
+      ifShow: ({ model }) => model[FormFieldsEnum.FUNCTION_TYPE] === FunctionTypeEnum.PROPERTIES,
+      colSlot: FormFieldsEnum.DATA_TYPE_FORM,
+    },
+    createFunctionNameFormItem({
+      ifShow: ({ model }) => model[FormFieldsEnum.FUNCTION_TYPE] !== FunctionTypeEnum.PROPERTIES,
+    }),
+    createIdentifierFormItem({
+      ifShow: ({ model }) => model[FormFieldsEnum.FUNCTION_TYPE] !== FunctionTypeEnum.PROPERTIES,
+    }),
+    {
+      field: FormFieldsEnum.EXTENSION_DESC,
+      component: 'Input',
+      label: FormFieldsNameEnum.EXTENSION_DESC,
+      slot: FormFieldsEnum.EXTENSION_DESC,
+      ifShow: ({ model }) =>
+        transportType === TransportTypeEnum.TCP &&
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ),
+    },
+    {
+      field: FormFieldsEnum.ACCESS_MODE,
+      component: 'ApiRadioGroup',
+      label: FormFieldsNameEnum.ACCESS_MODE,
+      required: true,
+      ifShow: ({ model }) =>
+        ![FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ),
+      defaultValue: ObjectModelAccessModeEnum.READ_AND_WRITE,
+      componentProps: {
+        placeholder: '请选择读写类型',
+        api: findDictItemByCode,
+        params: {
+          dictCode: DictEnum.READ_WRITE_TYP,
+        },
+        labelField: 'itemText',
+        valueField: 'itemValue',
+      },
+    },
+
+    // 服务
+    {
+      field: FormFieldsEnum.CALL_TYPE,
+      label: FormFieldsNameEnum.CALL_TYPE,
+      component: 'RadioGroup',
+      defaultValue: ServiceCallTypeEnum.ASYNC,
+      required: true,
+      ifShow: ({ model }) => model[FormFieldsEnum.FUNCTION_TYPE] === FunctionTypeEnum.SERVICE,
+      componentProps: () => {
+        return {
+          options: Object.keys(ServiceCallTypeEnum).map((value) => ({
+            label: ServiceCallTypeNameEnum[value],
+            value,
+          })),
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.SERVICE_COMMAND,
+      label: FormFieldsNameEnum.SERVICE_COMMAND,
+      component: 'Input',
+      required: true,
+      rules: [{ message: '输入参数为必填项', required: true }, ...createHexCommandRuleValidator()],
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.FUNCTION_TYPE] === FunctionTypeEnum.SERVICE &&
+        transportType === TransportTypeEnum.TCP,
+      componentProps: () => {
+        return {
+          placeholder: '请输入ASCII或HEX服务命令',
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.INPUT_DATA,
+      label: FormFieldsNameEnum.INPUT_DATA,
+      component: 'Input',
+      slot: FormFieldsEnum.INPUT_DATA,
+      changeEvent: 'update:value',
+      valueField: 'value',
+      required: true,
+      ifShow: ({ model }) =>
+        model[FormFieldsEnum.FUNCTION_TYPE] === FunctionTypeEnum.SERVICE &&
+        transportType !== TransportTypeEnum.TCP,
+    },
+
+    // 事件
+    {
+      field: FormFieldsEnum.EVENT_TYPE,
+      label: FormFieldsNameEnum.EVENT_TYPE,
+      required: true,
+      component: 'ApiRadioGroup',
+      defaultValue: ObjectEventTypeEnum.INFO,
+      ifShow: ({ model }) => model[FormFieldsEnum.FUNCTION_TYPE] === FunctionTypeEnum.EVENTS,
+      componentProps: () => {
+        return {
+          placeholder: '请选择事件类型',
+          api: findDictItemByCode,
+          params: {
+            dictCode: DictEnum.EVENT_TYPE,
+          },
+          labelField: 'itemText',
+          valueField: 'itemValue',
+          getPopupContainer: () => document.body,
+        };
+      },
+    },
+    {
+      field: FormFieldsEnum.OUTPUT_DATA,
+      label: FormFieldsNameEnum.OUTPUT_DATA,
+      component: 'Input',
+      slot: FormFieldsEnum.OUTPUT_DATA,
+      changeEvent: 'update:value',
+      valueField: 'value',
+      ifShow: ({ model }) =>
+        [FunctionTypeEnum.SERVICE, FunctionTypeEnum.EVENTS].includes(
+          model[FormFieldsEnum.FUNCTION_TYPE]
+        ),
+    },
+
+    {
+      field: FormFieldsEnum.REMARK,
+      label: FormFieldsNameEnum.REMARK,
+      component: 'InputTextArea',
+      componentProps: {
+        rows: 4,
+        maxLength: 100,
+        placeholder: '请输入描述',
+      },
+    },
+  ];
+};

+import { Rule } from '/@/components/Form';
+
+export { default as ObjectModelForm } from './index.vue';
+
+export function createHexCommandRuleValidator(): Rule[] {
+  return [
+    {
+      message: '请输入ASCII或HEX服务命令(0~9/A~F)',
+      validator(_rule, value, _callback) {
+        const reg = /^[\s0-9a-fA-F]+$/;
+
+        if (reg.test(value)) return Promise.resolve();
+        return Promise.reject('请输入ASCII或HEX服务命令(0~9/A~F)');
+      },
+    },
+  ];
+}

+<script setup lang="ts">
+  import { useForm, BasicForm } from '/@/components/Form';
+  import { getFormSchemas, FormFieldsEnum } from './config';
+  import { StructFormItem } from './StructFormItem';
+  import { useObjectFormData } from './useObjectFormData';
+  import { computed, ref, unref } from 'vue';
+  import { TransportTypeEnum } from '/@/enums/deviceEnum';
+  import { DataTypeForm } from './DataTypeForm';
+  import { DataActionModeEnum } from '/@/enums/toolEnum';
+  import { ExtendDesc } from './ExtendDesc';
+  import { createObjectModelFormContext } from './useObjectModelFormContext';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
+
+  const props = defineProps<{
+    transportType?: TransportTypeEnum;
+    mode?: DataActionModeEnum;
+  }>();
+
+  const dataTypeFormRef = ref<InstanceType<typeof DataTypeForm>>();
+
+  const [register, formActionType] = useForm({
+    schemas: getFormSchemas(props),
+    layout: 'vertical',
+    showActionButtonGroup: false,
+  });
+
+  const { getFieldsValue, setFieldsValue, validate, resetFieldsValue } = useObjectFormData({
+    formActionType,
+    dataTypeFormRef,
+    transportType: props.transportType!,
+  });
+
+  const objectModelType = ref(DataTypeEnum.NUMBER_INT);
+
+  createObjectModelFormContext({
+    getTransportType: computed(() => props.transportType),
+    getDataType: computed(() => unref(objectModelType)),
+    getModalMode: computed(() => props.mode),
+  });
+
+  const handleDataTypeFormChange = (field: string, value: any) => {
+    if (field === FormFieldsEnum.DATA_TYPE) {
+      objectModelType.value = value;
+    }
+  };
+
+  defineExpose({
+    getFieldsValue,
+    setFieldsValue,
+    validate,
+    resetFieldsValue,
+  });
+</script>
+
+<template>
+  <BasicForm @register="register" :disabled="mode === DataActionModeEnum.READ">
+    <template #dataTypeForm>
+      <DataTypeForm
+        ref="dataTypeFormRef"
+        :mode="mode"
+        @field-value-change="handleDataTypeFormChange"
+      />
+    </template>
+    <template #inputData="{ model, field }">
+      <StructFormItem v-model:value="model[field]" buttonName="+ 增加参数" :mode="mode" />
+    </template>
+    <template #outputData="{ model, field }">
+      <StructFormItem v-model:value="model[field]" buttonName="+ 增加参数" :mode="mode" />
+    </template>
+    <template #extensionDesc="{ model, field }">
+      <ExtendDesc v-model:value="model[field]" :disabled="mode === DataActionModeEnum.READ" />
+    </template>
+  </BasicForm>
+</template>

+import { FormFieldsEnum } from './config';
+import { ExtensionDesc, StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { ServiceCallTypeEnum } from '/@/enums/deviceEnum';
+import {
+  FunctionTypeEnum,
+  ObjectEventTypeEnum,
+  ObjectModelAccessModeEnum,
+} from '/@/enums/objectModelEnum';
+
+export interface ObjectModelFormGetFieldsValueType {
+  [FormFieldsEnum.FUNCTION_TYPE]: FunctionTypeEnum;
+  [FormFieldsEnum.ACCESS_MODE]?: ObjectModelAccessModeEnum;
+  [FormFieldsEnum.REMARK]?: string;
+  [FormFieldsEnum.FUNCTION_NAME]: string;
+  [FormFieldsEnum.IDENTIFIER]: string;
+  [FormFieldsEnum.EVENT_TYPE]?: ObjectEventTypeEnum;
+
+  [FormFieldsEnum.CALL_TYPE]?: ServiceCallTypeEnum;
+  [FormFieldsEnum.INPUT_DATA]?: StructJSON[];
+  [FormFieldsEnum.OUTPUT_DATA]?: StructJSON[];
+
+  [FormFieldsEnum.SERVICE_COMMAND]?: string;
+  [FormFieldsEnum.EXTENSION_DESC]?: ExtensionDesc;
+
+  // EXTENSION_DESC = 'extensionDesc',
+  // STRUCT_DATA = 'structData',
+  // INPUT_DATA = 'inputData',
+  // OUTPUT_DATA = 'outputData',
+}

+import DataTypeForm from './DataTypeForm.vue';
+import { FormFieldsEnum } from './config';
+import { ObjectModelFormGetFieldsValueType } from './types';
+import { DefineComponentsBasicExpose } from '/#/utils';
+import { ModelOfMatterParams, StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { FormActionType } from '/@/components/Form';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
+import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
+import { Ref, toRaw, unref } from 'vue';
+
+interface UseObjectFormDataParamsType {
+  formActionType: FormActionType;
+  dataTypeFormRef: Ref<InstanceType<typeof DataTypeForm> | undefined>;
+  transportType: TransportTypeEnum;
+}
+
+function handlePropertiesType(
+  value: ObjectModelFormGetFieldsValueType,
+  dataTypeFormValue: StructJSON,
+  transportType?: TransportTypeEnum
+): ModelOfMatterParams {
+  const { functionType, accessMode, remark, extensionDesc } = value;
+  const { functionName, identifier, dataType } = dataTypeFormValue;
+
+  const result: ModelOfMatterParams = {
+    functionType,
+    functionName,
+    identifier,
+    functionJson: {
+      dataType,
+    },
+    accessMode,
+    remark,
+  };
+
+  if (transportType === TransportTypeEnum.TCP && extensionDesc)
+    result.extensionDesc = extensionDesc;
+
+  return result;
+}
+
+function handleServiceType(
+  value: ObjectModelFormGetFieldsValueType,
+  transportType: TransportTypeEnum
+): ModelOfMatterParams {
+  const {
+    functionName,
+    identifier,
+    functionType,
+    remark,
+    inputData = [],
+    outputData = [],
+    serviceCommand,
+  } = value;
+
+  return {
+    functionType,
+    functionName,
+    identifier,
+    remark,
+    functionJson: {
+      inputData:
+        transportType === TransportTypeEnum.TCP
+          ? [{ [FormFieldsEnum.SERVICE_COMMAND]: serviceCommand } as unknown as StructJSON]
+          : inputData,
+      outputData,
+    },
+  };
+}
+
+function handleEventType(value: ObjectModelFormGetFieldsValueType): ModelOfMatterParams {
+  const { functionName, identifier, functionType, remark, eventType, outputData = [] } = value;
+
+  return {
+    functionType,
+    functionName,
+    identifier,
+    remark,
+    eventType,
+    functionJson: {
+      outputData,
+    },
+  };
+}
+
+export const useObjectFormData = ({
+  formActionType,
+  dataTypeFormRef,
+  transportType,
+}: UseObjectFormDataParamsType): DefineComponentsBasicExpose<ModelOfMatterParams> => {
+  const getFieldsValue = (): ModelOfMatterParams => {
+    const value = formActionType.getFieldsValue() as ObjectModelFormGetFieldsValueType;
+    const { functionType } = value;
+
+    if (functionType === FunctionTypeEnum.PROPERTIES) {
+      const dataTypeFormValue = unref(dataTypeFormRef)?.getFieldsValue?.();
+      return handlePropertiesType(value, dataTypeFormValue!, transportType);
+    }
+
+    if (functionType === FunctionTypeEnum.EVENTS) {
+      return handleEventType(value);
+    } else {
+      return handleServiceType(value, transportType);
+    }
+  };
+
+  const setFieldsValue = (values: ModelOfMatterParams) => {
+    values = toRaw(unref(values));
+    const {
+      functionName,
+      identifier,
+      functionJson,
+      functionType,
+      accessMode,
+      callType,
+      remark,
+      extensionDesc,
+    } = values;
+    const { dataType, inputData = [], outputData = [] } = functionJson || {};
+
+    formActionType.setFieldsValue({
+      identifier,
+      functionName,
+      functionType,
+      accessMode,
+      callType,
+      inputData,
+      outputData,
+      remark,
+      serviceCommand: transportType === TransportTypeEnum.TCP ? inputData?.[0]?.serviceCommand : '',
+      extensionDesc,
+    } as ObjectModelFormGetFieldsValueType);
+
+    if (functionType === FunctionTypeEnum.PROPERTIES) {
+      unref(dataTypeFormRef)?.setFieldsValue({
+        functionName,
+        identifier,
+        dataType,
+      } as StructJSON);
+    }
+  };
+
+  const validate = async () => {
+    await formActionType.validate();
+    await unref(dataTypeFormRef)?.validate?.();
+  };
+
+  const resetFieldsValue = () => {
+    formActionType.resetFields();
+  };
+
+  return { getFieldsValue, setFieldsValue, validate, resetFieldsValue };
+};

+import type { InjectionKey, ComputedRef } from 'vue';
+import { createContext, useContext } from '/@/hooks/core/useContext';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
+import { DataActionModeEnum } from '/@/enums/toolEnum';
+
+export interface ObjectModelFormContextProps {
+  getTransportType: ComputedRef<TransportTypeEnum | undefined>;
+  getDataType: ComputedRef<DataTypeEnum>;
+  getModalMode: ComputedRef<DataActionModeEnum | undefined>;
+}
+
+const key: InjectionKey<ObjectModelFormContextProps> = Symbol();
+
+export function createObjectModelFormContext(context: ObjectModelFormContextProps) {
+  return createContext<ObjectModelFormContextProps>(context, key, { native: true });
+}
+
+export function useObjectModelFormContext() {
+  return useContext<ObjectModelFormContextProps>(key);
+}

 <script lang="ts" setup>
   import { computed } from 'vue';
   import COAPDescription from './COAPDescription.vue';
-  import { TransportTypeEnum } from './const';
   import DefaultConfiguration from './DefaultConfiguration.vue';
   import LWM2MDescription from './LWM2MDescription.vue';
   import MQTTConfiguration from './MQTTConfiguration.vue';
   import SNMPDescription from './SNMPDescription.vue';
   import TCPDescription from './TCPDescription.vue';
   import { DeviceRecord } from '/@/api/device/model/deviceModel';
+  import { TransportTypeEnum } from '/@/enums/deviceEnum';
 
   const props = defineProps<{
     record: DeviceRecord;

-export enum TransportTypeEnum {
-  DEFAULT = 'DEFAULT',
-  MQTT = 'MQTT',
-  COAP = 'COAP',
-  LWM2M = 'LWM2M',
-  SNMP = 'SNMP',
-  TCP = 'TCP',
-}
-
 export enum TransportPayloadTypeEnum {
   PROTOBUF = 'PROTOBUF',
   JSON = 'JSON',

@@ -2,8 +2,7 @@ import { BasicColumn, FormSchema } from '/@/components/Table';
 import { findDictItemByCode } from '/@/api/system/dict';
 import { h, unref } from 'vue';
 import { Tooltip } from 'ant-design-vue';
-
-import { FunctionType } from '/@/views/device/profiles/step/cpns/physical/cpns/config';
+import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
 import { useMessage } from '/@/hooks/web/useMessage';
 import { useClipboard } from '@vueuse/core';
 import { DictEnum } from '/@/enums/dictEnum';
@@ -26,10 +25,10 @@ export const columns: BasicColumn[] = [
   },
 ];
 
-export const formatFunctionType: Record<FunctionType, string> = {
-  [FunctionType.PROPERTIES]: '属性',
-  [FunctionType.EVENTS]: '事件',
-  [FunctionType.SERVICE]: '服务',
+export const formatFunctionType: Record<FunctionTypeEnum, string> = {
+  [FunctionTypeEnum.PROPERTIES]: '属性',
+  [FunctionTypeEnum.EVENTS]: '事件',
+  [FunctionTypeEnum.SERVICE]: '服务',
 };
 
 const handleCopy = async (value: string) => {
@@ -45,7 +44,7 @@ export const columnsDrawer: BasicColumn[] = [
     title: '功能类型',
     dataIndex: 'functionType',
     width: 90,
-    format: (text: FunctionType) => {
+    format: (text: FunctionTypeEnum) => {
       return formatFunctionType[text];
     },
   },

@@ -5,7 +5,8 @@ import { MessageEnum } from '/@/enums/messageEnum';
 import { numberRule } from '/@/utils/rules';
 
 import { deviceConfigGetRuleChain } from '/@/api/device/deviceConfigApi';
-import { FormField, FunctionType } from './step/cpns/physical/cpns/config';
+import { FormField } from './step/cpns/physical/cpns/config';
+import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
 import { h, unref } from 'vue';
 import { Tag, Tooltip } from 'ant-design-vue';
 import { EventType, EventTypeColor, EventTypeName } from '../list/cpns/tabs/EventManage/config';
@@ -68,10 +69,10 @@ export const steps = [
   },
 ];
 
-export const formatFunctionType: Record<FunctionType, string> = {
-  [FunctionType.PROPERTIES]: '属性',
-  [FunctionType.EVENTS]: '事件',
-  [FunctionType.SERVICE]: '服务',
+export const formatFunctionType: Record<FunctionTypeEnum, string> = {
+  [FunctionTypeEnum.PROPERTIES]: '属性',
+  [FunctionTypeEnum.EVENTS]: '事件',
+  [FunctionTypeEnum.SERVICE]: '服务',
 };
 
 export const physicalColumn: BasicColumn[] = [
@@ -79,7 +80,7 @@ export const physicalColumn: BasicColumn[] = [
     title: '功能类型',
     dataIndex: FormField.FUNCTION_TYPE,
     width: 90,
-    format: (text: FunctionType) => {
+    format: (text: FunctionTypeEnum) => {
       return formatFunctionType[text];
     },
   },
@@ -153,9 +154,12 @@ export const modelOfMatterForm: FormSchema[] = [
     colProps: { span: 8 },
     componentProps: {
       options: [
-        { label: formatFunctionType[FunctionType.PROPERTIES], value: FunctionType.PROPERTIES },
-        { label: formatFunctionType[FunctionType.EVENTS], value: FunctionType.EVENTS },
-        { label: formatFunctionType[FunctionType.SERVICE], value: FunctionType.SERVICE },
+        {
+          label: formatFunctionType[FunctionTypeEnum.PROPERTIES],
+          value: FunctionTypeEnum.PROPERTIES,
+        },
+        { label: formatFunctionType[FunctionTypeEnum.EVENTS], value: FunctionTypeEnum.EVENTS },
+        { label: formatFunctionType[FunctionTypeEnum.SERVICE], value: FunctionTypeEnum.SERVICE },
       ],
     },
   },

@@ -147,7 +147,6 @@
     getModelList,
     releaseModel,
   } from '/@/api/device/modelOfMatter';
-  import { OpenModelOfMatterModelParams, OpenModelMode } from './cpns/physical/types';
   import {
     ModelOfMatterItemRecordType,
     ModelOfMatterParams,
@@ -156,8 +155,9 @@
   import { isObject } from '/@/utils/is';
   import { useRole } from '/@/hooks/business/useRole';
   import { ExportModelCategory } from '/@/api/device/modelOfMatter';
-  import { FunctionType } from './cpns/physical/cpns/config';
+  import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
   import SelectImport from '../components/SelectImport.vue';
+  import { DataActionModeEnum } from '/@/enums/toolEnum';
 
   const { isPlatformAdmin, isSysadmin } = useRole();
   defineEmits(['register']);
@@ -209,23 +209,17 @@
     if (record) {
       openModal(true, {
         record,
-        mode: OpenModelMode.VIEW,
-      } as OpenModelOfMatterModelParams);
+        mode: DataActionModeEnum.READ,
+      } as ModalParamsType<ModelOfMatterParams>);
     }
   };
 
   // 新增或编辑
   const handleCreateOrEdit = (record?: ModelOfMatterParams) => {
-    if (record) {
-      openModal(true, {
-        mode: OpenModelMode.UPDATE,
-        record,
-      } as OpenModelOfMatterModelParams);
-    } else {
-      openModal(true, {
-        mode: OpenModelMode.CREATE,
-      } as OpenModelOfMatterModelParams);
-    }
+    openModal(true, {
+      record,
+      mode: record ? DataActionModeEnum.UPDATE : DataActionModeEnum.CREATE,
+    } as ModalParamsType<ModelOfMatterParams>);
   };
 
   const handleDeleteOrBatchDelete = async (record?: ModelOfMatterItemRecordType) => {
@@ -287,15 +281,15 @@
     return Promise.all([
       ExportModelCategory({
         deviceProfileId,
-        functionType: FunctionType.EVENTS,
+        functionType: FunctionTypeEnum.EVENTS,
       }),
       ExportModelCategory({
         deviceProfileId,
-        functionType: FunctionType.PROPERTIES,
+        functionType: FunctionTypeEnum.PROPERTIES,
       }),
       ExportModelCategory({
         deviceProfileId,
-        functionType: FunctionType.SERVICE,
+        functionType: FunctionTypeEnum.SERVICE,
       }),
     ]);
   };

 <template>
-  <div>
-    <BasicModal
-      :maskClosable="false"
-      destroy-on-close
-      v-bind="$attrs"
-      width="55rem"
-      @register="register"
-      @ok="handleSubmit"
-      @cancel="handleCancel"
-    >
-      <div class="relative">
-        <div v-if="openModalMode === OpenModelMode.CREATE">
-          <Typography>
-            <TypographyParagraph>
-              <blockquote class="bg-gray-100">{{ blockContent }}</blockquote>
-            </TypographyParagraph>
-          </Typography>
-        </div>
-        <Tabs
-          v-if="openModalMode === OpenModelMode.CREATE"
-          type="card"
-          v-model:activeKey="activeKey"
-          :size="size"
-        >
-          <TabPane :key="FunctionType.PROPERTIES" tab="属性" />
-          <TabPane :key="FunctionType.SERVICE" :disabled="isTCPGatewaySubDevice" tab="服务" />
-          <TabPane :key="FunctionType.EVENTS" tab="事件" :disabled="isTCPGatewaySubDevice" />
-        </Tabs>
-        <Attribute
-          v-if="activeKey === FunctionType.PROPERTIES"
-          :openModalMode="openModalMode"
-          :transportType="record?.transportType"
-          ref="AttrRef"
-        />
-        <Service
-          v-if="activeKey === FunctionType.SERVICE"
-          :record="$props.record"
-          :openModalMode="openModalMode"
-          ref="ServiceRef"
-        />
-        <Events
-          v-if="activeKey === FunctionType.EVENTS"
-          :openModalMode="openModalMode"
-          ref="EventsRef"
-        />
-        <!-- <div
-          v-if="openModalMode === OpenModelMode.VIEW"
-          class="absolute w-full h-full top-0 cursor-not-allowed z-50"
-        ></div> -->
-      </div>
-    </BasicModal>
-  </div>
+  <BasicModal v-bind="$attrs" :width="480" @register="register" @ok="handleSubmit">
+    <Typography>
+      <TypographyParagraph>
+        <blockquote class="bg-gray-100">{{ blockContent }}</blockquote>
+      </TypographyParagraph>
+    </Typography>
+    <ObjectModelForm
+      ref="objectModelElRef"
+      :mode="openModalMode"
+      :transport-type="(record.transportType as TransportTypeEnum)"
+    />
+  </BasicModal>
 </template>
 <script lang="ts" setup>
-  import { ref, unref, nextTick, computed } from 'vue';
+  import { ref, unref, nextTick } from 'vue';
   import { BasicModal, useModalInner } from '/@/components/Modal';
-  import { Tabs, TabPane, Typography, TypographyParagraph } from 'ant-design-vue';
-  import Attribute from './cpns/Attribute.vue';
-  import Service from './cpns/Service.vue';
-  import Events from './cpns/Events.vue';
+  import { Typography, TypographyParagraph } from 'ant-design-vue';
   import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
   import {
     createModel,
@@ -66,128 +23,77 @@
     createModelCategory,
     updateModelCategory,
   } from '/@/api/device/modelOfMatter';
-  import { DeviceRecord, DeviceTypeEnum } from '/@/api/device/model/deviceModel';
+  import { DeviceRecord } from '/@/api/device/model/deviceModel';
   import { useMessage } from '/@/hooks/web/useMessage';
-  import { OpenModelMode, OpenModelOfMatterModelParams } from './types/index';
-  import { FunctionType } from './cpns/config';
   import { useRole } from '/@/hooks/business/useRole';
+  import { ObjectModelForm } from '../../../components/ObjectModelForm';
+  import { TransportTypeEnum } from '/@/enums/deviceEnum';
+  import { DataActionModeEnum, DataActionModeNameEnum } from '/@/enums/toolEnum';
 
   const { isPlatformAdmin, isSysadmin } = useRole();
 
   const emit = defineEmits(['register', 'success']);
 
+  const objectModelElRef = ref<InstanceType<typeof ObjectModelForm>>();
+
   const props = defineProps<{
     record: DeviceRecord;
   }>();
 
-  const isTCPGatewaySubDevice = computed(() => {
-    const { record } = props;
-    const { deviceType, transportType } = record || {};
-    return deviceType === DeviceTypeEnum.SENSOR && transportType === 'TCP';
-  });
-
   const blockContent = `属性一般是指设备的运行状态，如当前温度等；服务是指设备可被调用的方法，支持定义参数，如执行某项任务；事件则是指设备上报的通知，如告警，需要被及时处理。`;
-  const activeKey = ref<FunctionType>(FunctionType.PROPERTIES);
-  const size = ref('small');
-
-  const AttrRef = ref<InstanceType<typeof Attribute>>();
 
-  const ServiceRef = ref<InstanceType<typeof Service>>();
+  const openModalMode = ref<DataActionModeEnum>(DataActionModeEnum.CREATE);
 
-  const EventsRef = ref<InstanceType<typeof Events>>();
-  const openModalMode = ref<OpenModelMode>(OpenModelMode.CREATE);
-  const openModalParams = ref<OpenModelOfMatterModelParams>();
-
-  const functionType = ref<FunctionType>();
   const { createMessage } = useMessage();
 
-  const setAttrFormData = (data: ModelOfMatterParams) => AttrRef.value?.setFormData(data);
-  const setServiceFormData = (data: ModelOfMatterParams) => ServiceRef.value?.setFormData(data);
-  const setEventsFormData = (data: ModelOfMatterParams) => EventsRef.value?.setFormData(data);
-
-  const enums = {
-    [FunctionType.PROPERTIES]: setAttrFormData,
-    [FunctionType.SERVICE]: setServiceFormData,
-    [FunctionType.EVENTS]: setEventsFormData,
-  };
-
-  function setFormData(type: FunctionType, value: ModelOfMatterParams) {
-    const setFn = enums[type];
-    setFn(value);
-  }
+  const currentActionModel = ref<ModelOfMatterParams>();
 
   const [register, { closeModal, setModalProps }] = useModalInner(
-    async (data: OpenModelOfMatterModelParams) => {
-      openModalParams.value = data;
+    async (data: ModalParamsType<ModelOfMatterParams>) => {
       const { mode, record } = data;
       openModalMode.value = mode;
       if (record) {
-        functionType.value = data.record.functionType;
-        activeKey.value = data.record.functionType;
         await nextTick();
-        setFormData(record.functionType, record as unknown as ModelOfMatterParams);
       }
-      if (unref(openModalMode) === OpenModelMode.VIEW) {
-        setModalProps({
-          showOkBtn: false,
-          showCancelBtn: false,
-          title: '查看物模型',
-        });
-      } else {
-        const title = unref(openModalMode) === OpenModelMode.UPDATE ? '编辑物模型' : '新增物模型';
-        setModalProps({ title, showOkBtn: true, showCancelBtn: true });
+      const title = `${DataActionModeNameEnum[mode]}物模型`;
+      setModalProps({
+        showOkBtn: mode !== DataActionModeEnum.READ,
+        title,
+      });
+
+      if (mode !== DataActionModeEnum.CREATE && record) {
+        currentActionModel.value = record;
+        unref(objectModelElRef)?.setFieldsValue(record || {});
       }
-      AttrRef.value?.setDisable(unref(openModalMode) === OpenModelMode.VIEW);
-      EventsRef.value?.setDisable(unref(openModalMode) === OpenModelMode.VIEW);
-      ServiceRef.value?.setDisable(unref(openModalMode) === OpenModelMode.VIEW);
     }
   );
 
-  const handleCancel = (flag) => {
-    AttrRef.value?.resetFormData();
-    ServiceRef.value?.resetFormData();
-    EventsRef.value?.resetFormData();
-    activeKey.value = FunctionType.PROPERTIES;
-    if (flag) {
-      closeModal();
-    }
-  };
-
   const handleSubmit = async () => {
     try {
       setModalProps({ loading: false, okButtonProps: { loading: true } });
+      await unref(objectModelElRef)?.validate?.();
+      const value = unref(objectModelElRef)!.getFieldsValue();
 
-      let params: Partial<ModelOfMatterParams>;
-      if (activeKey.value == FunctionType.PROPERTIES) {
-        params = (await AttrRef.value?.getFormData()) || {};
-      } else if (activeKey.value == FunctionType.SERVICE) {
-        params = (await ServiceRef.value?.getFormData()) || {};
-      } else {
-        params = (await EventsRef.value?.getFormData()) || {};
-      }
-      params.deviceProfileId = props.record.id;
-
-      if (unref(openModalMode) === OpenModelMode.CREATE) {
-        (unref(isSysadmin) || unref(isPlatformAdmin)) && props.record.ifShowClass
-          ? await createModelCategory({
-              ...params,
-              deviceProfileId: undefined,
-              categoryId: props.record.id,
-            })
-          : await createModel(params);
-        createMessage.success('创建成功');
-      } else {
-        params.id = unref(openModalParams)?.record.id;
-        (unref(isSysadmin) || unref(isPlatformAdmin)) && props.record.ifShowClass
-          ? await updateModelCategory({
-              ...params,
-              deviceProfileId: undefined,
-              categoryId: props.record.id,
-            })
-          : await updateModel(params);
-        createMessage.success('修改成功');
-      }
+      const isCategoryAction =
+        (unref(isSysadmin) || unref(isPlatformAdmin)) && props.record.ifShowClass;
+
+      const submitFn =
+        unref(openModalMode) === DataActionModeEnum.CREATE
+          ? isCategoryAction
+            ? createModelCategory
+            : createModel
+          : isCategoryAction
+          ? updateModelCategory
+          : updateModel;
+
+      value[isCategoryAction ? 'categoryId' : 'deviceProfileId'] = props.record.id;
+
+      if (unref(openModalMode) !== DataActionModeEnum.CREATE)
+        value.id = unref(currentActionModel)?.id;
+
+      await submitFn(value);
 
+      createMessage.success('操作成功');
       closeModal();
       emit('success');
     } catch (error) {

@@ -24,7 +24,7 @@
   import { DeviceRecord } from '/@/api/device/model/deviceModel';
   import { Button } from 'ant-design-vue';
   import { getModelTsl } from '/@/api/device/modelOfMatter';
-  import { FunctionType } from './cpns/config';
+  import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
   import { isObject } from '/@/utils/is';
 
   defineEmits(['register']);
@@ -75,15 +75,15 @@
     return Promise.all([
       getModelTsl({
         deviceProfileId,
-        functionType: FunctionType.EVENTS,
+        functionType: FunctionTypeEnum.EVENTS,
       }),
       getModelTsl({
         deviceProfileId,
-        functionType: FunctionType.PROPERTIES,
+        functionType: FunctionTypeEnum.PROPERTIES,
       }),
       getModelTsl({
         deviceProfileId,
-        functionType: FunctionType.SERVICE,
+        functionType: FunctionTypeEnum.SERVICE,
       }),
     ]);
   };

-<script lang="ts" setup>
-  import { BasicForm, useForm } from '/@/components/Form';
-  import { DataType, ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
-  import { StructFormValue } from '/@/components/Form/src/externalCompns/components/StructForm/type';
-  import {
-    transfromToStructJSON,
-    excludeIdInStructJSON,
-  } from '/@/components/Form/src/externalCompns/components/StructForm/util';
-  import { FunctionType } from './config';
-  import { isArray } from 'lodash';
-  import { OpenModelMode } from '../types';
-  import { formSchemas } from '/@/components/Form/src/externalCompns/components/StructForm/config';
-  import { TransportTypeEnum } from '../../../../components/TransportDescript/const';
-  import { DataTypeEnum } from '/@/enums/objectModelEnum';
-  import { ref, unref } from 'vue';
-  import EnumList from '/@/components/Form/src/externalCompns/components/StructForm/EnumList.vue';
-
-  const props = defineProps<{ openModalMode: OpenModelMode; transportType?: string | undefined }>();
-
-  const enumListRef = ref<InstanceType<typeof EnumList>>();
-
-  const [register, { validate, getFieldsValue, resetFields, setFieldsValue }] = useForm({
-    labelWidth: 100,
-    schemas: formSchemas({
-      hasStructForm: false,
-      hiddenAccessMode: false,
-      isTcp: props.transportType === TransportTypeEnum.TCP,
-    }),
-    showActionButtonGroup: false,
-  });
-
-  const disabled = ref(false);
-  const setDisable = (flag: boolean) => {
-    disabled.value = flag;
-  };
-
-  async function getFormData(): Promise<Partial<ModelOfMatterParams>> {
-    await validate();
-    await unref(enumListRef)?.validate?.();
-
-    const _values = getFieldsValue() as StructFormValue;
-    const { functionName, remark, identifier, accessMode } = _values;
-    const structJSON = transfromToStructJSON(_values, unref(enumListRef)?.getFieldsValue?.());
-
-    const dataType = excludeIdInStructJSON(structJSON.dataType!);
-
-    const value = {
-      functionName,
-      functionType: FunctionType.PROPERTIES,
-      remark,
-      identifier,
-      accessMode,
-      extensionDesc: _values.extensionDesc,
-      functionJson: {
-        dataType: dataType,
-      },
-    } as ModelOfMatterParams;
-
-    return value;
-  }
-
-  const resetFormData = () => {
-    resetFields();
-  };
-
-  const setFormData = (record: ModelOfMatterParams) => {
-    const { functionJson } = record;
-    const { dataType } = functionJson!;
-
-    const { specs } = (dataType! || {}) as DataType;
-
-    const value = {
-      ...record,
-      ...functionJson,
-      ...dataType,
-      ...(isArray(specs) ? specs : { ...specs }),
-      hasStructForm: (dataType as DataType)?.type === DataTypeEnum.STRUCT,
-      enumList:
-        (dataType as DataType)?.type === DataTypeEnum.ENUM
-          ? unref((dataType as DataType).specsList)
-          : [],
-    };
-    setFieldsValue(value);
-  };
-
-  defineExpose({
-    resetFormData,
-    getFormData,
-    setFormData,
-    setDisable,
-  });
-</script>
-
-<template>
-  <BasicForm @register="register" :disabled="disabled">
-    <template #EnumList="{ field, model }">
-      <EnumList ref="enumListRef" :value="model[field]" :disabled="disabled" />
-    </template>
-  </BasicForm>
-</template>
-
-<style lang="less" scoped></style>

-<template>
-  <BasicForm @register="register" />
-</template>
-<script lang="ts" setup>
-  import { BasicForm, useForm } from '/@/components/Form';
-  import { eventSchemas, FunctionType } from './config';
-  import { ModelOfMatterParams, StructJSON } from '/@/api/device/model/modelOfMatterModel';
-  import { StructFormValue } from '/@/components/Form/src/externalCompns/components/StructForm/type';
-  import { excludeIdInStructJSON } from '/@/components/Form/src/externalCompns/components/StructForm/util';
-  import { OpenModelMode } from '../types';
-
-  defineProps<{ openModalMode: OpenModelMode }>();
-
-  const [register, { validate, resetFields, setFieldsValue, setProps }] = useForm({
-    labelWidth: 100,
-    schemas: eventSchemas,
-    actionColOptions: {
-      span: 14,
-    },
-    showResetButton: false,
-    submitOnReset: false,
-    showActionButtonGroup: false,
-  });
-
-  const setDisable = (flag: boolean) => {
-    setProps({ disabled: flag });
-  };
-
-  //回显数据
-  const setFormData = (record: ModelOfMatterParams) => {
-    const { functionJson = {}, functionName, identifier, remark, eventType } = record;
-    const { outputData } = functionJson;
-    const value = {
-      functionName,
-      identifier,
-      remark,
-      outputData,
-      eventType,
-    };
-    setFieldsValue(value);
-  };
-
-  async function getFormData() {
-    const _values = (await validate()) as StructFormValue;
-    const { functionName, remark, identifier, outputData: _outputData = [], eventType } = _values;
-    if (!_values) return {} as unknown as ModelOfMatterParams;
-
-    const outputData = (_outputData as unknown as StructJSON[]).map((item) => {
-      const dataType = excludeIdInStructJSON(item.dataType!);
-      return {
-        ...item,
-        dataType,
-      };
-    });
-
-    const value = {
-      functionName,
-      identifier,
-      remark,
-      functionType: FunctionType.EVENTS,
-      eventType,
-      functionJson: {
-        outputData,
-      },
-    } as ModelOfMatterParams;
-
-    return value;
-  }
-
-  //清空数据
-  const resetFormData = () => {
-    resetFields();
-  };
-
-  defineExpose({
-    setFormData,
-    resetFormData,
-    getFormData,
-    setDisable,
-  });
-</script>
-<style lang="less" scoped></style>

-<template>
-  <BasicForm @register="register" />
-</template>
-<script lang="ts" setup>
-  import { BasicForm, useForm } from '/@/components/Form';
-  import { FormField, serviceSchemas } from './config';
-  import { FunctionType } from './config';
-  import { StructFormValue } from '/@/components/Form/src/externalCompns/components/StructForm/type';
-  import { ModelOfMatterParams, StructJSON } from '/@/api/device/model/modelOfMatterModel';
-  import { DeviceRecord } from '/@/api/device/model/deviceModel';
-  import { excludeIdInStructJSON } from '/@/components/Form/src/externalCompns/components/StructForm/util';
-  import { OpenModelMode } from '../types';
-  import { isArray } from '/@/utils/is';
-  import { DataTypeEnum } from '/@/enums/objectModelEnum';
-
-  const props = defineProps<{
-    record: DeviceRecord;
-    openModalMode: OpenModelMode;
-  }>();
-
-  const [register, { validate, resetFields, setFieldsValue, setProps }] = useForm({
-    labelWidth: 100,
-    schemas: serviceSchemas(props.record.transportType === 'TCP'),
-    actionColOptions: {
-      span: 14,
-    },
-    disabled: props.openModalMode === OpenModelMode.VIEW,
-    showResetButton: false,
-    submitOnReset: false,
-    showActionButtonGroup: false,
-  });
-
-  const setDisable = (flag: boolean) => {
-    setProps({ disabled: flag });
-  };
-
-  //回显数据
-  const setFormData = (record: ModelOfMatterParams) => {
-    const { functionJson = {}, functionName, identifier, remark, callType } = record;
-    const { inputData = [], outputData } = functionJson;
-    const { serviceCommand } =
-      (inputData.at(0) as unknown as { serviceCommand: string }) ||
-      ({} as { serviceCommand: string });
-    const value = {
-      functionName,
-      identifier,
-      remark,
-      inputData,
-      outputData,
-      serviceCommand,
-      callType,
-    };
-
-    if (
-      isArray(inputData) &&
-      inputData.find((item) => item?.dataType?.type === DataTypeEnum.STRUCT)
-    ) {
-      Reflect.set(value, FormField.HAS_STRUCT_FROM, true);
-    }
-
-    setFieldsValue(value);
-  };
-
-  //获取数据
-  async function getFormData() {
-    const _values = (await validate()) as StructFormValue;
-    const {
-      functionName,
-      remark,
-      identifier,
-      inputData: _inputData = [],
-      outputData: _outputData = [],
-      serviceCommand,
-      callType,
-    } = _values;
-    if (!_values) return {};
-
-    const outputData = (_outputData as unknown as StructJSON[]).map((item) => {
-      const dataType = excludeIdInStructJSON(item.dataType!);
-      return {
-        ...item,
-        dataType,
-      };
-    });
-    const inputData = (_inputData as unknown as StructJSON[]).map((item) => {
-      const dataType = excludeIdInStructJSON(item.dataType!);
-      return {
-        ...item,
-        dataType,
-      };
-    });
-
-    const value = {
-      functionName,
-      identifier,
-      remark,
-      functionType: FunctionType.SERVICE,
-      callType,
-      functionJson: {
-        inputData,
-        outputData,
-        ...(serviceCommand
-          ? { inputData: [{ serviceCommand: serviceCommand.replaceAll(/\s/g, '').toUpperCase() }] }
-          : {}),
-      },
-    } as ModelOfMatterParams;
-
-    return value;
-  }
-
-  //清空数据
-  const resetFormData = () => {
-    resetFields();
-  };
-
-  defineExpose({
-    setFormData,
-    resetFormData,
-    getFormData,
-    setDisable,
-  });
-</script>
-<style lang="less" scoped></style>

@@ -9,9 +9,9 @@
     </div>
     <div>
       <Tabs type="card" v-model:active-key="activeKey" @change="handleSwitchTsl">
-        <Tabs.TabPane :key="FunctionType.PROPERTIES" tab="属性" />
-        <Tabs.TabPane :key="FunctionType.SERVICE" tab="服务" />
-        <Tabs.TabPane :key="FunctionType.EVENTS" tab="事件" />
+        <Tabs.TabPane :key="FunctionTypeEnum.PROPERTIES" tab="属性" />
+        <Tabs.TabPane :key="FunctionTypeEnum.SERVICE" tab="服务" />
+        <Tabs.TabPane :key="FunctionTypeEnum.EVENTS" tab="事件" />
         <template #tabBarExtraContent>
           <Button class="ml-2" @click="handleCopy">
             <template #icon>
@@ -38,7 +38,7 @@
   import { CopyOutlined } from '@ant-design/icons-vue';
   import { useMessage } from '/@/hooks/web/useMessage';
   import { Button, Typography, TypographyParagraph, Tabs, Spin, Input } from 'ant-design-vue';
-  import { FunctionType } from './config';
+  import { FunctionTypeEnum } from '/@/enums/objectModelEnum';
   import useCommon from '../hook/useCommon';
   import { DeviceRecord } from '/@/api/device/model/deviceModel';
   import { getModelTsl } from '/@/api/device/modelOfMatter';
@@ -56,7 +56,7 @@
 
   const jsonValue = ref();
 
-  const activeKey = ref(FunctionType.PROPERTIES);
+  const activeKey = ref(FunctionTypeEnum.PROPERTIES);
 
   const { copied, copy } = useClipboard({ legacy: true });
   const handleCopy = async () => {
@@ -81,7 +81,7 @@
     jsonValue.value = null;
   };
 
-  const handleSwitchTsl = async (functionType: FunctionType) => {
+  const handleSwitchTsl = async (functionType: FunctionTypeEnum) => {
     try {
       loading.value = true;
       const record = await getModelTsl({
@@ -102,8 +102,8 @@
   };
 
   onMounted(() => {
-    activeKey.value = FunctionType.PROPERTIES;
-    handleSwitchTsl(FunctionType.PROPERTIES);
+    activeKey.value = FunctionTypeEnum.PROPERTIES;
+    handleSwitchTsl(FunctionTypeEnum.PROPERTIES);
   });
 
   defineExpose({

@@ -33,17 +33,6 @@ export enum FormField {
   HAS_STRUCT_FROM = 'hasStructForm',
 }
 
-export enum FunctionType {
-  PROPERTIES = 'properties',
-  EVENTS = 'events',
-  SERVICE = 'services',
-}
-
-export enum AssessMode {
-  READ = 'r',
-  WRITE = 'w',
-}
-
 const isNumber = (type: string) => {
   return type === DataTypeEnum.NUMBER_INT || type === DataTypeEnum.NUMBER_DOUBLE;
 };

-import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
-
-export enum OpenModelMode {
-  UPDATE = 'update',
-  CREATE = 'create',
-  VIEW = 'view',
-}
-
-export interface OpenModelOfMatterModelParams {
-  mode: OpenModelMode;
-  record: ModelOfMatterParams;
-}
-
 export interface IAllData {
   properties: string[];
   events: string[];

@@ -87,7 +87,10 @@ export const modeForm = (disabled: boolean): FormSchema[] => {
             },
           },
           onChange: () => {
-            setFieldsValue({ [BasicInfoFormField.DATA_SOURCE_DEVICE]: [] });
+            setFieldsValue({
+              [BasicInfoFormField.DATA_SOURCE_DEVICE]: [],
+              [BasicInfoFormField.CONVERT_CONFIG_ID]: null,
+            });
           },
         };
       },

+import { toRaw, unref } from 'vue';
 import { OperationType } from './type';
+import { DeviceModelOfMatterAttrs } from '/@/api/device/model/deviceModel';
 import { FormSchema } from '/@/components/Form';
 import {
   BooleanOperationEnum,
@@ -11,6 +13,7 @@ import {
   StringOperationNameEnum,
   TriggerValueTypeEnum,
 } from '/@/enums/linkedgeEnum';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
 
 export enum FormFieldsEnum {
   CONDITION_OPERATION = 'operation',
@@ -26,6 +29,7 @@ export enum FormFieldsNameEnum {
 
 interface GetFormSchemasParamsType {
   triggerType: TriggerValueTypeEnum;
+  objectModel?: DeviceModelOfMatterAttrs;
 }
 
 export interface ConditionFormRecordType {
@@ -58,7 +62,10 @@ const getOperation = (type: TriggerValueTypeEnum) => {
   return Object.keys(value).map((value) => ({ label: label[value], value }));
 };
 
-const getOperationValueFormSchemas = (triggerType: TriggerValueTypeEnum): FormSchema[] => {
+const getOperationValueFormSchemas = ({
+  triggerType,
+  objectModel,
+}: GetFormSchemasParamsType): FormSchema[] => {
   const getNumberSchemas = (): FormSchema[] => {
     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 = {
     [TriggerValueTypeEnum.BOOLEAN]: getBoolSchemas,
     [TriggerValueTypeEnum.DATE_TIME]: getDateSchemas,
-    [TriggerValueTypeEnum.NUMERIC]: getNumberSchemas,
+    [TriggerValueTypeEnum.NUMERIC]:
+      objectModel?.detail?.dataType?.type === DataTypeEnum.ENUM
+        ? getEnumsSchemas
+        : getNumberSchemas,
     [TriggerValueTypeEnum.STRING]: getStringSchemas,
   };
 
   return schemasMap[triggerType]?.() || [];
 };
 
-export const getFormSchemas = ({ triggerType }: GetFormSchemasParamsType): FormSchema[] => {
+export const getFormSchemas = ({
+  triggerType,
+  objectModel,
+}: GetFormSchemasParamsType): FormSchema[] => {
   return [
     {
       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 { Card, Tag, Button, Tooltip } from 'ant-design-vue';
   import { Icon } from '/@/components/Icon';
@@ -24,8 +24,8 @@
   });
 
   const getSchemas = computed(() => {
-    const { triggerType } = props;
-    return getFormSchemas({ triggerType });
+    const { triggerType, objectModel } = props;
+    return getFormSchemas({ triggerType, objectModel });
   });
 
   const conditionListElRef = ref<ConditionListItemType[]>([getNewConditionFilterItem()]);
@@ -40,8 +40,8 @@
 
   const handleConditionFormValueChange = () => {
     const condition = getConditionFormValues();
-    const { triggerType } = props;
-    const message = useConditionFilterMessage({ triggerType, condition });
+    const { triggerType, objectModel } = props;
+    const message = useConditionFilterMessage({ triggerType, condition, objectModel });
     conditionMessageList.value = message;
   };
 
@@ -84,6 +84,13 @@
     await validate?.();
   };
 
+  watch(
+    () => props.objectModel,
+    () => {
+      handleConditionFormValueChange();
+    }
+  );
+
   defineExpose({ getFieldsValue, setFieldsValue, validate });
 </script>
 

 import { FormFieldsEnum, getOperationMap } from './config';
+import { DeviceModelOfMatterAttrs } from '/@/api/device/model/deviceModel';
 import {
   BooleanOperationValueEnum,
   BooleanOperationValueNameEnum,
   TriggerValueTypeEnum,
 } from '/@/enums/linkedgeEnum';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
+import { isNullOrUnDef } from '/@/utils/is';
 
 export type ConditionMessageItemType = Record<
   Exclude<FormFieldsEnum, FormFieldsEnum.CONDITION_VALUE_IGNORE_CASE>,
@@ -13,24 +16,39 @@ export type ConditionMessageItemType = Record<
 interface UseConditionFilterMessageParamsType {
   triggerType: TriggerValueTypeEnum;
   condition: ConditionMessageItemType[];
+  objectModel?: DeviceModelOfMatterAttrs;
 }
 
 export function useConditionFilterMessage({
   triggerType,
   condition,
+  objectModel,
 }: UseConditionFilterMessageParamsType) {
   const { label } = getOperationMap(triggerType);
   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) {
     let { defaultValue, operation } = item;
-    if (!defaultValue || !operation) continue;
+    if (isNullOrUnDef(defaultValue) || isNullOrUnDef(operation)) continue;
     operation = label[operation];
     if (triggerType === TriggerValueTypeEnum.BOOLEAN)
       defaultValue =
         defaultValue === BooleanOperationValueEnum.TRUE
           ? BooleanOperationValueNameEnum.TRUE
           : BooleanOperationValueNameEnum.FALSE;
-    list.push({ operation, defaultValue });
+
+    list.push({ operation, defaultValue: isEnumsType ? enumsMap[defaultValue] : defaultValue });
   }
   return list;
 }

 import { FormSchema, useComponentRegister } from '/@/components/Form';
 import {
-  CommandTypeEnum,
-  CommandTypeNameEnum,
   ExecutionActionEnum,
   ExecutionActionNameEnum,
   TriggerEntityTypeEnum,
   TriggerEntityTypeNameEnum,
 } from '/@/enums/linkedgeEnum';
+import { CommandTypeEnum, CommandTypeNameEnum } from '/@/enums/deviceEnum';
 import AlarmProfileSelect from './AlarmProfileSelect.vue';
 import {
   byOrganizationIdGetMasterDevice,
@@ -21,15 +20,15 @@ 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 { ServiceCallTypeEnum, ServiceCallTypeNameEnum } from '/@/enums/deviceEnum';
 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';
+import { validateTCPCustomCommand } from '/@/components/Form/src/components/ThingsModelForm';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
 
 export enum FormFieldsEnum {
   OUT_TARGET = 'outTarget',

@@ -5,9 +5,9 @@ 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';
+import { ExecutionActionEnum, TriggerEntityTypeEnum } from '/@/enums/linkedgeEnum';
+import { CommandTypeEnum, ServiceCallTypeEnum } from '/@/enums/deviceEnum';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
 
 export interface ExecutionActionListRefItemType {
   key: string;

@@ -7,12 +7,13 @@ import {
   ExecutionActionFormItemRecordType,
   ExecutionActionListRefItemType,
 } from './type';
-import { CommandTypeEnum, ExecutionActionEnum } from '/@/enums/linkedgeEnum';
-import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
+import { ExecutionActionEnum } from '/@/enums/linkedgeEnum';
+import { CommandTypeEnum } from '/@/enums/deviceEnum';
 import { useJsonParse } from '/@/hooks/business/useJsonParse';
 import { createNewExecutionActionItem } from '.';
 import { FormFieldsEnum } from './config';
 import { isObject, isString } from '/@/utils/is';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
 
 export function useExecutionActionData(
   executionActionListRef: Ref<ExecutionActionListRefItemType[]>,

@@ -27,11 +27,11 @@ import { DeviceModelOfMatterAttrs, DeviceProfileModel } from '/@/api/device/mode
 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 { FunctionTypeEnum } from '/@/enums/objectModelEnum';
 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';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
 
 export enum FormFieldEnum {
   FLIP_FLOP_TYPE = 'flipFlopType',
@@ -77,6 +77,7 @@ function getTriggerValueTypeByThingsModelType(type: DataTypeEnum) {
     [DataTypeEnum.NUMBER_INT]: TriggerValueTypeEnum.NUMERIC,
     [DataTypeEnum.STRING]: TriggerValueTypeEnum.STRING,
     [DataTypeEnum.STRUCT]: TriggerValueTypeEnum.STRING,
+    [DataTypeEnum.ENUM]: TriggerValueTypeEnum.NUMERIC,
   };
 
   return map[type];
@@ -405,7 +406,7 @@ export const getFormSchemas = (
           labelField: 'functionName',
           valueField: 'identifier',
           params: {
-            functionType: FunctionType.EVENTS,
+            functionType: FunctionTypeEnum.EVENTS,
             deviceProfileId: formModel[FormFieldEnum.DEVICE_PROFILE_ID],
           },
           placeholder: `请选择${FormFieldNameEnum.DEVICE_EVENT_TRIGGER_KEY}`,
@@ -419,6 +420,7 @@ export const getFormSchemas = (
       colProps: { span: 24, xxl: 24, xl: 24, lg: 24, md: 24, sm: 24, xs: 24 },
       ifShow: ({ model }) =>
         model[FormFieldEnum.CONDITION_TYPE] === DeviceTriggerTypeEum.TIME_SERIES &&
+        // model[FormFieldEnum.CONDITION_KEY_DETAIL] &&
         model[FormFieldEnum.CONDITION_KEY] &&
         model[FormFieldEnum.CONDITION_VALUE_TYPE],
       colSlot: 'conditionFilter',

-import { ref, unref } from 'vue';
+import { ref } from 'vue';
 import { BasicColumn, FormSchema } from '/@/components/Table';
-import {
-  byOrganizationIdGetMasterDevice,
-  screenLinkOrganizationGetApi,
-  getAttribute,
-} from '/@/api/ruleengine/ruleengineApi';
-import { scheduleOptions } from './formatData';
+import { screenLinkOrganizationGetApi } from '/@/api/ruleengine/ruleengineApi';
 import { copyTransFun } from '/@/utils/fnUtils';
-import { numberAndNonegativeRule } from '/@/utils/rules';
-import { findDictItemByCode } from '/@/api/system/dict';
-import { queryDeviceProfileBy } from '/@/api/device/deviceManager';
-import { getModelServices } from '/@/api/device/modelOfMatter';
-import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
-import useCommonFun from '../hooks/useCommonFun';
-import { DeviceProfileModel } from '/@/api/device/model/deviceModel';
-import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
 import { useComponentRegister } from '/@/components/Form';
 import { OrgTreeSelect } from '/@/views/common/OrgTreeSelect';
-import { isArray } from '/@/utils/is';
-import { ReadAndWriteEnum } from '/@/enums/toolEnum';
 
 useComponentRegister('OrgTreeSelect', OrgTreeSelect);
 
-const { useByProductGetAttribute } = useCommonFun();
 export type TOption = {
   label: string;
   value: string;
 };
 
-export enum CommandTypeEnum {
-  CUSTOM = 0,
-  SERVICE = 1,
-  ATTRIBUTE = 2,
-}
-
 /**
  * 所使用的枚举值
  */
@@ -174,733 +152,3 @@ export const searchFormSchema: FormSchema[] = [
     colProps: { span: 6 },
   },
 ];
-// 持续时间
-const isTimeDuration = (type) => {
-  return type === 'DURATION';
-};
-const isReplace = (type) => {
-  return type === 'REPEATING';
-};
-// 部分
-const isPart = (type: string) => {
-  return type === 'PART';
-};
-//新增代码2022-11-23
-const isPartOrAll = (type: string) => {
-  return type === 'ALL' || type === 'PART';
-};
-const isService = (type: string) => {
-  return Number(type) === 1;
-};
-const isDefine = (type: string) => {
-  return Number(type) === 0;
-};
-//新增代码2022-11-23
-
-export const trigger_condition_schema: FormSchema[] = [
-  {
-    field: 'triggered',
-    label: '',
-    component: 'Select',
-    defaultValue: 'SIMPLE',
-    componentProps: {
-      placeholder: '请选择触发类型',
-      options: [
-        { label: '简单', value: 'SIMPLE' },
-        { label: '持续时长', value: 'DURATION' },
-        { label: '重复次数', value: 'REPEATING' },
-      ],
-    },
-    colProps: { span: 6 },
-  },
-  {
-    field: 'deviceType',
-    label: '',
-    component: 'ApiSelect',
-    colProps: { span: 6 },
-    defaultValue: 'SENSOR',
-    componentProps: ({ formActionType }) => {
-      const { setFieldsValue } = formActionType;
-      return {
-        api: findDictItemByCode,
-        params: {
-          dictCode: 'device_type',
-        },
-        placeholder: '请选择类型',
-        labelField: 'itemText',
-        valueField: 'itemValue',
-        getPopupContainer: (triggerNode) => triggerNode.parentNode,
-        onChange(e) {
-          if (e) {
-            setFieldsValue({ deviceProfileId: '' });
-          }
-        },
-      };
-    },
-  },
-  {
-    field: 'deviceProfileId',
-    label: '',
-    component: 'ApiSelect',
-    colProps: { span: 6 },
-    componentProps: ({ formActionType, formModel }) => {
-      const { updateSchema, setFieldsValue } = formActionType;
-      const deviceType = formModel['deviceType'];
-
-      return {
-        api: queryDeviceProfileBy,
-        params: {
-          deviceType,
-        },
-        showSearch: true,
-        placeholder: '请选择产品',
-        labelField: 'name',
-        valueField: 'id',
-        getPopupContainer: (triggerNode) => triggerNode.parentNode,
-        onChange: async (e) => {
-          if (e) {
-            setFieldsValue({ type2: '', entityId: [] });
-            const res = await getAttribute(e);
-            const options = ref<TOption[]>([]);
-            useByProductGetAttribute(res, updateSchema, options);
-          }
-        },
-        filterOption: (inputValue: string, option: Record<'label' | 'value', string>) => {
-          let { label, value } = option;
-          label = label.toLowerCase();
-          value = value.toLowerCase();
-          inputValue = inputValue.toLowerCase();
-          return label.includes(inputValue) || value.includes(inputValue);
-        },
-      };
-    },
-  },
-  {
-    field: 'device',
-    label: '',
-    component: 'Select',
-    componentProps: {
-      placeholder: '请选择设备',
-      options: [
-        { label: '全部', value: 'ALL' },
-        { label: '部分', value: 'PART' },
-      ],
-    },
-    colProps: { span: 6 },
-  },
-
-  {
-    field: 'entityId',
-    label: '',
-    component: 'ApiSelect',
-    componentProps: ({ formModel }) => {
-      const deviceProfileId = formModel['deviceProfileId'];
-      return {
-        mode: 'multiple',
-        api: async () => {
-          if (unref(organizationId)) {
-            try {
-              const data = await byOrganizationIdGetMasterDevice({
-                organizationId: unref(organizationId),
-                deviceProfileId,
-              });
-              if (data)
-                return data.map((item) => ({
-                  ...item,
-                  label: item.alias || item.name,
-                  value: item.tbDeviceId,
-                }));
-            } catch (error) {}
-          }
-          return [];
-        },
-        placeholder: '请选择设备',
-        getPopupContainer: (triggerNode) => triggerNode.parentNode,
-        filterOption: (inputValue: string, option: Record<'label' | 'value', string>) => {
-          let { label, value } = option;
-          label = label.toLowerCase();
-          value = value.toLowerCase();
-          inputValue = inputValue.toLowerCase();
-          return label.includes(inputValue) || value.includes(inputValue);
-        },
-      };
-    },
-    ifShow: ({ values }) => isPart(values.device),
-    colProps: { span: 6 },
-  },
-
-  {
-    field: 'time',
-    label: '',
-    component: 'Input',
-    ifShow: ({ values }) => isTimeDuration(values.triggered),
-    colProps: { span: 6 },
-    slot: 'time',
-    rules: numberAndNonegativeRule,
-  },
-  {
-    field: 'timeUnit',
-    label: '',
-    component: 'Select',
-    defaultValue: 'SECONDS',
-    ifShow: ({ values }) => isTimeDuration(values.triggered),
-    show: false,
-  },
-  {
-    field: 'replaceValue',
-    label: '',
-    component: 'Input',
-    componentProps: {
-      placeholder: '事件计数值',
-    },
-    ifShow: ({ values }) => isReplace(values.triggered),
-    colProps: { span: 6 },
-    rules: numberAndNonegativeRule,
-  },
-  {
-    field: 'triggerType',
-    label: '',
-    component: 'Select',
-    componentProps: {
-      placeholder: '设备触发',
-      options: [
-        { label: '设备触发', value: 'DEVICE_TRIGGER' },
-        // { label: '定时触发', value: 'SCHEDULE_TRIGGER' },
-        // { label: '场景触发', value: 'SCENE_TRIGGER' },
-        // { label: '手动触发', value: 'HAND_ACT' },
-      ],
-    },
-    colProps: { span: 6 },
-  },
-
-  {
-    field: 'type1',
-    label: '',
-    component: 'Select',
-    componentProps: {
-      placeholder: '属性触发方式',
-      options: [{ label: '属性触发', value: 'TIME_SERIES' }],
-    },
-    ifShow: ({ values }) => isDevice(values.triggerType),
-    colProps: { span: 6 },
-  },
-  {
-    field: 'type2',
-    label: '',
-    component: 'Select',
-    componentProps: {
-      placeholder: '请选择属性',
-    },
-    ifShow: ({ values }) => isDevice(values.triggerType),
-    colProps: { span: 6 },
-    // rules: numberAndEngLishRule,
-  },
-  {
-    field: 'operationType',
-    label: '',
-    component: 'Select',
-    slot: 'operationType',
-    colProps: { span: 6 },
-  },
-  // {
-  //   field: 'detail',
-  //   label: '',
-  //   component: 'InputTextArea',
-  //   componentProps: {
-  //     placeholder: '请输入详情',
-  //   },
-  //   colProps: {
-  //     span: 13,
-  //   },
-  // },
-];
-// !!!----------------------------------------------------^_^------------------------------------------------------------!!!
-enum ActionEnum {
-  DEVICE_OUT = 'DEVICE_OUT',
-  ALARM_OUT = 'MSG_NOTIFY',
-}
-const isDeviceOut = (type: string) => type === ActionEnum.DEVICE_OUT;
-const isAlarmOut = (type: string) => type === ActionEnum.ALARM_OUT;
-
-export const actionSchema: FormSchema[] = [
-  {
-    field: 'outTarget',
-    label: '',
-    component: 'Select',
-    required: true,
-    componentProps: {
-      placeholder: '请选择执行动作',
-    },
-    slot: 'outTarget',
-    colProps: { span: 6 },
-  },
-  {
-    field: 'deviceType',
-    label: '',
-    component: 'ApiSelect',
-    colProps: { span: 6 },
-    defaultValue: 'SENSOR',
-    componentProps: ({ formActionType }) => {
-      const { setFieldsValue } = formActionType;
-      return {
-        api: findDictItemByCode,
-        params: {
-          dictCode: 'device_type',
-        },
-        placeholder: '请选择类型',
-        labelField: 'itemText',
-        valueField: 'itemValue',
-        getPopupContainer: (triggerNode) => triggerNode.parentNode,
-        onChange(e) {
-          if (e) {
-            setFieldsValue({ deviceProfileId: '' });
-          }
-        },
-      };
-    },
-    ifShow: ({ values }) => isDeviceOut(values.outTarget),
-  },
-  {
-    field: 'transportType',
-    label: '',
-    component: 'Input',
-    show: false,
-  },
-  {
-    field: 'deviceProfileId',
-    label: '',
-    component: 'ApiSelect',
-    colProps: { span: 6 },
-    componentProps: ({ formActionType, formModel }) => {
-      const { setFieldsValue } = formActionType;
-      const deviceType = formModel['deviceType'];
-      return {
-        api: queryDeviceProfileBy,
-        params: {
-          deviceType,
-        },
-        placeholder: '请选择产品',
-        labelField: 'name',
-        valueField: 'id',
-        getPopupContainer: (triggerNode) => triggerNode.parentNode,
-        onChange: (_value: string, options = {} as DeviceProfileModel) => {
-          const oldType = formModel['transportType'];
-
-          const updateFlag =
-            oldType === TransportTypeEnum.TCP || options.transportType === TransportTypeEnum.TCP;
-
-          setFieldsValue({
-            thingsModelId: '',
-            deviceId: [],
-            transportType: options.transportType,
-            ...(updateFlag ? { doContext: null } : {}),
-          });
-        },
-        onOptionsChange(options: DeviceProfileModel[]) {
-          const deviceProfileId = formModel['deviceProfileId'];
-          if (deviceProfileId) {
-            const index = options.findIndex(
-              (item) => (item as Recordable).value === deviceProfileId
-            );
-
-            ~index && setFieldsValue({ transportType: options[index].transportType });
-          }
-        },
-      };
-    },
-    ifShow: ({ values }) => isDeviceOut(values.outTarget),
-  },
-  {
-    field: 'device',
-    label: '',
-    component: 'Select',
-    componentProps: ({ formActionType }) => {
-      const { setFieldsValue } = formActionType;
-      return {
-        placeholder: '请选择设备',
-        options: [
-          { label: '全部', value: 'ALL' },
-          { label: '部分', value: 'PART' },
-        ],
-        onChange: () => {
-          setFieldsValue({ deviceId: [], thingsModelId: null });
-        },
-      };
-    },
-    ifShow: ({ values }) => isDeviceOut(values.outTarget) && values['deviceProfileId'],
-    colProps: { span: 6 },
-  },
-  {
-    field: 'deviceId',
-    label: '',
-    component: 'ApiSelect',
-    componentProps: ({ formModel }) => {
-      const deviceProfileId = formModel['deviceProfileId'];
-      return {
-        mode: 'multiple',
-        api: async () => {
-          if (unref(organizationId)) {
-            try {
-              const data = await byOrganizationIdGetMasterDevice({
-                organizationId: unref(organizationId),
-                deviceProfileId,
-              });
-              if (data)
-                return data.map((item) => ({
-                  ...item,
-                  label: item.alias || item.name,
-                  value: item.tbDeviceId,
-                }));
-            } catch (error) {}
-          }
-          return [];
-        },
-        placeholder: '请选择设备',
-        getPopupContainer: (triggerNode) => triggerNode.parentNode,
-      };
-    },
-    ifShow: ({ values }) => isPart(values.device) && isDeviceOut(values.outTarget),
-    colProps: { span: 6 },
-  },
-  //新增代码2022-11-23
-  {
-    field: 'commandType',
-    label: '',
-    required: true,
-    component: 'ApiSelect',
-    colProps: {
-      span: 6,
-    },
-    defaultValue: '0',
-    componentProps: ({ formActionType }) => {
-      const { setFieldsValue } = formActionType;
-      return {
-        placeholder: '请选择类型',
-        api: async (parmas: Recordable) => {
-          try {
-            const record = await findDictItemByCode(parmas);
-            return record.filter(
-              (item) =>
-                item.itemValue !== CommandTypeEnum.ATTRIBUTE.toString() || item.itemText != '属性'
-            );
-          } catch (error) {
-            return [];
-          }
-        },
-        labelField: 'itemText',
-        valueField: 'itemValue',
-        params: {
-          dictCode: 'custom_define',
-        },
-        numberToString: true,
-        getPopupContainer: (triggerNode) => triggerNode.parentNode,
-        onChange: () => {
-          setFieldsValue({ doContext: null, thingsModelId: null });
-        },
-      };
-    },
-    ifShow: ({ values }) => isDeviceOut(values.outTarget) && isPartOrAll(values.device),
-  },
-  //新增代码2022-11-23
-  {
-    field: 'callType',
-    label: '',
-    required: true,
-    component: 'ApiSelect',
-    colProps: {
-      span: 6,
-    },
-    defaultValue: 'SYNC',
-    componentProps: {
-      placeholder: '请选择类型',
-      api: findDictItemByCode,
-      params: {
-        dictCode: 'call_mode',
-      },
-      labelField: 'itemText',
-      valueField: 'itemValue',
-      getPopupContainer: (triggerNode) => triggerNode.parentNode,
-    },
-    ifShow: ({ values }) =>
-      isDeviceOut(values.outTarget) && isPartOrAll(values.device) && isDefine(values.commandType),
-  },
-  {
-    field: 'serviceIdentifier',
-    label: '',
-    component: 'Input',
-    show: false,
-  },
-  {
-    field: 'thingsModelKeys',
-    label: '',
-    show: false,
-    component: 'Select',
-    componentProps: {
-      mode: 'multiple',
-    },
-  },
-  {
-    field: 'thingsModelId',
-    label: '',
-    required: true,
-    component: 'ApiSelect',
-    colProps: {
-      span: 6,
-    },
-    componentProps: ({ formModel, formActionType }) => {
-      const { updateSchema, setFieldsValue } = formActionType;
-      const deviceProfileId = Reflect.get(formModel, 'deviceProfileId');
-      const thingsModelId = Reflect.get(formModel, 'thingsModelId');
-      const transportType = Reflect.get(formModel, 'transportType');
-      return {
-        placeholder: '请选择服务',
-        api: async (params: Recordable) => {
-          try {
-            if (!Reflect.get(params, 'deviceProfileId')) return [];
-            const record =
-              (await getModelServices(params as Record<'deviceProfileId', string>)) || [];
-            const selected = record.find((item) => item.id === thingsModelId);
-            selected &&
-              updateSchema({
-                field: 'serviceInputValue',
-                componentProps: {
-                  inputData: selected?.functionJson.inputData,
-                },
-              });
-            selected &&
-              setFieldsValue({
-                callType: selected.callType,
-                serviceIdentifier: selected?.identifier,
-                thingsModelKeys: isArray(selected?.functionJson?.inputData)
-                  ? selected?.functionJson?.inputData
-                      .filter((item) => item.accessMode === ReadAndWriteEnum.READ_AND_WRITE)
-                      .map((item) => item.identifier)
-                  : [],
-              });
-            return record;
-          } catch (error) {
-            console.error(error);
-            return [];
-          }
-        },
-        params: {
-          deviceProfileId,
-        },
-        labelField: 'functionName',
-        valueField: 'id',
-        getPopupContainer: (triggerNode) => triggerNode.parentNode,
-        onChange: (_, options: ModelOfMatterParams) => {
-          if (options) {
-            // setFieldsValue({ doContext: { ...options.functionJson, callType: options.callType } });
-            // if ( )
-            const record = {
-              callType: options.callType,
-              serviceIdentifier: options.identifier,
-              thingsModelKeys: isArray(options?.functionJson?.inputData)
-                ? options?.functionJson?.inputData
-                    .filter((item) => item.accessMode === ReadAndWriteEnum.READ_AND_WRITE)
-                    .map((item) => item.identifier)
-                : [],
-            };
-            transportType === TransportTypeEnum.TCP
-              ? Object.assign(record, {
-                  tcpServiceCommand: options.functionJson?.inputData?.[0]?.serviceCommand,
-                })
-              : updateSchema({
-                  field: 'serviceInputValue',
-                  componentProps: {
-                    inputData: options.functionJson.inputData,
-                  },
-                });
-
-            setFieldsValue(record);
-          } else {
-            setFieldsValue({ serviceIdentifier: null });
-          }
-        },
-      };
-    },
-    ifShow: ({ values }) => isDeviceOut(values.outTarget) && isService(values.commandType),
-  },
-  //新增代码2022-11-23
-  {
-    field: 'alarm_config',
-    label: '',
-    component: 'Input',
-    componentProps: {
-      placeholder: '请选择告警配置',
-    },
-    slot: 'alarmConfigSlot',
-    ifShow: ({ values }) => values.outTarget === 'MSG_NOTIFY',
-    colProps: { span: 6 },
-  },
-  //新增代码2022-11-23
-  {
-    field: 'doContext',
-    component: 'Input',
-    label: '',
-    slot: 'doContext',
-    show: ({ values }) => {
-      return (
-        isDeviceOut(values.outTarget) && isPartOrAll(values.device) && isDefine(values.commandType)
-      );
-    },
-    colProps: {
-      span: 24,
-    },
-  },
-  //新增代码2022-11-23
-  {
-    field: 'alarm_level',
-    component: 'Select',
-    label: '',
-    show: ({ values }) => isAlarmOut(values.outTarget),
-    // dynamicRules: (params) => {
-    //   const { outTarget } = params.values;
-    //   return [
-    //     {
-    //       required: outTarget == 'MSG_NOTIFY' ? true : false,
-    //       validator: (_, value) => {
-    //         if (!value) return Promise.reject('请选择告警配置');
-    //         Promise.resolve();
-    //       },
-    //     },
-    //   ];
-    // },
-    componentProps: {
-      placeholder: '请选择告警等级',
-      options: [
-        {
-          label: '紧急',
-          value: 'CRITICAL',
-        },
-        {
-          label: '重要',
-          value: 'MAJOR',
-        },
-        {
-          label: '次要',
-          value: 'MINOR',
-        },
-        {
-          label: '警告',
-          value: 'WARNING',
-        },
-        {
-          label: '不确定',
-          value: 'INDETERMINATE',
-        },
-      ],
-    },
-    colProps: {
-      span: 6,
-    },
-  },
-  {
-    field: 'clear_alarm',
-    component: 'Checkbox',
-    label: '',
-    show: ({ values }) => isAlarmOut(values.outTarget),
-    colProps: {
-      span: 8,
-    },
-    slot: 'clearAlarm',
-  },
-  {
-    field: 'tcpServiceCommand',
-    component: 'Input',
-    label: '服务命令',
-    colProps: { span: 24 },
-    dynamicDisabled: true,
-    show: ({ values }) =>
-      values['thingsModelId'] && values['transportType'] === TransportTypeEnum.TCP,
-  },
-  {
-    field: 'serviceInputValue',
-    component: 'ObjectModelValidateForm',
-    label: '',
-    changeEvent: 'update:value',
-    valueField: 'value',
-    show: ({ values }) =>
-      values['thingsModelId'] && values['transportType'] !== TransportTypeEnum.TCP,
-    colProps: {
-      span: 24,
-    },
-    componentProps: {},
-  },
-];
-
-export const alarmScheduleSchemas: FormSchema[] = [
-  {
-    field: 'schedule',
-    label: '',
-    component: 'Select',
-    componentProps({ formActionType }) {
-      const { resetFields } = formActionType;
-      return {
-        options: scheduleOptions,
-        allowClear: false,
-        onChange() {
-          resetFields();
-        },
-      };
-    },
-  },
-  {
-    field: 'timezone',
-    label: '时区',
-    component: 'Select',
-    defaultValue: 'Asia/Shanghai',
-    componentProps: {
-      options: [
-        {
-          label: 'Asia/Shanghai',
-          value: 'Asia/Shanghai',
-        },
-      ],
-      allowClear: false,
-    },
-    ifShow: ({ values }) => values.schedule !== 'ANY_TIME',
-  },
-  {
-    field: 'daysOfWeek',
-    label: '天',
-    component: 'CheckboxGroup',
-    rules: [
-      {
-        message: '请至少选择一天',
-        required: true,
-      },
-    ],
-    componentProps: {
-      options: [
-        { label: '星期一', value: 1 },
-        { label: '星期二', value: 2 },
-        { label: '星期三', value: 3 },
-        { label: '星期四', value: 4 },
-        { label: '星期五', value: 5 },
-        { label: '星期六', value: 6 },
-        { label: '星期日', value: 7 },
-      ],
-    },
-    colProps: {
-      span: 24,
-    },
-    ifShow: ({ values }) => values.schedule === 'SPECIFIC_TIME',
-  },
-  {
-    field: 'time',
-    label: '时间',
-    labelWidth: 40,
-    component: 'RangePicker',
-    ifShow: ({ values }) => values.schedule === 'SPECIFIC_TIME',
-    slot: 'timing',
-  },
-  {
-    field: 'day',
-    label: '天',
-    component: 'CheckboxGroup',
-    slot: 'customEnable',
-    ifShow: ({ values }) => values.schedule === 'CUSTOM',
-  },
-];

@@ -8,12 +8,12 @@ import {
 } from '../DevicePicker';
 import { PollCommandInput, ModeEnum } from '../PollCommandInput';
 import { DeviceProfileModel } from '/@/api/device/model/deviceModel';
-import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
 import { JSONEditorValidator } from '/@/components/CodeEditor/src/JSONEditor';
 import { BooleanStringEnum, TimeUnitEnum, TimeUnitNameEnum } from '/@/enums/toolEnum';
 import { dateUtil } from '/@/utils/dateUtil';
 import { ProductPicker, validateProductPicker } from '../ProductPicker';
 import { useGlobSetting } from '/@/hooks/setting';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
 
 useComponentRegister('DevicePicker', DevicePicker);
 useComponentRegister('ProductPicker', ProductPicker);

@@ -37,5 +37,15 @@
 </script>
 
 <template>
-  <BasicForm @register="register" />
+  <BasicForm @register="register" class="data-board-source-form" />
 </template>
+
+<style lang="less" scoped>
+  .data-board-source-form {
+    :deep(.ant-form-item-control-input-content) {
+      > div > div {
+        width: 100%;
+      }
+    }
+  }
+</style>

@@ -197,8 +197,7 @@
         <label class="w-24 text-right pr-2">数据源{{ index + 1 }}</label>
         <component
           :ref="(event) => setDataSourceFormsEl(item.uuid, event, index)"
-          class="flex-1 bg-light-50 dark:bg-dark-400"
-          style="max-width: calc(100% - 216px)"
+          class="flex-1 bg-light-50 dark:bg-dark-400 data-board-source-form"
           :is="getComponent"
           :component-config="componentConfig"
           :values="item"
@@ -238,9 +237,11 @@
 </template>
 
 <style scoped lang="less">
-  :deep(#deviceId) {
-    div {
-      width: 100%;
+  .data-board-source-form {
+    :deep(.ant-form-item-control-input-content) {
+      > div > div {
+        width: 100%;
+      }
     }
   }
 </style>

 <script lang="ts" setup>
   import { computed } from 'vue';
-  import { PackagesCategoryEnum } from '../../../packages/index.type';
   import { SelectedWidgetKeys } from '../../index.type';
   import { Alert } from 'ant-design-vue';
 
@@ -9,10 +8,10 @@
   }>();
 
   const alert = {
-    [PackagesCategoryEnum.MAP]: [
-      '1、绑定数据源为结构体时，可以自行选择结构体里的属性作为经纬度',
-      '2、绑定数据源为非结构体时，第一数据源为经度，第二数据源为纬度，且数据源为同一设备，并同时上报。否则地图组件不能正常显示。',
-    ],
+    // [PackagesCategoryEnum.MAP]: [
+    //   '1、绑定数据源为结构体时，可以自行选择结构体里的属性作为经纬度',
+    //   '2、绑定数据源为非结构体时，第一数据源为经度，第二数据源为纬度，且数据源为同一设备，并同时上报。否则地图组件不能正常显示。',
+    // ],
   };
 
   const getMessage = computed(() => {

 <script lang="ts" setup>
-  import { ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
+  import { ComponentMode, ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
   import { option } from './config';
   import { Spin } from 'ant-design-vue';
   import { computed, ref, unref } from 'vue';
   import { useComponentScale } from '../../../hook/useComponentScale';
-  import { useSendCommand } from '../../../hook/useSendCommand';
   import { DeviceName } from '/@/views/visual/commonComponents/DeviceName';
   import { DataFetchUpdateFn } from '../../../hook/socket/useSocket.type';
   import { useDataFetch } from '../../../hook/socket/useSocket';
-  import { getSendValues } from '../config';
   import { useModal } from '/@/components/Modal';
   import PasswordModal from '../component/PasswordModal.vue';
+  import { useCommandDelivery } from '../../../hook/useCommandDelivery';
+  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
 
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
@@ -20,48 +20,31 @@
 
   const currentValue = ref(false);
 
+  const { getDeviceProfileTslByIdWithIdentifier } = useDeviceProfileQueryContext();
+
   const getDesign = computed(() => {
     const { option, persetOption } = props.config;
-    const {
-      attribute,
-      attributeRename,
-      attributeName,
-      componentInfo,
-      commandType,
-      extensionDesc,
-      codeType,
-      deviceCode,
-      customCommand,
-    } = option;
+    const { attribute, attributeRename, componentInfo, commandType, deviceProfileId } = option;
 
     const { fontSize: persetFontSize, password: persetPassword } = persetOption || {};
     const { fontSize, password } = componentInfo || {};
+
+    const tsl = getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, attribute);
     return {
-      attribute: attributeRename || attributeName || attribute,
+      attribute: attributeRename || tsl?.functionName || attribute,
       fontSize: fontSize || persetFontSize || 14,
       password: password || persetPassword,
-      extensionDesc: extensionDesc ? JSON.parse(extensionDesc) : {},
       commandType,
-      codeType,
-      deviceCode,
-      customCommand,
     };
   });
 
-  const { sendCommand, loading } = useSendCommand();
+  const { doCommandDeliver, loading } = useCommandDelivery();
 
-  const handleSendCommand = async (data) => {
-    const { control: event } = data || {};
-    const target = event.target as HTMLInputElement;
-    const value = !target.checked;
+  const handleSendCommand = async () => {
+    if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
     const { option } = props.config || {};
-
-    const { values, isModbusCommand, sendValue } =
-      (await getSendValues(option, unref(getDesign), value)) || {};
-
-    const flag = await sendCommand(values, isModbusCommand ? sendValue : value, isModbusCommand);
-    if (flag) currentValue.value = value;
-    flag ? (currentValue.value = value) : (target.checked = !value);
+    const result = await doCommandDeliver(option, Number(!unref(currentValue)));
+    currentValue.value = result ? !unref(currentValue) : unref(currentValue);
   };
 
   const handleChange = async (event: Event) => {
@@ -74,16 +57,7 @@
       return;
     }
 
-    const target = event.target as HTMLInputElement;
-    const value = target.checked;
-    const { option } = props.config || {};
-
-    const { values, isModbusCommand, sendValue } =
-      (await getSendValues(option, unref(getDesign), value)) || {};
-
-    const flag = await sendCommand(values, isModbusCommand ? sendValue : value, isModbusCommand);
-    if (flag) currentValue.value = value;
-    flag ? (currentValue.value = value) : (target.checked = !value);
+    handleSendCommand();
   };
 
   const updateFn: DataFetchUpdateFn = (message, attribute) => {

 <script lang="ts" setup>
-  import { ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
+  import { ComponentMode, ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
   import { option } from './config';
   import { SvgIcon } from '/@/components/Icon';
   import { Switch } from 'ant-design-vue';
   import { computed, ref } from 'vue';
   import { useComponentScale } from '../../../hook/useComponentScale';
-  import { useSendCommand } from '../../../hook/useSendCommand';
   import { unref } from 'vue';
   import { DeviceName } from '/@/views/visual/commonComponents/DeviceName';
   import { DataFetchUpdateFn } from '../../../hook/socket/useSocket.type';
   import { useDataFetch } from '../../../hook/socket/useSocket';
-  import { getSendValues } from '../config';
   import { useModal } from '/@/components/Modal';
   import PasswordModal from '../component/PasswordModal.vue';
+  import { useCommandDelivery } from '../../../hook/useCommandDelivery';
+  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
 
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
@@ -20,19 +20,11 @@
 
   const checked = ref(false);
 
+  const { getDeviceProfileTslByIdWithIdentifier } = useDeviceProfileQueryContext();
+
   const getDesign = computed(() => {
     const { option, persetOption } = props.config;
-    const {
-      componentInfo,
-      attribute,
-      attributeRename,
-      attributeName,
-      commandType,
-      extensionDesc,
-      codeType,
-      deviceCode,
-      customCommand,
-    } = option;
+    const { componentInfo, attribute, deviceProfileId, attributeRename, commandType } = option;
     const {
       icon: presetIcon,
       iconColor: presetIconColor,
@@ -41,21 +33,18 @@
     } = persetOption || {};
     const { icon, iconColor, fontSize, password } = componentInfo || {};
 
+    const tsl = getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, attribute);
     return {
       icon: icon ?? presetIcon,
       iconColor: iconColor || presetIconColor,
-      attribute: attributeRename || attributeName || attribute,
-      extensionDesc: extensionDesc ? JSON.parse(extensionDesc) : {},
+      attribute: attributeRename || tsl?.functionName || attribute,
       fontSize: fontSize || persetFontSize || 14,
       password: password || persetPassword,
       commandType,
-      codeType,
-      deviceCode,
-      customCommand,
     };
   });
 
-  const { sendCommand, loading } = useSendCommand();
+  const { loading, doCommandDeliver } = useCommandDelivery();
 
   const handleChange = async () => {
     if (unref(getDesign).password) {
@@ -63,32 +52,14 @@
       checked.value = !unref(checked);
       return;
     }
-    const { option } = props.config || {};
-
-    const { values, isModbusCommand, sendValue } =
-      (await getSendValues(option, unref(getDesign), unref(checked))) || {};
-
-    const flag = await sendCommand(
-      values,
-      isModbusCommand ? sendValue : unref(checked),
-      isModbusCommand
-    );
-    if (!flag) checked.value = !unref(checked);
+    handleSendCommand();
   };
 
   const handleSendCommand = async () => {
+    if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
     const { option } = props.config || {};
-    checked.value = !unref(checked);
-
-    const { values, isModbusCommand, sendValue } =
-      (await getSendValues(option, unref(getDesign), unref(checked))) || {};
-
-    const flag = await sendCommand(
-      values,
-      isModbusCommand ? sendValue : unref(checked),
-      isModbusCommand
-    );
-    if (!flag) checked.value = !unref(checked);
+    const result = await doCommandDeliver(option, Number(unref(checked)));
+    if (!result) checked.value = !unref(checked);
   };
 
   const updateFn: DataFetchUpdateFn = (message, attribute) => {

 <script lang="ts" setup>
-  import { ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
+  import { ComponentMode, ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
   import { option } from './config';
   import { Spin } from 'ant-design-vue';
   import { computed, ref, unref } from 'vue';
   import { useComponentScale } from '../../../hook/useComponentScale';
-  import { useSendCommand } from '../../../hook/useSendCommand';
   import { DeviceName } from '/@/views/visual/commonComponents/DeviceName';
   import { DataFetchUpdateFn } from '../../../hook/socket/useSocket.type';
   import { useDataFetch } from '../../../hook/socket/useSocket';
-  import { getSendValues } from '../config';
   import PasswordModal from '../component/PasswordModal.vue';
   import { useModal } from '/@/components/Modal';
+  import { useCommandDelivery } from '../../../hook/useCommandDelivery';
+  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
 
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
@@ -20,34 +20,31 @@
 
   const currentValue = ref(false);
 
+  const { getDeviceProfileTslByIdWithIdentifier } = useDeviceProfileQueryContext();
+
   const getDesign = computed(() => {
     const { option, persetOption } = props.config;
-    const {
-      attribute,
-      attributeRename,
-      attributeName,
-      commandType,
-      extensionDesc,
-      codeType,
-      deviceCode,
-      customCommand,
-      componentInfo,
-    } = option;
+    const { attribute, deviceProfileId, attributeRename, commandType, componentInfo } = option;
     const { fontSize: persetFontSize, password: persetPassword } = persetOption || {};
     const { fontSize, password } = componentInfo || {};
+
+    const tsl = getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, attribute);
+
     return {
-      attribute: attributeRename || attributeName || attribute,
-      extensionDesc: extensionDesc ? JSON.parse(extensionDesc) : {},
+      attribute: attributeRename || tsl?.functionName || attribute,
       password: password || persetPassword,
       commandType,
-      codeType,
-      deviceCode,
-      customCommand,
       fontSize: fontSize || persetFontSize || 14,
     };
   });
+  const { doCommandDeliver, loading } = useCommandDelivery();
 
-  const { loading, sendCommand } = useSendCommand();
+  const handleSendCommand = async () => {
+    if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
+    const { option } = props.config || {};
+    const result = await doCommandDeliver(option, Number(!unref(currentValue)));
+    currentValue.value = result ? !unref(currentValue) : unref(currentValue);
+  };
   const handleChange = async (event: Event) => {
     if (unref(getDesign).password) {
       const target = event.target as HTMLInputElement;
@@ -57,29 +54,7 @@
       openModal(true, { password: unref(getDesign).password, control: event });
       return;
     }
-
-    const target = event.target as HTMLInputElement;
-    const value = target.checked;
-    const { option } = props.config || {};
-
-    const { values, isModbusCommand, sendValue } =
-      (await getSendValues(option, unref(getDesign), value)) || {};
-
-    const flag = await sendCommand(values, isModbusCommand ? sendValue : value, isModbusCommand);
-    flag ? (currentValue.value = value) : (target.checked = !value);
-  };
-
-  const handleSendCommand = async (data) => {
-    const { control: event } = data || {};
-    const target = event.target as HTMLInputElement;
-    const value = !target.checked;
-    const { option } = props.config || {};
-
-    const { values, isModbusCommand, sendValue } =
-      (await getSendValues(option, unref(getDesign), value)) || {};
-
-    const flag = await sendCommand(values, isModbusCommand ? sendValue : value, isModbusCommand);
-    flag ? (currentValue.value = value) : (target.checked = !value);
+    handleSendCommand();
   };
 
   const updateFn: DataFetchUpdateFn = (message, attribute) => {

 <script lang="ts" setup>
-  import { ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
+  import { ComponentMode, ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
   import { option } from './config';
   import { Slider, Spin } from 'ant-design-vue';
   import { computed, ref, unref } from 'vue';
   import { useComponentScale } from '../../../hook/useComponentScale';
   import { DeviceName } from '/@/views/visual/commonComponents/DeviceName';
-  import { useSendCommand } from '../../../hook/useSendCommand';
   import { useReceiveValue } from '../../../hook/useReceiveValue';
   import { DataFetchUpdateFn } from '../../../hook/socket/useSocket.type';
   import { useDataFetch } from '../../../hook/socket/useSocket';
-  import { TaskTypeEnum } from '/@/views/task/center/config';
-  import { useMessage } from '/@/hooks/web/useMessage';
-  import { SingleToHex } from '/@/views/device/list/cpns/tabs/ObjectModelCommandDeliveryModal/config';
-  import { genModbusCommand } from '/@/api/task';
   import PasswordModal from '../component/PasswordModal.vue';
   import { useModal } from '/@/components/Modal';
+  import { useCommandDelivery } from '../../../hook/useCommandDelivery';
+  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
 
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
   }>();
 
   const sliderValue = ref<number>(33);
-  const oldSliderValue = ref<number>(33);
-  const noSendValue = ref<number>(0);
-  const sliderEl = ref<Nullable<InstanceType<typeof Slider>>>(null);
+  const sliderElRef = ref<InstanceType<typeof Slider>>();
 
-  const { loading, sendCommand } = useSendCommand();
+  const { getDeviceProfileTslByIdWithIdentifier } = useDeviceProfileQueryContext();
 
   const getDesign = computed(() => {
     const { option, persetOption } = props.config;
-    const {
-      componentInfo,
-      attribute,
-      attributeRename,
-      attributeName,
-      commandType,
-      extensionDesc,
-      codeType,
-      deviceCode,
-      customCommand,
-    } = option;
+    const { componentInfo, attribute, deviceProfileId, attributeRename, commandType } = option;
+
     const {
       controlBarColor: persetControlBarColor,
       fonColor: persetFontColor,
@@ -50,6 +36,8 @@
       fontSize: persetFontSize,
       password: persetPassword,
     } = persetOption || {};
+
+    const tsl = getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, attribute);
     const {
       controlBarColor,
       password,
@@ -61,16 +49,12 @@
       fontSize,
     } = componentInfo || {};
     return {
-      attribute: attributeRename || attributeName || attribute,
+      attribute: attributeRename || tsl?.functionName || attribute,
       controlBarColor: controlBarColor ?? persetControlBarColor,
       fontColor: fontColor ?? persetFontColor,
       minNumber: minNumber ?? persetMinNumber,
       maxNumber: maxNumber ?? persetMaxNumber,
-      extensionDesc: extensionDesc ? JSON.parse(extensionDesc) : {},
       commandType,
-      codeType,
-      deviceCode,
-      customCommand,
       textColor: textColor || persetTextColor,
       valueSize: valueSize || persetValueSize || 20,
       fontSize: fontSize || persetFontSize || 14,
@@ -78,153 +62,28 @@
     };
   });
 
-  const index = ref<number>(0);
-  const afterValue = ref<number>(0); //点击Slider获取的值
-
-  const handleChange = async (e) => {
-    index.value++;
-    afterValue.value = e;
-    if (index.value == 1) {
-      oldSliderValue.value = unref(sliderValue);
-      return; //这个是因为设置了最大值时，当sliderValue的值大于最大值时只会显示设置的最大值，会执行一次change
-    }
-    sliderValue.value = e;
-  };
-
-  const handleAfterChange = async () => {
-    unref(sliderEl)?.blur();
-    if (unref(sliderValue) == unref(afterValue)) return;
-    if (unref(getDesign).password) return;
-    sliderValue.value = afterValue.value; //这一步是因为当我们是点击不是拖动时候，会让值更新不了，所以需要赋值一次
-  };
-
-  const { createMessage } = useMessage();
-
-  // 获取小数
-  const getFloatPart = (number: string | number) => {
-    const isLessZero = Number(number) < 0;
-    number = number.toString();
-    const floatPartStartIndex = number.indexOf('.');
-    const value = ~floatPartStartIndex
-      ? `${isLessZero ? '-' : ''}0.${number.substring(floatPartStartIndex + 1)}`
-      : '0';
-    return Number(value);
+  const sendValue = ref(0);
+  const handleChange = async (value: number) => {
+    sendValue.value = value;
   };
 
-  const getArray = (values) => {
-    const str = values.replace(/\s+/g, '');
-    const array: any = [];
+  const { loading, doCommandDeliver } = useCommandDelivery();
 
-    for (let i = 0; i < str.length; i += 4) {
-      const chunk = parseInt(str.substring(i, i + 4), 16);
-      array.push(chunk);
-    }
-    return array;
-  };
-
-  const getSendValue = async (value: number) => {
-    const { extensionDesc, codeType, deviceCode, customCommand } = unref(getDesign) || {};
-    const { transportType } = customCommand || {};
-    const { registerAddress, actionType, zoomFactor } = extensionDesc || {};
-    const newZoomValue = zoomFactor ? Number(zoomFactor) : 1;
-    if (transportType == 'TCP' && codeType == TaskTypeEnum.MODBUS_RTU) {
-      if (!deviceCode) {
-        createMessage.warning('当前设备没有设置地址码');
-        return;
-      }
-      const modbusForm = ref({
-        crc: 'CRC_16_LOWER',
-        deviceCode: deviceCode,
-        method: actionType == '16' ? '10' : actionType,
-        registerAddress,
-        registerNumber: 1,
-        registerValues: [value],
-      }) as any;
-      if (!actionType) {
-        createMessage.warning('当前物模型扩展描述没有填写');
-        return;
-      }
-      if (actionType == '06') {
-        const newValue = Math.trunc(value) * newZoomValue + getFloatPart(value) * newZoomValue;
-        if (newValue % 1 != 0) {
-          createMessage.warning(`值必须是整数,缩放因子为${unref(newZoomValue)}`);
-          return;
-        }
-
-        if (newValue > 65535) {
-          createMessage.warning(`值不能超过65535,缩放因子是${unref(newZoomValue)}`);
-          return;
-        }
-        modbusForm.value.registerValues = [newValue];
-      }
-      if (actionType == '05') {
-        if (Number(value) != 0 || Number(value) != 1) {
-          createMessage.warning(`当前物模型仅支持值为0和1`);
-          return;
-        }
-      }
-      if (actionType == '16' || actionType == '10') {
-        const regex = /^-?\d+(\.\d{0,2})?$/;
-        const values =
-          Math.trunc(value) * unref(newZoomValue) + getFloatPart(value) * unref(newZoomValue);
-        if (!regex.test(values as any)) {
-          createMessage.warning(`值精确到两位小数,缩放因子是${unref(newZoomValue)}`);
-          return;
-        }
-        const newValue = values == 0 ? [0, 0] : getArray(SingleToHex(values));
-        modbusForm.value.registerValues = newValue;
-        modbusForm.value.registerNumber = 2;
-        modbusForm.value.method = '10';
-      }
-      const sendValue = await genModbusCommand(unref(modbusForm));
-      return sendValue;
-    }
-  };
-
-  const handleBlur = async () => {
+  const handleAfterChange = () => {
     if (unref(getDesign).password) {
-      sliderValue.value = oldSliderValue.value;
-      openModal(true, { password: unref(getDesign).password, value: afterValue.value });
+      openModal(true, { password: unref(getDesign).password });
       return;
     }
-
-    if (unref(oldSliderValue) !== unref(sliderValue)) {
-      const { codeType, customCommand } = unref(getDesign) || {};
-      const { transportType } = customCommand || {};
-      const sendValue = ref<any>(unref(sliderValue));
-      const isModbusCommand = ref<boolean>(false);
-      if (transportType == 'TCP' && codeType == TaskTypeEnum.MODBUS_RTU) {
-        sendValue.value = await getSendValue(unref(sliderValue));
-        isModbusCommand.value = true;
-      }
-      const flag = await sendCommand(props.config.option, unref(sendValue), unref(isModbusCommand));
-      flag
-        ? ((sliderValue.value = unref(sliderValue)),
-          (oldSliderValue.value = sliderValue.value),
-          (index.value = 0))
-        : (sliderValue.value = unref(oldSliderValue));
-    }
+    handleSendCommand();
   };
 
-  const handleSendCommand = async (data) => {
-    const { value } = data || {};
-    sliderValue.value = value;
-    if (unref(oldSliderValue) !== unref(sliderValue)) {
-      const { codeType, customCommand } = unref(getDesign) || {};
-      const { transportType } = customCommand || {};
-      const sendValue = ref<any>(unref(sliderValue));
-      const isModbusCommand = ref<boolean>(false);
-      if (transportType == 'TCP' && codeType == TaskTypeEnum.MODBUS_RTU) {
-        sendValue.value = await getSendValue(unref(sliderValue));
-        isModbusCommand.value = true;
-      }
-      const flag = await sendCommand(props.config.option, unref(sendValue), unref(isModbusCommand));
-      flag
-        ? ((sliderValue.value = unref(sliderValue)),
-          (oldSliderValue.value = sliderValue.value),
-          (index.value = 0))
-        : (sliderValue.value = unref(oldSliderValue));
-    }
+  const handleSendCommand = async () => {
+    if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
+    const value = unref(sendValue);
+    const { option } = props.config || {};
+    const result = await doCommandDeliver(option, value);
+    unref(sliderElRef)?.blur();
+    sliderValue.value = result ? value : unref(sliderValue);
   };
 
   const { getNumberValue } = useReceiveValue();
@@ -233,7 +92,6 @@
     const [latest] = data[attribute] || [];
     const [name, value] = latest;
     if (!name && !value) return;
-    noSendValue.value = getNumberValue(value);
     sliderValue.value = getNumberValue(value);
   };
 
@@ -254,10 +112,11 @@
               fontSize: (getRatio ? getRatio * getDesign.valueSize : getDesign.valueSize) + 'px',
             }"
             class="font-bold text-xl mt-3 text-center"
-            >{{ sliderValue }}</span
           >
+            {{ sliderValue }}
+          </span>
           <Slider
-            ref="sliderEl"
+            ref="sliderElRef"
             :style="{
               '--slider-color': getDesign.controlBarColor,
               '--slider-handle': (getRatio ? getRatio * 14 : 14) + 'px',
@@ -270,7 +129,6 @@
             :max="getDesign.maxNumber"
             @change="handleChange"
             @afterChange="handleAfterChange"
-            @blur="handleBlur"
           />
 
           <span

@@ -8,6 +8,47 @@ import {
 } from '/@/views/visual/packages/index.type';
 import { PublicConfigClass, componentInitConfig } from '/@/views/visual/packages/publicConfig';
 import { ComponentConfigFieldEnum } from '../../../enum';
+import { buildUUID } from '/@/utils/uuid';
+
+export interface SwitchItemType extends Recordable {
+  id: string;
+  checked: boolean;
+  deviceId?: string;
+  deviceProfileId?: string;
+  attribute?: string;
+  deviceName?: string;
+  attributeName?: string;
+  openCommand?: string;
+  closeCommand?: string;
+  openService?: string;
+  closeService?: string;
+}
+
+export const DEFAULT_VALUE: SwitchItemType[] = [
+  {
+    deviceName: '光照设备',
+    attributeName: '光照',
+    icon: 'zongfushe',
+    unit: 'kw',
+    iconColor: '#367BFF',
+    fontColor: '#357CFB',
+    checked: false,
+    fontSize: 16,
+    id: buildUUID(),
+  },
+  {
+    value: 53.7,
+    deviceName: '风机设备',
+    attributeName: '风机',
+    icon: 'guangzhaoqiangdu',
+    unit: '℃',
+    iconColor: '#FFA000',
+    fontColor: '#FFA000',
+    checked: true,
+    fontSize: 16,
+    id: buildUUID(),
+  },
+];
 
 export const option: PublicPresetOptions = {
   multipleDataSourceComponent: true,

 <script lang="ts" setup>
-  import { ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
-  import { option } from './config';
+  import { ComponentMode, ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
+  import { DEFAULT_VALUE, option, SwitchItemType } from './config';
   import { SvgIcon } from '/@/components/Icon';
   import { Switch } from 'ant-design-vue';
-  import { computed, ref } from 'vue';
+  import { computed, ref, toRaw } from 'vue';
   import { useComponentScale } from '../../../hook/useComponentScale';
-  import { useSendCommand } from '../../../hook/useSendCommand';
   import { unref } from 'vue';
   import { DeviceName } from '/@/views/visual/commonComponents/DeviceName';
   import { MultipleDataFetchUpdateFn } from '../../../hook/socket/useSocket.type';
   import { useMultipleDataFetch } from '../../../hook/socket/useSocket';
   import { useReceiveMessage } from '../../../hook/useReceiveMessage';
   import { useReceiveValue } from '../../../hook/useReceiveValue';
-  import { DataSource } from '/@/views/visual/palette/types';
-  import { getSendValues, CommandTypeEnumLIst } from '../config';
   import { useModal } from '/@/components/Modal';
   import PasswordModal from '../component/PasswordModal.vue';
+  import {
+    DoCommandDeliverDataSourceType,
+    useCommandDelivery,
+  } from '../../../hook/useCommandDelivery';
+  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
 
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
   }>();
 
-  const svgList = ref<any>([
-    {
-      value: 26.2,
-      deviceName: '光照设备',
-      attributeName: '光照',
-      icon: 'zongfushe',
-      unit: 'kw',
-      iconColor: '#367BFF',
-      fontColor: '#357CFB',
-      checked: false,
-      id: 0,
-    },
-    {
-      value: 53.7,
-      deviceName: '风机设备',
-      attributeName: '风机',
-      icon: 'guangzhaoqiangdu',
-      unit: '℃',
-      iconColor: '#FFA000',
-      fontColor: '#FFA000',
-      checked: true,
-      id: 1,
-    },
-  ]);
+  const { getDeviceProfileTslByIdWithIdentifier } = useDeviceProfileQueryContext();
 
   const getDesign = computed(() => {
     const { persetOption = {}, option } = props.config;
@@ -64,90 +43,66 @@
         const {
           attribute,
           attributeRename,
-          attributeName,
           deviceId,
           deviceName,
           deviceRename,
           commandType,
-          extensionDesc,
-          codeType,
-          deviceCode,
-          customCommand,
+          deviceProfileId,
+          openCommand,
+          closeCommand,
+          openService,
+          closeService,
         } = item;
+
+        const tsl = getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, attribute);
+
         return {
           unit: unit ?? persetUnit,
+          deviceProfileId,
+          deviceId,
           fontColor: fontColor ?? persetFontColor,
           icon: icon ?? persetIcon,
           iconColor: iconColor ?? persetIconColor,
           attribute: attribute,
-          attributeName: attributeRename || attributeName,
+          attributeName: attributeRename || tsl?.functionName || attribute,
           showDeviceName,
           deviceName: deviceRename || deviceName,
           id: deviceId,
-          extensionDesc: extensionDesc ? JSON.parse(extensionDesc) : {},
           commandType,
-          codeType,
-          deviceCode,
-          customCommand,
           fontSize: fontSize || persetFontSize || 14,
           password: password || persetPassword,
-        };
+          checked: false,
+          openCommand,
+          closeCommand,
+          openService,
+          closeService,
+        } as SwitchItemType;
       }),
     };
   });
 
-  const { loading, sendCommand } = useSendCommand();
-  const handleChange = async (index: number, checked: Boolean, item: any) => {
+  const handleChange = async (item) => {
     if (item.password) {
-      openModal(true, { password: item.password, index, checked });
-      controlList.value[index].checked = !checked;
+      openModal(true, { password: item.password });
       return;
     }
-    const { heightPx, itemHeightRatio, itemWidthRatio, mode, widthPx, dataSource } =
-      props.config.option;
-    const data = {
-      ...dataSource?.[index],
-      heightPx,
-      itemHeightRatio,
-      itemWidthRatio,
-      mode,
-      widthPx,
-    } as DataSource;
-    const { values, isModbusCommand, sendValue } =
-      (await getSendValues(data, unref(getDesign).dataSource[index], checked)) || {};
-
-    const flag = await sendCommand(values, isModbusCommand ? sendValue : checked, isModbusCommand);
-    if (!flag) controlList.value[index].checked = !checked;
+    handleSendCommand(item);
   };
 
   const { forEachGroupMessage } = useReceiveMessage();
   const { getNumberValue } = useReceiveValue();
 
   const controlList = ref(
-    props.config.option.dataSource
-      ? unref(getDesign).dataSource.map((item) => {
-          return { ...item, checked: false };
-        })
-      : svgList
+    props.config.option.dataSource ? unref(getDesign).dataSource : DEFAULT_VALUE
   );
-  const handleSendCommand = async (modalData) => {
-    const { index, checked } = modalData || {};
-    const { heightPx, itemHeightRatio, itemWidthRatio, mode, widthPx, dataSource } =
-      props.config.option;
-    const data = {
-      ...dataSource?.[index],
-      heightPx,
-      itemHeightRatio,
-      itemWidthRatio,
-      mode,
-      widthPx,
-    } as DataSource;
-    controlList.value[index].checked = checked;
-    const { values, isModbusCommand, sendValue } =
-      (await getSendValues(data, unref(getDesign).dataSource[index], checked)) || {};
 
-    const flag = await sendCommand(values, isModbusCommand ? sendValue : checked, isModbusCommand);
-    if (!flag) controlList.value[index].checked = !checked;
+  const { loading, doCommandDeliver } = useCommandDelivery();
+  const handleSendCommand = async (modalData: SwitchItemType) => {
+    if (props.config.option.mode === ComponentMode.SELECT_PREVIEW) return;
+    await doCommandDeliver(
+      toRaw(unref(modalData)) as DoCommandDeliverDataSourceType,
+      Number(unref(modalData).checked)
+    );
   };
 
   const updateFn: MultipleDataFetchUpdateFn = async (message, deviceId, attribute) => {
@@ -169,34 +124,26 @@
   <main class="w-full h-full flex flex-col justify-evenly items-center">
     <DeviceName :config="config" />
     <div
-      style="width: 86%"
-      v-for="(item, index) in controlList"
+      v-for="item in controlList"
       :key="item.id"
-      class="flex justify-between items-center"
+      class="flex justify-between items-center w-full px-4"
     >
-      <div class="flex items-center">
-        <SvgIcon
-          :name="item.icon!"
-          prefix="iconfont"
-          :size="getRatio ? 30 * getRatio : 30"
-          :style="{ color: item.iconColor }"
-        />
-
-        <div
-          class="text-gray-500 truncate ml-6"
-          :style="{ fontSize: (getRatio ? getRatio * item.fontSize : item.fontSize) + 'px' }"
-          >{{
-            `${item.deviceName} - ${
-              item.commandType ? CommandTypeEnumLIst[item.commandType].name : item.attributeName
-            }`
-          }}</div
-        >
+      <SvgIcon
+        :name="item.icon!"
+        prefix="iconfont"
+        :size="getRatio ? 30 * getRatio : 30"
+        :style="{ color: item.iconColor }"
+      />
+      <div
+        class="text-gray-500 truncate mx-2"
+        :style="{ fontSize: (getRatio ? getRatio * item.fontSize : item.fontSize) + 'px' }"
+      >
+        {{ `${item.deviceName} - ${item.attributeName}` }}
       </div>
-
       <Switch
         v-model:checked="item.checked"
         :loading="loading"
-        @change="handleChange(index, item.checked, item)"
+        @change="handleChange(item)"
         :style="{ transform: `scale(${getRatio || 1})` }"
       />
     </div>

-import { ref, unref } from 'vue';
-import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
-import { CommandTypeEnum } from '/@/views/rule/linkedge/config/config.data';
-import { TaskTypeEnum } from '/@/views/task/center/config';
-import { genModbusCommand } from '/@/api/task';
-import { useMessage } from '/@/hooks/web/useMessage';
-import { SingleToHex } from '/@/views/device/list/cpns/tabs/ObjectModelCommandDeliveryModal/config';
-
-const getArray = (values) => {
-  const str = values.replace(/\s+/g, '');
-  const array: any = [];
-
-  for (let i = 0; i < str.length; i += 4) {
-    const chunk = parseInt(str.substring(i, i + 4), 16);
-    array.push(chunk);
-  }
-  return array;
-};
-
-export const getSendValues = async (option, getDesign, checked) => {
-  const values: any = option;
-  const isModbusCommand = ref<boolean>(false); //判断是否是TCP设备-> 且设备标识符是modeBUs，切选择是下发命令类型是属性
-  const { extensionDesc, commandType, codeType, deviceCode, customCommand } = getDesign || {};
-  const { registerAddress, actionType } = extensionDesc || {};
-  const { openCommand, closeCommand, transportType } = customCommand || {};
-  const modBUS = ref<any>({});
-  const sendValue = ref();
-
-  const { createMessage } = useMessage();
-  //判断是不是TCP类型设备
-  if (transportType === TransportTypeEnum.TCP) {
-    if (
-      //判断TCP下发类型是否是自定义还是服务
-      commandType === CommandTypeEnum.CUSTOM.toString() ||
-      commandType == CommandTypeEnum.SERVICE.toString()
-    ) {
-      values.customCommand.command = checked ? openCommand : closeCommand;
-      values.customCommand.command = values.customCommand.command
-        .replaceAll(/\s/g, '')
-        .toUpperCase();
-    }
-    if (
-      //判断命令下发类型是不是属性 且是modbus
-      commandType === CommandTypeEnum.ATTRIBUTE.toString() &&
-      codeType === TaskTypeEnum.MODBUS_RTU
-    ) {
-      if (!deviceCode) {
-        createMessage.warning('当前设备没有设置地址码');
-        return;
-      }
-      if (!actionType) {
-        createMessage.warning('当前物模型扩展描述没有填写');
-        return;
-      }
-      isModbusCommand.value = true;
-      modBUS.value = {
-        crc: 'CRC_16_LOWER',
-        deviceCode: deviceCode,
-        method: actionType == '16' ? '10' : actionType,
-        registerAddress,
-        registerNumber: 1,
-        registerValues: [Number(checked)],
-      };
-
-      if (actionType == '16' || actionType == '10') {
-        const newValue = Number(checked) == 0 ? [0, 0] : getArray(SingleToHex(Number(checked)));
-        modBUS.value.registerValues = newValue;
-        modBUS.value.registerNumber = 2;
-        modBUS.value.method = '10';
-      }
-
-      sendValue.value = await genModbusCommand(unref(modBUS));
-    }
-  }
-
-  return { values, sendValue: unref(sendValue), isModbusCommand: unref(isModbusCommand) };
-};
-
-export const CommandTypeEnumLIst = {
-  '0': { CUSTOM: 0, name: '自定义' },
-  '1': { CUSTOM: 1, name: '服务' },
-  '2': { CUSTOM: 2, name: '属性' },
-};

@@ -11,3 +11,7 @@ export const ControlList = [
   LateralNumericalControlConfig,
   SwitchListConfig,
 ];
+
+export enum ControlComponentEnum {
+  LATERAL_NUMERICAL_CONTROL = 'LateralNumericalControl',
+}

@@ -3,11 +3,15 @@
   import { BasicModal, useModalInner } from '/@/components/Modal';
   import { formSchema, getHistorySearchParams, SchemaFiled } from './history.config';
   import { HistoryModalOkEmitParams } from './type';
-  import { ref, unref } from 'vue';
+  import { computed, ref, unref } from 'vue';
   import { getAllDeviceByOrg } from '/@/api/dataBoard';
   import { getDeviceHistoryInfo } from '/@/api/alarm/position';
   import { DataSource } from '/@/views/visual/palette/types';
-  import { cloneDeep } from 'lodash-es';
+  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
+  import { DataTypeEnum } from '/@/enums/objectModelEnum';
+  import { StructJSON } from '/@/api/device/model/modelOfMatterModel';
+  import { HistoryData } from '/@/api/alarm/position/model';
+  import { useJsonParse } from '/@/hooks/business/useJsonParse';
 
   const emit = defineEmits(['register', 'ok']);
 
@@ -20,47 +24,44 @@
   });
 
   const loading = ref(false);
-  const getDesign = ref();
+  const dataSourceRef = ref<DataSource[]>([]);
 
-  const getTwoMap = async (dataSource) => {
-    if (dataSource.length < 2) return;
-    dataSource = dataSource.splice(0, 2);
-    const deviceRecord = dataSource?.at(0) || ({} as DataSource);
+  const getPositionRecord = computed<DataSource>(() => unref(dataSourceRef).at(0) as DataSource);
+
+  const { getDeviceProfileTslByIdWithIdentifier } = useDeviceProfileQueryContext();
+
+  const handleSetForm = async () => {
+    const deviceRecord = unref(getPositionRecord) || {};
 
     if (!deviceRecord.organizationId) return;
     const deviceList = await getAllDeviceByOrg(
       deviceRecord.organizationId,
       deviceRecord.deviceProfileId
     );
+
     const options = deviceList
       .filter((item) => item.tbDeviceId === deviceRecord.deviceId)
       .map((item) => ({ ...item, label: item.alias || item.name, value: item.tbDeviceId }));
 
-    const attKey = dataSource.map((item) => ({
-      ...item,
-      label: item.attribute,
-      value: item.attribute,
-    }));
+    const { latitudeIdentifier, longitudeIdentifier, deviceProfileId } = deviceRecord;
 
-    updateSchemaMap(options, attKey, deviceRecord);
-  };
+    const attKey = [latitudeIdentifier, longitudeIdentifier].map((item) => {
+      const [identifier, structIdentifier] = item || [];
+      const detail = getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, identifier);
 
-  const getOneMap = async (dataSource) => {
-    const deviceRecord = dataSource?.[0];
-    if (!deviceRecord.organizationId) return;
-    const deviceList = await getAllDeviceByOrg(
-      deviceRecord.organizationId,
-      deviceRecord.deviceProfileId
-    );
-    const options = deviceList
-      .filter((item) => item.tbDeviceId === deviceRecord.deviceId)
-      .map((item) => ({ ...item, label: item.alias || item.name, value: item.tbDeviceId }));
+      if (detail?.specs?.dataType.type === DataTypeEnum.STRUCT) {
+        const structIdentifierDetail = (detail.specs.dataType.specs as StructJSON[])?.find(
+          (temp) => temp.identifier === structIdentifier
+        );
+        return {
+          label: `${detail.functionName} / ${structIdentifierDetail?.functionName}`,
+          value: identifier,
+        };
+      }
+
+      return { label: detail?.functionName, value: identifier };
+    });
 
-    const attKey = dataSource?.map((item) => ({
-      ...item,
-      label: item.attributeName,
-      value: item.attribute,
-    }));
     updateSchemaMap(options, attKey, deviceRecord);
   };
 
@@ -92,81 +93,73 @@
 
   const [registerModal, { closeModal }] = useModalInner(async (dataSource: DataSource[]) => {
     try {
-      getDesign.value = dataSource;
-      dataSource = cloneDeep(dataSource);
-      //判断选择是不是结构体
-      if (dataSource.length == 1 && dataSource?.[0]?.lal) {
-        getOneMap(dataSource);
-        return;
-      }
-      getTwoMap(dataSource);
+      dataSourceRef.value = dataSource;
+      handleSetForm();
     } catch (error) {
       throw error;
     }
   });
 
-  const getMultipleDataSource = async (res) => {
+  const getPositionDataSource = async (res: HistoryData) => {
+    const keys = Object.keys(res);
+    const track: Record<'lng' | 'lat', number>[] = [];
+
+    const {
+      latitudeIdentifier = [],
+      longitudeIdentifier = [],
+      deviceProfileId,
+    } = unref(getPositionRecord);
+
+    const [latIdentifier] = latitudeIdentifier || [];
+    const [lngIdentifier] = longitudeIdentifier || [];
+
+    if (!latIdentifier || !lngIdentifier) return track;
+
+    const latDetail = getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, latIdentifier);
+    const lngDetail = getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, lngIdentifier);
+
+    if (!latDetail || !lngDetail) return track;
+
     let timespanList = Object.keys(res).reduce((prev, next) => {
       const ts = res[next].map((item) => item.ts);
       return [...prev, ...ts];
     }, [] as number[]);
     timespanList = [...new Set(timespanList)];
 
-    const track: Record<'lng' | 'lat', number>[] = [];
-    const keys = Object.keys(res);
+    for (const position of [longitudeIdentifier, latitudeIdentifier]) {
+      const [attribute] = position;
+      const detail = getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, attribute);
+      if (!detail) continue;
+      const { identifier } = detail || {};
+
+      if (detail?.specs?.dataType.type === DataTypeEnum.STRUCT) {
+        const [, structIdentifier] = position;
+        res[identifier].forEach((temp) => {
+          const structJSON = useJsonParse(temp.value).value;
+          temp.value = structJSON?.[structIdentifier];
+        });
+      }
+    }
 
     for (const ts of timespanList) {
       const list: { ts: number; value: number }[] = [];
       for (const key of keys) {
         const record = res[key].find((item) => ts === item.ts);
-        if (!validEffective(record?.value)) {
-          continue;
-        }
         list.push(record as any);
       }
 
       if (list.length === 2 && list.every(Boolean)) {
-        const lng = list.at(0)?.value;
-        const lat = list.at(1)?.value;
-        if (lng && lat) track.push({ lng, lat });
+        let lng = list.at(0)?.value;
+        let lat = list.at(1)?.value;
+        if (lng && lat) {
+          track.push({ lng: Number(lng), lat: Number(lat) });
+        }
       }
     }
-    return track;
-  };
-
-  // 单数据源选择结构体
-  const getSingleDataSource = async (res) => {
-    const [keys] = Object.keys(res);
-    const track: Record<'lng' | 'lat', number>[] = [];
-    const dataSource = res[keys]?.map((item) => {
-      return {
-        value: item.value ? JSON.parse(item.value) : {},
-      };
-    });
-    const list: { value: number }[] = [];
-    dataSource?.forEach((item) => {
-      if (
-        //判断结构体得值是不是数字
-        Object.values(item.value).every((item1) => {
-          return validEffective(item1 as any);
-        })
-      ) {
-        list.push(item.value);
-      }
-    });
-    const { latitude, longitude } = unref(getDesign)?.[0]; //获取选择的经纬度选项
 
-    list.forEach((item) => {
-      const lng = item[longitude];
-      const lat = item[latitude];
-      if (lng && lat) track.push({ lng, lat });
-    });
     return track;
   };
 
-  const validEffective = (value = '') => {
-    return !!(value && !isNaN(value as unknown as number));
-  };
   const handleOk = async () => {
     try {
       await validate();
@@ -180,9 +173,8 @@
         ...value,
         [SchemaFiled.KEYS]: value[SchemaFiled.KEYS].join(','),
       });
-      const ifSingle = unref(getDesign)?.length === 1 && unref(getDesign)?.[0]?.lal;
 
-      const track = ifSingle ? await getSingleDataSource(res) : await getMultipleDataSource(res);
+      const track = await getPositionDataSource(res);
       emit('ok', { track, value } as HistoryModalOkEmitParams);
       closeModal();
     } catch (error) {

+import { CategoryEnum } from '../..';
 import { useComponentKeys } from '/@/views/visual/packages/hook/useComponentKeys';
 import { ConfigType, PackagesCategoryEnum } from '/@/views/visual/packages/index.type';
 
@@ -6,5 +7,6 @@ const componentKeys = useComponentKeys('MapComponentTrackHistory');
 export const MapComponentTrackHistoryConfig: ConfigType = {
   ...componentKeys,
   title: '历史轨迹',
+  category: CategoryEnum.MAP,
   package: PackagesCategoryEnum.MAP,
 };

@@ -50,6 +50,7 @@
       endTs,
       formatType
     )}`;
+
     genTrackPlaybackAnimation(track as any[]);
   };
 

+import { CategoryEnum } from '../..';
 import { useComponentKeys } from '/@/views/visual/packages/hook/useComponentKeys';
 import { ConfigType, PackagesCategoryEnum } from '/@/views/visual/packages/index.type';
 
@@ -6,5 +7,6 @@ const componentKeys = useComponentKeys('MapComponentTrackReal');
 export const MapComponentTrackRealConfig: ConfigType = {
   ...componentKeys,
   title: '实时轨迹',
+  category: CategoryEnum.MAP,
   package: PackagesCategoryEnum.MAP,
 };

@@ -9,6 +9,7 @@
   import { useMapTrackPlayBack } from './useMapTrackPlayback';
   import { useMultipleDataFetch } from '../../../hook/socket/useSocket';
   import { MultipleDataFetchUpdateFn } from '../../../hook/socket/useSocket.type';
+  import get from 'lodash-es/get';
 
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
@@ -24,44 +25,36 @@
     return props.config.option.dataSource?.at(0)?.deviceId;
   });
 
-  const getDesign = computed(() => {
-    const { option } = props.config;
-    const { dataSource } = option || {};
-    return {
-      dataSource: dataSource,
-    };
-  });
-
   /**
    * @description 经度key
    */
   const getLngKey = computed(() => {
-    return props.config.option.dataSource?.at(0)?.attribute || '';
+    return props.config.option.dataSource?.at(0)?.longitudeIdentifier || [];
   });
 
   /**
    * @description 纬度key
    */
   const getLatKey = computed(() => {
-    return props.config.option.dataSource?.at(1)?.attribute || '';
+    return props.config.option.dataSource?.at(0)?.latitudeIdentifier || [];
   });
 
   const validEffective = (value = '') => {
     return !!(value && !isNaN(value as unknown as number));
   };
 
-  const getTwoMap = (message, deviceId) => {
+  const handleMessage = (message, deviceId) => {
     if (unref(getDeviceId) !== deviceId) return;
 
     const { data = {} } = message;
 
     const bindMessage = data[deviceId];
 
-    const lngData = bindMessage[unref(getLngKey)] || [];
+    const lngData = get(bindMessage, unref(getLngKey)) || [];
     const [lngLatest] = lngData;
     const [, lng] = lngLatest || [];
 
-    const latData = bindMessage[unref(getLatKey)] || [];
+    const latData = get(bindMessage, unref(getLatKey)) || [];
     const [latLatest] = latData;
     const [, lat] = latLatest || [];
 
@@ -70,32 +63,8 @@
     }
   };
 
-  const getOneMap = (message, deviceId) => {
-    if (unref(getDeviceId) !== deviceId) return;
-
-    const { longitude, latitude, attribute } = unref(getDesign)?.dataSource?.[0] || {};
-    const { data } = message || {};
-    const bindMessage = data[deviceId];
-    const [, values] = attribute && bindMessage?.[attribute][0];
-
-    const mapValues = values ? JSON.parse(values) : {};
-    const lng = longitude && mapValues[longitude];
-    const lat = latitude && mapValues[latitude];
-
-    if (validEffective(lng) && validEffective(lat)) {
-      drawLine({ lng: Number(lng), lat: Number(lat) });
-    }
-  };
-
   const updateFn: MultipleDataFetchUpdateFn = (message, deviceId) => {
-    const { lal } = unref(getDesign)?.dataSource?.[0] || {};
-    // 属性选择结构体类型时
-    if (lal && unref(getDesign)?.dataSource?.length == 1) {
-      getOneMap(message, deviceId);
-      return;
-    }
-    // 选择两个属性时
-    getTwoMap(message, deviceId);
+    handleMessage(message, deviceId);
   };
 
   useMultipleDataFetch(props, updateFn);

-import cloneDeep from 'lodash-es/cloneDeep';
-import { SwitchSignalLightConfig } from '.';
-import {
-  ConfigType,
-  CreateComponentType,
-  PublicComponentOptions,
-  PublicPresetOptions,
-} from '/@/views/visual/packages/index.type';
-import { PublicConfigClass, componentInitConfig } from '/@/views/visual/packages/publicConfig';
-import { ComponentConfigFieldEnum } from '/@/views/visual/packages/enum';
-
-export const option: PublicPresetOptions = {
-  [ComponentConfigFieldEnum.OPEN_COLOR]: '#30f230',
-  [ComponentConfigFieldEnum.CLOSE_COLOR]: '#eeeeee',
-  [ComponentConfigFieldEnum.SHOW_DEVICE_NAME]: true,
-};
-
-export default class Config extends PublicConfigClass implements CreateComponentType {
-  public key: string = SwitchSignalLightConfig.key;
-
-  public attr = { ...componentInitConfig };
-
-  public componentConfig: ConfigType = cloneDeep(SwitchSignalLightConfig);
-
-  public persetOption = cloneDeep(option);
-
-  public option: PublicComponentOptions;
-
-  constructor(option: PublicComponentOptions) {
-    super();
-    this.option = { ...option };
-  }
-}

-<script lang="ts" setup>
-  import { ComponentConfigFieldEnum } from '/@/views/visual/packages/enum';
-  import { useForm, BasicForm } from '/@/components/Form';
-  import { PublicFormInstaceType } from '/@/views/visual/dataSourceBindPanel/index.type';
-  import { option } from './config';
-
-  const [register, { getFieldsValue, setFieldsValue, resetFields }] = useForm({
-    schemas: [
-      {
-        field: ComponentConfigFieldEnum.OPEN_COLOR,
-        label: 'ON颜色',
-        component: 'ColorPicker',
-        changeEvent: 'update:value',
-        componentProps: {
-          defaultValue: option.openColor,
-        },
-      },
-      {
-        field: ComponentConfigFieldEnum.CLOSE_COLOR,
-        label: 'OFF颜色',
-        component: 'ColorPicker',
-        changeEvent: 'update:value',
-        componentProps: {
-          defaultValue: option.closeColor,
-        },
-      },
-      {
-        field: ComponentConfigFieldEnum.SHOW_DEVICE_NAME,
-        label: '显示设备名称',
-        component: 'Checkbox',
-        defaultValue: option.showDeviceName,
-      },
-    ],
-    showActionButtonGroup: false,
-    labelWidth: 120,
-    baseColProps: {
-      span: 12,
-    },
-  });
-
-  const getFormValues = () => {
-    return getFieldsValue();
-  };
-
-  const setFormValues = (data: Recordable) => {
-    return setFieldsValue(data);
-  };
-
-  defineExpose({
-    getFormValues,
-    setFormValues,
-    resetFormValues: resetFields,
-  } as PublicFormInstaceType);
-</script>
-
-<template>
-  <BasicForm @register="register" />
-</template>

-<script lang="ts" setup>
-  import { commonDataSourceSchemas } from '../../../config/common.config';
-  import { BasicForm, useForm } from '/@/components/Form';
-  import { PublicFormInstaceType } from '/@/views/visual/dataSourceBindPanel/index.type';
-
-  const [register, { getFieldsValue, setFieldsValue, validate, resetFields }] = useForm({
-    labelWidth: 0,
-    showActionButtonGroup: false,
-    layout: 'horizontal',
-    labelCol: { span: 0 },
-    schemas: commonDataSourceSchemas(),
-  });
-
-  const getFormValues = () => {
-    return getFieldsValue();
-  };
-
-  const setFormValues = (record: Recordable) => {
-    return setFieldsValue(record);
-  };
-
-  defineExpose({
-    getFormValues,
-    setFormValues,
-    validate,
-    resetFormValues: resetFields,
-  } as PublicFormInstaceType);
-</script>
-
-<template>
-  <BasicForm @register="register" />
-</template>

-// import { ComponentEnum, ComponentNameEnum } from '../index.type';
-import { useComponentKeys } from '/@/views/visual/packages/hook/useComponentKeys';
-import { ConfigType, PackagesCategoryEnum } from '/@/views/visual/packages/index.type';
-
-const componentKeys = useComponentKeys('SwitchSignalLight');
-export const SwitchSignalLightConfig: ConfigType = {
-  ...componentKeys,
-  // title: ComponentNameEnum.TEXT_COMPONENT_1,
-  title: '开关量信号灯',
-  package: PackagesCategoryEnum.TEXT,
-};

-<script lang="ts" setup>
-  import { ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
-  import { option } from './config';
-  import { useComponentScale } from '/@/views/visual/packages/hook/useComponentScale';
-  import { ref, onMounted, unref } from 'vue';
-  import { useIntervalFn } from '@vueuse/core';
-  import { DeviceName } from '/@/views/visual/commonComponents/DeviceName';
-  import { useReceiveValue } from '../../../hook/useReceiveValue';
-  import { useDataFetch } from '../../../hook/socket/useSocket';
-  import { DataFetchUpdateFn } from '../../../hook/socket/useSocket.type';
-
-  const props = defineProps<{
-    config: ComponentPropsConfigType<typeof option>;
-  }>();
-
-  const isOpenClose = ref<boolean>(true);
-
-  const randomFn = () => {
-    useIntervalFn(() => {
-      isOpenClose.value = !unref(isOpenClose);
-    }, 2000);
-  };
-  const { getNumberValue } = useReceiveValue();
-  const updateFn: DataFetchUpdateFn = (message, attribute) => {
-    const { data = {} } = message;
-    const [latest] = data[attribute] || [];
-    const [_, value] = latest;
-    isOpenClose.value = Boolean(getNumberValue(value));
-  };
-
-  onMounted(() => {
-    !props.config.option.uuid && randomFn();
-  });
-
-  useDataFetch(props, updateFn);
-
-  const { getScale } = useComponentScale(props);
-</script>
-
-<template>
-  <main :style="getScale" class="w-full h-full flex flex-col justify-center items-center">
-    <DeviceName :config="config" class="text-center" />
-    <div
-      style="--open-color: `${getDesign.openColor}`; --close-color: `${getDesign.closeColor}`"
-      :class="isOpenClose ? 'switch_open' : 'switch_close'"
-    >
-    </div>
-  </main>
-</template>
-<style lang="less" scoped>
-  .switch_open {
-    background: var(--open-color);
-    box-shadow: var(--open-color) 0 0 10px 3px;
-    width: 60px;
-    height: 60px;
-    border-radius: 50%;
-    margin: 10px 0;
-  }
-
-  .switch_close {
-    background-color: var(--close-color);
-    box-shadow: none;
-    width: 42.023px;
-    height: 42.023px;
-    border-radius: 50%;
-    margin: 10px 0;
-  }
-</style>

@@ -2,11 +2,13 @@
   import { ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
   import { option } from './config';
   import { useComponentScale } from '/@/views/visual/packages/hook/useComponentScale';
-  import { computed } from 'vue';
+  import { computed, unref } from 'vue';
   import { ref } from 'vue';
   import { DeviceName } from '/@/views/visual/commonComponents/DeviceName';
   import { useDataFetch } from '../../../hook/socket/useSocket';
   import { DataFetchUpdateFn } from '../../../hook/socket/useSocket.type';
+  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
+  import { useThingsModelValueTransform } from '/@/views/visual/palette/hooks/useThingsModelValueTransform';
 
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
@@ -14,6 +16,15 @@
 
   const currentValue = ref<string | number>(123);
 
+  const { getDeviceProfileTslByIdWithIdentifier } = useDeviceProfileQueryContext();
+
+  const getThingModelTsl = computed(() => {
+    const { option } = props.config;
+
+    const { deviceProfileId, attribute } = option;
+    return getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, attribute);
+  });
+
   const getDesign = computed(() => {
     const { persetOption = {}, option } = props.config;
 
@@ -23,14 +34,14 @@
       valueSize: persetValueSize,
     } = persetOption;
 
-    const { componentInfo, attribute, attributeRename, attributeName } = option;
+    const { componentInfo, attribute, attributeRename } = option;
 
     const { fontColor, fontSize, valueSize } = componentInfo || {};
     return {
       fontColor: fontColor || persetFontColor,
       fontSize: fontSize || persetFontSize || 14,
       valueSize: valueSize || persetValueSize || 20,
-      attribute: attributeRename || attributeName || attribute,
+      attribute: attributeRename || unref(getThingModelTsl)?.functionName || attribute,
     };
   });
 
@@ -39,7 +50,10 @@
     const [latest] = data[attribute] || [];
     if (!latest.length) return;
     const [_, value] = latest;
-    currentValue.value = value;
+    currentValue.value = useThingsModelValueTransform(
+      value,
+      unref(getThingModelTsl)?.specs?.dataType
+    );
   };
 
   useDataFetch(props, updateFn);
@@ -52,7 +66,7 @@
     <DeviceName :config="config" />
 
     <h1
-      class="my-4 font-bold !my-2 truncate"
+      class="my-4 font-bold !my-2 truncate w-full text-center"
       :style="{
         color: getDesign.fontColor,
         fontSize: (getRatio ? getRatio * getDesign.valueSize : getDesign.valueSize) + 'px',
@@ -63,10 +77,8 @@
     <div
       class="text-gray-500 truncate"
       :style="{ fontSize: (getRatio ? getRatio * getDesign.fontSize : getDesign.fontSize) + 'px' }"
-      >{{ getDesign.attribute || '温度' }}</div
     >
-    <!-- <div v-if="config.option.componentInfo.showDeviceName">
-      {{ config.option.deviceRename || config.option.deviceName }}
-    </div> -->
+      {{ getDesign.attribute || '温度' }}
+    </div>
   </main>
 </template>

@@ -2,12 +2,14 @@
   import { ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
   import { option } from './config';
   import { useComponentScale } from '/@/views/visual/packages/hook/useComponentScale';
-  import { computed } from 'vue';
+  import { computed, unref } from 'vue';
   import { ref } from 'vue';
   import { UpdateTime } from '/@/views/visual/commonComponents/UpdateTime';
   import { DeviceName } from '/@/views/visual/commonComponents/DeviceName';
   import { useDataFetch } from '../../../hook/socket/useSocket';
   import { DataFetchUpdateFn } from '../../../hook/socket/useSocket.type';
+  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
+  import { useThingsModelValueTransform } from '/@/views/visual/palette/hooks/useThingsModelValueTransform';
 
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
@@ -16,6 +18,15 @@
   const currentValue = ref<string | number>(123);
   const time = ref<Nullable<number>>(null);
 
+  const { getDeviceProfileTslByIdWithIdentifier } = useDeviceProfileQueryContext();
+
+  const getThingModelTsl = computed(() => {
+    const { option } = props.config;
+
+    const { deviceProfileId, attribute } = option;
+    return getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, attribute);
+  });
+
   const getDesign = computed(() => {
     const { persetOption = {}, option } = props.config;
 
@@ -25,7 +36,7 @@
       fontSize: persetFontSize,
     } = persetOption;
 
-    const { componentInfo, attribute, attributeName, attributeRename } = option;
+    const { componentInfo, attribute, attributeRename } = option;
 
     const { fontColor, valueSize, fontSize } = componentInfo || {};
 
@@ -33,7 +44,7 @@
       fontColor: fontColor || persetFontColor,
       valueSize: valueSize || persetValueSize || 20,
       fontSize: fontSize || persetFontSize || 14,
-      attribute: attributeRename || attributeName || attribute,
+      attribute: attributeRename || unref(getThingModelTsl)?.functionName || attribute,
     };
   });
 
@@ -42,7 +53,10 @@
     const [info] = data[attribute] || [];
     if (!info.length) return;
     const [timespan, value] = info;
-    currentValue.value = value;
+    currentValue.value = useThingsModelValueTransform(
+      value,
+      unref(getThingModelTsl)?.specs?.dataType
+    );
     time.value = timespan;
   };
 
@@ -54,9 +68,9 @@
 <template>
   <main class="w-full h-full flex flex-col justify-center items-center">
     <DeviceName :config="config" />
-    <div class="flex-1 flex justify-center items-center flex-col" :style="getScale">
+    <div class="flex-1 flex justify-center items-center flex-col w-full" :style="getScale">
       <h1
-        class="my-4 font-bold !my-2 truncate"
+        class="my-4 font-bold !my-2 truncate w-full text-center"
         :style="{
           color: getDesign.fontColor,
           fontSize: (getRatio ? getRatio * getDesign.valueSize : getDesign.valueSize) + 'px',

@@ -2,13 +2,15 @@
   import { ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
   import { option } from './config';
   import { useComponentScale } from '/@/views/visual/packages/hook/useComponentScale';
-  import { ref } from 'vue';
+  import { ref, unref } from 'vue';
   import { UpdateTime } from '/@/views/visual/commonComponents/UpdateTime';
   import { SvgIcon } from '/@/components/Icon';
   import { computed } from 'vue';
   import { DeviceName } from '/@/views/visual/commonComponents/DeviceName';
   import { useDataFetch } from '../../../hook/socket/useSocket';
   import { DataFetchUpdateFn } from '../../../hook/socket/useSocket.type';
+  import { useThingsModelValueTransform } from '/@/views/visual/palette/hooks/useThingsModelValueTransform';
+  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
 
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
@@ -18,6 +20,15 @@
 
   const time = ref<Nullable<number>>(null);
 
+  const { getDeviceProfileTslByIdWithIdentifier } = useDeviceProfileQueryContext();
+
+  const getThingModelTsl = computed(() => {
+    const { option } = props.config;
+
+    const { deviceProfileId, attribute } = option;
+    return getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, attribute);
+  });
+
   const getDesign = computed(() => {
     const { persetOption = {}, option } = props.config;
 
@@ -49,7 +60,10 @@
     const [latest] = data[attribute] || [];
     if (!latest.length) return;
     const [timespan, value] = latest;
-    currentValue.value = value;
+    currentValue.value = useThingsModelValueTransform(
+      value,
+      unref(getThingModelTsl)?.specs?.dataType
+    );
     time.value = timespan;
   };
 
@@ -61,7 +75,7 @@
 <template>
   <main :style="getScale" class="w-full h-full flex flex-col justify-center items-center">
     <DeviceName :config="config" />
-    <div class="flex-1 flex justify-center items-center flex-col">
+    <div class="flex-1 flex justify-center items-center flex-col w-full">
       <SvgIcon
         :name="getDesign.icon!"
         prefix="iconfont"
@@ -69,7 +83,7 @@
         :style="{ color: getDesign.iconColor }"
       />
       <h1
-        class="font-bold m-2 truncate"
+        class="font-bold m-2 truncate w-full text-center"
         :style="{
           color: getDesign.fontColor,
           fontSize: (getRatio ? getRatio * getDesign.valueSize : getDesign.valueSize) + 'px',

@@ -2,12 +2,14 @@
   import { ComponentPropsConfigType } from '/@/views/visual/packages/index.type';
   import { option } from './config';
   import { useComponentScale } from '/@/views/visual/packages/hook/useComponentScale';
-  import { computed } from 'vue';
+  import { computed, unref } from 'vue';
   import { ref } from 'vue';
   import { SvgIcon } from '/@/components/Icon';
   import { DeviceName } from '/@/views/visual/commonComponents/DeviceName';
   import { useDataFetch } from '../../../hook/socket/useSocket';
   import { DataFetchUpdateFn } from '../../../hook/socket/useSocket.type';
+  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
+  import { useThingsModelValueTransform } from '/@/views/visual/palette/hooks/useThingsModelValueTransform';
 
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
@@ -15,6 +17,15 @@
 
   const currentValue = ref<string | number>(123);
 
+  const { getDeviceProfileTslByIdWithIdentifier } = useDeviceProfileQueryContext();
+
+  const getThingModelTsl = computed(() => {
+    const { option } = props.config;
+
+    const { deviceProfileId, attribute } = option;
+    return getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, attribute);
+  });
+
   const getDesign = computed(() => {
     const { persetOption = {}, option } = props.config;
 
@@ -27,7 +38,7 @@
       fontSize: persetFontSize,
     } = persetOption;
 
-    const { componentInfo, attribute, attributeRename, attributeName } = option;
+    const { componentInfo, attribute, attributeRename } = option;
 
     const { icon, iconColor, fontColor, unit, valueSize, fontSize } = componentInfo || {};
     return {
@@ -35,7 +46,7 @@
       unit: unit ?? perseUnit,
       icon: icon || persetIcon,
       fontColor: fontColor || persetFontColor,
-      attribute: attributeRename || attributeName || attribute,
+      attribute: attributeRename || unref(getThingModelTsl)?.functionName || attribute,
       valueSize: valueSize || persetValueSize || 20,
       fontSize: fontSize || persetFontSize || 14,
     };
@@ -46,7 +57,10 @@
     const [info] = data[attribute] || [];
     if (!info.length) return;
     const [_, value] = info;
-    currentValue.value = value;
+    currentValue.value = useThingsModelValueTransform(
+      value,
+      unref(getThingModelTsl)?.specs?.dataType
+    );
   };
 
   useDataFetch(props, updateFn);
@@ -57,7 +71,7 @@
 <template>
   <main class="w-full h-full flex flex-col justify-center items-center">
     <DeviceName :config="config" />
-    <div :style="getScale" class="flex-1 flex justify-center items-center flex-col">
+    <div :style="getScale" class="flex-1 flex justify-center items-center flex-col w-full">
       <SvgIcon
         :name="getDesign.icon!"
         prefix="iconfont"
@@ -65,7 +79,7 @@
         :style="{ color: getDesign.iconColor }"
       />
       <h1
-        class="my-4 font-bold !my-2 truncate"
+        class="my-4 font-bold !my-2 truncate w-full text-center"
         :style="{
           color: getDesign.fontColor,
           fontSize: (getRatio ? getRatio * getDesign.valueSize : getDesign.valueSize) + 'px',

@@ -10,6 +10,7 @@
   import { useMultipleDataFetch } from '../../../hook/socket/useSocket';
   import { MultipleDataFetchUpdateFn } from '../../../hook/socket/useSocket.type';
   import { useComponentScale } from '../../../hook/useComponentScale';
+  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
 
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
@@ -56,6 +57,8 @@
     },
   ];
 
+  const { getDeviceProfileTslByIdWithIdentifier } = useDeviceProfileQueryContext();
+
   const getDesign = computed(() => {
     const { persetOption = {}, option } = props.config;
     const { dataSource = [] } = option || {};
@@ -71,15 +74,17 @@
       dataSource: dataSource.map((item) => {
         const { unit, fontColor, backgroundColor, maxNumber, valueSize, fontSize } =
           item.componentInfo || {};
-        const { attribute, attributeRename, deviceName, deviceRename, deviceId, attributeName } =
+        const { attribute, attributeRename, deviceProfileId, deviceName, deviceRename, deviceId } =
           item;
+
+        const tsl = getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, attribute);
         return {
           unit: unit ?? presetUnit,
           fontColor: fontColor ?? presetFontColor,
           backgroundColor: backgroundColor ?? persetBackgroundColor,
           deviceName: deviceRename || deviceName,
           attribute,
-          attributeName: attributeRename || attributeName,
+          attributeName: attributeRename || tsl?.functionName,
           maxNumber: maxNumber || persetMaxNumber,
           id: deviceId,
           valueSize: valueSize || persetValueSize || 20,

@@ -10,6 +10,8 @@
   import { useMultipleDataFetch } from '../../../hook/socket/useSocket';
   import { MultipleDataFetchUpdateFn } from '../../../hook/socket/useSocket.type';
   import { useComponentScale } from '../../../hook/useComponentScale';
+  import { useDeviceProfileQueryContext } from '/@/views/visual/palette/hooks/useDeviceProfileQueryContext';
+  import { buildUUID } from '/@/utils/uuid';
 
   const props = defineProps<{
     config: ComponentPropsConfigType<typeof option>;
@@ -17,6 +19,8 @@
 
   const time = ref<Nullable<number>>(null);
 
+  const { getDeviceProfileTslByIdWithIdentifier } = useDeviceProfileQueryContext();
+
   const getDesign = computed(() => {
     const { persetOption = {}, option } = props.config;
     const { dataSource = [] } = option || {};
@@ -28,12 +32,13 @@
       valueSize: persetValueSize,
       fontSize: persetFontSize,
     } = persetOption || {};
+
     return {
       dataSource: dataSource.map((item) => {
         const { fontColor, icon, iconColor, unit, valueSize, fontSize } = item.componentInfo;
-        const { attribute, attributeRename, deviceName, deviceRename, deviceId, attributeName } =
+        const { attribute, attributeRename, deviceName, deviceRename, deviceId, deviceProfileId } =
           item;
-
+        const tsl = getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, attribute);
         return {
           unit: unit ?? persetUnit,
           fontColor: fontColor ?? persetFontColor,
@@ -41,7 +46,7 @@
           iconColor: iconColor ?? persetIconColor,
           attribute,
           deviceName: deviceRename || deviceName,
-          attributeName: attributeRename || attributeName,
+          attributeName: attributeRename || tsl?.functionName,
           id: deviceId,
           valueSize: valueSize || persetValueSize || 20,
           fontSize: fontSize || persetFontSize || 14,
@@ -49,8 +54,10 @@
       }),
     };
   });
-  const defaultSvgList = ref<any>([
+
+  const defaultSvgList = ref([
     {
+      id: buildUUID(),
       value: 26.2,
       deviceName: '温湿度',
       attributeName: '温度',
@@ -58,8 +65,11 @@
       unit: '℃',
       iconColor: '#367BFF',
       fontColor: '#357CFB',
+      fontSize: 16,
+      valueSize: 16,
     },
     {
+      id: buildUUID(),
       value: 53.7,
       deviceName: '温湿度',
       attributeName: '湿度',
@@ -67,6 +77,8 @@
       unit: '℃',
       iconColor: '#FFA000',
       fontColor: '#FFA000',
+      fontSize: 16,
+      valueSize: 16,
     },
   ]);
 
@@ -108,7 +120,6 @@
           :size="getRatio ? 30 * getRatio : 30"
           :style="{ color: item.iconColor }"
         />
-
         <div
           class="text-gray-500 ml-6"
           :style="{ fontSize: (getRatio ? getRatio * item.fontSize : item.fontSize) + 'px' }"
@@ -122,10 +133,9 @@
           fontSize: (getRatio ? getRatio * item.valueSize : item.valueSize) + 'px',
         }"
       >
-        <span> {{ item.value || 0 }}</span>
+        <span> {{ (item as any).value || 0 }}</span>
         <span>{{ item.unit }} </span>
       </span>
     </div>
-    <!-- <UpdateTime :time="time" /> -->
   </main>
 </template>

+export enum CategoryEnum {
+  MAP = 'MAP',
+}

@@ -3,21 +3,25 @@ import { useSelectWidgetKeys, useSelectWidgetMode } from '../../dataSourceBindPa
 import { PackagesCategoryEnum } from '../index.type';
 import { getDeviceProfile } from '/@/api/alarm/position';
 import { getDeviceAttributes, getMeetTheConditionsDevice } from '/@/api/dataBoard';
-import { DeviceAttributeParams, MasterDeviceList } from '/@/api/dataBoard/model';
-import { DeviceTypeEnum } from '/@/api/device/model/deviceModel';
-import { ModelOfMatterParams } from '/@/api/device/model/modelOfMatterModel';
+import { DeviceAttributeParams } from '/@/api/dataBoard/model';
 import { getModelServices } from '/@/api/device/modelOfMatter';
 import { findDictItemByCode } from '/@/api/system/dict';
-import { FormSchema, useComponentRegister } from '/@/components/Form';
+import { ApiCascader, FormSchema, useComponentRegister } from '/@/components/Form';
 import { OrgTreeSelect } from '/@/views/common/OrgTreeSelect';
-import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
-import { CommandTypeEnum } from '/@/views/rule/linkedge/config/config.data';
 import { DataActionModeEnum } from '/@/enums/toolEnum';
 import { TaskTypeEnum } from '/@/views/task/center/config';
 import { createPickerSearch } from '/@/utils/pickerSearch';
 import { DataTypeEnum } from '/@/enums/objectModelEnum';
+import { CommandTypeEnum, CommandTypeNameEnum } from '/@/enums/deviceEnum';
+import { TransportTypeEnum } from '/@/enums/deviceEnum';
+import { DeviceTypeEnum } from '/@/api/device/model/deviceModel';
+import { ControlComponentEnum } from '../components/Control';
+import { isNullOrUnDef } from '/@/utils/is';
+import { validateTCPCustomCommand } from '/@/components/Form/src/components/ThingsModelForm';
+import { CategoryEnum } from '../components';
 
 useComponentRegister('OrgTreeSelect', OrgTreeSelect);
+useComponentRegister('ApiCascader', ApiCascader);
 
 export interface CommonDataSourceBindValueType extends Record<DataSourceField, string> {
   customCommand?: {
@@ -31,30 +35,51 @@ export interface CommonDataSourceBindValueType extends Record<DataSourceField, s
 }
 
 export enum DataSourceField {
-  IS_GATEWAY_DEVICE = 'gatewayDevice',
+  // IS_GATEWAY_DEVICE = 'gatewayDevice',
   DEVICE_TYPE = 'deviceType',
   TRANSPORT_TYPE = 'transportType',
   ORIGINATION_ID = 'organizationId',
   DEVICE_ID = 'deviceId',
-  DEVICE_CODE = 'deviceCode', //设备地址码
+  // DEVICE_CODE = 'deviceCode', //设备地址码
   DEVICE_PROFILE_ID = 'deviceProfileId',
   ATTRIBUTE = 'attribute',
-  ATTRIBUTE_NAME = 'attributeName',
+  // ATTRIBUTE_NAME = 'attributeName',
   ATTRIBUTE_RENAME = 'attributeRename',
   DEVICE_NAME = 'deviceName',
   DEVICE_RENAME = 'deviceRename',
-  LONGITUDE_ATTRIBUTE = 'longitudeAttribute',
-  LATITUDE_ATTRIBUTE = 'latitudeAttribute',
+
   CODE_TYPE = 'codeType',
-  COMMAND = 'command',
+  // COMMAND = 'command',
+
   OPEN_COMMAND = 'openCommand',
   CLOSE_COMMAND = 'closeCommand',
+
   COMMAND_TYPE = 'commandType',
-  SERVICE = 'service',
+
+  // SERVICE = 'service',
+
+  /**
+   * @description 关服务标识符
+   */
   OPEN_SERVICE = 'openService',
+
+  /**
+   * @description 开服务标识符
+   */
   CLOSE_SERVICE = 'closeService',
-  EXTENSION_DESC = 'extensionDesc',
-  CALL_TYPE = 'callType',
+
+  /**
+   * @description 经度标识符
+   */
+  LONGITUDE_IDENTIFIER = 'longitudeIdentifier',
+
+  /**
+   * @description 纬度标识符号
+   */
+  LATITUDE_IDENTIFIER = 'latitudeIdentifier',
+
+  // EXTENSION_DESC = 'extensionDesc',
+  // CALL_TYPE = 'callType',
 }
 
 const isTcpProfile = (transportType: string) => transportType === TransportTypeEnum.TCP;
@@ -69,15 +94,6 @@ const isBooleanComponent = (componentKeys: { categoryKey?: string; componentKey?
   );
 };
 
-const getDeviceService = async (deviceProfileId: string) => {
-  try {
-    const data = await getModelServices({ deviceProfileId });
-    if (data)
-      return data.map((item) => ({ ...item, label: item.functionName, value: item.identifier }));
-  } catch (error) {}
-  return [];
-};
-
 const getDeviceAttribute = async (params: DeviceAttributeParams) => {
   try {
     const data = await getDeviceAttributes(params);
@@ -94,24 +110,6 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
 
   return [
     {
-      field: DataSourceField.IS_GATEWAY_DEVICE,
-      component: 'Switch',
-      label: '是否是网关设备',
-      show: false,
-    },
-    {
-      field: DataSourceField.DEVICE_NAME,
-      component: 'Input',
-      label: '设备名',
-      show: false,
-    },
-    {
-      field: DataSourceField.TRANSPORT_TYPE,
-      component: 'Input',
-      label: '设备配置类型',
-      show: false,
-    },
-    {
       field: DataSourceField.DEVICE_TYPE,
       component: 'ApiSelect',
       label: '设备类型',
@@ -127,13 +125,11 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
           valueField: 'itemValue',
           labelField: 'itemText',
           placeholder: '请选择设备类型',
-          onChange: (value: DeviceTypeEnum) => {
+          onChange: () => {
             setFieldsValue({
-              [DataSourceField.IS_GATEWAY_DEVICE]: value === DeviceTypeEnum.GATEWAY,
               [DataSourceField.DEVICE_PROFILE_ID]: null,
               [DataSourceField.DEVICE_ID]: null,
               [DataSourceField.ATTRIBUTE]: null,
-              [DataSourceField.ATTRIBUTE_NAME]: null,
               [DataSourceField.TRANSPORT_TYPE]: null,
             });
           },
@@ -142,6 +138,12 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
       },
     },
     {
+      field: DataSourceField.TRANSPORT_TYPE,
+      label: '传输协议',
+      component: 'Input',
+      ifShow: false,
+    },
+    {
       field: DataSourceField.DEVICE_PROFILE_ID,
       component: 'ApiSelect',
       label: '产品',
@@ -164,12 +166,11 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
           labelField: 'name',
           valueField: 'id',
           placeholder: '请选择产品',
-          onChange: (_, option = {} as Record<'transportType', string>) => {
+          onChange: (_, option: Record<'transportType', string>) => {
             setFieldsValue({
               [DataSourceField.DEVICE_ID]: null,
               [DataSourceField.ATTRIBUTE]: null,
-              [DataSourceField.ATTRIBUTE_NAME]: null,
-              [DataSourceField.TRANSPORT_TYPE]: option[DataSourceField.TRANSPORT_TYPE],
+              [DataSourceField.TRANSPORT_TYPE]: option?.[DataSourceField.TRANSPORT_TYPE],
               [DataSourceField.COMMAND_TYPE]: null,
             });
           },
@@ -201,10 +202,10 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
       },
     },
     {
-      field: DataSourceField.DEVICE_PROFILE_ID,
+      field: DataSourceField.DEVICE_NAME,
       component: 'Input',
-      label: '',
-      show: false,
+      label: '设备名称',
+      ifShow: false,
     },
     {
       field: DataSourceField.DEVICE_ID,
@@ -227,23 +228,32 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
                   deviceProfileId,
                   deviceType,
                 });
-                if (data)
-                  return data.map((item) => ({
+                if (data) {
+                  const result = data.map((item) => ({
                     ...item,
                     label: item.alias || item.name,
                     value: item.tbDeviceId,
                     deviceType: item.deviceType,
                   }));
+
+                  if (
+                    unref(selectWidgetKeys).componentKey ===
+                    ControlComponentEnum.LATERAL_NUMERICAL_CONTROL
+                  ) {
+                    return result.filter((item) => item.codeType === TaskTypeEnum.MODBUS_RTU);
+                  }
+
+                  return result;
+                }
               } catch (error) {}
             }
             return [];
           },
-          onChange(_value, record: MasterDeviceList) {
+          onChange(_value, options: Record<'label' | 'codeType', string>) {
             setFieldsValue({
-              [DataSourceField.DEVICE_NAME]: record?.label,
-              [DataSourceField.CODE_TYPE]: record?.codeType,
-              [DataSourceField.DEVICE_CODE]: record?.code,
               [DataSourceField.COMMAND_TYPE]: null,
+              [DataSourceField.DEVICE_NAME]: options?.label,
+              [DataSourceField.CODE_TYPE]: options?.codeType,
             });
           },
           placeholder: '请选择设备',
@@ -253,91 +263,9 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
     },
     {
       field: DataSourceField.CODE_TYPE,
+      label: '设备标识符类型',
       component: 'Input',
-      label: '设备标识符',
-      show: false,
-    },
-
-    {
-      field: DataSourceField.DEVICE_CODE,
-      component: 'Input',
-      show: false,
-      label: '设备地址码',
-    },
-
-    {
-      field: DataSourceField.ATTRIBUTE_NAME,
-      component: 'Input',
-      label: '属性名',
-      show: false,
-    },
-    {
-      field: DataSourceField.COMMAND_TYPE,
-      component: 'ApiSelect',
-      label: '命令类型',
-      defaultValue: CommandTypeEnum.CUSTOM.toString(),
-      rules: [{ required: true, message: '请选择命令类型' }],
-      colProps: { span: 8 },
-      ifShow: ({ model }) => {
-        return isControlComponent(category!) && isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]);
-      },
-      componentProps: ({ formActionType, formModel }) => {
-        const { setFieldsValue } = formActionType;
-        const { codeType, deviceType, transportType } = formModel || {};
-        return {
-          // api: findDictItemByCode,
-          api: async (params: Recordable) => {
-            try {
-              const record = await findDictItemByCode(params);
-              if (unref(selectWidgetKeys).componentKey == 'LateralNumericalControl') {
-                return record.filter(
-                  (item) => item.itemValue == CommandTypeEnum.ATTRIBUTE.toString()
-                );
-              }
-              // TCP网关子 --> 不能要服务命令类型
-              if (deviceType == 'SENSOR' && transportType == 'TCP') {
-                return codeType == 'MODBUS_RTU'
-                  ? record.filter((item) => item.itemValue == CommandTypeEnum.ATTRIBUTE.toString())
-                  : codeType == 'CUSTOM'
-                  ? record.filter((item) => item.itemValue == CommandTypeEnum.CUSTOM.toString())
-                  : [];
-              }
-
-              if (codeType == TaskTypeEnum.MODBUS_RTU) {
-                // setFieldsValue({ [DataSourceField.COMMAND_TYPE]: undefined });
-                return record.filter(
-                  (item) => item.itemValue !== CommandTypeEnum.CUSTOM.toString()
-                );
-              } else {
-                return record.filter(
-                  (item) => item.itemValue !== CommandTypeEnum.ATTRIBUTE.toString()
-                );
-              }
-            } catch (error) {
-              return [];
-            }
-          },
-          params: {
-            dictCode: 'custom_define',
-          },
-          labelField: 'itemText',
-          valueField: 'itemValue',
-          placeholder: '请选择命令类型',
-          getPopupContainer: () => document.body,
-          onChange() {
-            setFieldsValue({
-              [DataSourceField.COMMAND]: null,
-              [DataSourceField.SERVICE]: null,
-              [DataSourceField.OPEN_COMMAND]: null,
-              [DataSourceField.CLOSE_COMMAND]: null,
-              [DataSourceField.OPEN_SERVICE]: null,
-              [DataSourceField.CLOSE_SERVICE]: null,
-              [DataSourceField.CALL_TYPE]: null,
-              [DataSourceField.ATTRIBUTE]: null,
-            });
-          },
-        };
-      },
+      ifShow: false,
     },
     {
       field: DataSourceField.ATTRIBUTE,
@@ -345,9 +273,7 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
       label: '属性',
       colProps: { span: 8 },
       rules: [{ required: true, message: '请选择属性' }],
-      ifShow: ({ model }) =>
-        !(isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]) && isControlComponent(category!)) ||
-        model[DataSourceField.COMMAND_TYPE] == 2,
+      ifShow: () => category !== CategoryEnum.MAP,
       componentProps({ formModel, formActionType }) {
         const { setFieldsValue } = formActionType;
         const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
@@ -359,20 +285,25 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
                   deviceProfileId,
                   dataType:
                     (isControlComponent(category!) &&
-                      unref(selectWidgetKeys).componentKey !== 'LateralNumericalControl') ||
+                      unref(selectWidgetKeys).componentKey !==
+                        ControlComponentEnum.LATERAL_NUMERICAL_CONTROL) ||
                     isBooleanComponent(unref(selectWidgetKeys))
                       ? DataTypeEnum.BOOL
                       : undefined,
                 });
 
                 // 选择控制组件4的时候只能选择属性且是（int double类型）
-                if (unref(selectWidgetKeys).componentKey == 'LateralNumericalControl') {
+                if (
+                  unref(selectWidgetKeys).componentKey ===
+                  ControlComponentEnum.LATERAL_NUMERICAL_CONTROL
+                ) {
                   setFieldsValue({
                     [DataSourceField.COMMAND_TYPE]: CommandTypeEnum.ATTRIBUTE.toString(),
                   });
                   return option.filter(
                     (item) =>
-                      item.detail.dataType.type == 'INT' || item.detail.dataType.type == 'DOUBLE'
+                      item.detail.dataType.type === DataTypeEnum.NUMBER_INT ||
+                      item.detail.dataType.type == DataTypeEnum.NUMBER_DOUBLE
                   );
                 }
                 return option;
@@ -381,76 +312,133 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
             return [];
           },
           placeholder: '请选择属性',
-          onChange(value: string, option: Record<'label' | 'value' | any, string>) {
-            const { detail }: any = option || {};
-            setFieldsValue({
-              [DataSourceField.ATTRIBUTE_NAME]: value ? option.label : null,
-              [DataSourceField.EXTENSION_DESC]: value ? JSON.stringify(option.extensionDesc) : '',
-              // 地图组件结构体
-              lal:
-                category === 'MAP' && value && detail?.dataType.type === 'STRUCT'
-                  ? JSON.stringify(detail?.dataType.specs)
-                  : null,
-              latitude: null,
-              longitude: null,
-            });
-          },
           ...createPickerSearch(),
         };
       },
     },
     {
-      field: 'lal',
-      label: '经纬度存储的值',
-      component: 'Input',
-      show: false,
-    },
-    {
-      field: 'longitude',
+      field: DataSourceField.LONGITUDE_IDENTIFIER,
       label: '经度',
+      component: 'ApiCascader',
+      ifShow: ({}) => category === CategoryEnum.MAP,
       colProps: { span: 8 },
-      component: 'Select',
-      required: true,
-      ifShow: ({ model }) => category === 'MAP' && model.lal,
-      componentProps({ formModel }) {
-        const { lal } = formModel || {};
+      changeEvent: 'update:value',
+      valueField: 'value',
+      componentProps: ({ formModel }) => {
+        const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
         return {
+          api: async () => {
+            try {
+              if (deviceProfileId) {
+                const options = await getDeviceAttributes({
+                  deviceProfileId,
+                });
+
+                const _options = options.map((item) => {
+                  item = Object.assign(item, { functionName: item.name });
+                  if (item.detail.dataType.type === DataTypeEnum.STRUCT) {
+                    return Object.assign(item, { specs: item.detail.dataType.specs });
+                  }
+                  return item;
+                });
+                return _options;
+              }
+            } catch (error) {}
+            return [];
+          },
           placeholder: '请选择经度',
-          options: lal
-            ? JSON.parse(lal)?.map((item) => ({ label: item.functionName, value: item.identifier }))
-            : [],
+          getPopupContainer: () => document.body,
+          fieldNames: { label: 'functionName', value: 'identifier', children: 'specs' },
         };
       },
     },
     {
-      field: 'latitude',
+      field: DataSourceField.LATITUDE_IDENTIFIER,
       label: '纬度',
+      component: 'ApiCascader',
+      ifShow: ({}) => category === CategoryEnum.MAP,
       colProps: { span: 8 },
-      required: true,
-      component: 'Select',
-      ifShow: ({ model }) => category === 'MAP' && model.lal,
-      componentProps({ formModel }) {
-        const { lal } = formModel || {};
+      changeEvent: 'update:value',
+      valueField: 'value',
+      componentProps: ({ formModel }) => {
+        const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
+
         return {
+          api: async () => {
+            try {
+              if (deviceProfileId) {
+                const options = await getDeviceAttributes({
+                  deviceProfileId,
+                });
+
+                const _options = options.map((item) => {
+                  item = Object.assign(item, { functionName: item.name });
+
+                  if (item.detail.dataType.type === DataTypeEnum.STRUCT) {
+                    return Object.assign(item, { specs: item.detail.dataType.specs });
+                  }
+                  return item;
+                });
+
+                return _options;
+              }
+            } catch (error) {}
+            return [];
+          },
           placeholder: '请选择纬度',
-          options: lal
-            ? JSON.parse(lal)?.map((item) => ({ label: item.functionName, value: item.identifier }))
-            : [],
+          getPopupContainer: () => document.body,
+          fieldNames: { label: 'functionName', value: 'identifier', children: 'specs' },
         };
       },
     },
     {
-      field: DataSourceField.EXTENSION_DESC,
-      component: 'Input',
-      show: false,
-      label: '扩展描述符',
-    },
+      field: DataSourceField.COMMAND_TYPE,
+      component: 'Select',
+      label: '命令类型',
+      defaultValue: CommandTypeEnum.CUSTOM,
+      rules: [
+        {
+          required: true,
+          validator(_, value: number | string) {
+            if (isNullOrUnDef(value)) return Promise.reject('请选择命令类型');
+            return Promise.resolve();
+          },
+        },
+      ],
+      colProps: { span: 8 },
+      ifShow: ({ model }) => {
+        return (
+          isControlComponent(category!) &&
+          unref(selectWidgetKeys).componentKey !== ControlComponentEnum.LATERAL_NUMERICAL_CONTROL &&
+          isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]) &&
+          model[DataSourceField.CODE_TYPE] === TaskTypeEnum.CUSTOM
+        );
+      },
+      componentProps: ({ formActionType, formModel }) => {
+        const { setFieldsValue } = formActionType;
+        const deviceType = formModel[DataSourceField.DEVICE_TYPE];
+        const options: Record<'label' | 'value', string | number>[] = [
+          { label: CommandTypeNameEnum.CUSTOM, value: CommandTypeEnum.CUSTOM },
+        ];
 
-    {
-      field: DataSourceField.CALL_TYPE,
-      component: 'Input',
-      ifShow: false,
-      label: 'callType',
+        // 网关子设备无服务
+        if (deviceType !== DeviceTypeEnum.SENSOR)
+          options.push({ label: CommandTypeNameEnum.SERVICE, value: CommandTypeEnum.SERVICE });
+
+        return {
+          options,
+          placeholder: '请选择命令类型',
+          getPopupContainer: () => document.body,
+          onChange() {
+            setFieldsValue({
+              [DataSourceField.OPEN_COMMAND]: null,
+              [DataSourceField.CLOSE_COMMAND]: null,
+              [DataSourceField.OPEN_SERVICE]: null,
+              [DataSourceField.CLOSE_SERVICE]: null,
+            });
+          },
+        };
+      },
     },
     {
       field: DataSourceField.OPEN_SERVICE,
@@ -460,40 +448,19 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
       rules: [{ required: true, message: '请选择开服务' }],
       ifShow: ({ model }) =>
         isControlComponent(category!) &&
-        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.SERVICE.toString() &&
+        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.SERVICE &&
         isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]),
-      componentProps({ formModel, formActionType }) {
-        const { setFieldsValue } = formActionType;
+      componentProps({ formModel }) {
         const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
-        const transportType = formModel[DataSourceField.TRANSPORT_TYPE];
-        if (isUpdate && ![deviceProfileId, transportType].every(Boolean))
-          return { placeholder: '请选择开服务', getPopupContainer: () => document.body };
         return {
-          api: async () => {
-            try {
-              if (deviceProfileId) {
-                const services = await getDeviceService(deviceProfileId);
-                const value = formModel[DataSourceField.SERVICE];
-                if (value) {
-                  const selected = services.find((item) => item.value === value);
-                  selected && setFieldsValue({ [DataSourceField.CALL_TYPE]: selected.callType });
-                }
-                return services;
-              }
-            } catch (error) {}
-            return [];
+          api: getModelServices,
+          params: {
+            deviceProfileId,
           },
           placeholder: '请选择开服务',
+          labelField: 'functionName',
+          valueField: 'identifier',
           getPopupContainer: () => document.body,
-          onChange(value: string, options: ModelOfMatterParams) {
-            const command = value
-              ? (options.functionJson.inputData || [])[0]?.serviceCommand
-              : null;
-            setFieldsValue({
-              [DataSourceField.OPEN_COMMAND]: command,
-              [DataSourceField.CALL_TYPE]: value ? options.callType : null,
-            });
-          },
         };
       },
     },
@@ -505,40 +472,19 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
       rules: [{ required: true, message: '请选择关服务' }],
       ifShow: ({ model }) =>
         isControlComponent(category!) &&
-        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.SERVICE.toString() &&
+        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.SERVICE &&
         isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]),
-      componentProps({ formModel, formActionType }) {
-        const { setFieldsValue } = formActionType;
+      componentProps({ formModel }) {
         const deviceProfileId = formModel[DataSourceField.DEVICE_PROFILE_ID];
-        const transportType = formModel[DataSourceField.TRANSPORT_TYPE];
-        if (isUpdate && ![deviceProfileId, transportType].every(Boolean))
-          return { placeholder: '请选择关服务', getPopupContainer: () => document.body };
         return {
-          api: async () => {
-            try {
-              if (deviceProfileId) {
-                const services = await getDeviceService(deviceProfileId);
-                const value = formModel[DataSourceField.SERVICE];
-                if (value) {
-                  const selected = services.find((item) => item.value === value);
-                  selected && setFieldsValue({ [DataSourceField.CALL_TYPE]: selected.callType });
-                }
-                return services;
-              }
-            } catch (error) {}
-            return [];
+          api: getModelServices,
+          params: {
+            deviceProfileId,
           },
           placeholder: '请选择关服务',
+          labelField: 'functionName',
+          valueField: 'identifier',
           getPopupContainer: () => document.body,
-          onChange(value: string, options: ModelOfMatterParams) {
-            const command = value
-              ? (options.functionJson.inputData || [])[0]?.serviceCommand
-              : null;
-            setFieldsValue({
-              [DataSourceField.CLOSE_COMMAND]: command,
-              [DataSourceField.CALL_TYPE]: value ? options.callType : null,
-            });
-          },
         };
       },
     },
@@ -547,11 +493,11 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
       component: 'Input',
       label: '命令',
       colProps: { span: 8 },
-      rules: [{ required: true, message: '请输入开下发命令' }],
+      rules: [{ validator: validateTCPCustomCommand }],
       // 是控制组件  && 自定义命令  && 传输协议为TCP
       ifShow: ({ model }) =>
         isControlComponent(category!) &&
-        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.CUSTOM.toString() &&
+        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.CUSTOM &&
         model[DataSourceField.TRANSPORT_TYPE] &&
         isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]),
       componentProps: {
@@ -563,11 +509,11 @@ export const commonDataSourceSchemas = (): FormSchema[] => {
       component: 'Input',
       label: '命令',
       colProps: { span: 8 },
-      rules: [{ required: true, message: '请输入关下发命令' }],
+      rules: [{ validator: validateTCPCustomCommand }],
       // 是控制组件  && 自定义命令  && 传输协议为TCP
       ifShow: ({ model }) =>
         isControlComponent(category!) &&
-        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.CUSTOM.toString() &&
+        model[DataSourceField.COMMAND_TYPE] === CommandTypeEnum.CUSTOM &&
         model[DataSourceField.TRANSPORT_TYPE] &&
         isTcpProfile(model[DataSourceField.TRANSPORT_TYPE]),
       componentProps: {

@@ -24,6 +24,7 @@ import {
 } from './useSocket.type';
 import { ComponentPropsConfigType } from '../../index.type';
 import { isNullOrUnDef } from '/@/utils/is';
+import { CategoryEnum } from '../../components';
 
 interface DeviceGroupMapType {
   subscriptionId: number;
@@ -410,8 +411,20 @@ export const useMultipleDataFetch = (
       Object.keys(unref(getDataSourceGroup)).forEach((key) => {
         const item = unref(getDataSourceGroup)[key];
         const attributes = [...new Set(item.map((item) => item.attribute))];
+
+        if (props.config.componentConfig.category === CategoryEnum.MAP) {
+          const positionIdentifier = item.reduce((prev, next) => {
+            const [lat] = next.latitudeIdentifier || [];
+            const [lng] = next.longitudeIdentifier || [];
+
+            return [...prev, lat, lng];
+          }, []);
+
+          attributes.push(...new Set(positionIdentifier));
+        }
+
         subscriber.trackUpdateGroup(key, {
-          attributes,
+          attributes: attributes.filter(Boolean),
           fn: updateFn,
         });
       });

+import { ref } from 'vue';
+import { getDeviceDetail } from '/@/api/device/deviceManager';
+import { useDeviceProfileQueryContext } from '../../palette/hooks/useDeviceProfileQueryContext';
+import {
+  CommandTypeEnum,
+  RPCCommandMethodEnum,
+  ServiceCallTypeEnum,
+  TransportTypeEnum,
+} from '/@/enums/deviceEnum';
+import { RpcCommandType } from '/@/api/device/model/deviceConfigModel';
+import { useMessage } from '/@/hooks/web/useMessage';
+import { useGetModbusCommand } from './useGetModbusCommand';
+import { TaskTypeEnum } from '/@/views/task/center/config';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
+import { sendCommandOneway, sendCommandTwoway } from '/@/api/dataBoard';
+import { isNullOrUnDef } from '/@/utils/is';
+
+export interface DoCommandDeliverDataSourceType {
+  deviceId: string;
+  deviceProfileId: string;
+  attribute: string;
+  commandType?: CommandTypeEnum;
+  openCommand?: string;
+  closeCommand?: string;
+  openService?: string;
+  closeService?: string;
+}
+
+export function useCommandDelivery() {
+  const loading = ref(false);
+
+  const { createMessage } = useMessage();
+
+  const { getDeviceProfileTslByIdWithIdentifier } = useDeviceProfileQueryContext();
+
+  const doGetDeviceId = async (deviceId: string) => {
+    return await getDeviceDetail(deviceId);
+  };
+
+  const { validateCanGetCommand, getModbusCommand } = useGetModbusCommand();
+
+  const doCommandDeliver = async (
+    dataSource: DoCommandDeliverDataSourceType,
+    value: any
+  ): Promise<boolean> => {
+    try {
+      const { deviceId, deviceProfileId, attribute, commandType } = dataSource;
+
+      loading.value = true;
+      const tsl = getDeviceProfileTslByIdWithIdentifier?.(deviceProfileId, attribute);
+      const deviceDetail = await doGetDeviceId(deviceId);
+
+      let sendCommandFn = sendCommandOneway;
+
+      let params: string | Recordable | undefined = {
+        [attribute]: value,
+      };
+
+      if (deviceDetail.transportType === TransportTypeEnum.TCP) {
+        if (deviceDetail.codeType === TaskTypeEnum.MODBUS_RTU) {
+          if (!validateCanGetCommand(tsl?.extensionDesc, deviceDetail.code)) return false;
+          params = await getModbusCommand(value, tsl!.extensionDesc, deviceDetail.code!);
+        } else if (deviceDetail.codeType === TaskTypeEnum.CUSTOM) {
+          params = value;
+          if (commandType === CommandTypeEnum.CUSTOM) {
+            if (tsl?.specs?.dataType.type === DataTypeEnum.BOOL) {
+              const { openCommand, closeCommand } = dataSource;
+              params = !!Number(value) ? openCommand : closeCommand;
+            }
+          } else if (commandType === CommandTypeEnum.SERVICE) {
+            if (tsl?.specs?.dataType.type === DataTypeEnum.BOOL) {
+              const { openService, closeService } = dataSource;
+              const serviceIdentifier = !!Number(value) ? openService : closeService;
+              const serviceTsl = getDeviceProfileTslByIdWithIdentifier?.(
+                deviceProfileId,
+                serviceIdentifier!
+              );
+              params = serviceTsl?.inputData?.[0].serviceCommand;
+              sendCommandFn =
+                serviceTsl?.callType === ServiceCallTypeEnum.SYNC
+                  ? sendCommandTwoway
+                  : sendCommandOneway;
+            }
+          }
+        }
+      }
+
+      if (isNullOrUnDef(params)) return false;
+
+      const rpcCommand: RpcCommandType = {
+        additionalInfo: {
+          cmdType: CommandTypeEnum.API,
+        },
+        params,
+        method: RPCCommandMethodEnum.THINGSKIT,
+        persistent: true,
+      };
+
+      await sendCommandFn({ deviceId: deviceId, value: rpcCommand });
+
+      createMessage.success('命令下发成功');
+
+      return true;
+    } catch (e) {
+      return false;
+    } finally {
+      loading.value = false;
+    }
+  };
+
+  return {
+    loading,
+    doCommandDeliver,
+  };
+}

+import { ExtensionDesc } from '/@/api/device/model/modelOfMatterModel';
+import { genModbusCommand } from '/@/api/task';
+import { GenModbusCommandType } from '/@/api/task/model';
+import { ModbusCRCEnum, RegisterActionTypeEnum } from '/@/enums/objectModelEnum';
+import { useMessage } from '/@/hooks/web/useMessage';
+
+export const InsertString = (t: any, c: any, n: any) => {
+  const r: string | number[] = [];
+
+  for (let i = 0; i * 2 < t.length; i++) r.push(t.substr(i * 2, n));
+
+  return r.join(c);
+};
+
+export const FillString = (t: any, c: any, n: any, b: any) => {
+  if (t === '' || c.length !== 1 || n <= t.length) return t;
+
+  const l = t.length;
+
+  for (let i = 0; i < n - l; i++) {
+    if (b === true) t = c + t;
+    else t += c;
+  }
+  return t;
+};
+
+export const SingleToHex = (t: any) => {
+  if (t === '') return '';
+
+  t = parseFloat(t);
+
+  if (isNaN(t) === true) return 'Error';
+
+  if (t === 0) return '00000000';
+
+  let s, e, m;
+
+  if (t > 0) {
+    s = 0;
+  } else {
+    s = 1;
+
+    t = 0 - t;
+  }
+  m = t.toString(2);
+
+  if (m >= 1) {
+    if (m.indexOf('.') === -1) m = `${m}.0`;
+
+    e = m.indexOf('.') - 1;
+  } else {
+    e = 1 - m.indexOf('1');
+  }
+  if (e >= 0) m = m.replace('.', '');
+  else m = m.substring(m.indexOf('1'));
+
+  if (m.length > 24) m = m.substr(0, 24);
+  else m = FillString(m, '0', 24, false);
+
+  m = m.substring(1);
+
+  e = (e + 127).toString(2);
+
+  e = FillString(e, '0', 8, true);
+
+  let r = parseInt(s + e + m, 2).toString(16);
+
+  r = FillString(r, '0', 8, true);
+
+  return InsertString(r, ' ', 2).toUpperCase();
+};
+
+export const FormatHex = (t: any, n: any, ie: any) => {
+  const r: string[] = [];
+
+  let s = '';
+
+  let c = 0;
+
+  for (let i = 0; i < t.length; i++) {
+    if (t.charAt(i) !== ' ') {
+      s += t.charAt(i);
+
+      c += 1;
+
+      if (c === n) {
+        r.push(s);
+
+        s = '';
+
+        c = 0;
+      }
+    }
+    if (ie === false) {
+      if (i === t.length - 1 && s !== '') r.push(s);
+    }
+  }
+  return r.join('\n');
+};
+
+export const FormatHexBatch = (t: any, n: any, ie: any) => {
+  const a = t.split('\n');
+
+  const r: string[] = [];
+
+  for (let i = 0; i < a.length; i++) r[i] = FormatHex(a[i], n, ie);
+
+  return r.join('\n');
+};
+
+export const SingleToHexBatch = (t: any) => {
+  const a = t.split('\n');
+
+  const r: string[] = [];
+
+  for (let i = 0; i < a.length; i++) r[i] = SingleToHex(a[i]);
+
+  return r.join('\r\n');
+};
+
+const getArray = (values: any) => {
+  const str = values.replace(/\s+/g, '');
+  const array: any = [];
+
+  for (let i = 0; i < str.length; i += 4) {
+    const chunk = parseInt(str.substring(i, i + 4), 16);
+    array.push(chunk);
+  }
+  return array;
+};
+
+const getFloatPart = (number: string | number) => {
+  const isLessZero = Number(number) < 0;
+  number = number.toString();
+  const floatPartStartIndex = number.indexOf('.');
+  const value = ~floatPartStartIndex
+    ? `${isLessZero ? '-' : ''}0.${number.substring(floatPartStartIndex + 1)}`
+    : '0';
+  return Number(value);
+};
+
+const REGISTER_MAX_VALUE = Number(0xffff);
+
+export function useGetModbusCommand() {
+  const { createMessage } = useMessage();
+
+  const getModbusCommand = async (
+    value: number,
+    extensionDesc: ExtensionDesc,
+    deviceAddressCode: string
+  ) => {
+    const { registerAddress, actionType, zoomFactor } = extensionDesc as Required<ExtensionDesc>;
+
+    const params: GenModbusCommandType = {
+      crc: ModbusCRCEnum.CRC_16_LOWER,
+      registerNumber: 1,
+      deviceCode: deviceAddressCode,
+      registerAddress,
+      method: actionType,
+      registerValues: [value],
+    };
+
+    if (actionType === RegisterActionTypeEnum.INT) {
+      const newValue = Math.trunc(value) * zoomFactor + getFloatPart(value) * zoomFactor;
+
+      if (newValue % 1 !== 0) {
+        createMessage.warning(`属性下发类型必须是整数,缩放因子为${zoomFactor}`);
+        return;
+      }
+
+      if (value * zoomFactor > REGISTER_MAX_VALUE) {
+        createMessage.warning(`属性下发值不能超过${REGISTER_MAX_VALUE},缩放因子为${zoomFactor}`);
+        return;
+      }
+
+      params.registerValues = [newValue];
+    } else if (actionType === RegisterActionTypeEnum.DOUBLE) {
+      const regex = /^-?\d+(\.\d{0,2})?$/;
+      const values = Math.trunc(value) * zoomFactor + getFloatPart(value) * zoomFactor;
+
+      if (!regex.test(values.toString())) {
+        createMessage.warning(`属性下发值精确到两位小数,缩放因子为${zoomFactor}`);
+        return;
+      }
+
+      const newValue = values === 0 ? [0, 0] : getArray(SingleToHex(values));
+      params.registerValues = newValue;
+      params.registerNumber = 2;
+      params.method = '10';
+    }
+
+    return await genModbusCommand(params);
+  };
+
+  /**
+   *
+   * @param extensionDesc 物模型拓展描述符
+   * @param deviceAddressCode 设备地址码
+   */
+  const validateCanGetCommand = (
+    extensionDesc?: ExtensionDesc,
+    deviceAddressCode?: string,
+    createValidateMessage = true
+  ) => {
+    const result = { flag: true, message: '' };
+    if (!extensionDesc) {
+      result.flag = false;
+      result.message = '当前物模型扩展描述没有填写';
+    }
+
+    if (!deviceAddressCode) {
+      result.flag = false;
+      result.message = '当前设备未绑定设备地址码';
+    }
+
+    if (result.message && createValidateMessage) createMessage.warning(result.message);
+
+    return result;
+  };
+
+  return {
+    getModbusCommand,
+    validateCanGetCommand,
+  };
+}

-import { ref } from 'vue';
-import { DataSource } from '../../palette/types';
-import { sendCommandOneway, sendCommandTwoway } from '/@/api/dataBoard';
-import { useMessage } from '/@/hooks/web/useMessage';
-import { TransportTypeEnum } from '/@/views/device/profiles/components/TransportDescript/const';
-import { ServiceCallTypeEnum } from '/@/enums/toolEnum';
-
-const { createMessage } = useMessage();
-export function useSendCommand() {
-  const loading = ref(false);
-
-  const error = () => {
-    // createMessage.error('下发指令失败');
-    return false;
-  };
-
-  const sendCommand = async (record: DataSource, value: any, isModbusCommand = false) => {
-    if (!record) return false;
-    const { customCommand, attribute } = record || {};
-    const { deviceId } = record;
-    if (!deviceId) return false;
-
-    try {
-      loading.value = true;
-      let params: string | Recordable = {
-        [attribute!]: Number(value),
-      };
-      if (isModbusCommand) {
-        params = value;
-      }
-
-      let sendCommandFn = sendCommandOneway;
-      // 如果是TCP设备从物模型中获取下发命令(TCP网关子设备无物模型服务与事件)
-      if (customCommand?.transportType === TransportTypeEnum.TCP && !isModbusCommand) {
-        params = customCommand.command!;
-        if (customCommand.callType === ServiceCallTypeEnum.SYNC) {
-          sendCommandFn = sendCommandTwoway;
-        }
-      }
-      // 控制按钮下发命令为0 或 1
-      await sendCommandFn({
-        deviceId,
-        value: {
-          params: params || null,
-          persistent: true,
-          additionalInfo: {
-            cmdType: customCommand.commandType || 'API',
-          },
-          method: 'methodThingskit',
-        },
-      });
-      createMessage.success('命令下发成功');
-      return true;
-    } catch (msg) {
-      console.error(msg);
-      return error();
-    } finally {
-      loading.value = false;
-    }
-  };
-  return {
-    loading,
-    sendCommand,
-  };
-}

@@ -9,7 +9,7 @@ export const useApp = () => {
 
   const isPhone = () => {
     const values = location?.pathname.split('/') || [];
-    return values[values?.length - 2] === 'phone' ? true : false;
+    return values[values?.length - 2] === 'phone';
   };
 
   return { getIsAppPage, isPhone };

@@ -11,6 +11,8 @@ import {
 } from '../types';
 import { buildUUID } from '/@/utils/uuid';
 import { PublicComponentOptions } from '../../packages/index.type';
+import { batchGetObjectModel } from '/@/api/device/modelOfMatter';
+import { BatchGetObjectModelItemType } from '/@/api/device/model/modelOfMatterModel';
 
 export interface WidgetDataType extends Layout, ComponentDataType, PublicComponentOptions {}
 
@@ -23,6 +25,17 @@ export const useDataSource = (propsRef: ComputedRef<Recordable>) => {
 
   const dataSource = ref<WidgetDataType[]>([]);
 
+  const deviceProfilesMapRef = ref<Map<string, BatchGetObjectModelItemType>>();
+
+  const getAllDeviceProfileIdsByDataSource = computed(() => {
+    const result = unref(rawDataSource)?.componentData?.reduce((prev, next) => {
+      const ids = next.dataSource.map((temp) => temp.deviceProfileId);
+      return [...prev, ...ids];
+    }, []);
+
+    return [...new Set(result)];
+  });
+
   const getSharePageData = computed(() => {
     return unref(propsRef).value!;
   });
@@ -64,19 +77,8 @@ export const useDataSource = (propsRef: ComputedRef<Recordable>) => {
       loading.value = true;
       const { data } = await getDataBoradDetail();
       rawDataSource.value = data;
-      // const result: WidgetDataType[] = (data.componentData || []).map((item) => {
-      //   const { id } = item;
-
-      //   const layout =
-      //     (data.componentLayout || []).find((item) => item.id === id) ||
-      //     ({} as ComponentLayoutType);
-
-      //   return {
-      //     i: buildUUID(),
-      //     ...layout,
-      //     ...item,
-      //   } as WidgetDataType;
-      // });
+      await getAllDeviceProfiles();
+
       const result: WidgetDataType[] = data.componentLayout.map((item) => {
         const { id } = item;
         const dataSource =
@@ -129,8 +131,35 @@ export const useDataSource = (propsRef: ComputedRef<Recordable>) => {
     } catch (error) {}
   };
 
-  onMounted(() => {
-    getDataSource();
+  const getAllDeviceProfiles = async () => {
+    if (!unref(getAllDeviceProfileIdsByDataSource).length) return;
+    const result = await batchGetObjectModel({
+      deviceProfileIds: unref(getAllDeviceProfileIdsByDataSource),
+    });
+
+    const map = new Map();
+
+    result.forEach((item) => {
+      map.set(item.id, item);
+    });
+
+    deviceProfilesMapRef.value = map;
+  };
+
+  function getDeviceProfileDetailById(id: string) {
+    return unref(deviceProfilesMapRef)?.get(id);
+  }
+
+  function getDeviceProfileTslByIdWithIdentifier(id: string, identifier: string) {
+    const detail = getDeviceProfileDetailById(id);
+    if (!detail) return;
+    for (const item of detail.tsl) {
+      if (item.identifier === identifier) return item;
+    }
+  }
+
+  onMounted(async () => {
+    await getDataSource();
   });
 
   return {
@@ -138,8 +167,11 @@ export const useDataSource = (propsRef: ComputedRef<Recordable>) => {
     draggable: !unref(getIsSharePage) && !unref(getIsAppPage),
     resizable: !unref(getIsSharePage) && !unref(getIsAppPage),
     dataSource,
+    deviceProfilesMapRef,
     rawDataSource,
     getDataSource,
     setLayoutInfo,
+    getDeviceProfileDetailById,
+    getDeviceProfileTslByIdWithIdentifier,
   };
 };

+import { inject, provide } from 'vue';
+import { BatchGetObjectModelItemType, Tsl } from '/@/api/device/model/modelOfMatterModel';
+
+const SymbolKey = Symbol('data-board');
+
+export interface ContextOptionsType {
+  getDeviceProfileDetailById: (id: string) => BatchGetObjectModelItemType | undefined;
+  getDeviceProfileTslByIdWithIdentifier: (id: string, identifier?: string) => Tsl | undefined;
+}
+
+export const createDeviceProfileQueryContext = (options: ContextOptionsType) => {
+  provide(SymbolKey, options);
+};
+
+export const useDeviceProfileQueryContext = () => {
+  return inject<ContextOptionsType>(SymbolKey) || ({} as Partial<ContextOptionsType>);
+};

+import { DataType, Specs, StructJSON } from '/@/api/device/model/modelOfMatterModel';
+import { DataTypeEnum } from '/@/enums/objectModelEnum';
+import { useJsonParse } from '/@/hooks/business/useJsonParse';
+function getBoolTypeValue(value: number, Specs: Specs) {
+  const { boolOpen, boolClose } = Specs;
+
+  return Number(value) ? boolOpen : boolClose;
+}
+
+function getEnumTypeValue(value: number, specsList: Specs[]) {
+  const res = specsList.find((item) => item.value === Number(value));
+
+  return res?.name;
+}
+
+function getStructTypeValue(value: string, specs: StructJSON[]): string {
+  const res = useJsonParse(value).value;
+
+  function generateStruct(specs: StructJSON[], value: Recordable) {
+    if (!value) return {};
+
+    return specs.reduce((prev, next) => {
+      return {
+        ...prev,
+        [next.functionName!]: getValueByType(
+          next.dataType!.type,
+          value[next.identifier],
+          next.dataType!
+        ),
+      };
+    }, {});
+  }
+
+  return JSON.stringify(generateStruct(specs, res));
+}
+
+function getValueByType(type: string, value: any, dataType: DataType) {
+  switch (type) {
+    case DataTypeEnum.BOOL:
+      return getBoolTypeValue(value, dataType.specs as Specs);
+    case DataTypeEnum.STRUCT:
+      return getStructTypeValue(value, dataType.specs as StructJSON[]);
+    case DataTypeEnum.ENUM:
+      return getEnumTypeValue(value, dataType.specsList as Specs[]);
+    default:
+      return value;
+  }
+}
+export function useThingsModelValueTransform(value: any, thingsModelDataType?: DataType) {
+  if (!thingsModelDataType) return value;
+
+  const { type } = thingsModelDataType;
+  return getValueByType(type, value, thingsModelDataType);
+}

@@ -40,6 +40,7 @@
   import SIGNALSVG from '/@/assets/svg/signal.svg';
   import BATTERYSVG from '/@/assets/svg/battery.svg';
   import { useRoute } from 'vue-router';
+  import { createDeviceProfileQueryContext } from './hooks/useDeviceProfileQueryContext';
 
   const props = defineProps<{
     value?: Recordable;
@@ -53,8 +54,17 @@
 
   const ROUTE = useRoute();
 
-  const { loading, draggable, resizable, dataSource, rawDataSource, setLayoutInfo, getDataSource } =
-    useDataSource(getProps);
+  const {
+    loading,
+    draggable,
+    resizable,
+    dataSource,
+    rawDataSource,
+    setLayoutInfo,
+    getDataSource,
+    getDeviceProfileDetailById,
+    getDeviceProfileTslByIdWithIdentifier,
+  } = useDataSource(getProps);
 
   const { resize, resized, moved, containerResized } = useDragGridLayout(dataSource, setLayoutInfo);
 
@@ -157,6 +167,11 @@
 
   createDataBoardContext({ send, close });
 
+  createDeviceProfileQueryContext({
+    getDeviceProfileDetailById,
+    getDeviceProfileTslByIdWithIdentifier,
+  });
+
   const { getDarkMode } = useRootSetting();
   watch(
     getIsSharePage,

 import { PublicComponentOptions } from '../../packages/index.type';
+import { CommandTypeEnum } from '/@/enums/deviceEnum';
 
 export interface ComponentDataType<T = ExtraDataSource> {
   id: string;
@@ -19,19 +20,26 @@ export interface DataSource {
   deviceId: string;
   deviceType: string;
   attribute: string;
-  attributeName: string;
-  deviceName: string;
-  gatewayDevice: boolean;
-  slaveDeviceId: string;
+  commandType?: CommandTypeEnum;
+  openCommand?: string;
+  closeCommand?: string;
+  openService?: string;
+  closeService?: string;
+  // attributeName: string;
+  // deviceName: string;
+  // gatewayDevice: boolean;
+  // slaveDeviceId: string;
   deviceRename: string;
   attributeRename: string;
   componentInfo: ComponentInfo;
-  customCommand: CustomCommand;
   videoConfig?: VideoConfigType;
   [key: string]: any;
-  lal?: string;
-  latitude?: string | number;
-  longitude?: string | number;
+
+  latitudeIdentifier?: string[];
+  longitudeIdentifier?: string[];
+  // lal?: string;
+  // latitude?: string | number;
+  // longitude?: string | number;
 }
 
 export interface ExtraDataSource extends DataSource, PublicComponentOptions {