fix: 修复设备详情命令下发枚举类型无法下发&&优化命令下发逻辑

 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';
@@ -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

 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;
+}

@@ -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);

-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 { validateTCPCustomCommand } from '.';
 
 export const getFormSchemas = ({
   structJSON: structJson,
@@ -143,6 +144,7 @@ export const getFormSchemas = ({
       component: 'Input',
       required,
       defaultValue: serviceCommand,
+      rules: [{ validator: validateTCPCustomCommand }],
       componentProps: {
         placeholder: `请输入服务命令`,
       },

@@ -6,3 +6,45 @@ export enum TransportTypeEnum {
   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',
+}

@@ -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 = '属性',
-}

@@ -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',
-}

-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 { 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 { 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';
@@ -908,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: 'ThingsModelForm',
-      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,
-      },
-    },
-  ];
-};

+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 } = 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 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" setup>
-  import { 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 { parseStringToJSON } from '/@/components/CodeEditor/src/JSONEditor';
-  import { CommandDeliveryWayEnum } from '/@/enums/toolEnum';
-  import { TransportTypeEnum } from '/@/enums/deviceEnum';
-
-  defineEmits(['register']);
-
-  const props = defineProps<{
-    deviceDetail: DeviceRecord;
-  }>();
-
-  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;
-    }
-  };
-</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>

@@ -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';

@@ -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>

 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,7 +20,7 @@ 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';

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

@@ -7,7 +7,8 @@ import {
   ExecutionActionFormItemRecordType,
   ExecutionActionListRefItemType,
 } from './type';
-import { CommandTypeEnum, ExecutionActionEnum } from '/@/enums/linkedgeEnum';
+import { ExecutionActionEnum } from '/@/enums/linkedgeEnum';
+import { CommandTypeEnum } from '/@/enums/deviceEnum';
 import { useJsonParse } from '/@/hooks/business/useJsonParse';
 import { createNewExecutionActionItem } from '.';
 import { FormFieldsEnum } from './config';

@@ -3,7 +3,7 @@ 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';
-import { CommandTypeEnum } from '/@/enums/linkedgeEnum';
+import { CommandTypeEnum } from '/@/enums/deviceEnum';
 import { TransportTypeEnum } from '/@/enums/deviceEnum';
 
 const getArray = (values) => {

@@ -14,7 +14,7 @@ import { DataActionModeEnum } from '/@/enums/toolEnum';
 import { TaskTypeEnum } from '/@/views/task/center/config';
 import { createPickerSearch } from '/@/utils/pickerSearch';
 import { DataTypeEnum } from '/@/enums/objectModelEnum';
-import { CommandTypeEnum } from '/@/enums/linkedgeEnum';
+import { CommandTypeEnum } from '/@/enums/deviceEnum';
 import { TransportTypeEnum } from '/@/enums/deviceEnum';
 
 useComponentRegister('OrgTreeSelect', OrgTreeSelect);

@@ -2,8 +2,7 @@ import { ref } from 'vue';
 import { DataSource } from '../../palette/types';
 import { sendCommandOneway, sendCommandTwoway } from '/@/api/dataBoard';
 import { useMessage } from '/@/hooks/web/useMessage';
-import { ServiceCallTypeEnum } from '/@/enums/toolEnum';
-import { TransportTypeEnum } from '/@/enums/deviceEnum';
+import { TransportTypeEnum, ServiceCallTypeEnum } from '/@/enums/deviceEnum';
 
 const { createMessage } = useMessage();
 export function useSendCommand() {