commit: 设备台账联调；相关组件开发

+import {defHttp} from "/@/utils/http/axios";
+import {omit} from "lodash-es";
+
+/**
+ * 列表
+ */
+
+export const getLedgerList = (params) => {
+  const { page, pageSize } = params;
+  const otherParams = omit(params, ['page', 'pageSize']);
+  return defHttp.post<any>({
+    url: `/da/pageData?page=${page}&pageSize=${pageSize}`,
+    params: otherParams,
+  });
+};
+
+
+/**
+*组织
+*/
+export const getOrgList = () => {
+  return defHttp.get<any>({
+    url: `/organization/me/list`,
+  });
+};
+
+/**
+*组织
+*/
+export const getUserListByOrg = (params) => {
+  return defHttp.get<any>({
+    url: `/user/tenant/page`,
+    params,
+  });
+};
+
+/**
+ * 新增
+ */
+export const saveLedger = (params) => {
+  return defHttp.post<any>({
+    url: `/da/save`,
+    params,
+  });
+};
+
+/**
+ *详情
+ */
+export const ledgerEditDetailPage = (params) => {
+  return defHttp.get<any>({
+    url: `/da/detail`,
+    params,
+  });
+};
+/**
+ *删除
+ */
+export const deleteLedger = (params) => {
+  return defHttp.get<any>({
+    url: `/da/delete`,
+    params,
+  });
+};

@@ -132,6 +132,7 @@ export type ComponentType =
   | 'ControlGroup'
   | 'JSONEditor'
   | 'OrgTreeSelect'
+  | 'CategoryTreeSelect'
   | 'CreateSpeed'
   | 'ExtendDesc'
   | 'JavaScriptFunctionEditor'

@@ -51,6 +51,12 @@ export enum DeviceStatusEnum {
   OFFLINE = 'OFFLINE',
 }
 
+export enum SbStatusEnum {
+  FAULT = 'FAULT',
+  NORMAL = 'NORMAL',
+  SCRAP = 'SCRAP',
+}
+
 export enum CommandStatusEnum {
   QUEUED = 'QUEUED',
   SENT = 'SENT',

 export default {
   productText: '产品',
   deviceText: '设备',
+  codeText: '设备编码',
+  brandText: '设备品牌',
   attributeText: '属性',
   organizationText: '组织',
   tenantText: '租户',
@@ -29,4 +31,5 @@ export default {
   commandDeliveryText: '命令下发',
   serviceText: '服务',
   dateRangeText: '时间范围',
+  directorName: '负责人',
 };

@@ -85,6 +85,12 @@ export default {
     ONLINE: '在线',
     OFFLINE: '离线',
   },
+  sbStatus: {
+    ALL: '全部',
+    FAULT: '故障',
+    NORMAL: '正常',
+    SCRAP: '报废',
+  },
   commandStatus: {
     QUEUED: '队列中',
     SENT: '已发送',

@@ -6,4 +6,5 @@ export default {
   orderText: '排序',
   description: '描述',
   operationSuccessText: '操作成功',
+  categoryPlaceholderText: '请选择设备类别',
 };

 export default {
   ledgerListText: '台账列表',
+  nameCode: '设备编码',
+  brandText: '设备编码',
+  modelNumText: '型号',
+  buyDate: '购买时间',
+  productDate: '出厂日期',
+  registeDate: '登记日期',
+  receiveDate: '验收日期',
+  priceText: '价格',
+  specificationsText: '规格',
+  manufacturerText: '生产厂家',
+  description: '备注',
   createLedgerText: '创建台账',
+  editLedgerText: '编辑台账',
   importLedgerText: '导入台账',
   deviceName: '设备名称',
   deviceCode: '设备编码',
   deviceType: '设备类型',
   status: '状态',
-  description: '负责人',
   operationSuccessText: '操作成功',
   editProductText: '编辑台账',
   updateOrganization: '修改组织',
   batchActionText: '批量操作',
+  FAULT: '故障',
+  NORMAL: '正常',
+  SCRAP: '报废',
 }

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

+<template>
+  <section class="!flex">
+    <ApiTreeSelect v-bind="getBindProps" class="flex-auto" />
+    <Button v-if="getShowCreate" type="link" @click="handleOpenCreate" :disabled="disabled">
+      {{ t('component.orgSelect.createOrganizationText') }}
+    </Button>
+    <OrganizationDrawer v-if="getShowCreate" @register="registerDrawer" @success="handleReload" />
+  </section>
+</template>
+<script setup lang="ts">
+import { ApiTreeSelect } from '/@/components/Form';
+import { Button } from 'ant-design-vue';
+import {computed, ref, unref} from "vue";
+import {getAllCategory} from "/@/api/equipment/category";
+import {useI18n} from "/@/hooks/web/useI18n";
+const { t } = useI18n();
+const emit = defineEmits(['change', 'optionsChange']);
+
+const props = withDefaults(
+  defineProps<{
+    value?: string | string[];
+    apiTreeSelectProps?: Recordable;
+    showCreate?: boolean;
+    disabled?: boolean;
+  }>(),
+  {
+    showCreate: true,
+    disabled: false,
+  }
+);
+const timespan = ref(Date.now());
+const needReload = ref(true);
+const cateList = ref<Recordable[]>([]);
+const getBindProps = computed<Recordable>(() => {
+  const { value, apiTreeSelectProps = {}, disabled } = props;
+  const { params = {} } = apiTreeSelectProps;
+  return {
+    replaceFields: { children: 'children', key: 'id', title: 'name', value: 'id' },
+    getPopupContainer: () => document.body,
+    placeholder: t('equipment.category.categoryPlaceholderText'),
+    maxLength: 250,
+    disabled,
+    ...apiTreeSelectProps,
+    value,
+    dropdownStyle: { maxHeight: '300px' },
+    api: async (params: any) => {
+      try {
+        if (!unref(needReload)) return unref(cateList);
+        const result = ((await getAllCategory(params)) as unknown as Recordable[]) || [];
+        cateList.value = result;
+        needReload.value = false;
+        return result;
+      } catch (error) {
+        return unref(cateList);
+      }
+    },
+    params: {
+      ...params,
+      _t: unref(timespan),
+    },
+    onChange: (...args: any[]) => {
+      emit('change', ...args);
+    },
+    onOptionsChange: (...args: any[]) => emit('optionsChange', ...args),
+  };
+});
+
+</script>

@@ -8,11 +8,15 @@
 
 import { ref } from 'vue';
 import organizationIdTree from '../OrganizationIdTree.vue';
-export const useResetOrganizationTree = (searchInfo: Recordable) => {
+export const useResetOrganizationTree = (searchInfo: Recordable, type?: string) => {
   const organizationIdTreeRef = ref<InstanceType<typeof organizationIdTree>>();
   async function resetFn() {
     organizationIdTreeRef.value.resetOrganization();
-    searchInfo.organizationId = null;
+    if (type === 'equipment') {
+      searchInfo.categoryId = null;
+    }else {
+      searchInfo.organizationId = null;
+    }
   }
   return { organizationIdTreeRef, resetFn };
 };

@@ -25,6 +25,7 @@
   import { computed, onMounted, ref, unref, useAttrs } from 'vue';
   import { BasicTree, TreeItem } from '/@/components/Tree';
   import { getOrganizationList } from '/@/api/system/system';
+  import { getAllCategory } from '/@/api/equipment/category';
   import { CaretRightOutlined } from '@ant-design/icons-vue';
   import { getBoundingClientRect } from '/@/utils/domUtils';
   import { BasicTreePropsType, OrganizationTreeActionType } from './types';
@@ -34,7 +35,6 @@
   const props = defineProps<OrganizationTreePropsType>();
 
   const attrs = useAttrs();
-
   const tree = ref<Nullable<HTMLDivElement>>();
   const emit = defineEmits(['select', 'register']);
   const treeData = ref<TreeItem[]>([]);
@@ -75,7 +75,14 @@
   };
 
   onMounted(async () => {
-    treeData.value = (await getOrganizationList()) as unknown as TreeItem[];
+    let api:any;
+    if (attrs?.listType === 'equipment') {
+      api = getAllCategory()
+    }else {
+      api = getOrganizationList()
+    }
+
+    treeData.value = (await api) as unknown as TreeItem[];
     const getAllIds = findForAllId(treeData.value as any, []);
     //设置要展开的id
     treeExpandData.value = getAllIds;
@@ -88,12 +95,11 @@
   });
 
   const getProps = computed<OrganizationTreePropsType>(() => ({ ...props, ...unref(innerProps) }));
-
   const { t } = useI18n();
 
   const getBindData = computed(() => {
     return {
-      title: t('common.organizationList'),
+      title: attrs?.listType === 'equipment' ? t('equipment.category.categoryText') : t('common.organizationList'),
       toolbar: true,
       search: true,
       clickRowToExpand: false,

 export interface OrganizationTreePropsType {
   onSelect?: (selectKeys: string) => any;
+  listType?: string;
 }

+<template>
+  <BasicDrawer
+    destroyOnClose
+    v-bind="$attrs"
+    showFooter
+    width="35%"
+    :maskClosable="true"
+    :title="businessText"
+    @register="registerDrawer"
+    wrapClassName="report-drawer"
+    @ok="handleSubmit"
+    @close="handleClose"
+  >
+    <BasicForm @register="registerForm">
+
+    </BasicForm>
+  </BasicDrawer>
+</template>
+<script setup lang="ts">
+import {nextTick, reactive, ref} from "vue";
+import { BasicDrawer, useDrawerInner } from '/@/components/Drawer';
+import { SchemaFiled} from "../../config/enum";
+import {BasicForm,useForm} from "/@/components/Form";
+import {formSchema} from "../../config/data";
+import {useHooks} from "/@/views/report/config/hooks/index.hooks";
+import {getUserListByOrg,ledgerEditDetailPage,saveLedger } from "/@/api/equipment/ledger"
+import {useUserStore} from "/@/store/modules/user";
+import {useThrottleFn} from "@vueuse/shared/index";
+import {useMessage} from "/@/hooks/web/useMessage";
+import {useI18n} from "/@/hooks/web/useI18n";
+const {
+  setDefaultTime,
+  disableCustomWeekly,
+  setPropsForModal,
+  removeFields,
+} = useHooks();
+const userInfo = useUserStore();
+const restData = reactive({
+  data: {},
+});
+const { createMessage } = useMessage();
+const { t } = useI18n();
+const emits = defineEmits(['success', 'register']);
+const [registerForm, { validate, resetFields, setFieldsValue, updateSchema, setProps }] = useForm(
+  {
+    labelWidth: 140,
+    schemas: formSchema,
+    showActionButtonGroup: false,
+    fieldMapToTime: [[SchemaFiled.DATE_RANGE, [SchemaFiled.START_TS, SchemaFiled.END_TS]]],
+  }
+);
+// 定义人员选项
+const userOptions = ref<any[]>([]);
+
+// 监听 org 字段的变化
+const handleOrgChange = async (orgId: string) => {
+  if (!orgId) {
+    userOptions.value = []; // 清空人员选项
+    updateSchema({
+      field: 'directorId',
+      componentProps: { options: [] },
+    });
+    return;
+  }
+  const _data = {
+    page: '1',
+    pageSize: '999',
+    tenantId: userInfo.getUserInfo.tenantId!,
+    organizationId: orgId
+  }
+  // 调用接口 B 获取人员数据
+  const userList = await getUserListByOrg(_data);
+  console.log(userList,'userList')
+  userOptions.value = userList?.items.map(user => ({
+    label: user.username,
+    value: user.id,
+  }));
+
+  // 更新 user 字段的选项
+  updateSchema({
+    field: 'directorId',
+    componentProps: { options: userOptions.value },
+  });
+};
+
+
+
+
+const businessText = ref('');
+const [registerDrawer, { setDrawerProps, closeDrawer }] = useDrawerInner(async (data) => {
+  try {
+    await nextTick();
+    handleClose();
+    businessText.value = data.text;
+    // 更新 formSchema 中的 org 字段，绑定 change 事件
+    updateSchema({
+      field: 'org',
+      componentProps: {
+        onChange: handleOrgChange,
+      },
+    });
+    setFieldsValue(setDefaultTime());
+    updateSchema(disableCustomWeekly(0));
+    setDrawerProps(setPropsForModal(businessText.value));
+    if (businessText.value === 'add') return;
+    const rest = await ledgerEditDetailPage({id: data.record?.id});
+    restData.data = rest ?? {};
+
+    await setFieldsValue({
+      ...restData.data,
+    });
+
+  } finally {
+    setDrawerProps({ loading: false });
+  }
+});
+const handleClose = () => {
+  resetValue();
+}
+//重置表单
+const resetValue = () => {
+  resetFields();
+};
+
+const handleSubmit = () => {
+  useThrottle();
+};
+
+const useThrottle = useThrottleFn(() => {
+  getValue();
+}, 2000);
+
+const getValue = async () => {
+  try {
+    setDrawerProps({ confirmLoading: true });
+    const values = await validate();
+    if (!values) return;
+    const data = {
+      ...values,
+      buyDate: values.buyDate?.format('YYYY-MM-DD hh:mm:ss'),
+      productDate: values.productDate?.format('YYYY-MM-DD hh:mm:ss'),
+      receiveDate: values.receiveDate?.format('YYYY-MM-DD hh:mm:ss'),
+      registeDate: values.registeDate?.format('YYYY-MM-DD hh:mm:ss'),
+    };
+    removeFields.forEach((item) => {
+      Reflect.deleteProperty(data, item);
+    });
+    businessText.value === 'add'
+      ? await saveLedger(data)
+      : saveLedger({ ...restData.data, ...data });
+    createMessage.success(
+      t(businessText.value !== 'add' ? 'common.editSuccessText' : 'common.createSuccessText')
+    );
+    closeDrawer();
+    handleClose();
+    setTimeout(() => {
+      emits('success');
+    }, 500);
+  } finally {
+    setDrawerProps({ confirmLoading: false });
+  }
+};
+
+</script>

+import LedgerDrawer from './LedgerDrawer.vue';
+
+export { LedgerDrawer };

-import { FormSchema, useComponentRegister } from '/@/components/Form';
-import { findDictItemByCode } from '/@/api/system/dict';
-import { getGatewayDevice, queryDeviceProfileBy } from '/@/api/device/deviceManager';
-import { JSONEditor } from '/@/components/CodeEditor';
-import { DeviceRecord, DeviceTypeEnum } from '/@/api/device/model/deviceModel';
-import { h } from 'vue';
-import { TaskTypeEnum } from '/@/views/task/center/config';
-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 { TCPProtocolTypeEnum, TransportTypeEnum } from '/@/enums/deviceEnum';
-import { HexInput, InputTypeEnum } from '../../profiles/components/ObjectModelForm/HexInput';
-import { DeviceProfileDetail } from '/@/api/device/model/deviceConfigModel';
-import { getDeviceProfileOtaPackages, getOtaPackageInfo } from '/@/api/ota';
-import { QueryDeviceProfileOtaPackagesType } from '/@/api/ota/model';
-import { OTAPackageType } from '/@/enums/otaEnum';
-import { createPickerSearch } from '/@/utils/pickerSearch';
-import { useI18n } from '/@/hooks/web/useI18n';
-
-useComponentRegister('JSONEditor', JSONEditor);
-useComponentRegister('LockControlGroup', LockControlGroup);
-useComponentRegister('OrgTreeSelect', OrgTreeSelect);
-useComponentRegister('HexInput', HexInput);
-
+import {FormSchema as BFormSchema, useComponentRegister} from "../../../../components/Form";
+import {useI18n} from "../../../../hooks/web/useI18n";
 const { t } = useI18n();
-
-export enum TypeEnum {
-  IS_GATEWAY = 'GATEWAY',
-  SENSOR = 'SENSOR',
-}
-
-export const isGateWay = (type: string) => {
-  return type === TypeEnum.IS_GATEWAY;
-};
-
-const updateProductHelpMessage = [
-  t('deviceManagement.device.updateProductHelpMessage.text1'),
-  t('deviceManagement.device.updateProductHelpMessage.text2'),
-];
-
-export const updateOrgHelpMessage = [
-  t('deviceManagement.device.updateOrgHelpMessage.text1'),
-  t('deviceManagement.device.updateOrgHelpMessage.text2'),
-  t('deviceManagement.device.updateOrgHelpMessage.text3'),
+import { CategoryTreeSelect } from '../../../common/CategoryTreeSelect';
+import { OrgTreeSelect } from '../../../common/OrgTreeSelect';
+useComponentRegister('OrgTreeSelect', OrgTreeSelect);
+useComponentRegister('CategoryTreeSelect', CategoryTreeSelect);
+const statusOptions = [
+  { label: t('equipment.ledger.NORMAL'), value: 'NORMAL' },
+  { label: t('equipment.ledger.FAULT'), value: 'FAULT' },
+  { label: t('equipment.ledger.SCRAP'), value: 'SCRAP' },
 ];
-// 第一步的表单
-export const step1Schemas: FormSchema[] = [
-  {
-    field: 'icon',
-    label: t('business.deviceImageText'),
-    component: 'ApiUpload',
-    changeEvent: 'update:fileList',
-    valueField: 'fileList',
-    componentProps: ({ formModel }) => {
-      return {
-        listType: 'picture-card',
-        maxFileLimit: 1,
-        accept: '.png,.jpg,.jpeg,.gif',
-        api: async (file: File) => {
-          try {
-            const formData = new FormData();
-            formData.set('file', file);
-            const { fileStaticUri, fileName } = await uploadThumbnail(formData);
-            return {
-              uid: fileStaticUri,
-              name: fileName,
-              url: fileStaticUri,
-            };
-          } catch (error) {
-            return {};
-          }
-        },
-        onPreview: (fileList) => {
-          createImgPreview({ imageList: [fileList.url!] });
-        },
-        onDelete(url: string) {
-          formModel.deleteUrl = url!;
-        },
-      };
-    },
-  },
+export const formSchema: BFormSchema[] = [
   {
-    field: 'deleteUrl',
-    label: '',
-    component: 'Input',
-    show: false,
-  },
-  {
-    field: 'alias',
-    label: t('business.aliasText'),
+    field: 'code',
+    label: t('equipment.ledger.nameCode'),
     component: 'Input',
+    colProps: { span: 24 },
+    required: true,
     componentProps: {
-      maxLength: 32,
+      maxLength: 20,
     },
   },
   {
     field: 'name',
-    label: t('business.deviceNameText'),
+    label: t('equipment.ledger.deviceName'),
     component: 'Input',
+    colProps: { span: 24 },
+    required: true,
     componentProps: {
-      maxLength: 32,
+      maxLength: 20,
     },
-    required: true,
-    slot: 'snCode',
   },
   {
-    field: 'transportType',
-    label: '类型',
-    component: 'Input',
-    show: false,
-  },
-  {
-    field: 'deviceProfileId',
-    label: '',
-    component: 'Input',
-    show: false,
-  },
-  {
-    field: 'isUpdate',
-    label: '编辑模式',
-    component: 'Switch',
-    show: false,
-  },
-  {
-    field: 'tcpDeviceProtocol',
-    label: 'TCP设备协议类型',
-    component: 'Input',
-    show: false,
-  },
-
-  {
-    field: 'profileId',
-    label: t('business.affiliatedProductText'),
+    field: 'categoryId',
+    label: t('equipment.category.categoryText'),
+    colProps: { span: 24 },
+    component: 'CategoryTreeSelect',
     required: true,
-    component: 'LockControlGroup',
-    helpMessage: updateProductHelpMessage,
-    renderComponentContent: () => ({
-      popconfirmTitle: () =>
-        updateProductHelpMessage.map((text) => h('div', { style: { maxWidth: '200px' } }, text)),
-    }),
-    componentProps: ({ formActionType, formModel }) => {
-      const { setFieldsValue } = formActionType;
-      return {
-        component: 'ApiSelect',
-        defaultLockStatus: !!formModel?.isUpdate,
-        componentProps: {
-          api: async () => {
-            const options = await queryDeviceProfileBy({
-              deviceType: formModel?.isUpdate ? formModel?.deviceType : null,
-            });
-
-            return options;
-          },
-          labelField: 'name',
-          valueField: 'tbProfileId',
-          onChange(_value: string, option: DeviceProfileDetail) {
-            const { deviceType, transportType, id } = option;
-            setFieldsValue({
-              deviceType: deviceType,
-              transportType,
-              deviceProfileId: id,
-              gatewayId: null,
-              code: null,
-              addressCode: null,
-              tcpDeviceProtocol: option?.profileData?.transportConfiguration?.protocol,
-            });
-          },
-          onOptionsChange(options: (DeviceProfileDetail & Record<'value', string>)[]) {
-            const { profileId } = formModel;
-            if (profileId) {
-              const selectRecord = options.find((item) => item.value === profileId);
-              selectRecord &&
-                setFieldsValue({
-                  transportType: selectRecord!.transportType,
-                  tcpDeviceProtocol: selectRecord?.profileData?.transportConfiguration?.protocol,
-                });
-            }
-          },
-          placeholder: t('deviceManagement.device.productPlaceholderText'),
-          ...createPickerSearch(),
-        },
-      };
-    },
   },
   {
-    field: 'deviceType',
-    label: t('business.deviceTypeText'),
+    field: 'status',
+    component: 'Select',
+    label: t('equipment.ledger.status'),
     required: true,
-    component: 'ApiSelect',
-    dynamicDisabled: true,
-    helpMessage: t('deviceManagement.device.deviceTypeHelpText'),
+    colProps: { span: 24 },
+    defaultValue: 'NORMAL',
     componentProps: {
-      api: findDictItemByCode,
-      params: {
-        dictCode: 'device_type',
-      },
-      labelField: 'itemText',
-      valueField: 'itemValue',
-    },
-  },
-  {
-    field: 'addressType',
-    label: '',
-    component: 'Input',
-    show: false,
-    defaultValue: 'HEX',
-  },
-  {
-    field: 'deviceState',
-    label: '',
-    component: 'Input',
-    show: false,
-  },
-  {
-    field: 'addressCode',
-    label: t('deviceManagement.device.addressCodeText'),
-    dynamicDisabled({ values }) {
-      return (
-        values.isUpdate &&
-        values.deviceType === DeviceTypeEnum.SENSOR &&
-        values.deviceState === 'ONLINE' &&
-        values.transportType === TransportTypeEnum.TCP
-      );
-    },
-    dynamicRules({ values }) {
-      return [
-        {
-          required:
-            values?.transportType === TransportTypeEnum.TCP &&
-            values?.tcpDeviceProtocol === TCPProtocolTypeEnum.MODBUS_RTU,
-          message: t('deviceManagement.device.addressCodeHelpText'),
-          pattern: values?.addressType === 'HEX' ? /^[0-9A-Fa-f]{2}$/ : /^[0-9A-Fa-f]{1,2}$/,
-        },
-      ];
-    },
-    helpMessage({ values }) {
-      return [
-        t('deviceManagement.device.addressCodeHelpText'),
-        values.transportType === TransportTypeEnum.TCP &&
-        values.deviceType === DeviceTypeEnum.SENSOR
-          ? t('deviceManagement.device.tcpAddressCodeHelpText')
-          : '',
-      ];
-    },
-    component: 'HexInput',
-    changeEvent: 'update:value',
-    valueField: 'value',
-    componentProps: ({ formModel }) => {
-      return {
-        type: InputTypeEnum.HEX,
-        maxValue: parseInt('FF', 16),
-        onHexChange: (e) => {
-          formModel.addressType = e;
-        },
-      };
-    },
-    ifShow: ({ values }) => {
-      return (
-        values?.transportType === TransportTypeEnum.TCP &&
-        values?.tcpDeviceProtocol === TCPProtocolTypeEnum.MODBUS_RTU
-      );
-    },
-  },
-  {
-    field: 'code',
-    label: t('deviceManagement.device.codeText'),
-    dynamicRules({ values }) {
-      return [
-        {
-          required:
-            values?.transportType === TransportTypeEnum.TCP &&
-            values.deviceType === DeviceTypeEnum.SENSOR,
-        },
-      ];
-    },
-    dynamicDisabled({ values }) {
-      return (
-        values.isUpdate &&
-        values.deviceType === DeviceTypeEnum.SENSOR &&
-        values.deviceState === 'ONLINE' &&
-        values.transportType === TransportTypeEnum.TCP
-      );
-    },
-    helpMessage({ values }) {
-      return (
-        values.transportType === TransportTypeEnum.TCP &&
-        values.deviceType === DeviceTypeEnum.SENSOR
-          ? ['tcp网关子设备在线时，不能修改设备标识或地址码']
-          : false
-      ) as any;
-    },
-    component: 'Input',
-    componentProps: () => {
-      return {
-        maxLength: 255,
-        placeholder: t('deviceManagement.device.codePlaceholderText'),
-      };
-    },
-    ifShow: ({ values }) => {
-      return (
-        values?.transportType === TransportTypeEnum.TCP &&
-        values?.tcpDeviceProtocol === TaskTypeEnum.CUSTOM
-      );
+      options: statusOptions,
     },
   },
-
   {
-    field: 'brand',
-    component: 'ApiRadioGroup',
-    label: t('deviceManagement.device.brandText'),
+    field: 'org',
+    component: 'OrgTreeSelect',
+    label: '负责人组织',
     required: true,
-    defaultValue: 'DIY_',
+    colProps: { span: 24 },
     componentProps: {
-      api: findDictItemByCode,
-      params: {
-        dictCode: 'device_brand_gateway',
+      // 添加 change 事件
+      onChange: (value: string) => {
+        // 这里需要触发加载人员数据的逻辑
+        console.log(value,'value')
       },
-      labelField: 'itemText',
-      valueField: 'itemValue',
-    },
-    ifShow: ({ values }) => isGateWay(values.deviceType),
-  },
-  {
-    field: 'gatewayId',
-    label: t('enum.deviceType.GATEWAY'),
-    required: true,
-    component: 'ApiSelect',
-    ifShow: ({ values }) => values.deviceType === 'SENSOR',
-    componentProps: ({ formModel, formActionType }) => {
-      const { transportType, deviceType, gatewayId } = formModel;
-      const { setFieldsValue } = formActionType;
-      if (!transportType) return {};
-      return {
-        api: async (params: Recordable) => {
-          try {
-            const result = await getGatewayDevice(params as any);
-            return result.map((item) => ({ ...item, alias: item.alias || item.name }));
-          } catch (e) {
-            return [];
-          }
-        },
-        params: {
-          transportType,
-          gatewayId: deviceType === DeviceTypeEnum.SENSOR && gatewayId ? gatewayId : null,
-        },
-        valueField: 'tbDeviceId',
-        labelField: 'alias',
-        onChange: async (_value: string, option: DeviceRecord) => {
-          setFieldsValue({ sensorOrganizationId: option?.organizationId, organizationId: null });
-        },
-        onOptionsChange(options: (DeviceRecord & Record<'value', string>)[]) {
-          if (formModel?.deviceType === DeviceTypeEnum.SENSOR && formModel?.gatewayId) {
-            const result = options.find((item) => item.value === formModel?.gatewayId);
-            result && setFieldsValue({ sensorOrganizationId: result?.organizationId });
-          }
-        },
-        ...createPickerSearch(),
-      };
-    },
-  },
-  {
-    field: 'sensorOrganizationId',
-    label: '依据网关设备请求的组织数组',
-    component: 'Input',
-    ifShow: false,
-  },
-  {
-    field: 'customerId',
-    label: '用来判断编辑时禁用组织修改',
-    component: 'Input',
-    ifShow: false,
-  },
-  {
-    field: 'organizationId',
-    label: t('business.affiliatedOrganizationText'),
-    component: 'LockControlGroup',
-    required: true,
-    helpMessage: updateOrgHelpMessage,
-    renderComponentContent: () => ({
-      popconfirmTitle: () =>
-        updateOrgHelpMessage.map((text) => h('div', { style: { maxWidth: '240px' } }, text)),
-    }),
-    componentProps: ({ formModel, formActionType }) => {
-      return {
-        component: 'OrgTreeSelect',
-        defaultLockStatus: !!formModel?.isUpdate,
-        disabled: !!formModel?.customerId,
-        componentProps: {
-          apiTreeSelectProps: {
-            params: {
-              organizationId: formModel?.sensorOrganizationId,
-            },
-          },
-          onOptionsChange: (options: Recordable[]) => {
-            if (!formModel?.organizationId && formModel?.deviceType === DeviceTypeEnum.SENSOR) {
-              const firstItem = options?.[0];
-
-              if (firstItem && firstItem?.id) {
-                const { setFieldsValue, clearValidate } = formActionType;
-                setFieldsValue({ organizationId: firstItem.id });
-                clearValidate('organizationId');
-              }
-            }
-          },
-          placeholder: t('deviceManagement.device.organizationPlaceholderText'),
-        },
-      };
     },
   },
   {
     field: 'directorId',
-    label: t('deviceManagement.device.directorName'),
-    component: 'Input',
-    componentProps: {
-      maxLength: 255,
-    },
-  },
-  {
-    field: 'label',
-    label: t('deviceManagement.device.deviceLabelText'),
-    component: 'Input',
-    componentProps: {
-      maxLength: 255,
-    },
-  },
-  {
-    field: 'deviceAddress',
-    label: t('business.deviceLocationText'),
-    component: 'Input',
-    slot: 'deviceAddress',
-  },
-
-  {
-    field: 'firmwareId',
-    label: t('deviceManagement.product.assignHardwareText'),
-    component: 'ApiSearchSelect',
-    ifShow: ({ model }) => model?.isUpdate,
-    componentProps: ({ formModel }) => {
-      return {
-        api: async (params: QueryDeviceProfileOtaPackagesType) => {
-          if (!params.deviceProfileId) return [];
-          const result = await getDeviceProfileOtaPackages(params);
-          return result.data.map((item) => ({
-            label: `${item.title}(${item.version})`,
-            value: item.id.id,
-          }));
-        },
-        params: (textSearch: string) => {
-          return {
-            textSearch,
-            page: 0,
-            type: OTAPackageType.FIRMWARE,
-            pageSize: 10,
-            deviceProfileId: formModel?.profileId,
-          };
-        },
-        queryApi: async (id: string) => {
-          const result = await getOtaPackageInfo(id);
-          return { label: `${result.title}(${result.version})`, value: result.id.id };
-        },
-      };
-    },
-  },
-  {
-    field: 'softwareId',
-    label: t('deviceManagement.product.assignSoftwareText'),
-    component: 'ApiSearchSelect',
-    ifShow: ({ model }) => model?.isUpdate,
-    componentProps: ({ formModel }) => {
-      return {
-        api: async (params: QueryDeviceProfileOtaPackagesType) => {
-          if (!params.deviceProfileId) return [];
-          const result = await getDeviceProfileOtaPackages(params);
-          return result.data.map((item) => ({
-            label: `${item.title}(${item.version})`,
-            value: item.id.id,
-          }));
-        },
-        params: (textSearch: string) => {
-          return {
-            textSearch,
-            page: 0,
-            type: OTAPackageType.SOFTWARE,
-            pageSize: 10,
-            deviceProfileId: formModel?.profileId,
-          };
-        },
-        queryApi: async (id: string) => {
-          const result = await getOtaPackageInfo(id);
-          return { label: `${result.title}(${result.version})`, value: result.id.id };
-        },
-      };
-    },
-  },
-  {
-    field: 'description',
-    label: t('common.remarkText'),
-    component: 'InputTextArea',
-    componentProps: {
-      maxLength: 500,
-    },
-  },
-  {
-    field: 'id',
-    label: 'id',
-    component: 'Input',
-    show: false,
-    componentProps: {
-      maxLength: 36,
-      placeholder: '请输入id',
-    },
-  },
-  {
-    field: 'tenantId',
-    label: '租户Code',
-    component: 'Input',
-    show: false,
-    componentProps: {
-      maxLength: 36,
-      placeholder: '请输入租户Code',
-    },
-  },
-  {
-    field: 'tbDeviceId',
-    label: 'tbDeviceId',
-    component: 'Input',
-    show: false,
+    component: 'Select',
+    label: '负责人',
+    required: true,
+    colProps: { span: 24 },
     componentProps: {
-      maxLength: 36,
-      placeholder: '请输入tbDeviceId',
+      // 动态加载的选项
+      options: [], // 初始为空，后续动态加载
     },
   },
-];
-
-export enum credentialTypeEnum {
-  ACCESS_TOKEN = 'ACCESS_TOKEN',
-  X_509 = 'X509_CERTIFICATE',
-  MQTT_BASIC = 'MQTT_BASIC',
-}
-// 第二步的表单
-export const step2Schemas: FormSchema[] = [
-  {
-    label: '',
-    component: 'Checkbox',
-    field: 'addAgree',
-    slot: 'addAgree',
-  },
   {
-    label: t('deviceManagement.device.certificateTypeText'),
+    field: 'isOnline',
     component: 'Select',
-    field: 'credentialType',
+    label: '是否联网',
     required: true,
-    componentProps({ formActionType }) {
-      const { updateSchema, setFieldsValue } = formActionType;
-      return {
-        options: [
-          {
-            value: credentialTypeEnum.ACCESS_TOKEN,
-            label: 'Access Token',
-          },
-          {
-            value: credentialTypeEnum.X_509,
-            label: 'X.509',
-          },
-          {
-            value: credentialTypeEnum.MQTT_BASIC,
-            label: 'MQTT Basic',
-          },
-        ],
-        onChange(value) {
-          setFieldsValue({
-            publicKey: '',
-            credentialsId: '',
-            clientId: '',
-            username: '',
-            password: '',
-          });
-          if (value === credentialTypeEnum.ACCESS_TOKEN) {
-            updateSchema([
-              {
-                field: 'credentialsId',
-                ifShow: true,
-              },
-              {
-                field: 'clientId',
-                ifShow: false,
-              },
-              {
-                field: 'username',
-                ifShow: false,
-              },
-              {
-                field: 'password',
-                ifShow: false,
-              },
-              {
-                field: 'publicKey',
-                ifShow: false,
-              },
-            ]);
-          } else if (value === credentialTypeEnum.X_509) {
-            updateSchema([
-              {
-                field: 'publicKey',
-                ifShow: true,
-              },
-              {
-                field: 'credentialsId',
-                ifShow: false,
-              },
-              {
-                field: 'clientId',
-                ifShow: false,
-              },
-              {
-                field: 'username',
-                ifShow: false,
-              },
-              {
-                field: 'password',
-                ifShow: false,
-              },
-            ]);
-          } else if (value === credentialTypeEnum.MQTT_BASIC) {
-            updateSchema([
-              {
-                field: 'clientId',
-                ifShow: true,
-              },
-              {
-                field: 'username',
-                ifShow: true,
-              },
-              {
-                field: 'password',
-                ifShow: true,
-              },
-              {
-                field: 'publicKey',
-                ifShow: false,
-              },
-              {
-                field: 'credentialsId',
-                ifShow: false,
-              },
-            ]);
-          } else {
-            updateSchema([
-              {
-                field: 'clientId',
-                ifShow: false,
-              },
-              {
-                field: 'username',
-                ifShow: false,
-              },
-              {
-                field: 'password',
-                ifShow: false,
-              },
-              {
-                field: 'publicKey',
-                ifShow: false,
-              },
-              {
-                field: 'credentialsId',
-                ifShow: false,
-              },
-            ]);
-          }
+    colProps: { span: 24 },
+    componentProps: {
+      options: [
+        {
+          label: '是',
+          value: true,
         },
-      };
+        {
+          label: '否',
+          value: false,
+        }
+      ],
     },
-    ifShow: ({ values }) => values.addAgree,
   },
   {
-    label: t('deviceManagement.device.accessTokenText'),
+    field: 'brand',
+    label: t('equipment.ledger.brandText'),
     component: 'Input',
-    field: 'credentialsId',
-    required: true,
-    ifShow: false,
-    slot: 'credentialsId',
+    colProps: { span: 24 },
     componentProps: {
-      maxLength: 36,
+      maxLength: 20,
     },
   },
   {
-    label: t('deviceManagement.device.rsaPublicKeyText'),
-    component: 'InputTextArea',
-    field: 'publicKey',
-    required: true,
-    ifShow: false,
+    field: 'modelNum',
+    label: t('equipment.ledger.modelNumText'),
+    component: 'Input',
+    colProps: { span: 24 },
     componentProps: {
-      rows: 8,
+      maxLength: 20,
     },
   },
   {
-    label: t('deviceManagement.device.clientIdText'),
+    field: 'specifications',
+    label: t('equipment.ledger.specificationsText'),
     component: 'Input',
-    field: 'clientId',
-    ifShow: false,
-    slot: 'clientId',
+    colProps: { span: 24 },
     componentProps: {
-      maxLength: 36,
+      maxLength: 20,
     },
   },
   {
-    label: t('deviceManagement.device.usernameText'),
+    field: 'specifications',
+    label: t('equipment.ledger.manufacturerText'),
     component: 'Input',
-    field: 'username',
-    required: true,
-    ifShow: false,
+    colProps: { span: 24 },
     componentProps: {
-      maxLength: 255,
+      maxLength: 20,
     },
   },
   {
-    label: t('deviceManagement.device.passwordText'),
-    component: 'InputPassword',
-    field: 'password',
+    field: 'buyDate',
+    label: t('equipment.ledger.buyDate'),
+    component: 'DatePicker',
+    colProps: { span: 24 },
     componentProps: {
-      maxLength: 36,
-    },
-    ifShow: false,
-  },
-];
-
-// 管理凭证的表单配置项
-export const TokenSchemas: FormSchema[] = [
-  {
-    label: t('deviceManagement.device.certificateTypeText'),
-    component: 'Select',
-    field: 'credentialType',
-    required: true,
-    componentProps({ formActionType }) {
-      const { updateSchema, setFieldsValue } = formActionType;
-      return {
-        options: [
-          {
-            value: credentialTypeEnum.ACCESS_TOKEN,
-            label: 'Access Token',
-          },
-          {
-            value: credentialTypeEnum.X_509,
-            label: 'X.509',
-          },
-          {
-            value: credentialTypeEnum.MQTT_BASIC,
-            label: 'MQTT Basic',
-          },
-        ],
-        onChange(value) {
-          setFieldsValue({
-            publicKey: '',
-            credentialsId: '',
-            clientId: '',
-            username: '',
-            password: '',
-          });
-          if (value === credentialTypeEnum.ACCESS_TOKEN) {
-            updateSchema([
-              {
-                field: 'credentialsId',
-                ifShow: true,
-              },
-              {
-                field: 'clientId',
-                ifShow: false,
-              },
-              {
-                field: 'username',
-                ifShow: false,
-              },
-              {
-                field: 'password',
-                ifShow: false,
-              },
-              {
-                field: 'publicKey',
-                ifShow: false,
-              },
-            ]);
-          } else if (value === credentialTypeEnum.X_509) {
-            updateSchema([
-              {
-                field: 'publicKey',
-                ifShow: true,
-              },
-              {
-                field: 'credentialsId',
-                ifShow: false,
-              },
-              {
-                field: 'clientId',
-                ifShow: false,
-              },
-              {
-                field: 'username',
-                ifShow: false,
-              },
-              {
-                field: 'password',
-                ifShow: false,
-              },
-            ]);
-          } else if (value === credentialTypeEnum.MQTT_BASIC) {
-            updateSchema([
-              {
-                field: 'clientId',
-                ifShow: true,
-              },
-              {
-                field: 'username',
-                ifShow: true,
-              },
-              {
-                field: 'password',
-                ifShow: true,
-              },
-              {
-                field: 'publicKey',
-                ifShow: false,
-              },
-              {
-                field: 'credentialsId',
-                ifShow: false,
-              },
-            ]);
-          } else {
-            updateSchema([
-              {
-                field: 'clientId',
-                ifShow: false,
-              },
-              {
-                field: 'username',
-                ifShow: false,
-              },
-              {
-                field: 'password',
-                ifShow: false,
-              },
-              {
-                field: 'publicKey',
-                ifShow: false,
-              },
-              {
-                field: 'credentialsId',
-                ifShow: false,
-              },
-            ]);
-          }
-        },
-      };
+      format: 'YYYY-MM-DD hh:mm:ss', // 设置日期格式
+      showTime: true, // 显示时间选择器
     },
   },
-  {
-    label: t('deviceManagement.device.accessTokenText'),
-    component: 'Input',
-    field: 'credentialsId',
-    required: true,
-    ifShow: false,
-    slot: 'credentialsId',
+{
+    field: 'price',
+    label: t('equipment.ledger.priceText'),
+    component: 'InputNumber',
+    colProps: { span: 24 },
     componentProps: {
-      maxLength: 36,
     },
   },
   {
-    label: t('deviceManagement.device.rsaPublicKeyText'),
-    component: 'InputTextArea',
-    field: 'publicKey',
-    required: true,
-    ifShow: false,
+    field: 'productDate',
+    label: t('equipment.ledger.productDate'),
+    component: 'DatePicker',
+    colProps: { span: 24 },
     componentProps: {
-      rows: 8,
+      format: 'YYYY-MM-DD hh:mm:ss', // 设置日期格式
+      showTime: true, // 显示时间选择器
     },
   },
   {
-    label: t('deviceManagement.device.clientIdText'),
-    component: 'Input',
-    field: 'clientId',
-    ifShow: false,
-    slot: 'clientId',
+    field: 'receiveDate',
+    label: t('equipment.ledger.receiveDate'),
+    component: 'DatePicker',
+    colProps: { span: 24 },
     componentProps: {
-      maxLength: 36,
+      format: 'YYYY-MM-DD hh:mm:ss', // 设置日期格式
+      showTime: true, // 显示时间选择器
     },
   },
   {
-    label: t('deviceManagement.device.usernameText'),
-    component: 'Input',
-    field: 'username',
-    required: true,
-    ifShow: false,
+    field: 'registeDate',
+    label: t('equipment.ledger.registeDate'),
+    component: 'DatePicker',
+    colProps: { span: 24 },
     componentProps: {
-      maxLength: 255,
+      format: 'YYYY-MM-DD hh:mm:ss', // 设置日期格式
+      showTime: true, // 显示时间选择器
     },
   },
   {
-    label: t('deviceManagement.device.passwordText'),
-    component: 'InputPassword',
-    field: 'password',
-    ifShow: false,
+    field: 'supplierId',
+    component: 'OrgTreeSelect',
+    label: '供应商',
+    colProps: { span: 24 },
     componentProps: {
-      maxLength: 36,
-    },
-  },
-  {
-    label: 'id',
-    component: 'Input',
-    field: 'id',
-    show: false,
-    componentProps: {
-      maxLength: 36,
-      placeholder: '请输入id',
+      // 添加 change 事件
+      onChange: (value: string) => {
+        // 这里需要触发加载人员数据的逻辑
+        console.log(value,'value')
+      },
     },
   },
   {
-    label: 'tbDeviceId',
-    component: 'Input',
-    field: 'tbDeviceId',
-    show: false,
+    field: 'description',
+    label: t('equipment.ledger.description'),
+    component: 'InputTextArea',
+    colProps: { span: 24 },
     componentProps: {
-      maxLength: 36,
-      placeholder: '请输入tbDeviceId',
-    },
-    dynamicRules: () => {
-      return [
-        {
-          required: false,
-          validator: (_, value) => {
-            if (String(value).length > 36) {
-              return Promise.reject('字数不超过36个字');
-            }
-            return Promise.resolve();
-          },
-        },
-      ];
+      maxLength: 200,
     },
   },
+
 ];

+export enum SchemaFiled {
+  WAY = 'queryMode',
+  TIME_PERIOD = 'timePeriod',
+  KEYS = 'keys',
+  DATE_RANGE = 'dataRange',
+  START_TS = 'startTs',
+  END_TS = 'endTs',
+  INTERVAL = 'interval',
+  LIMIT = 'limit',
+  AGG = 'agg',
+  ORDER_BY = 'orderBy',
+  DATA_TYPE = 'dataType',
+}

-import { formatToDate } from '/@/utils/dateUtil';
 import { BasicColumn } from '/@/components/Table';
 import { FormSchema } from '/@/components/Table';
-import { DeviceRecord } from '/@/api/device/model/deviceModel';
-// import { deviceProfile } from '/@/api/device/deviceManager';
 import { h } from 'vue';
-import { Tag, Tooltip } from 'ant-design-vue';
+import { Tooltip } from 'ant-design-vue';
 import { handeleCopy } from '../../../device/profiles/step/topic';
 import { useI18n } from '/@/hooks/web/useI18n';
-import { DeviceStatusEnum, DeviceTypeEnum } from '/@/enums/deviceEnum';
+import { SbStatusEnum } from '/@/enums/deviceEnum';
 
 const { t } = useI18n();
 import edgefornt from '/@/assets/icons/edgefornt.svg';
@@ -73,16 +70,15 @@ export enum DeviceListAuthEnum {
 export const columns: BasicColumn[] = [
   {
     title: t('business.deviceStatusText'),
-    dataIndex: 'deviceState',
+    dataIndex: 'status',
     width: 110,
     className: 'device-status',
-    slots: { customRender: 'deviceState' },
+    slots: { customRender: 'status' },
   },
   {
-    title: t('business.deviceImageText'),
-    dataIndex: 'deviceInfo.avatar',
-    width: 70,
-    slots: { customRender: 'img' },
+    title: t('business.codeText'),
+    dataIndex: 'code',
+    width: 100,
   },
   {
     dataIndex: 'name',
@@ -142,53 +138,18 @@ export const columns: BasicColumn[] = [
   },
   {
     title: t('business.deviceTypeText'),
-    dataIndex: 'deviceType',
-    width: 130,
-    customRender({ text }) {
-      return h(Tag, { color: 'success' }, () => t(`enum.deviceType.${text}`));
-    },
-  },
-  {
-    title: t('business.affiliatedProductText'),
-    dataIndex: 'deviceProfile.name',
-    width: 180,
-    slots: { customRender: 'deviceProfile' },
-    ellipsis: true,
-  },
-  {
-    title: t('business.affiliatedOrganizationText'),
-    dataIndex: 'organizationDTO.name',
-    width: 100,
-  },
-  // {
-  //   title: '客户',
-  //   dataIndex: 'customerName',
-  //   width: 100,
-  // },
-  {
-    title: t('business.publicText'),
-    dataIndex: 'public',
-    width: 100,
-    customRender({ record }: { record: DeviceRecord }) {
-      const flag = record?.customerAdditionalInfo?.isPublic;
-      return h(Tag, { color: flag ? 'blue' : 'orange' }, () =>
-        flag ? t('business.publicText') : t('business.privateText')
-      );
-    },
+    dataIndex: 'categoryName',
+    width: 120,
   },
   {
-    title: t('deviceManagement.device.lastOnlineTimeText'),
-    dataIndex: 'lastOnlineTime',
-    format: (text) => text && formatToDate(text, 'YYYY-MM-DD HH:mm:ss'),
-    width: 160,
+    title: t('business.directorName'),
+    dataIndex: 'directorName',
+    width: 120,
   },
   {
-    title: t('deviceManagement.device.lastOfflineTimeText'),
-    dataIndex: 'lastOfflineTime',
-    format: (text) => {
-      return text ? formatToDate(text, 'YYYY-MM-DD HH:mm:ss') : '';
-    },
-    width: 160,
+    title: t('business.brandText'),
+    dataIndex: 'brand',
+    width: 120,
   },
 ];
 
@@ -204,24 +165,12 @@ export const searchFormSchema: FormSchema[] = [
     },
   },
   {
-    field: 'deviceType',
-    label: t('equipment.ledger.deviceType'),
-    component: 'Select',
-    componentProps: {
-      options: Object.values(DeviceTypeEnum).map((value) => ({
-        label: t(`enum.deviceType.${value}`),
-        value,
-      })),
-    },
-    colProps: { span: 6 },
-  },
-  {
-    field: 'deviceState',
+    field: 'status',
     label: t('business.deviceStatusText'),
     component: 'Select',
     componentProps: {
-      options: Object.values(DeviceStatusEnum).map((value) => ({
-        label: t(`enum.deviceStatus.${value}`),
+      options: Object.values(SbStatusEnum).map((value) => ({
+        label: t(`enum.sbStatus.${value}`),
         value,
       })),
     },

 <template>
   <div>
     <PageWrapper dense contentFullHeight contentClass="flex">
-      <OrganizationIdTree @select="handleSelect" ref="organizationIdTreeRef" />
+      <OrganizationIdTree @select="handleSelect" ref="organizationIdTreeRef" listType="equipment"/>
       <BasicTable style="flex: auto" @register="registerTable" class="w-5/6 xl:w-4/5 device-table">
         <template #toolbar>
           <Authority :value="DeviceListAuthEnum.CREATE">
-            <a-button type="primary" @click="handleCreate" v-if="authBtn(role)">
+            <a-button type="primary" @click="handleBussinessDrawer('add', null)" v-if="authBtn(role)">
               {{ t('equipment.ledger.createLedgerText') }}
             </a-button>
           </Authority>
-
-          <Authority :value="DeviceListAuthEnum.IMPORT">
-            <Button type="primary" >
-              {{ t('equipment.ledger.importLedgerText') }}
-            </Button>
-          </Authority>
-
-          <Authority
-            :value="[
-              DeviceListAuthEnum.DELETE,
-              DeviceListAuthEnum.ASSIGN,
-              DeviceListAuthEnum.UPDATE_PRODUCT,
-            ]"
-          >
-            <AuthDropDown
-              v-if="authBtn(role)"
-              :disabled="isPublicAndPrivateFlag || !isExistOption"
-              :dropMenuList="[
-                {
-                  text: t('common.delText'),
-                  auth: DeviceListAuthEnum.DELETE,
-                  icon: 'ant-design:delete-outlined',
-                  event: '',
-                  disabled: !batchPrivateFlag,
-                  popconfirm: {
-                    title: t('common.deleteConfirmText'),
-                    onConfirm: () => handleDelete(),
-                  },
-                },
-                {
-                  text: t('equipment.ledger.editProductText'),
-                  auth: DeviceListAuthEnum.UPDATE_PRODUCT,
-                  icon: 'clarity:note-edit-line',
-                  event: '',
-                  disabled: !batchPrivateFlag || batchUpdateProductFlag,
-                  onClick: handelOpenBatchUpdateProductModal,
-                },
-                {
-                  text: t('business.publicText'),
-                  icon: 'ant-design:wallet-outlined',
-                  event: '',
-                  disabled: !batchPrivateFlag,
-                  onClick: handleBatchPublic.bind(null),
-                },
-                {
-                  text: t('business.privateText'),
-                  icon: 'ant-design:wallet-outlined',
-                  event: '',
-                  disabled: batchPrivateFlag,
-                  onClick: handleBatchPrivate.bind(null),
-                },
-                {
-                  text: t('equipment.ledger.updateOrganization'),
-                  icon: 'ant-design:wallet-outlined',
-                  event: '',
-                  disabled: !batchPrivateFlag || batchSensorFlag || diffBatchSensorFlag,
-                  onClick: handleBatchOrg.bind(null),
-                },
-              ]"
-            >
-              <Button type="primary" :disabled="isPublicAndPrivateFlag || !isExistOption">
-                {{ t('equipment.ledger.batchActionText') }}
-              </Button>
-            </AuthDropDown>
-          </Authority>
-        </template>
-        <template #img="{ record }">
-          <TableImg
-            :size="30"
-            :showBadge="false"
-            :simpleShow="true"
-            :imgList="
-              typeof record?.deviceInfo?.avatar !== 'undefined' &&
-              record?.deviceInfo?.avatar !== '' &&
-              record?.deviceInfo?.avatar != null
-                ? [record.deviceInfo.avatar]
-                : null
-            "
-          />
         </template>
-        <template #deviceProfile="{ record }">
-          <Button
-            @click="!isCustomer ? goDeviceProfile(record.deviceProfile.name) : null"
-            type="link"
-          >
-            {{ record.deviceProfile.name }}
-          </Button>
-        </template>
-        <template #deviceState="{ record }">
-          <div v-if="record.isCollect">
-            <div class="absolute top-0 left-0 device-collect"> </div>
-            <Icon
-              icon="ph:star-fill"
-              class="fill-light-50 absolute top-0.5 left-0.5"
-              color="#fff"
-              :size="12"
-            />
-          </div>
-
+        <template #status="{ record }">
           <Tag
             :color="
-              record.deviceState == DeviceState.INACTIVE
+              record.status == SbStatusEnum.SCRAP
                 ? 'warning'
-                : record.deviceState == DeviceState.ONLINE
-                ? 'success'
-                : record.deviceState == DeviceState.ACTIVE
+                : record.status == SbStatusEnum.NORMAL
                 ? 'success'
+                : record.status == SbStatusEnum.FAULT
+                ? 'error'
                 : 'error'
             "
             class="ml-2"
           >
-            {{ t(`enum.deviceStatus.${record.deviceState}`) }}
+            {{ t(`enum.sbStatus.${record.status}`) }}
           </Tag>
         </template>
         <template #action="{ record }">
           <TableAction
             :actions="[
-              {
-                label: AlarmDetailActionButton({ hasAlarm: !!record.alarmStatus }),
-                icon: 'ant-design:eye-outlined',
-                auth: DeviceListAuthEnum.DETAIL,
-                // onClick: handleDetail.bind(null, record),
-              },
-              {
-                label: t('common.editText'),
-                auth: DeviceListAuthEnum.UPDATE,
-                icon: 'clarity:note-edit-line',
-                ifShow: authBtn(role),
-                // onClick: handleEdit.bind(null, record),
-              },
-            ]"
-            :dropDownActions="[
-              // record.customerId
-              //   ? {
-              //       label: t('deviceManagement.device.cancelAssignText'),
-              //       icon: 'mdi:account-arrow-left',
-              //       ifShow: authBtn(role) && !record?.customerAdditionalInfo?.isPublic,
-              //       auth: DeviceListAuthEnum.ASSIGN,
-              //       popConfirm: {
-              //         title: t('deviceManagement.device.cancelAssignConfirmText'),
-              //         confirm: handleCancelDispatchCustomer.bind(null, record),
-              //       },
-              //     }
-              //   : {
-              //       label: t('deviceManagement.device.assignCustomerText'),
-              //       icon: 'mdi:account-arrow-right',
-              //       ifShow: authBtn(role),
-              //       auth: DeviceListAuthEnum.ASSIGN,
-              //       onClick: handleDispatchCustomer.bind(null, record),
-              //     },
-              {
-                label: record?.customerAdditionalInfo?.isPublic
-                  ? t('business.privateText')
-                  : t('business.publicText'),
-                auth: DeviceListAuthEnum.PUBLIC,
-                icon: record?.customerAdditionalInfo?.isPublic
-                  ? 'ant-design:lock-outlined'
-                  : 'ant-design:unlock-outlined',
-                // onClick: handlePublicDevice.bind(null, record),
-              },
-              {
-                label: t('deviceManagement.device.onlineRecordText'),
-                auth: DeviceListAuthEnum.ONLINE,
-                icon: 'ant-design:rise-outlined',
-                // onClick: handleUpAndDownRecord.bind(null, record),
+            {
+              label: t('common.viewText'),
+              icon: 'ant-design:eye-outlined',
+              onClick: handleBussinessDrawer.bind(null, 'view', record),
+            },
+            {
+              label: t('common.editText'),
+              icon: 'clarity:note-edit-line',
+              onClick: handleBussinessDrawer.bind(null, 'edit', record),
+            },
+            {
+              label: t('common.delText'),
+              icon: 'ant-design:delete-outlined',
+              color: 'error',
+              popConfirm: {
+                title: t('common.isDelete'),
+                confirm: handleDelete.bind(null, record),
               },
-              !record.isCollect
-                ? {
-                    label: t('deviceManagement.device.collectText'),
-                    icon: 'ant-design:heart-outlined',
-                    // onClick: handelCollect.bind(null, record),
-                  }
-                : {
-                    label: t('deviceManagement.device.cancelCollectText'),
-                    icon: 'ant-design:heart-outlined',
-                    popConfirm: {
-                      title: t('deviceManagement.device.cancelCollectConfirmText'),
-                      // confirm: handelCollect.bind(null, record),
-                    },
-                  },
-              {
-                label: t('common.delText'),
-                auth: DeviceListAuthEnum.DELETE,
-                icon: 'ant-design:delete-outlined',
-                ifShow: authBtn(role) && record.customerId === undefined,
-                color: 'error',
-                popConfirm: {
-                  title: !!record.isEdge
-                    ? t('common.edgeDeviceOperationConfirm')
-                    : t('common.deleteConfirmText'),
-                  confirm: handleDelete.bind(null, record),
-                },
-              },
-            ]"
-          />
+            },
+          ]"
+          >
+          </TableAction>
         </template>
       </BasicTable>
-<!--      <LedgerDetailDrawer-->
-<!--        @register="registerDetailDrawer"-->
-<!--        @open-tb-device-detail="handleOpenTbDeviceDetail"-->
-<!--        @open-gateway-device-detail="handleOpenGatewayDetail"-->
-<!--      />-->
+      <LedgerDrawer @register="registerDrawer" @success="handleSuccess" @reload="handleSuccess"  />
     </PageWrapper>
   </div>
 </template>
 <script setup lang="ts">
-import {CSSProperties, h, reactive, ref} from "vue";
+import { reactive} from "vue";
 import { PageWrapper } from '/@/components/Page';
+import { LedgerDrawer } from "./components/modal/index"
 const searchInfo = reactive<Recordable>({});
-const { organizationIdTreeRef, resetFn } = useResetOrganizationTree(searchInfo);
-import {BasicTable, TableAction, TableImg, useTable} from "/@/components/Table";
+const { organizationIdTreeRef, resetFn } = useResetOrganizationTree(searchInfo,'equipment');
+import {BasicTable, TableAction, useTable} from "/@/components/Table";
 import {OrganizationIdTree, useResetOrganizationTree} from "/@/views/common/organizationIdTree";
-import {
-  deleteDevice,
-  devicePage,
-  doBatchPrivateDevice,
-  doBatchPublicDevice
-} from "/@/api/device/deviceManager";
+import { getLedgerList, deleteLedger } from "/@/api/equipment/ledger"
 import {
   columns,
   DeviceListAuthEnum,
   searchFormSchema
 } from "/@/views/equipment/ledger/config/ledger.data";
-import {DeviceModel, DeviceRecord, DeviceState} from "/@/api/device/model/deviceModel";
+import { SbStatusEnum } from '/@/enums/deviceEnum';
+
 import {useI18n} from "/@/hooks/web/useI18n";
 import {authBtn} from "/@/enums/roleEnum";
-import {Badge, Button, Tag} from "ant-design-vue";
+import {Button, Tag} from "ant-design-vue";
 import {Authority} from "/@/components/Authority";
-import {AuthDropDown} from "/@/components/Widget";
 import {getAuthCache} from "/@/utils/auth";
 import {USER_INFO_KEY} from "/@/enums/cacheEnum";
-import {useBatchOperation} from "/@/utils/useBatchOperation";
 import {useMessage} from "/@/hooks/web/useMessage";
-import {DataActionModeEnum} from "/@/enums/toolEnum";
-import {
-  BatchUpdateProductModalParamsType
-} from "/@/views/device/list/cpns/modal/BatchUpdateProductModal/index";
-import {useModal} from "/@/components/Modal";
-import Icon from "/@/components/Icon";
-// import LedgerDetailDrawer from "./cpns/modal/LedgerDetailDrawer.vue";
+
+import {useDrawer} from "/@/components/Drawer";
+
+// 业务弹窗
+const [registerDrawer, { openDrawer }] = useDrawer();
 const { t } = useI18n();
 const userInfo: any = getAuthCache(USER_INFO_KEY);
 const role: string = userInfo.roles[0];
-const isPublicAndPrivateFlag = ref(false);
-const batchPrivateFlag = ref(true);
-const batchUpdateProductFlag = ref(true);
-const batchSensorFlag = ref(false);
-const { createMessage } = useMessage();
-const diffBatchSensorFlag = ref(false);
-const [registerOrgModal, { openModal: openOrgodal }] = useModal();
-const [registerBatchUpdateProductModal, { openModal: openBatchUpdateProductModal }] = useModal();
 
-const AlarmDetailActionButton = ({ hasAlarm }: { hasAlarm?: boolean }) =>
-  h(
-    Badge,
-    { offset: [0, -5] },
-    {
-      default: () => h('span', { style: { color: '#377dff' } }, t('common.detailText')),
-      count: () =>
-        h(
-          'div',
-          {
-            style: {
-              visibility: hasAlarm ? 'visible' : 'hidden',
-              width: '14px',
-              height: '14px',
-              display: 'flex',
-              justifyContent: 'center',
-              alignItems: 'center',
-              border: '1px solid #f46161',
-              borderRadius: '50%',
-            } as CSSProperties,
-          },
-          h(Icon, { icon: 'mdi:bell-warning', color: '#f46161', size: 12 })
-        ),
-    }
-  );
+const { createMessage } = useMessage();
 
 const [
   registerTable,
@@ -295,13 +99,13 @@ const [
     setSelectedRowKeys,
     getForm,
     getSelectRowKeys,
-    getSelectRows,
+    setProps,
     getRowSelection,
     clearSelectedRowKeys,
   },
 ] = useTable({
   title: t('equipment.ledger.ledgerListText'),
-  api: devicePage,
+  api: getLedgerList,
   columns,
   beforeFetch: (params) => {
     const { deviceProfileId } = params;
@@ -327,7 +131,7 @@ const [
   rowKey: 'id',
   searchInfo: searchInfo,
   clickToRowSelect: false,
-  rowClassName: (record) => ((record as DeviceRecord).alarmStatus ? 'device-alarm-badge' : ''),
+  rowClassName: (record) => ((record as any).alarmStatus ? 'device-alarm-badge' : ''),
   actionColumn: {
     width: 200,
     title: t('common.actionText'),
@@ -336,126 +140,27 @@ const [
   },
   rowSelection: {
     type: 'checkbox',
-    getCheckboxProps: (record: DeviceModel) => {
-      return { disabled: !!record.customerId && record.customerName !== 'Public' };
-    },
-    onSelect(_record, _selected, selectedRows) {
-      const [firstItem] = selectedRows as DeviceRecord[];
-      const { deviceType } = firstItem || {};
-      batchUpdateProductFlag.value =
-        !selectedRows.length ||
-        !selectedRows.every((item) => (item as DeviceRecord).deviceType === deviceType);
-
-      batchPrivateFlag.value = selectedRows.some((item: DeviceRecord) => !item?.customerId);
-      const filterSensor = selectedRows.map((filterItem: DeviceRecord) => filterItem.deviceType);
-      batchSensorFlag.value =
-        filterSensor.includes('SENSOR') &&
-        (filterSensor.includes('DIRECT_CONNECTION') || filterSensor.includes('GATEWAY')); // 网关子和直连设备或者网关设备，则禁用组织修改
-      const filterGatewayId = selectedRows
-        .filter((filterItem: DeviceRecord) => filterItem.deviceType === 'SENSOR')
-        .map((mapItem: DeviceRecord) => mapItem.gatewayId);
-      diffBatchSensorFlag.value = [...new Set(filterGatewayId)].length > 1; // 数组长度大于1，说明选择的网关子设备所属网关为多个，则禁用组织修改
-      isPublicAndPrivateFlag.value =
-        selectedRows.some((item: DeviceRecord) => !item?.customerId) &&
-        selectedRows.some((item: DeviceRecord) => item?.customerAdditionalInfo?.isPublic);
-    },
-    onSelectAll(_selected, selectedRows) {
-      const [firstItem] = selectedRows as DeviceRecord[];
-      const { deviceType } = firstItem || {};
-      batchUpdateProductFlag.value =
-        !selectedRows.length ||
-        !selectedRows.every((item) => (item as DeviceRecord).deviceType === deviceType);
-
-      batchPrivateFlag.value = selectedRows.some((item) => !item?.customerId);
-      const filterSensor = selectedRows.map((filterItem) => filterItem.deviceType);
-      batchSensorFlag.value =
-        filterSensor.includes('SENSOR') &&
-        (filterSensor.includes('DIRECT_CONNECTION') || filterSensor.includes('GATEWAY')); // 网关子和直连设备或者网关设备，则禁用组织修改
-      const filterGatewayId = selectedRows
-        .filter((filterItem: DeviceRecord) => filterItem.deviceType === 'SENSOR')
-        .map((mapItem: DeviceRecord) => mapItem.gatewayId);
-      diffBatchSensorFlag.value = [...new Set(filterGatewayId)].length > 1; // 数组长度大于1，说明选择的网关子设备所属网关为多个，则禁用组织修改
-      isPublicAndPrivateFlag.value =
-        selectedRows.some((item) => !item?.customerId) &&
-        selectedRows.some((item) => item?.customerAdditionalInfo?.isPublic);
-    },
+    getCheckboxProps: (record: any) => {},
   },
 });
 
-const { isExistOption } = useBatchOperation(getRowSelection, setSelectedRowKeys);
-function handleCreate() {
-  // openModal(true, {
-  //   isUpdate: false,
-  // });
-}
 
-// 批量公开设备
-const handleBatchPublic = async () => {
-  setLoading(true);
-  try {
-    const options = getSelectRows();
-    const tbDeviceIdJoinStr = options.map((item) => item.tbDeviceId).join(',');
-    const res = await doBatchPublicDevice(tbDeviceIdJoinStr);
-    createMessage.success(
-      res === '公开成功' ? t('common.publicSuccess') : t('common.publicError')
-    );
-  } finally {
-    handleReload();
-    setLoading(false);
-  }
+// 业务弹窗
+const handleBussinessDrawer = (text, record) => {
+  const modalParams = {
+    text,
+    record,
+  };
+  openDrawer(true, modalParams);
 };
 
-function handleReload() {
-  setSelectedRowKeys([]);
-  handleSuccess();
-}
 
-// 批量私有设备
-const handleBatchPrivate = async () => {
-  setLoading(true);
-  try {
-    const options = getSelectRows();
-    const tbDeviceIdJoinStr = options.map((item) => item.tbDeviceId).join(',');
-    const res = await doBatchPrivateDevice(tbDeviceIdJoinStr);
-    createMessage.success(
-      res === '私有成功' ? t('common.privateSuccess') : t('common.privateError')
-    );
-  } finally {
-    handleReload();
-    setLoading(false);
-  }
-};
+const handleDelete = async (record?: any) => {
+  let _id: string = record.id;
 
-const handleBatchOrg = () => {
-  const options = getSelectRows();
-  openOrgodal(true, options);
-};
-
-const handelOpenBatchUpdateProductModal = () => {
-  const rows: DeviceRecord[] = getSelectRows();
-  const [firstItem] = rows;
-
-  openBatchUpdateProductModal(true, {
-    mode: DataActionModeEnum.UPDATE,
-    record: {
-      sourceDeviceProfileName: firstItem.deviceProfile.name,
-      deviceType: firstItem.deviceType,
-      deviceIds: rows.map((item) => item.tbDeviceId),
-      deviceProfile: firstItem.deviceProfile,
-    },
-  } as BatchUpdateProductModalParamsType);
-};
-
-const handleDelete = async (record?: DeviceRecord) => {
-  let ids: string[] = [];
-  if (record) {
-    ids.push(record.id);
-  } else {
-    ids = getSelectRowKeys();
-  }
   try {
     setLoading(true);
-    await deleteDevice(ids);
+    await deleteLedger({id: _id});
     createMessage.success(t('common.deleteSuccessText'));
     handleReload();
   } catch (error) {
@@ -465,12 +170,19 @@ const handleDelete = async (record?: DeviceRecord) => {
   }
 };
 
+
+function handleReload() {
+  setSelectedRowKeys([]);
+  handleSuccess();
+}
+
+
 function handleSuccess() {
   reload();
 }
 
 function handleSelect(organization) {
-  searchInfo.organizationId = organization;
+  searchInfo.categoryId = organization;
   handleSuccess();
 }