From f7402f582260e475bffbf85ed4acf49a21dec208 Mon Sep 17 00:00:00 2001
From: zhoux <zhouxia@supervision.ltd>
Date: Mon, 18 Dec 2023 11:34:28 +0800
Subject: [PATCH] =?UTF-8?q?feat:=20=E8=B5=84=E6=BA=90=E7=AE=A1=E7=90=86?=
 =?UTF-8?q?=E8=AE=BE=E5=A4=87=E7=8A=B6=E6=80=81=E9=9D=99=E6=80=81=E5=AE=8C?=
 =?UTF-8?q?=E6=88=90=EF=BC=8Cfabric=E7=9B=91=E6=8E=A7=E4=BF=A1=E6=81=AF?=
 =?UTF-8?q?=E5=B1=95=E7=A4=BA=E5=88=9D=E5=A7=8B=E5=8C=96?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 config/routes.ts                              |   15 +
 src/enums/status.ts                           |  100 +-
 src/global.css                                |    9 +-
 src/global.less                               |    9 +-
 src/pages/DCSDevice/DeviceStatus/index.tsx    |   62 +-
 .../Room/components/ColumnDrawer.tsx          |  167 ++
 src/pages/FabricView/Room/index.tsx           |  204 ++
 .../components/DeviceStatusCard.tsx           |  158 ++
 .../Resource/ResourceDeviceStatus/index.tsx   |  181 ++
 src/testData/fabricGroupRoom.ts               | 1644 +++++++++++++++
 src/testData/fabricRoomList.ts                |  147 ++
 src/testData/fabricRoomSvg.ts                 |   49 +
 src/testData/fabricWatchIcons.ts              | 1825 +++++++++++++++++
 13 files changed, 4503 insertions(+), 67 deletions(-)
 create mode 100644 src/pages/FabricView/Room/components/ColumnDrawer.tsx
 create mode 100644 src/pages/FabricView/Room/index.tsx
 create mode 100644 src/pages/Resource/ResourceDeviceStatus/components/DeviceStatusCard.tsx
 create mode 100644 src/pages/Resource/ResourceDeviceStatus/index.tsx
 create mode 100644 src/testData/fabricGroupRoom.ts
 create mode 100644 src/testData/fabricRoomList.ts
 create mode 100644 src/testData/fabricRoomSvg.ts
 create mode 100644 src/testData/fabricWatchIcons.ts

diff --git a/config/routes.ts b/config/routes.ts
index 5852a18..2f4c003 100644
--- a/config/routes.ts
+++ b/config/routes.ts
@@ -185,6 +185,11 @@ export default [
       'path': '/resource/model-version-list',
       'component': 'Resource/ModelVersionList',
       'access': 'canReadMenu'
+    },{
+      'name': 'resource-device-status', // 2
+      'path': '/resource/resource-device-status',
+      'component': 'Resource/ResourceDeviceStatus',
+      'access': 'canReadMenu'
     }]
   },
   {
@@ -259,4 +264,14 @@ export default [
     layout: false,
     component: './404',
   },
+  {
+    name: 'fabricView',
+    path: '/fabricView',
+    routes: [{
+      'name': 'fabricView-room',
+      'path': '/fabricView/room',
+      'component': 'FabricView/Room',
+      'access': 'canReadMenu'
+    }]
+  },
 ];
diff --git a/src/enums/status.ts b/src/enums/status.ts
index 2b9e423..af51370 100644
--- a/src/enums/status.ts
+++ b/src/enums/status.ts
@@ -1,30 +1,72 @@
+export const deviceStatusEnums: Record<string, any> = {
+  allStatus: {
+    miniName: '全部',
+    value: '0',
+    color: '',
+  },
+  onlineStatus: {
+    miniName: '在线',
+    value: '1',
+    color: 'success',
+  },
+  outlineStatus: {
+    miniName: '离线',
+    value: '2',
+    color: 'default',
+  },
+  processingStatus: {
+    miniName: '运行中',
+    value: '3',
+    color: 'warning',
+  },
+  errorStatus: {
+    miniName: '故障',
+    value: '4',
+    color: 'error',
+  },
+};
 
-
-
-export const deviceStatusEnums : Record<string,any> = {
-    'allStatus': {
-        miniName: '全部',
-        value: '0',
-        color: ''
-    },
-    'onlineStatus': {
-        miniName: '在线',
-        value: '1',
-        color: 'success'
-    },
-    'outlineStatus': {
-        miniName: '离线',
-        value: '2',
-        color: 'default'
-    },
-    'processingStatus': {
-        miniName: '运行中',
-        value: '3',
-        color: 'warning'
-    },
-    'errorStatus': {
-        miniName: '故障',
-        value: '4',
-        color: 'error'
-    }
-}
\ No newline at end of file
+export const resourceDeviceStatusEnums: Record<string, any> = {
+  allStatus: {
+    miniName: '全部异常',
+    value: '0',
+    color: '',
+    renderType: '',
+  },
+  storageWarn: {
+    miniName: '存储告警',
+    value: '1',
+    color: 'error',
+    renderType: 'progress',
+  },
+  GPUWarn: {
+    miniName: 'GPU告警',
+    value: '2',
+    color: 'success',
+    renderType: 'progress',
+  },
+  memoryWarn: {
+    miniName: '内存告警',
+    value: '3',
+    color: 'success',
+    renderType: 'progress',
+  },
+  errorStatus: {
+    miniName: 'CPU告警',
+    value: '4',
+    color: 'warning',
+    renderType: 'progress',
+  },
+  codeError: {
+    miniName: '代码出错',
+    value: '5',
+    color: 'error',
+    renderType: 'dot',
+  },
+  serveTimeOut: {
+    miniName: '服务器超时',
+    value: '6',
+    color: 'error',
+    renderType: 'dot',
+  },
+};
diff --git a/src/global.css b/src/global.css
index ece78f6..b0bcb37 100644
--- a/src/global.css
+++ b/src/global.css
@@ -116,6 +116,8 @@ a.ant-dropdown-trigger {
 .ant-menu-light .ant-menu-item-selected,
 .ant-menu-light > .ant-menu .ant-menu-item-selected {
   background-color: #e8effb;
+  border-left: 3px solid #155BD4;
+  border-radius: 0;
 }
 .ant-select-dropdown .ant-select-item-option-active:not(.ant-select-item-option-disabled) {
   background-color: #e8effb;
@@ -131,6 +133,9 @@ a.ant-dropdown-trigger {
 .ant-steps .ant-steps-item-active > .ant-steps-item-container > .ant-steps-item-content > .ant-steps-item-description {
   color: #155BD4;
 }
+.ant-layout-sider-children {
+  background-color: white;
+}
 .ant-btn-link.ant-btn-dangerous,
 .ant-btn-default.ant-btn-dangerous {
   color: #E80D0D;
@@ -174,7 +179,7 @@ a.ant-dropdown-trigger {
   border-radius: 8px;
 }
 .ant-pro-list .ant-pro-table-list-toolbar-left {
-  flex: 0.8;
+  flex: 1;
 }
 .ant-popover .ant-popover-content {
   min-width: 200px;
@@ -295,7 +300,7 @@ a.ant-dropdown-trigger {
 }
 .gn .proListActionBox .ant-btn.ant-btn-sm {
   padding: 0;
-  font-size: 12px;
+  font-size: 14px;
 }
 .gn.fw7 {
   font-weight: 700;
diff --git a/src/global.less b/src/global.less
index 269f86e..f4313b2 100644
--- a/src/global.less
+++ b/src/global.less
@@ -142,6 +142,8 @@ a.ant-dropdown-trigger{
 
 .ant-menu-light .ant-menu-item-selected, .ant-menu-light>.ant-menu .ant-menu-item-selected {
   background-color: #e8effb;
+  border-left: 3px solid #155BD4;
+  border-radius: 0;
 }
 
 .ant-select-dropdown .ant-select-item-option-active:not(.ant-select-item-option-disabled) {
@@ -163,6 +165,9 @@ a.ant-dropdown-trigger{
 
   }
 }
+.ant-layout-sider-children{
+  background-color: white;
+}
 
 .ant-btn-link.ant-btn-dangerous, .ant-btn-default.ant-btn-dangerous {
   color: #E80D0D;
@@ -226,7 +231,7 @@ a.ant-dropdown-trigger{
   }
 
   .ant-pro-table-list-toolbar-left{
-    flex: 0.8
+    flex: 1
   }
 
 }
@@ -363,7 +368,7 @@ a.ant-dropdown-trigger{
   .proListActionBox{
     .ant-btn.ant-btn-sm{
       padding: 0;
-      font-size: 12px;
+      font-size: 14px;
     }
   }
   
diff --git a/src/pages/DCSDevice/DeviceStatus/index.tsx b/src/pages/DCSDevice/DeviceStatus/index.tsx
index 746b398..64d3c13 100644
--- a/src/pages/DCSDevice/DeviceStatus/index.tsx
+++ b/src/pages/DCSDevice/DeviceStatus/index.tsx
@@ -1,11 +1,3 @@
-/*
- * @Author: zhoux zhouxia@supervision.ltd
- * @Date: 2023-12-08 10:11:54
- * @LastEditors: zhoux zhouxia@supervision.ltd
- * @LastEditTime: 2023-12-11 17:15:39
- * @FilePath: \general-ai-platform-web\src\pages\DCSDevice\DeviceStatus\index.tsx
- * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
- */
 import TableActionCard from '@/components/TableActionCard';
 import IsConfirmAction from '@/components/TableActionCard/isConfirmAction';
 import { deviceStatusEnums } from '@/enums/status';
@@ -19,9 +11,9 @@ import DeviceStatusCard from './components/DeviceStatusCard';
 
 /**
  * @交互说明
- * 1、列表选择栏位
- * 2、卡片比照UI效果图
- * 3、详情弹框
+ * 1、列表分页展示分布式设备状态（分类查询）
+ * 2、详情展示基础信息、日志
+ * 3、重启设备
  */
 const tabOptions: Record<string, any> = {
   allStatus: 90,
@@ -76,24 +68,34 @@ const DeviceStatus: React.FC = () => {
     }
     return {
       content: (
-        <ProCard          className="gn"
-         style={{ backgroundColor: '#FAFAFA', margin: 0, padding: 0  }} bodyStyle={{ margin: 0, padding: 0 }}>
+        <ProCard
+          className="gn"
+          style={{ backgroundColor: '#FAFAFA', margin: 0, padding: 0 }}
+          bodyStyle={{ margin: 0, padding: 0 }}
+        >
           <div
             style={{
               display: 'flex',
               alignItems: 'center',
               padding: 12,
               justifyContent: 'space-between',
-              borderBottom: '1px solid rgba(224, 224, 224, 1)'
+              borderBottom: '1px solid rgba(224, 224, 224, 1)',
             }}
           >
-            <div style={{
-              display: 'flex',
-              alignItems: 'center',
-              maxWidth: '60%'
-            }}>
+            <div
+              style={{
+                display: 'flex',
+                alignItems: 'center',
+                maxWidth: '60%',
+              }}
+            >
               <Tag color={currColor}>{record.status}</Tag>
-              <p  className='gn single_line text_1 fw7' style={{maxWidth: '80%', padding: 0, margin: 0}}>控制设备控制设备{index + 1}</p>
+              <p
+                className="gn single_line text_1 fw7"
+                style={{ maxWidth: '80%', padding: 0, margin: 0 }}
+              >
+                控制设备控制设备{index + 1}
+              </p>
             </div>
             <TableActionCard
               key="TableActionCardRef"
@@ -137,8 +139,6 @@ const DeviceStatus: React.FC = () => {
                       onClick={() => {
                         handleDetailModal();
                         setCurrentRow(record);
-                        // doToDetail(record);
-                        // setShowDetail(true);
                       }}
                     >
                       <FormattedMessage id="pages.searchTable.detail" defaultMessage="Update" />
@@ -153,14 +153,7 @@ const DeviceStatus: React.FC = () => {
       ),
     };
   });
-  
-  const columns: ProColumns<Record<string, any>>[] = [
-    {
-      title: '123',
-      dataIndex: 'status',
-      // hideInSearch: true,
-    },
-  ];
+
   return (
     <PageContainer>
       <ProList<any>
@@ -190,7 +183,7 @@ const DeviceStatus: React.FC = () => {
                     {Object.keys(deviceStatusEnums).includes(item)
                       ? deviceStatusEnums[item].miniName
                       : ''}
-                    （{tabOptions[item]}）
+                  {"("+tabOptions[item]+ ')'}
                   </Button>
                 );
               })}
@@ -201,8 +194,8 @@ const DeviceStatus: React.FC = () => {
           bodyStyle: {
             background: 'white',
             padding: '8px 16px 16px',
-            borderRadius: 8
-          }
+            borderRadius: 8,
+          },
         }}
         pagination={{
           ...proTablePaginationOptions,
@@ -211,9 +204,10 @@ const DeviceStatus: React.FC = () => {
         }}
         showActions="hover"
         rowSelection={false}
-        grid={{ gutter: 16, xs: 1, md: 2, lg: 3, xl: 4, xxl: 4 }}
+        grid={{ gutter: 16, xs: 1, md: 2, lg: 2, xl: 3, xxl: 4 }}
         metas={{
           type: {
+            // 不展示在筛选项
             hideInSearch: true,
           },
           content: {
diff --git a/src/pages/FabricView/Room/components/ColumnDrawer.tsx b/src/pages/FabricView/Room/components/ColumnDrawer.tsx
new file mode 100644
index 0000000..5b4187f
--- /dev/null
+++ b/src/pages/FabricView/Room/components/ColumnDrawer.tsx
@@ -0,0 +1,167 @@
+/*
+ * @Author: zhoux zhouxia@supervision.ltd
+ * @Date: 2023-11-01 13:56:33
+ * @LastEditors: zhoux zhouxia@supervision.ltd
+ * @LastEditTime: 2023-12-15 16:58:50
+ * @FilePath: \general-ai-platform-web\src\pages\Resource\ModelCategoryList\components\ColumnDrawer.tsx
+ * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+ */
+import { CloseOutlined } from '@ant-design/icons';
+import { ProColumns, ProDescriptions, ProDescriptionsItemProps } from '@ant-design/pro-components';
+import React, { useEffect, useState } from 'react';
+
+export type ColumnDrawProps = {
+  handleDrawer: (id?: any) => void;
+  isShowDetail: boolean;
+  columns: ProColumns<API.ModelCategory>[];
+  currentRow: Record<string, any>;
+  clipPathData: Record<string, any>;
+};
+
+const ColumnDrawer: React.FC<ColumnDrawProps> = (props) => {
+  const [positionStyle, setPositionStyle] = useState<React.CSSProperties>({});
+  // 生成模型详情卡片位置
+  function initPointPosition() {
+    type Point = { x: number; y: number };
+    type Position = 'left' | 'right' | 'top' | 'bottom';
+    let currPositionStyle: React.CSSProperties = {};
+    const modelInfoPosition: Position[] = ['right'];
+    const maxX = props.clipPathData?.width; // 画布宽度
+    const maxY = props.clipPathData?.height; // 画布高度
+    const x = props.currentRow.baseInfo?.left; // 模型x轴位置
+    const y = props.currentRow.baseInfo?.top; // 模型y轴位置
+    const modelWidth: number = 120; // 模型自身宽度
+    const modelHeight: number = 54; // 模型自身高度
+    const modelInfoWidth: number = 400; // 模型信息卡片宽度
+    const modelInfoHeight: number = 240; // 模型信息卡片高度
+    // if (x < 0 || x > maxX || y < 0 || y > maxY) {
+    //   // 模型超过范围
+    // }
+    if (x > maxX / 2) {
+      modelInfoPosition.push('left');
+      // if (x < maxX / 2) {
+      //     modelInfoPosition.push('left');
+      //   } else {
+      //     modelInfoPosition.push('right');
+      //   }
+    } else {
+      modelInfoPosition.push('right');
+      //   if (y < maxY / 2) {
+      //     modelInfoPosition.push('top');
+      //   } else {
+      //     modelInfoPosition.push('bottom');
+      //   }
+    }
+    console.log(props.currentRow, 'currentRow');
+    if (modelInfoPosition.includes('left')) {
+      let topValue = y - modelInfoHeight / 2 + modelHeight / 2
+      if(topValue> maxY - modelInfoHeight){
+        topValue = maxY - modelInfoHeight
+      }
+      if(topValue<0){
+        topValue = 0
+      }
+      currPositionStyle = {
+        top: topValue,
+        left: x - modelInfoWidth - 10,
+      };
+    } else {
+      let topValue = y - modelInfoHeight / 2 + modelHeight / 2
+      if(topValue> maxY - modelInfoHeight){
+        topValue = maxY - modelInfoHeight
+      }
+      if(topValue<0){
+        topValue = 0
+      }
+      currPositionStyle = {
+        top: topValue,
+        left: x + modelWidth + 10,
+      };
+    }
+    setPositionStyle(currPositionStyle);
+  }
+
+  useEffect(() => {
+    if (props.currentRow) {
+      initPointPosition();
+    }
+  }, [props.currentRow, props.clipPathData]);
+  return props.isShowDetail ? (
+    <div
+      style={{
+        position: 'absolute',
+        background: '#fff',
+        borderRadius: 4,
+        width: 400,
+        boxShadow: '0px 8px 12px rgba(0, 0, 0, 0.25)',
+        border: '1px solid #eee',
+        ...positionStyle,
+      }}
+    >
+      <div
+        style={{
+          display: 'flex',
+          justifyContent: 'space-between',
+          padding: '16px 24px',
+          borderBottom: '1px solid #eee',
+          color: '#1E1E1E',
+          fontSize: 20,
+          fontWeight: 700,
+          marginBottom: 16,
+        }}
+      >
+        <span>设备信息</span>
+        <CloseOutlined onClick={() => props.handleDrawer()} />
+      </div>
+      <ProDescriptions
+        style={{
+          padding: '0 24px',
+        }}
+        column={2}
+        dataSource={props.currentRow || {}}
+        columns={props.columns as ProDescriptionsItemProps<API.ModelCategory>[]}
+      ></ProDescriptions>
+    </div>
+  ) : (
+    <></>
+  );
+
+  // <Modal
+  //   title="设备信息"
+  //   mask={false}
+
+  //   open={props.isShowDetail}
+  //   width={500}
+  //   footer={null}
+  //   onCancel={() => props.handleDrawer()}
+  // >
+
+  // </Modal>
+  // <Drawer
+  //   width={500}
+  //   open={props.isShowDetail}
+  //   onClose={() => {
+  //     props.handleDrawer();
+  //   }}
+  //   closable={true}
+  // >
+  //   {props.currentRow?.id && (
+  //     <ProDescriptions<API.ModelCategory>
+  //       style={{
+  //         // paddingLeft: 4,
+  //         // paddingRight: 4
+  //       }}
+  //       column={2}
+  //       title={props.currentRow?.id}
+  //       request={async () => ({
+  //         data: props.currentRow || {},
+  //       })}
+  //       params={{
+  //         id: props.currentRow?.id,
+  //       }}
+  //       columns={props.columns as ProDescriptionsItemProps<API.ModelCategory>[]}
+  //     />
+  //   )}
+  // </Drawer>
+};
+export { ColumnDrawer };
diff --git a/src/pages/FabricView/Room/index.tsx b/src/pages/FabricView/Room/index.tsx
new file mode 100644
index 0000000..a8035df
--- /dev/null
+++ b/src/pages/FabricView/Room/index.tsx
@@ -0,0 +1,204 @@
+/*
+ * @Author: zhoux zhouxia@supervision.ltd
+ * @Date: 2023-12-12 10:57:54
+ * @LastEditors: zhoux zhouxia@supervision.ltd
+ * @LastEditTime: 2023-12-15 17:06:36
+ * @FilePath: \general-ai-platform-web\src\pages\FabricView\Room\index.tsx
+ * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+ */
+
+// import { useUuid } from '@/hooks/useUuid';
+import { currJson } from '@/testData/fabricRoomList';
+import { bgImageData } from '@/testData/fabricRoomSvg';
+import { ProCard } from '@ant-design/pro-components';
+import { useIntl } from '@umijs/max';
+import { Button } from 'antd';
+import { fabric } from 'fabric';
+import React, { useEffect, useRef, useState } from 'react';
+import { ColumnDrawer } from './components/ColumnDrawer';
+
+export const ModelCategoryColumns = [
+  {
+    title: '设备ID',
+    dataIndex: 'id',
+  },
+  {
+    title: '设备名称',
+    dataIndex: 'deviceName',
+  },
+  {
+    title: '设备代码',
+    dataIndex: 'deviceCode',
+  },
+  {
+    title: '设备位置',
+    dataIndex: 'deviceLocation',
+  },
+  {
+    title: '设备代码',
+    dataIndex: 'deviceCode',
+  },
+  {
+    title: '设备名称',
+    dataIndex: 'deviceName',
+  },
+  {
+    title: '设备代码',
+    dataIndex: 'deviceCode',
+  },
+  {
+    title: '设备名称',
+    dataIndex: 'deviceName',
+  },
+];
+const FabricViewRoom: React.FC = () => {
+  const intl = useIntl();
+  const canvasRef = useRef(null);
+  const itemsRef = useRef(null);
+  const [cvs, setCanvas] = useState(null);
+  const [descriptors, setDescriptors] = useState<Record<string, any>>({});
+  const [category_fk_id_open, set_category_fk_id_open] = useState(false);
+  const [currentModelUserProperty, setCurrentModelUserProperty] = useState<Record<string, any>>({});
+
+  const [changeId, setChangeId] = useState<string[]>([]);
+  const [currentTargetObject, setCurrentTargetObject] = useState<any>(null);
+
+  const [clipPathData, setClipPathData] = useState({
+    width: 1200, // 宽
+    height: 900, // 高
+  });
+  const [jsonData, setJsonData] = useState<Record<string, any>>({});
+
+  /*test */
+  // const { fetchUuid } = useUuid();
+
+  function changeModelStatus() {
+    setChangeId(['2', '3']);
+  }
+
+  const handle_category_fk_id = () => {
+    if (category_fk_id_open) {
+      set_category_fk_id_open(false);
+    }
+  };
+
+  function closeSelectedModel(targetCvs?: any) {
+    let finalCvs = cvs;
+    if (targetCvs) {
+      finalCvs = targetCvs;
+    }
+    finalCvs.getObjects().forEach((item) => {
+      // if (changeId.includes(item?.userProperty?.id)) {
+      const groupObject = item;
+      // 选中组合对象
+      // canvasObject.setActiveObject(groupObject); // 可以改变 selectable 值
+      finalCvs.requestRenderAll();
+      // 获取组合对象中的子对象
+      const objectsInGroup = groupObject.getObjects();
+      groupObject.item(0).item(1).set({
+        fill: '#DCDCDC',
+      });
+      groupObject.item(1).set({
+        fill: 'rgb(0,0,0)',
+      })
+      finalCvs.renderAll();
+      // 遍历子对象找到要修改的子对象
+
+      // }
+    });
+  }
+  // 初始化加载画布&渲染模型
+  useEffect(() => {
+    const canvasObject = new fabric.Canvas(canvasRef.current);
+    canvasObject.setBackgroundImage(bgImageData.src, canvasObject.renderAll.bind(canvasObject), {
+      width: clipPathData.width,
+      height: clipPathData.height,
+      originX: 'left',
+      originY: 'top',
+    });
+    canvasObject.loadFromJSON(JSON.stringify(currJson), () => {
+      canvasObject.renderAll();
+      // const groupObjectList = canvasObject.getObjects()
+
+      // const groupObject = canvasObject.getObjects()[0];
+
+      // 选中组合对象
+      // console.log(groupObject, 'groupObject', canvasObject.getObjects());
+      // 注册事件监听器
+      canvasObject.on('mouse:down', (event) => {
+        // 获取事件的目标对象
+        const targetObject = event.target;
+        // set_category_fk_id_open(false);
+
+        // 检查目标对象是否为组合对象
+        if (targetObject && targetObject?.userProperty) {
+          // canvasObject.setActiveObject(targetObject);
+          setChangeId([targetObject?.userProperty?.id]);
+          // console.log('mouse:up:', targetObject);
+          setCurrentModelUserProperty(targetObject.userProperty);
+          set_category_fk_id_open(true);
+        }
+        // 检查目标对象是否为组合对象
+        if (targetObject) {
+          setCurrentTargetObject(targetObject);
+          closeSelectedModel(canvasObject);
+
+          // console.log('mouse:down:', );
+          targetObject.item(0).item(1).set({
+            fill: 'blue',
+          });
+          targetObject.item(1).set({
+            fill: 'blue',
+          })
+        }
+        canvasObject.renderAll();
+      });
+    });
+    setCanvas(canvasObject);
+    return () => {
+      canvasObject.dispose();
+    };
+  }, []);
+
+  useEffect(() => {
+    // TODO_3 需要加个loading效果
+    // import('./Descriptors.json').then((descriptors) => {
+    //   setDescriptors(descriptors);
+    // });
+    // console.log(fetchUuid(), 'fetchUuid');
+    if (changeId && changeId.length && !category_fk_id_open) {
+      closeSelectedModel();
+    }
+  }, [changeId, category_fk_id_open]);
+
+  return (
+    <ProCard
+      gutter={24}
+      extra={
+        <>
+          <Button type="primary" onClick={changeModelStatus}>
+            切换状态
+          </Button>
+        </>
+      }
+    >
+      {/* <ProCard colSpan={4}>
+        <ImageMapItems ref={itemsRef} canvasRef={canvasRef} descriptors={descriptors} />
+      </ProCard> */}
+      <ProCard colSpan={24} style={{ padding: 0, margin: 0 }} bodyStyle={{ padding: 0, margin: 0 }}>
+        <canvas ref={canvasRef} {...clipPathData} style={{ border: '1px dashed #eee' }}></canvas>
+
+        <ColumnDrawer
+          handleDrawer={handle_category_fk_id}
+          isShowDetail={category_fk_id_open}
+          columns={ModelCategoryColumns}
+          currentRow={currentModelUserProperty}
+          clipPathData={clipPathData}
+        />
+      </ProCard>
+    </ProCard>
+    // 属性预览
+  );
+};
+
+export default FabricViewRoom;
diff --git a/src/pages/Resource/ResourceDeviceStatus/components/DeviceStatusCard.tsx b/src/pages/Resource/ResourceDeviceStatus/components/DeviceStatusCard.tsx
new file mode 100644
index 0000000..07874ac
--- /dev/null
+++ b/src/pages/Resource/ResourceDeviceStatus/components/DeviceStatusCard.tsx
@@ -0,0 +1,158 @@
+/*
+ * @Author: zhoux zhouxia@supervision.ltd
+ * @Date: 2023-11-06 16:12:17
+ * @LastEditors: zhoux zhouxia@supervision.ltd
+ * @LastEditTime: 2023-12-15 14:00:33
+ * @FilePath: \general-ai-platform-web\src\pages\Setting\components\ProjectCardList.tsx
+ * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+ */
+import React from 'react';
+
+import { Progress } from 'antd';
+// import { postModelVersionGetModelVersionListByIds } from '@/services/resource/ModelVersion';
+
+// const [tabs, setTabs] = useState([]);
+// const [projectData, setProjectData] = useState<any>({});
+// const [tab, setTab] = useState('');
+// const [modelVersionData, setModelVersionData] = useState<any[]>([]);
+
+/**styles */
+const listItemStyle = {
+  display: 'flex',
+  fontSize: 14,
+  color: '#333333',
+  width: '100%',
+  alignItems: 'center',
+  padding: '4px 0 0',
+};
+
+const listItemLabelStyle = {
+  display: 'flex',
+  alignItems: 'center',
+  fontSize: 12,
+  color: '#666666',
+  minWidth: 53
+};
+
+const listItemTextStyle = {
+  fontSize: 14,
+  margin: 0,
+};
+// 卡片
+export type UpdateProjectProps = {
+  info: Record<string, any>;
+  // reload: any;
+};
+
+type DeviceItemProgress = {
+  label: string;
+  percent: number;
+};
+
+// 进度条
+// TODO 进度条的边框圆角调整为矩形
+const DeviceItemProgress: React.FC<DeviceItemProgress> = (props) => {
+  let strokeColor = 'rgb(243,48,5)';
+  switch (props.label) {
+    case '存储告警':
+      strokeColor = 'rgb(243,48,5)';
+      break;
+    case 'GPU告警':
+    case '内存告警':
+      strokeColor = 'rgb(33,169,122)';
+      break;
+    case 'CPU告警':
+      strokeColor = 'rgb(250,173,20)';
+      break;
+  }
+
+  return (
+    <div style={{ width: '100%', display: 'flex' }} className="rectProgress_box">
+      <span style={listItemLabelStyle}>{props.label}</span>
+      <Progress
+        style={{ padding: 0, margin: 0, borderRadius: 0 }}
+        size={['100%', 10]}
+        percent={props.percent * 100}
+        strokeColor={strokeColor}
+        showInfo={false}
+      />
+    </div>
+  );
+};
+
+const DeviceStatusCard: React.FC<UpdateProjectProps> = ({
+  info,
+}: {
+  info: Record<string, any>;
+}) => {
+  return (
+    <div
+      style={{
+        width: '100%',
+        display: 'flex',
+        flexDirection: 'column',
+        alignItems: 'left',
+        paddingLeft: 8,
+        paddingRight: 8,
+      }}
+    >
+      {/* <div style={{ display: 'flex', alignItems: 'center', paddingBottom: 10 }}>
+        <span style={{ fontWeight: 700, fontSize: 14, paddingRight: 10 }}>苏胜天算法模型</span>
+        <Tag color="#44AEF5">经典算法</Tag>
+      </div> */}
+      <ul
+        style={{
+          display: 'flex',
+          alignItems: 'center',
+          justifyContent: 'space-between',
+          fontSize: 12,
+          color: '#E80D0D',
+          padding: '8px 0 0',
+          lineHeight: '18px',
+          margin: 0,
+        }}
+      >
+        <li>
+          <span
+            style={{
+              display: 'inline-block',
+              width: 8,
+              height: 8,
+              borderRadius: '50%',
+              backgroundColor: '#E80D0D',
+            }}
+          ></span>
+          <span style={{ paddingLeft: 8 }}>代码出错</span>
+        </li>
+        <li>
+          <span
+            style={{
+              display: 'inline-block',
+              width: 8,
+              height: 8,
+              borderRadius: '50%',
+              backgroundColor: '#E80D0D',
+            }}
+          ></span>
+          <span style={{ paddingLeft: 8 }}>服务超时</span>
+        </li>
+      </ul>
+      <ul style={{ width: '100%', marginBottom: 8 }}>
+        <li style={listItemStyle}>
+          <DeviceItemProgress label="存储告警" percent={0.79}></DeviceItemProgress>
+        </li>
+        <li style={listItemStyle}>
+          <DeviceItemProgress label="GPU告警" percent={0.18}></DeviceItemProgress>
+        </li>
+        <li style={listItemStyle}>
+          <DeviceItemProgress label="内存告警" percent={0.16}></DeviceItemProgress>
+        </li>
+        <li style={listItemStyle}>
+          <DeviceItemProgress label="CPU告警" percent={0.58}></DeviceItemProgress>
+        </li>
+      </ul>
+    </div>
+  );
+};
+
+export default DeviceStatusCard;
diff --git a/src/pages/Resource/ResourceDeviceStatus/index.tsx b/src/pages/Resource/ResourceDeviceStatus/index.tsx
new file mode 100644
index 0000000..87f4dae
--- /dev/null
+++ b/src/pages/Resource/ResourceDeviceStatus/index.tsx
@@ -0,0 +1,181 @@
+import TableActionCard from '@/components/TableActionCard';
+import IsConfirmAction from '@/components/TableActionCard/isConfirmAction';
+import { resourceDeviceStatusEnums } from '@/enums/status';
+import { PageContainer, ProCard, ProColumns, ProList } from '@ant-design/pro-components';
+import { FormattedMessage } from '@umijs/max';
+import { Button, Tag } from 'antd';
+import React, { useState } from 'react';
+import { proTableCommonOptions, proTablePaginationOptions } from '../../../../config/defaultTable';
+import DeviceStatusCard from './components/DeviceStatusCard';
+
+/**
+ * @交互说明
+ * 1、列表分页展示分布式设备状态（分类查询）
+ * 2、详情展示基础信息、日志
+ * 3、重启设备
+ */
+const tabOptions: Record<string, any> = {
+  allStatus: 90,
+  storageWarn: 20,
+  GPUWarn: 20,
+  memoryWarn: 10,
+  errorStatus: 20,
+  codeError: 10,
+  serveTimeOut: 20,
+};
+
+const ResourceDeviceStatus: React.FC = () => {
+  const [detailModalOpen, setDetailModalOpen] = useState<boolean>(false);
+  const [currentRow, setCurrentRow] = useState<Record<string, any>>({});
+  //  动态设置每页数量
+  const [currentPageSize, setCurrentPageSize] = useState<number>(15);
+
+  const [activeTabIndex, setActiveTabIndex] = useState<number>(0);
+
+
+  const dataTestList = [
+    { status: '存储告警' },
+    { status: 'GPU告警' },
+    { status: '内存告警' },
+    { status: 'CPU告警' },
+    { status: '代码出错' },
+    { status: '服务器超时' },
+    { status: '存储告警' },
+    { status: '代码出错' },
+    { status: '存储告警' },
+    { status: 'GPU告警' },
+    { status: '内存告警' },
+    { status: 'CPU告警' },
+    { status: '代码出错' },
+    { status: '服务器超时' },
+    { status: '存储告警' },
+    { status: '代码出错' },
+  ].map((record, index) => {
+    return {
+      content: (
+        <ProCard
+          className="gn"
+          style={{ backgroundColor: '#fafafa', margin: 0, padding: 0 }}
+          bodyStyle={{ margin: 0, padding: 0 }}
+        >
+          <div
+            style={{
+              display: 'flex',
+              alignItems: 'center',
+              backgroundColor: 'rgba(21, 77, 221, 0.10)',
+              padding: 12,
+              justifyContent: 'space-between',
+              borderBottom: '1px solid rgba(224, 224, 224, 1)',
+            }}
+          >
+        
+              <p
+                className="gn single_line text_1 fw7"
+                style={{ maxWidth: 'calc(100% - 12px)', padding: 0, margin: 0 }}
+              >
+                控制设备{index + 1}
+              </p>
+         
+          </div>
+          <DeviceStatusCard info={record}></DeviceStatusCard>{' '}
+        </ProCard>
+      ),
+    };
+  });
+
+  return (
+    <PageContainer>
+      <ProList<any>
+        className="gn"
+        ghost={true}
+        itemCardProps={{
+          ghost: true,
+          bodyStyle: { padding: 0, margin: 0 },
+        }}
+        headerTitle={
+          <>
+            <ProCard style={{padding: 0, margin: 0}} bodyStyle={{padding: 0, margin: 0}}>
+              {Object.keys(tabOptions).map((item, index) => {
+                // eslint-disable-next-line react/jsx-key
+                return (
+                  <Button
+                    style={{ marginRight: 12, marginTop: 8 }}
+                    type={activeTabIndex === index ? 'primary' : 'default'}
+                    key={index}
+                    onClick={() => {
+                      setActiveTabIndex(index);
+                    }}
+                  >
+                    {Object.keys(resourceDeviceStatusEnums).includes(item)
+                      ? resourceDeviceStatusEnums[item].miniName
+                      : ''}
+                  {"("+tabOptions[item]+ ')'}
+                  </Button>
+                );
+              })}
+            </ProCard>
+          </>
+        }
+        cardProps={{
+          bodyStyle: {
+            background: 'white',
+            padding: '0px 16px 16px',
+            borderRadius: 8,
+          },
+        }}
+        pagination={{
+          ...proTablePaginationOptions,
+          pageSize: currentPageSize,
+          onChange: (page, pageSize) => setCurrentPageSize(pageSize),
+        }}
+        showActions="hover"
+        rowSelection={false}
+        grid={{ gutter: 16, xs: 1, md: 3, lg: 4, xl: 5, xxl: 7 }}
+        metas={{
+          type: {
+          
+          },
+          content: {
+          },
+          actions: {
+            cardActionProps: 'extra',
+          }
+        }}
+        request={async (params = {}, sort) => {
+          const { current, ...rest } = params;
+          const reqParams = {
+            page: current,
+            desc: false,
+            orderKey: '',
+            ...rest,
+          };
+          if (sort && Object.keys(sort).length) {
+            reqParams.orderKey = Object.keys(sort)[0];
+            let sort_select = sort[reqParams.orderKey];
+            reqParams.desc = sort_select === 'descend';
+          }
+          // TODO 联调查询设备状态接口
+          // let resps = await postDeviceGroupGetDeviceGroupList({ ...reqParams });
+          let resp = {
+            success: true,
+            data: {
+              list: dataTestList,
+              total: 16,
+              page: 1,
+              pageSize: 16,
+            },
+          };
+          return {
+            data: resp.data.list,
+            success: resp.success,
+            total: resp.data.total,
+            current: resp.data.page,
+            pageSize: resp.data.pageSize,
+          };
+        }}
+      />
+    </PageContainer>
+  );
+};
+
+export default ResourceDeviceStatus;
diff --git a/src/testData/fabricGroupRoom.ts b/src/testData/fabricGroupRoom.ts
new file mode 100644
index 0000000..dd05cf3
--- /dev/null
+++ b/src/testData/fabricGroupRoom.ts
@@ -0,0 +1,1644 @@
+const modelGroup: Record<string, any>[] = [
+  {
+    type: 'group',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: 0,
+    top: 0,
+    width: 115.6016,
+    height: 39,
+    fill: 'rgb(0,0,0)',
+    stroke: null,
+    strokeWidth: 0,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    id: 'b6ca8fad-c240-4659-9952-a90167699ce9',
+    selectable: false,
+    hasControls: true,
+    userProperty: {},
+    objects: [
+      {
+        type: 'group',
+        version: '5.3.0',
+        originX: 'left',
+        originY: 'top',
+        left: -57.8008,
+        top: -19.5,
+        width: 36,
+        height: 39,
+        fill: 'rgb(0,0,0)',
+        stroke: null,
+        strokeWidth: 0,
+        strokeDashArray: null,
+        strokeLineCap: 'butt',
+        strokeDashOffset: 0,
+        strokeLineJoin: 'miter',
+        strokeUniform: false,
+        strokeMiterLimit: 4,
+        scaleX: 1,
+        scaleY: 1,
+        angle: 0,
+        flipX: false,
+        flipY: false,
+        opacity: 1,
+        shadow: '',
+        visible: true,
+        backgroundColor: '',
+        fillRule: 'nonzero',
+        paintFirst: 'fill',
+        globalCompositeOperation: 'source-over',
+        skewX: 0,
+        skewY: 0,
+        selectable: true,
+        hasControls: true,
+        objects: [
+          {
+            type: 'path',
+            version: '5.3.0',
+            originX: 'left',
+            originY: 'top',
+            left: -12.5,
+            top: -18,
+            width: 24,
+            height: 27,
+            fill: 'white',
+            stroke: null,
+            strokeWidth: 1,
+            strokeDashArray: null,
+            strokeLineCap: 'butt',
+            strokeDashOffset: 0,
+            strokeLineJoin: 'miter',
+            strokeUniform: false,
+            strokeMiterLimit: 4,
+            scaleX: 1,
+            scaleY: 1,
+            angle: 0,
+            flipX: false,
+            flipY: false,
+            opacity: 1,
+            shadow: null,
+            visible: true,
+            backgroundColor: '',
+            fillRule: 'evenodd',
+            paintFirst: 'fill',
+            globalCompositeOperation: 'source-over',
+            skewX: 0,
+            skewY: 0,
+            selectable: true,
+            hasControls: true,
+            path: [
+              ['M', 19.2704, 25.9335],
+              ['C', 25.3006, 25.299, 30, 20.1983, 30, 14],
+              ['C', 30, 7.37258, 24.6274, 2, 18, 2],
+              ['C', 11.3726, 2, 6, 7.37258, 6, 14],
+              ['C', 6, 19.8172, 10.1393, 24.6677, 15.6332, 25.7667],
+              ['L', 17.5, 29],
+              ['L', 19.2704, 25.9335],
+              ['Z'],
+            ],
+          },
+          {
+            type: 'path',
+            version: '5.3.0',
+            originX: 'left',
+            originY: 'top',
+            left: -13.5,
+            top: -19,
+            width: 26,
+            height: 30,
+            fill: '#DCDCDC',
+            stroke: null,
+            strokeWidth: 1,
+            strokeDashArray: null,
+            strokeLineCap: 'butt',
+            strokeDashOffset: 0,
+            strokeLineJoin: 'miter',
+            strokeUniform: false,
+            strokeMiterLimit: 4,
+            scaleX: 1,
+            scaleY: 1,
+            angle: 0,
+            flipX: false,
+            flipY: false,
+            opacity: 1,
+            shadow: null,
+            visible: true,
+            backgroundColor: '',
+            fillRule: 'nonzero',
+            paintFirst: 'fill',
+            globalCompositeOperation: 'source-over',
+            skewX: 0,
+            skewY: 0,
+            selectable: true,
+            hasControls: true,
+            path: [
+              ['M', 19.2704, 25.9335],
+              ['L', 19.1658, 24.939],
+              ['L', 18.6591, 24.9924],
+              ['L', 18.4044, 25.4335],
+              ['L', 19.2704, 25.9335],
+              ['Z'],
+              ['M', 15.6332, 25.7667],
+              ['L', 16.4993, 25.2667],
+              ['L', 16.273, 24.8748],
+              ['L', 15.8294, 24.7861],
+              ['L', 15.6332, 25.7667],
+              ['Z'],
+              ['M', 17.5, 29],
+              ['L', 16.634, 29.5],
+              ['L', 17.5, 31],
+              ['L', 18.366, 29.5],
+              ['L', 17.5, 29],
+              ['Z'],
+              ['M', 29, 14],
+              ['C', 29, 19.6811, 24.6924, 24.3575, 19.1658, 24.939],
+              ['L', 19.3751, 26.9281],
+              ['C', 25.9088, 26.2405, 31, 20.7155, 31, 14],
+              ['L', 29, 14],
+              ['Z'],
+              ['M', 18, 3],
+              ['C', 24.0751, 3, 29, 7.92487, 29, 14],
+              ['L', 31, 14],
+              ['C', 31, 6.8203, 25.1797, 1, 18, 1],
+              ['L', 18, 3],
+              ['Z'],
+              ['M', 7, 14],
+              ['C', 7, 7.92487, 11.9249, 3, 18, 3],
+              ['L', 18, 1],
+              ['C', 10.8203, 1, 5, 6.8203, 5, 14],
+              ['L', 7, 14],
+              ['Z'],
+              ['M', 15.8294, 24.7861],
+              ['C', 10.7937, 23.7788, 7, 19.3313, 7, 14],
+              ['L', 5, 14],
+              ['C', 5, 20.3032, 9.48488, 25.5566, 15.4371, 26.7472],
+              ['L', 15.8294, 24.7861],
+              ['Z'],
+              ['M', 14.7672, 26.2667],
+              ['L', 16.634, 29.5],
+              ['L', 18.366, 28.5],
+              ['L', 16.4993, 25.2667],
+              ['L', 14.7672, 26.2667],
+              ['Z'],
+              ['M', 18.366, 29.5],
+              ['L', 20.1364, 26.4335],
+              ['L', 18.4044, 25.4335],
+              ['L', 16.634, 28.5],
+              ['L', 18.366, 29.5],
+              ['Z'],
+            ],
+          },
+        ],
+      },
+      {
+        type: 'group',
+        version: '5.3.0',
+        originX: 'left',
+        originY: 'top',
+        left: -47.8008,
+        top: -13.4177,
+        width: 16,
+        height: 16,
+        fill: 'rgb(0,0,0)',
+        stroke: null,
+        strokeWidth: 0,
+        strokeDashArray: null,
+        strokeLineCap: 'butt',
+        strokeDashOffset: 0,
+        strokeLineJoin: 'miter',
+        strokeUniform: false,
+        strokeMiterLimit: 4,
+        scaleX: 1,
+        scaleY: 1,
+        angle: 0,
+        flipX: false,
+        flipY: false,
+        opacity: 1,
+        shadow: '',
+        visible: true,
+        backgroundColor: '',
+        fillRule: 'nonzero',
+        paintFirst: 'fill',
+        globalCompositeOperation: 'source-over',
+        skewX: 0,
+        skewY: 0,
+        selectable: true,
+        hasControls: true,
+        objects: [
+          {
+            type: 'path',
+            version: '5.3.0',
+            originX: 'left',
+            originY: 'top',
+            left: -6.9333,
+            top: -6.6,
+            width: 12.6666,
+            height: 0,
+            fill: '',
+            stroke: '#52C41A',
+            strokeWidth: 1.2,
+            strokeDashArray: null,
+            strokeLineCap: 'round',
+            strokeDashOffset: 0,
+            strokeLineJoin: 'round',
+            strokeUniform: false,
+            strokeMiterLimit: 4,
+            scaleX: 1,
+            scaleY: 1,
+            angle: 0,
+            flipX: false,
+            flipY: false,
+            opacity: 1,
+            shadow: null,
+            visible: true,
+            backgroundColor: '',
+            fillRule: 'nonzero',
+            paintFirst: 'fill',
+            globalCompositeOperation: 'source-over',
+            skewX: 0,
+            skewY: 0,
+            selectable: true,
+            hasControls: true,
+            path: [
+              ['M', 14.3334, 2],
+              ['L', 7.66675, 2],
+              ['L', 1.66675, 2],
+            ],
+          },
+          {
+            type: 'path',
+            version: '5.3.0',
+            originX: 'left',
+            originY: 'top',
+            left: -0.9332,
+            top: -6.6,
+            width: 0,
+            height: 5.6667,
+            fill: '',
+            stroke: '#52C41A',
+            strokeWidth: 1.2,
+            strokeDashArray: null,
+            strokeLineCap: 'round',
+            strokeDashOffset: 0,
+            strokeLineJoin: 'round',
+            strokeUniform: false,
+            strokeMiterLimit: 4,
+            scaleX: 1,
+            scaleY: 1,
+            angle: 0,
+            flipX: false,
+            flipY: false,
+            opacity: 1,
+            shadow: null,
+            visible: true,
+            backgroundColor: '',
+            fillRule: 'nonzero',
+            paintFirst: 'fill',
+            globalCompositeOperation: 'source-over',
+            skewX: 0,
+            skewY: 0,
+            selectable: true,
+            hasControls: true,
+            path: [
+              ['M', 7.66675, 7.66667],
+              ['L', 7.66675, 2],
+            ],
+          },
+          {
+            type: 'path',
+            version: '5.3.0',
+            originX: 'left',
+            originY: 'top',
+            left: -6.9994,
+            top: -2.0727,
+            width: 11.833,
+            height: 7.0096,
+            fill: '#52C41A',
+            stroke: '#52C41A',
+            strokeWidth: 1.2,
+            strokeDashArray: null,
+            strokeLineCap: 'round',
+            strokeDashOffset: 0,
+            strokeLineJoin: 'round',
+            strokeUniform: false,
+            strokeMiterLimit: 4,
+            scaleX: 1,
+            scaleY: 1,
+            angle: 0,
+            flipX: false,
+            flipY: false,
+            opacity: 1,
+            shadow: null,
+            visible: true,
+            backgroundColor: '',
+            fillRule: 'nonzero',
+            paintFirst: 'fill',
+            globalCompositeOperation: 'source-over',
+            skewX: 0,
+            skewY: 0,
+            selectable: true,
+            hasControls: true,
+            path: [
+              ['M', 2.80841, 6.52734],
+              ['L', 13.4336, 9.37438],
+              ['L', 12.8528, 10.254],
+              ['L', 11.5187, 12.6573],
+              ['L', 10.9379, 13.5369],
+              ['L', 1.60059, 11.035],
+              ['L', 2.80841, 6.52734],
+              ['Z'],
+            ],
+          },
+          {
+            type: 'path',
+            version: '5.3.0',
+            originX: 'left',
+            originY: 'top',
+            left: 2.9186,
+            top: 1.6539,
+            width: 2.622,
+            height: 2.9209,
+            fill: '',
+            stroke: '#52C41A',
+            strokeWidth: 1.2,
+            strokeDashArray: null,
+            strokeLineCap: 'round',
+            strokeDashOffset: 0,
+            strokeLineJoin: 'round',
+            strokeUniform: false,
+            strokeMiterLimit: 4,
+            scaleX: 1,
+            scaleY: 1,
+            angle: 0,
+            flipX: false,
+            flipY: false,
+            opacity: 1,
+            shadow: null,
+            visible: true,
+            backgroundColor: '',
+            fillRule: 'nonzero',
+            paintFirst: 'fill',
+            globalCompositeOperation: 'source-over',
+            skewX: 0,
+            skewY: 0,
+            selectable: true,
+            hasControls: true,
+            path: [
+              ['M', 12.8527, 10.2539],
+              ['L', 14.1406, 10.599],
+              ['L', 13.4504, 13.1748],
+              ['L', 11.5186, 12.6572],
+            ],
+          },
+          {
+            type: 'circle',
+            version: '5.3.0',
+            originX: 'left',
+            originY: 'top',
+            left: -5,
+            top: 0,
+            width: 2.5,
+            height: 2.5,
+            fill: '',
+            stroke: 'white',
+            strokeWidth: 0.5,
+            strokeDashArray: null,
+            strokeLineCap: 'butt',
+            strokeDashOffset: 0,
+            strokeLineJoin: 'miter',
+            strokeUniform: false,
+            strokeMiterLimit: 4,
+            scaleX: 1,
+            scaleY: 1,
+            angle: 0,
+            flipX: false,
+            flipY: false,
+            opacity: 1,
+            shadow: null,
+            visible: true,
+            backgroundColor: '',
+            fillRule: 'nonzero',
+            paintFirst: 'fill',
+            globalCompositeOperation: 'source-over',
+            skewX: 0,
+            skewY: 0,
+            radius: 1.25,
+            startAngle: 0,
+            endAngle: 360,
+            selectable: true,
+            hasControls: true,
+          },
+        ],
+      },
+      {
+        type: 'textbox',
+        version: '5.3.0',
+        originX: 'left',
+        originY: 'top',
+        left: -19.6724,
+        top: -13.5967,
+        width: 400,
+        height: 90.4,
+        fill: 'rgb(0,0,0)',
+        stroke: null,
+        strokeWidth: 1,
+        strokeDashArray: null,
+        strokeLineCap: 'butt',
+        strokeDashOffset: 0,
+        strokeLineJoin: 'miter',
+        strokeUniform: false,
+        strokeMiterLimit: 4,
+        scaleX: 0.1932,
+        scaleY: 0.1932,
+        angle: 0,
+        flipX: false,
+        flipY: false,
+        opacity: 1,
+        shadow: '',
+        visible: true,
+        backgroundColor: '',
+        fillRule: 'nonzero',
+        paintFirst: 'fill',
+        globalCompositeOperation: 'source-over',
+        skewX: 0,
+        skewY: 0,
+        fontFamily: 'arial',
+        fontWeight: 'normal',
+        fontSize: 80,
+        text: '监控设备',
+        underline: false,
+        overline: false,
+        linethrough: false,
+        textAlign: 'left',
+        fontStyle: 'normal',
+        lineHeight: 1.16,
+        textBackgroundColor: '',
+        charSpacing: 0,
+        styles: [],
+        direction: 'ltr',
+        path: null,
+        pathStartOffset: 0,
+        pathSide: 'left',
+        pathAlign: 'baseline',
+        minWidth: 20,
+        splitByGrapheme: true,
+        selectable: true,
+        hasControls: false,
+      },
+    ],
+  },
+];
+
+const currJson0: Record<string, any> = {
+  version: '5.3.0',
+  objects: [
+    {
+      type: 'group',
+      version: '5.3.0',
+      originX: 'left',
+      originY: 'top',
+      left: 247.0215,
+      top: 444.5797,
+      width: 115.6016,
+      height: 39,
+      fill: 'rgb(0,0,0)',
+      stroke: null,
+      strokeWidth: 0,
+      strokeDashArray: null,
+      strokeLineCap: 'butt',
+      strokeDashOffset: 0,
+      strokeLineJoin: 'miter',
+      strokeUniform: false,
+      strokeMiterLimit: 4,
+      scaleX: 1,
+      scaleY: 1,
+      angle: 0,
+      flipX: false,
+      flipY: false,
+      opacity: 1,
+      shadow: null,
+      visible: true,
+      backgroundColor: '',
+      fillRule: 'nonzero',
+      paintFirst: 'fill',
+      globalCompositeOperation: 'source-over',
+      skewX: 0,
+      skewY: 0,
+      id: 'b6ca8fad-c240-4659-9952-a90167699ce9',
+      selectable: false,
+      hasControls: true,
+      userProperty: {
+        modelId: '121',
+        status: '0',
+        id: '2',
+        label: '正常',
+        des: '卧室B',
+
+        param1: '',
+      },
+      objects: [
+        {
+          type: 'group',
+          version: '5.3.0',
+          originX: 'left',
+          originY: 'top',
+          left: -57.8008,
+          top: -19.5,
+          width: 36,
+          height: 39,
+          fill: 'rgb(0,0,0)',
+          stroke: null,
+          strokeWidth: 0,
+          strokeDashArray: null,
+          strokeLineCap: 'butt',
+          strokeDashOffset: 0,
+          strokeLineJoin: 'miter',
+          strokeUniform: false,
+          strokeMiterLimit: 4,
+          scaleX: 1,
+          scaleY: 1,
+          angle: 0,
+          flipX: false,
+          flipY: false,
+          opacity: 1,
+          shadow: '',
+          visible: true,
+          backgroundColor: '',
+          fillRule: 'nonzero',
+          paintFirst: 'fill',
+          globalCompositeOperation: 'source-over',
+          skewX: 0,
+          skewY: 0,
+          selectable: true,
+          hasControls: true,
+          objects: [
+            {
+              type: 'path',
+              version: '5.3.0',
+              originX: 'left',
+              originY: 'top',
+              left: -12.5,
+              top: -18,
+              width: 24,
+              height: 27,
+              fill: 'white',
+              stroke: null,
+              strokeWidth: 1,
+              strokeDashArray: null,
+              strokeLineCap: 'butt',
+              strokeDashOffset: 0,
+              strokeLineJoin: 'miter',
+              strokeUniform: false,
+              strokeMiterLimit: 4,
+              scaleX: 1,
+              scaleY: 1,
+              angle: 0,
+              flipX: false,
+              flipY: false,
+              opacity: 1,
+              shadow: null,
+              visible: true,
+              backgroundColor: '',
+              fillRule: 'evenodd',
+              paintFirst: 'fill',
+              globalCompositeOperation: 'source-over',
+              skewX: 0,
+              skewY: 0,
+              selectable: true,
+              hasControls: true,
+              path: [
+                ['M', 19.2704, 25.9335],
+                ['C', 25.3006, 25.299, 30, 20.1983, 30, 14],
+                ['C', 30, 7.37258, 24.6274, 2, 18, 2],
+                ['C', 11.3726, 2, 6, 7.37258, 6, 14],
+                ['C', 6, 19.8172, 10.1393, 24.6677, 15.6332, 25.7667],
+                ['L', 17.5, 29],
+                ['L', 19.2704, 25.9335],
+                ['Z'],
+              ],
+            },
+            {
+              type: 'path',
+              version: '5.3.0',
+              originX: 'left',
+              originY: 'top',
+              left: -13.5,
+              top: -19,
+              width: 26,
+              height: 30,
+              fill: '#DCDCDC',
+              stroke: null,
+              strokeWidth: 1,
+              strokeDashArray: null,
+              strokeLineCap: 'butt',
+              strokeDashOffset: 0,
+              strokeLineJoin: 'miter',
+              strokeUniform: false,
+              strokeMiterLimit: 4,
+              scaleX: 1,
+              scaleY: 1,
+              angle: 0,
+              flipX: false,
+              flipY: false,
+              opacity: 1,
+              shadow: null,
+              visible: true,
+              backgroundColor: '',
+              fillRule: 'nonzero',
+              paintFirst: 'fill',
+              globalCompositeOperation: 'source-over',
+              skewX: 0,
+              skewY: 0,
+              selectable: true,
+              hasControls: true,
+              path: [
+                ['M', 19.2704, 25.9335],
+                ['L', 19.1658, 24.939],
+                ['L', 18.6591, 24.9924],
+                ['L', 18.4044, 25.4335],
+                ['L', 19.2704, 25.9335],
+                ['Z'],
+                ['M', 15.6332, 25.7667],
+                ['L', 16.4993, 25.2667],
+                ['L', 16.273, 24.8748],
+                ['L', 15.8294, 24.7861],
+                ['L', 15.6332, 25.7667],
+                ['Z'],
+                ['M', 17.5, 29],
+                ['L', 16.634, 29.5],
+                ['L', 17.5, 31],
+                ['L', 18.366, 29.5],
+                ['L', 17.5, 29],
+                ['Z'],
+                ['M', 29, 14],
+                ['C', 29, 19.6811, 24.6924, 24.3575, 19.1658, 24.939],
+                ['L', 19.3751, 26.9281],
+                ['C', 25.9088, 26.2405, 31, 20.7155, 31, 14],
+                ['L', 29, 14],
+                ['Z'],
+                ['M', 18, 3],
+                ['C', 24.0751, 3, 29, 7.92487, 29, 14],
+                ['L', 31, 14],
+                ['C', 31, 6.8203, 25.1797, 1, 18, 1],
+                ['L', 18, 3],
+                ['Z'],
+                ['M', 7, 14],
+                ['C', 7, 7.92487, 11.9249, 3, 18, 3],
+                ['L', 18, 1],
+                ['C', 10.8203, 1, 5, 6.8203, 5, 14],
+                ['L', 7, 14],
+                ['Z'],
+                ['M', 15.8294, 24.7861],
+                ['C', 10.7937, 23.7788, 7, 19.3313, 7, 14],
+                ['L', 5, 14],
+                ['C', 5, 20.3032, 9.48488, 25.5566, 15.4371, 26.7472],
+                ['L', 15.8294, 24.7861],
+                ['Z'],
+                ['M', 14.7672, 26.2667],
+                ['L', 16.634, 29.5],
+                ['L', 18.366, 28.5],
+                ['L', 16.4993, 25.2667],
+                ['L', 14.7672, 26.2667],
+                ['Z'],
+                ['M', 18.366, 29.5],
+                ['L', 20.1364, 26.4335],
+                ['L', 18.4044, 25.4335],
+                ['L', 16.634, 28.5],
+                ['L', 18.366, 29.5],
+                ['Z'],
+              ],
+            },
+          ],
+        },
+        {
+          type: 'group',
+          version: '5.3.0',
+          originX: 'left',
+          originY: 'top',
+          left: -47.8008,
+          top: -13.4177,
+          width: 16,
+          height: 16,
+          fill: 'rgb(0,0,0)',
+          stroke: null,
+          strokeWidth: 0,
+          strokeDashArray: null,
+          strokeLineCap: 'butt',
+          strokeDashOffset: 0,
+          strokeLineJoin: 'miter',
+          strokeUniform: false,
+          strokeMiterLimit: 4,
+          scaleX: 1,
+          scaleY: 1,
+          angle: 0,
+          flipX: false,
+          flipY: false,
+          opacity: 1,
+          shadow: '',
+          visible: true,
+          backgroundColor: '',
+          fillRule: 'nonzero',
+          paintFirst: 'fill',
+          globalCompositeOperation: 'source-over',
+          skewX: 0,
+          skewY: 0,
+          selectable: true,
+          hasControls: true,
+          objects: [
+            {
+              type: 'path',
+              version: '5.3.0',
+              originX: 'left',
+              originY: 'top',
+              left: -6.9333,
+              top: -6.6,
+              width: 12.6666,
+              height: 0,
+              fill: '',
+              stroke: '#52C41A',
+              strokeWidth: 1.2,
+              strokeDashArray: null,
+              strokeLineCap: 'round',
+              strokeDashOffset: 0,
+              strokeLineJoin: 'round',
+              strokeUniform: false,
+              strokeMiterLimit: 4,
+              scaleX: 1,
+              scaleY: 1,
+              angle: 0,
+              flipX: false,
+              flipY: false,
+              opacity: 1,
+              shadow: null,
+              visible: true,
+              backgroundColor: '',
+              fillRule: 'nonzero',
+              paintFirst: 'fill',
+              globalCompositeOperation: 'source-over',
+              skewX: 0,
+              skewY: 0,
+              selectable: true,
+              hasControls: true,
+              path: [
+                ['M', 14.3334, 2],
+                ['L', 7.66675, 2],
+                ['L', 1.66675, 2],
+              ],
+            },
+            {
+              type: 'path',
+              version: '5.3.0',
+              originX: 'left',
+              originY: 'top',
+              left: -0.9332,
+              top: -6.6,
+              width: 0,
+              height: 5.6667,
+              fill: '',
+              stroke: '#52C41A',
+              strokeWidth: 1.2,
+              strokeDashArray: null,
+              strokeLineCap: 'round',
+              strokeDashOffset: 0,
+              strokeLineJoin: 'round',
+              strokeUniform: false,
+              strokeMiterLimit: 4,
+              scaleX: 1,
+              scaleY: 1,
+              angle: 0,
+              flipX: false,
+              flipY: false,
+              opacity: 1,
+              shadow: null,
+              visible: true,
+              backgroundColor: '',
+              fillRule: 'nonzero',
+              paintFirst: 'fill',
+              globalCompositeOperation: 'source-over',
+              skewX: 0,
+              skewY: 0,
+              selectable: true,
+              hasControls: true,
+              path: [
+                ['M', 7.66675, 7.66667],
+                ['L', 7.66675, 2],
+              ],
+            },
+            {
+              type: 'path',
+              version: '5.3.0',
+              originX: 'left',
+              originY: 'top',
+              left: -6.9994,
+              top: -2.0727,
+              width: 11.833,
+              height: 7.0096,
+              fill: '#52C41A',
+              stroke: '#52C41A',
+              strokeWidth: 1.2,
+              strokeDashArray: null,
+              strokeLineCap: 'round',
+              strokeDashOffset: 0,
+              strokeLineJoin: 'round',
+              strokeUniform: false,
+              strokeMiterLimit: 4,
+              scaleX: 1,
+              scaleY: 1,
+              angle: 0,
+              flipX: false,
+              flipY: false,
+              opacity: 1,
+              shadow: null,
+              visible: true,
+              backgroundColor: '',
+              fillRule: 'nonzero',
+              paintFirst: 'fill',
+              globalCompositeOperation: 'source-over',
+              skewX: 0,
+              skewY: 0,
+              selectable: true,
+              hasControls: true,
+              path: [
+                ['M', 2.80841, 6.52734],
+                ['L', 13.4336, 9.37438],
+                ['L', 12.8528, 10.254],
+                ['L', 11.5187, 12.6573],
+                ['L', 10.9379, 13.5369],
+                ['L', 1.60059, 11.035],
+                ['L', 2.80841, 6.52734],
+                ['Z'],
+              ],
+            },
+            {
+              type: 'path',
+              version: '5.3.0',
+              originX: 'left',
+              originY: 'top',
+              left: 2.9186,
+              top: 1.6539,
+              width: 2.622,
+              height: 2.9209,
+              fill: '',
+              stroke: '#52C41A',
+              strokeWidth: 1.2,
+              strokeDashArray: null,
+              strokeLineCap: 'round',
+              strokeDashOffset: 0,
+              strokeLineJoin: 'round',
+              strokeUniform: false,
+              strokeMiterLimit: 4,
+              scaleX: 1,
+              scaleY: 1,
+              angle: 0,
+              flipX: false,
+              flipY: false,
+              opacity: 1,
+              shadow: null,
+              visible: true,
+              backgroundColor: '',
+              fillRule: 'nonzero',
+              paintFirst: 'fill',
+              globalCompositeOperation: 'source-over',
+              skewX: 0,
+              skewY: 0,
+              selectable: true,
+              hasControls: true,
+              path: [
+                ['M', 12.8527, 10.2539],
+                ['L', 14.1406, 10.599],
+                ['L', 13.4504, 13.1748],
+                ['L', 11.5186, 12.6572],
+              ],
+            },
+            {
+              type: 'circle',
+              version: '5.3.0',
+              originX: 'left',
+              originY: 'top',
+              left: -5,
+              top: 0,
+              width: 2.5,
+              height: 2.5,
+              fill: '',
+              stroke: 'white',
+              strokeWidth: 0.5,
+              strokeDashArray: null,
+              strokeLineCap: 'butt',
+              strokeDashOffset: 0,
+              strokeLineJoin: 'miter',
+              strokeUniform: false,
+              strokeMiterLimit: 4,
+              scaleX: 1,
+              scaleY: 1,
+              angle: 0,
+              flipX: false,
+              flipY: false,
+              opacity: 1,
+              shadow: null,
+              visible: true,
+              backgroundColor: '',
+              fillRule: 'nonzero',
+              paintFirst: 'fill',
+              globalCompositeOperation: 'source-over',
+              skewX: 0,
+              skewY: 0,
+              radius: 1.25,
+              startAngle: 0,
+              endAngle: 360,
+              selectable: true,
+              hasControls: true,
+            },
+          ],
+        },
+        {
+          type: 'textbox',
+          version: '5.3.0',
+          originX: 'left',
+          originY: 'top',
+          left: -19.6724,
+          top: -13.5967,
+          width: 400,
+          height: 90.4,
+          fill: 'rgb(0,0,0)',
+          stroke: null,
+          strokeWidth: 1,
+          strokeDashArray: null,
+          strokeLineCap: 'butt',
+          strokeDashOffset: 0,
+          strokeLineJoin: 'miter',
+          strokeUniform: false,
+          strokeMiterLimit: 4,
+          scaleX: 0.1932,
+          scaleY: 0.1932,
+          angle: 0,
+          flipX: false,
+          flipY: false,
+          opacity: 1,
+          shadow: '',
+          visible: true,
+          backgroundColor: '',
+          fillRule: 'nonzero',
+          paintFirst: 'fill',
+          globalCompositeOperation: 'source-over',
+          skewX: 0,
+          skewY: 0,
+          fontFamily: 'arial',
+          fontWeight: 'normal',
+          fontSize: 80,
+          text: '监控设备',
+          underline: false,
+          overline: false,
+          linethrough: false,
+          textAlign: 'left',
+          fontStyle: 'normal',
+          lineHeight: 1.16,
+          textBackgroundColor: '',
+          charSpacing: 0,
+          styles: [],
+          direction: 'ltr',
+          path: null,
+          pathStartOffset: 0,
+          pathSide: 'left',
+          pathAlign: 'baseline',
+          minWidth: 20,
+          splitByGrapheme: true,
+          selectable: true,
+          hasControls: false,
+        },
+      ],
+    },
+    {
+      type: 'group',
+      version: '5.3.0',
+      originX: 'left',
+      originY: 'top',
+      left: 778.0535,
+      top: 172.6152,
+      width: 48.205,
+      height: 48.205,
+      fill: 'rgb(0,0,0)',
+      stroke: null,
+      strokeWidth: 0,
+      strokeDashArray: null,
+      strokeLineCap: 'butt',
+      strokeDashOffset: 0,
+      strokeLineJoin: 'miter',
+      strokeUniform: false,
+      strokeMiterLimit: 4,
+      scaleX: 1,
+      scaleY: 1,
+      angle: 0,
+      flipX: false,
+      flipY: false,
+      opacity: 1,
+      shadow: null,
+      visible: true,
+      backgroundColor: '',
+      fillRule: 'nonzero',
+      paintFirst: 'fill',
+      globalCompositeOperation: 'source-over',
+      skewX: 0,
+      skewY: 0,
+      id: 'f772494d-01de-4a9e-b21d-67faed778e60',
+      selectable: false,
+      hasControls: true,
+      userProperty: {
+        modelId: '121',
+        status: '0',
+        id: '2',
+        label: '正常',
+        des: '卧室B',
+      },
+      objects: [
+        {
+          type: 'circle',
+          version: '5.3.0',
+          originX: 'left',
+          originY: 'top',
+          left: -24.1025,
+          top: -24.1025,
+          width: 300,
+          height: 300,
+          fill: 'rgba(44,246,72,0.99)',
+          stroke: 'rgba(45,240,230,1)',
+          strokeWidth: 10,
+          strokeDashArray: null,
+          strokeLineCap: 'butt',
+          strokeDashOffset: 0,
+          strokeLineJoin: 'miter',
+          strokeUniform: false,
+          strokeMiterLimit: 4,
+          scaleX: 0.1555,
+          scaleY: 0.1555,
+          angle: 0,
+          flipX: false,
+          flipY: false,
+          opacity: 1,
+          shadow: '',
+          visible: true,
+          backgroundColor: '',
+          fillRule: 'nonzero',
+          paintFirst: 'fill',
+          globalCompositeOperation: 'source-over',
+          skewX: 0,
+          skewY: 0,
+          radius: 150,
+          startAngle: 0,
+          endAngle: 360,
+          selectable: false,
+          hasControls: true,
+        },
+        {
+          type: 'i-text',
+          version: '5.3.0',
+          originX: 'left',
+          originY: 'top',
+          left: -16.7824,
+          top: -8.9323,
+          width: 160,
+          height: 90.4,
+          fill: 'rgba(255,255,255,1)',
+          stroke: null,
+          strokeWidth: 1,
+          strokeDashArray: null,
+          strokeLineCap: 'butt',
+          strokeDashOffset: 0,
+          strokeLineJoin: 'miter',
+          strokeUniform: false,
+          strokeMiterLimit: 4,
+          scaleX: 0.1954,
+          scaleY: 0.1954,
+          angle: 0,
+          flipX: false,
+          flipY: false,
+          opacity: 1,
+          shadow: '',
+          visible: true,
+          backgroundColor: '',
+          fillRule: 'nonzero',
+          paintFirst: 'fill',
+          globalCompositeOperation: 'source-over',
+          skewX: 0,
+          skewY: 0,
+          fontFamily: 'arial',
+          fontWeight: 'normal',
+          fontSize: 80,
+          text: '正常',
+          underline: false,
+          overline: false,
+          linethrough: false,
+          textAlign: 'left',
+          fontStyle: 'normal',
+          lineHeight: 1.16,
+          textBackgroundColor: '',
+          charSpacing: 0,
+          styles: [],
+          direction: 'ltr',
+          path: null,
+          pathStartOffset: 0,
+          pathSide: 'left',
+          pathAlign: 'baseline',
+          selectable: false,
+          hasControls: true,
+        },
+      ],
+    },
+    {
+      type: 'group',
+      version: '5.3.0',
+      originX: 'left',
+      originY: 'top',
+      left: 384.136,
+      top: 153.6373,
+      width: 48.205,
+      height: 48.205,
+      fill: 'rgb(0,0,0)',
+      stroke: null,
+      strokeWidth: 0,
+      strokeDashArray: null,
+      strokeLineCap: 'butt',
+      strokeDashOffset: 0,
+      strokeLineJoin: 'miter',
+      strokeUniform: false,
+      strokeMiterLimit: 4,
+      scaleX: 1,
+      scaleY: 1,
+      angle: 0,
+      flipX: false,
+      flipY: false,
+      opacity: 1,
+      shadow: null,
+      visible: true,
+      backgroundColor: '',
+      fillRule: 'nonzero',
+      paintFirst: 'fill',
+      globalCompositeOperation: 'source-over',
+      skewX: 0,
+      skewY: 0,
+      id: '3fea9335-b7a3-4b01-bf7b-7d15b4ca6b62',
+      selectable: false,
+      hasControls: true,
+      userProperty: {
+        modelId: '120',
+        status: '1',
+        id: '1',
+        label: '异常',
+        des: '卧室A',
+      },
+      objects: [
+        {
+          type: 'circle',
+          version: '5.3.0',
+          originX: 'left',
+          originY: 'top',
+          left: -24.1025,
+          top: -24.1025,
+          width: 300,
+          height: 300,
+          fill: 'rgba(248,9,3,0.94)',
+          stroke: 'rgba(255,243,47,1)',
+          strokeWidth: 10,
+          strokeDashArray: null,
+          strokeLineCap: 'butt',
+          strokeDashOffset: 0,
+          strokeLineJoin: 'miter',
+          strokeUniform: false,
+          strokeMiterLimit: 4,
+          scaleX: 0.1555,
+          scaleY: 0.1555,
+          angle: 0,
+          flipX: false,
+          flipY: false,
+          opacity: 1,
+          shadow: '',
+          visible: true,
+          backgroundColor: '',
+          fillRule: 'nonzero',
+          paintFirst: 'fill',
+          globalCompositeOperation: 'source-over',
+          skewX: 0,
+          skewY: 0,
+          radius: 150,
+          startAngle: 0,
+          endAngle: 360,
+          selectable: false,
+          hasControls: true,
+        },
+        {
+          type: 'i-text',
+          version: '5.3.0',
+          originX: 'left',
+          originY: 'top',
+          left: -15.8708,
+          top: -8.9298,
+          width: 160,
+          height: 90.4,
+          fill: 'rgba(255,255,255,1)',
+          stroke: null,
+          strokeWidth: 1,
+          strokeDashArray: null,
+          strokeLineCap: 'butt',
+          strokeDashOffset: 0,
+          strokeLineJoin: 'miter',
+          strokeUniform: false,
+          strokeMiterLimit: 4,
+          scaleX: 0.1954,
+          scaleY: 0.1954,
+          angle: 0,
+          flipX: false,
+          flipY: false,
+          opacity: 1,
+          shadow: '',
+          visible: true,
+          backgroundColor: '',
+          fillRule: 'nonzero',
+          paintFirst: 'fill',
+          globalCompositeOperation: 'source-over',
+          skewX: 0,
+          skewY: 0,
+          fontFamily: 'arial',
+          fontWeight: 'normal',
+          fontSize: 80,
+          text: '警告',
+          underline: false,
+          overline: false,
+          linethrough: false,
+          textAlign: 'left',
+          fontStyle: 'normal',
+          lineHeight: 1.16,
+          textBackgroundColor: '',
+          charSpacing: 0,
+          styles: [],
+          direction: 'ltr',
+          path: null,
+          pathStartOffset: 0,
+          pathSide: 'left',
+          pathAlign: 'baseline',
+          selectable: false,
+          hasControls: true,
+        },
+      ],
+    },
+    {
+      type: 'group',
+      version: '5.3.0',
+      originX: 'left',
+      originY: 'top',
+      left: 409.6953,
+      top: 437.8391,
+      width: 48.205,
+      height: 48.205,
+      fill: 'rgb(0,0,0)',
+      stroke: null,
+      strokeWidth: 0,
+      strokeDashArray: null,
+      strokeLineCap: 'butt',
+      strokeDashOffset: 0,
+      strokeLineJoin: 'miter',
+      strokeUniform: false,
+      strokeMiterLimit: 4,
+      scaleX: 1,
+      scaleY: 1,
+      angle: 0,
+      flipX: false,
+      flipY: false,
+      opacity: 1,
+      shadow: null,
+      visible: true,
+      backgroundColor: '',
+      fillRule: 'nonzero',
+      paintFirst: 'fill',
+      globalCompositeOperation: 'source-over',
+      skewX: 0,
+      skewY: 0,
+      id: '16c614ab-6172-4d06-b787-75e8ddc33c68',
+      selectable: false,
+      hasControls: true,
+      userProperty: {
+        modelId: '122',
+        status: '0',
+        id: '3',
+        label: '正常',
+        des: '客厅1',
+      },
+      objects: [
+        {
+          type: 'circle',
+          version: '5.3.0',
+          originX: 'left',
+          originY: 'top',
+          left: -24.1025,
+          top: -24.1025,
+          width: 300,
+          height: 300,
+          fill: 'rgba(44,246,72,0.99)',
+          stroke: 'rgba(45,240,230,1)',
+          strokeWidth: 10,
+          strokeDashArray: null,
+          strokeLineCap: 'butt',
+          strokeDashOffset: 0,
+          strokeLineJoin: 'miter',
+          strokeUniform: false,
+          strokeMiterLimit: 4,
+          scaleX: 0.1555,
+          scaleY: 0.1555,
+          angle: 0,
+          flipX: false,
+          flipY: false,
+          opacity: 1,
+          shadow: '',
+          visible: true,
+          backgroundColor: '',
+          fillRule: 'nonzero',
+          paintFirst: 'fill',
+          globalCompositeOperation: 'source-over',
+          skewX: 0,
+          skewY: 0,
+          radius: 150,
+          startAngle: 0,
+          endAngle: 360,
+          selectable: false,
+          hasControls: true,
+        },
+        {
+          type: 'i-text',
+          version: '5.3.0',
+          originX: 'left',
+          originY: 'top',
+          left: -16.7824,
+          top: -8.9323,
+          width: 160,
+          height: 90.4,
+          fill: 'rgba(255,255,255,1)',
+          stroke: null,
+          strokeWidth: 1,
+          strokeDashArray: null,
+          strokeLineCap: 'butt',
+          strokeDashOffset: 0,
+          strokeLineJoin: 'miter',
+          strokeUniform: false,
+          strokeMiterLimit: 4,
+          scaleX: 0.1954,
+          scaleY: 0.1954,
+          angle: 0,
+          flipX: false,
+          flipY: false,
+          opacity: 1,
+          shadow: '',
+          visible: true,
+          backgroundColor: '',
+          fillRule: 'nonzero',
+          paintFirst: 'fill',
+          globalCompositeOperation: 'source-over',
+          skewX: 0,
+          skewY: 0,
+          fontFamily: 'arial',
+          fontWeight: 'normal',
+          fontSize: 80,
+          text: '正常',
+          underline: false,
+          overline: false,
+          linethrough: false,
+          textAlign: 'left',
+          fontStyle: 'normal',
+          lineHeight: 1.16,
+          textBackgroundColor: '',
+          charSpacing: 0,
+          styles: [],
+          direction: 'ltr',
+          path: null,
+          pathStartOffset: 0,
+          pathSide: 'left',
+          pathAlign: 'baseline',
+          selectable: false,
+          hasControls: true,
+        },
+      ],
+    },
+    {
+      type: 'group',
+      version: '5.3.0',
+      originX: 'left',
+      originY: 'top',
+      left: 384.136,
+      top: 706.1746,
+      width: 48.205,
+      height: 48.205,
+      fill: 'rgb(0,0,0)',
+      stroke: null,
+      strokeWidth: 0,
+      strokeDashArray: null,
+      strokeLineCap: 'butt',
+      strokeDashOffset: 0,
+      strokeLineJoin: 'miter',
+      strokeUniform: false,
+      strokeMiterLimit: 4,
+      scaleX: 1,
+      scaleY: 1,
+      angle: 0,
+      flipX: false,
+      flipY: false,
+      opacity: 1,
+      shadow: null,
+      visible: true,
+      backgroundColor: '',
+      fillRule: 'nonzero',
+      paintFirst: 'fill',
+      globalCompositeOperation: 'source-over',
+      skewX: 0,
+      skewY: 0,
+      id: '6217576c-4b4a-4916-948a-e99fe9f03bbc',
+      selectable: false,
+      hasControls: true,
+      userProperty: {
+        modelId: '124',
+        status: '1',
+        id: '4',
+        label: '异常',
+        des: '卧室C',
+      },
+      objects: [
+        {
+          type: 'circle',
+          version: '5.3.0',
+          originX: 'left',
+          originY: 'top',
+          left: -24.1025,
+          top: -24.1025,
+          width: 300,
+          height: 300,
+          fill: 'rgba(248,9,3,0.94)',
+          stroke: 'rgba(255,243,47,1)',
+          strokeWidth: 10,
+          strokeDashArray: null,
+          strokeLineCap: 'butt',
+          strokeDashOffset: 0,
+          strokeLineJoin: 'miter',
+          strokeUniform: false,
+          strokeMiterLimit: 4,
+          scaleX: 0.1555,
+          scaleY: 0.1555,
+          angle: 0,
+          flipX: false,
+          flipY: false,
+          opacity: 1,
+          shadow: '',
+          visible: true,
+          backgroundColor: '',
+          fillRule: 'nonzero',
+          paintFirst: 'fill',
+          globalCompositeOperation: 'source-over',
+          skewX: 0,
+          skewY: 0,
+          radius: 150,
+          startAngle: 0,
+          endAngle: 360,
+          selectable: false,
+          hasControls: true,
+        },
+        {
+          type: 'i-text',
+          version: '5.3.0',
+          originX: 'left',
+          originY: 'top',
+          left: -15.8708,
+          top: -8.9298,
+          width: 160,
+          height: 90.4,
+          fill: 'rgba(255,255,255,1)',
+          stroke: null,
+          strokeWidth: 1,
+          strokeDashArray: null,
+          strokeLineCap: 'butt',
+          strokeDashOffset: 0,
+          strokeLineJoin: 'miter',
+          strokeUniform: false,
+          strokeMiterLimit: 4,
+          scaleX: 0.1954,
+          scaleY: 0.1954,
+          angle: 0,
+          flipX: false,
+          flipY: false,
+          opacity: 1,
+          shadow: '',
+          visible: true,
+          backgroundColor: '',
+          fillRule: 'nonzero',
+          paintFirst: 'fill',
+          globalCompositeOperation: 'source-over',
+          skewX: 0,
+          skewY: 0,
+          fontFamily: 'arial',
+          fontWeight: 'normal',
+          fontSize: 80,
+          text: '警告',
+          underline: false,
+          overline: false,
+          linethrough: false,
+          textAlign: 'left',
+          fontStyle: 'normal',
+          lineHeight: 1.16,
+          textBackgroundColor: '',
+          charSpacing: 0,
+          styles: [],
+          direction: 'ltr',
+          path: null,
+          pathStartOffset: 0,
+          pathSide: 'left',
+          pathAlign: 'baseline',
+          selectable: false,
+          hasControls: true,
+        },
+      ],
+    },
+  ],
+  clipPath: {
+    type: 'rect',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: 0,
+    top: 0,
+    width: 1200,
+    height: 900,
+    fill: 'rgba(255,255,255,1)',
+    stroke: null,
+    strokeWidth: 0,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    rx: 0,
+    ry: 0,
+    selectable: false,
+    hasControls: true,
+  },
+};
+let currJson00: Record<string, any> = {
+  ...currJson0,
+  // objects: [],
+};
+
+// 生成100到1100之间的随机整数
+// function generateRandomNumber(minNum, maxNum) {
+//   // 生成0到1之间的随机小数
+//   const randomFraction = Math.random();
+
+//   // 将随机小数映射到100到1100之间的范围
+//   const randomNumber = Math.floor(randomFraction * (maxNum - minNum + 1) + minNum);
+
+//   return randomNumber;
+// }
+// let startTime = new Date().getTime()
+// let endTime = new Date().getTime()
+
+// for (let i = 0; i < 2; i++) {
+//   let currObjects = JSON.parse(JSON.stringify(currJson0.objects))
+//   currObjects = currObjects.map(item=>{
+//     item.left = generateRandomNumber(100, 1100)
+//     item.top = generateRandomNumber(100, 800)
+//     return item
+//   })
+//   currJson00.objects = currJson00.objects.concat(currObjects)
+// }
+// endTime = new Date().getTime()
+// console.log(currJson00,'currJson00', endTime-startTime)
+
+export const currJson1 = currJson00;
+
+export const modelGroups = modelGroup
diff --git a/src/testData/fabricRoomList.ts b/src/testData/fabricRoomList.ts
new file mode 100644
index 0000000..b917dda
--- /dev/null
+++ b/src/testData/fabricRoomList.ts
@@ -0,0 +1,147 @@
+/*
+ * @Author: zhoux zhouxia@supervision.ltd
+ * @Date: 2023-12-12 15:41:56
+ * @LastEditors: zhoux zhouxia@supervision.ltd
+ * @LastEditTime: 2023-12-15 17:22:03
+ * @FilePath: \general-ai-platform-web\src\testData\fabricRoomList.ts
+ * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+ */
+
+import { fetchWatchGroupObjects } from './fabricWatchIcons';
+// 模型状态 在线 离线 告警  故障
+const startData: Record<string, any> = {
+  modelsList: [
+    {
+      deviceType: '1', // 模型类型 1 设备1 2 设备2
+      id: '1001', // 模型id
+      status: 'watchOnline', //
+      deviceName: '监控设备1', // 模型名称
+      deviceCode: 'code1002',
+      deviceLocation: '客厅',
+      deviceParams: '设备参数',
+      deviceCategory: '控制器',
+      diviceGroup: '组1',
+      baseInfo: {
+        left: 527.0215, // 相对x
+        top: 24.5797, // 相对y
+      },
+    },
+    {
+      deviceType: '1', // 模型类型 1 设备1 2 设备2
+      id: '1002', // 模型id
+      status: 'watchError', // 模型状态 在线 离线 告警  故障
+      deviceName: '监控设备2', // 模型名称
+      deviceCode: 'code1001',
+      deviceLocation: '客厅',
+      deviceParams: '设备参数',
+      deviceCategory: '控制器',
+      diviceGroup: '组1',
+      baseInfo: {
+        left: 397.0215, // 相对x
+        top: 444.5797, // 相对y
+      },
+    },
+    {
+      deviceType: '1', // 模型类型 1 设备1 2 设备2
+      id: '1003', // 模型id
+      status: 'watchOutline', // 模型状态 在线 离线 告警  故障
+      deviceName: '监控设备2', // 模型名称
+      deviceCode: 'code1001',
+      deviceLocation: '客厅',
+      deviceParams: '设备参数',
+      deviceCategory: '控制器',
+      diviceGroup: '组1',
+      baseInfo: {
+        left: 397.0215, // 相对x
+        top: 144.5797, // 相对y
+      },
+    },
+    {
+      deviceType: '1', // 模型类型 1 设备1 2 设备2
+      id: '1004', // 模型id
+      status: 'watchOutline', // 模型状态 在线 离线 告警  故障
+      deviceName: '监控设备2', // 模型名称
+      deviceCode: 'code1001',
+      deviceLocation: '客厅',
+      deviceParams: '设备参数',
+      deviceCategory: '控制器',
+      diviceGroup: '组1',
+      baseInfo: {
+        left: 297.0215, // 相对x
+        top: 644.5797, // 相对y
+      },
+    },
+    {
+      deviceType: '1', // 模型类型 1 设备1 2 设备2
+      id: '1005', // 模型id
+      status: 'watchWarn', // 模型状态 在线 离线 告警  故障
+      deviceName: '监控设备2', // 模型名称
+      deviceCode: 'code1001',
+      deviceLocation: '客厅',
+      deviceParams: '设备参数',
+      deviceCategory: '控制器',
+      diviceGroup: '组1',
+      baseInfo: {
+        left: 797.0215, // 相对x
+        top: 844.5797, // 相对y
+      },
+    },
+  ],
+};
+
+const fabricRoomListData: Record<string, any>[] = [];
+startData.modelsList.forEach((item: Record<string, any>) => {
+  const { baseInfo, ...restInfo } = item;
+  fabricRoomListData.push(
+    JSON.parse(
+      JSON.stringify({
+        ...fetchWatchGroupObjects(item),
+        ...baseInfo,
+        userProperty: item,
+        selectable: false,
+      }),
+    ),
+  );
+});
+
+export const currJson = {
+  version: '5.3.0',
+  objects: fabricRoomListData,
+  clipPath: {
+    type: 'rect',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: 0,
+    top: 0,
+    width: 1200,
+    height: 900,
+    fill: 'rgba(255,255,255,1)',
+    stroke: null,
+    strokeWidth: 0,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    rx: 0,
+    ry: 0,
+    selectable: false,
+    hasControls: true,
+  },
+};
diff --git a/src/testData/fabricRoomSvg.ts b/src/testData/fabricRoomSvg.ts
new file mode 100644
index 0000000..0fa87a9
--- /dev/null
+++ b/src/testData/fabricRoomSvg.ts
@@ -0,0 +1,49 @@
+/*
+ * @Author: zhoux zhouxia@supervision.ltd
+ * @Date: 2023-12-12 14:11:22
+ * @LastEditors: zhoux zhouxia@supervision.ltd
+ * @LastEditTime: 2023-12-15 18:00:38
+ * @FilePath: \general-ai-platform-web\src\testData\fabricRoomSvg.ts
+ * @Description: 这是默认设置,请设置`customMade`, 打开koroFileHeader查看配置 进行设置: https://github.com/OBKoro1/koro1FileHeader/wiki/%E9%85%8D%E7%BD%AE
+ */
+export const bgImageData = {
+  type: 'image',
+  version: '5.3.0',
+  originX: 'left',
+  originY: 'top',
+  left: 1.531,
+  top: 0,
+  width: 1600,
+  height: 1200,
+  fill: 'rgb(0,0,0)',
+  stroke: null,
+  strokeWidth: 0,
+  strokeDashArray: null,
+  strokeLineCap: 'butt',
+  strokeDashOffset: 0,
+  strokeLineJoin: 'miter',
+  strokeUniform: false,
+  strokeMiterLimit: 4,
+  scaleX: 1,
+  scaleY: 1,
+  angle: 0,
+  flipX: false,
+  flipY: false,
+  opacity: 1,
+  shadow: null,
+  visible: true,
+  backgroundColor: '',
+  fillRule: 'nonzero',
+  paintFirst: 'fill',
+  globalCompositeOperation: 'source-over',
+  skewX: 0,
+  skewY: 0,
+  cropX: 0,
+  cropY: 0,
+  id: 'a3fccbda-f75a-4c52-9fc0-98a2dde189b9',
+  selectable: true,
+  hasControls: true,
+  src: 'data:image/png;base64,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',
+  crossOrigin: null,
+  filters: [],
+};
diff --git a/src/testData/fabricWatchIcons.ts b/src/testData/fabricWatchIcons.ts
new file mode 100644
index 0000000..0f09a84
--- /dev/null
+++ b/src/testData/fabricWatchIcons.ts
@@ -0,0 +1,1825 @@
+export const watchIcon1: Record<string, any>[] = [
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -60,
+    top: -31.5,
+    width: 119,
+    height: 54,
+    fill: 'white',
+    stroke: null,
+    strokeWidth: 1,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'evenodd',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 10, 2],
+      ['C', 7.79086, 2, 6, 3.79086, 6, 6],
+      ['L', 6, 44],
+      ['C', 6, 46.2091, 7.79086, 48, 10, 48],
+      ['L', 58.8, 48],
+      ['L', 66, 56],
+      ['L', 73.2, 48],
+      ['L', 121, 48],
+      ['C', 123.209, 48, 125, 46.2091, 125, 44],
+      ['L', 125, 6],
+      ['C', 125, 3.79086, 123.209, 2, 121, 2],
+      ['L', 10, 2],
+      ['Z'],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -61,
+    top: -32.5,
+    width: 121,
+    height: 56.4948,
+    fill: 'rgba(21,77,221,0.2)',
+    stroke: null,
+    strokeWidth: 1,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 58.8, 48],
+      ['L', 59.5433, 47.331],
+      ['L', 59.2454, 47],
+      ['L', 58.8, 47],
+      ['L', 58.8, 48],
+      ['Z'],
+      ['M', 66, 56],
+      ['L', 65.2567, 56.669],
+      ['L', 66, 57.4948],
+      ['L', 66.7433, 56.669],
+      ['L', 66, 56],
+      ['Z'],
+      ['M', 73.2, 48],
+      ['L', 73.2, 47],
+      ['L', 72.7546, 47],
+      ['L', 72.4567, 47.331],
+      ['L', 73.2, 48],
+      ['Z'],
+      ['M', 7, 6],
+      ['C', 7, 4.34315, 8.34315, 3, 10, 3],
+      ['L', 10, 1],
+      ['C', 7.23858, 1, 5, 3.23857, 5, 6],
+      ['L', 7, 6],
+      ['Z'],
+      ['M', 7, 44],
+      ['L', 7, 6],
+      ['L', 5, 6],
+      ['L', 5, 44],
+      ['L', 7, 44],
+      ['Z'],
+      ['M', 10, 47],
+      ['C', 8.34315, 47, 7, 45.6569, 7, 44],
+      ['L', 5, 44],
+      ['C', 5, 46.7614, 7.23858, 49, 10, 49],
+      ['L', 10, 47],
+      ['Z'],
+      ['M', 58.8, 47],
+      ['L', 10, 47],
+      ['L', 10, 49],
+      ['L', 58.8, 49],
+      ['L', 58.8, 47],
+      ['Z'],
+      ['M', 58.0567, 48.669],
+      ['L', 65.2567, 56.669],
+      ['L', 66.7433, 55.331],
+      ['L', 59.5433, 47.331],
+      ['L', 58.0567, 48.669],
+      ['Z'],
+      ['M', 66.7433, 56.669],
+      ['L', 73.9433, 48.669],
+      ['L', 72.4567, 47.331],
+      ['L', 65.2567, 55.331],
+      ['L', 66.7433, 56.669],
+      ['Z'],
+      ['M', 121, 47],
+      ['L', 73.2, 47],
+      ['L', 73.2, 49],
+      ['L', 121, 49],
+      ['L', 121, 47],
+      ['Z'],
+      ['M', 124, 44],
+      ['C', 124, 45.6569, 122.657, 47, 121, 47],
+      ['L', 121, 49],
+      ['C', 123.761, 49, 126, 46.7614, 126, 44],
+      ['L', 124, 44],
+      ['Z'],
+      ['M', 124, 6],
+      ['L', 124, 44],
+      ['L', 126, 44],
+      ['L', 126, 6],
+      ['L', 124, 6],
+      ['Z'],
+      ['M', 121, 3],
+      ['C', 122.657, 3, 124, 4.34315, 124, 6],
+      ['L', 126, 6],
+      ['C', 126, 3.23858, 123.761, 1, 121, 1],
+      ['L', 121, 3],
+      ['Z'],
+      ['M', 10, 3],
+      ['L', 121, 3],
+      ['L', 121, 1],
+      ['L', 10, 1],
+      ['L', 10, 3],
+      ['Z'],
+    ],
+  },
+  {
+    type: 'rect',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -52,
+    top: -24.5,
+    width: 32,
+    height: 32,
+    fill: '#E80D0D',
+    stroke: null,
+    strokeWidth: 1,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    rx: 2,
+    ry: 2,
+    selectable: true,
+    hasControls: true,
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -45.9945,
+    top: -17.6,
+    width: 19.8963,
+    height: 0,
+    fill: '',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 40.0018, 16],
+      ['L', 29.5301, 16],
+      ['L', 20.1055, 16],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -36.5727,
+    top: -17.6,
+    width: 0,
+    height: 8.8419,
+    fill: '',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 29.5273, 24.8419],
+      ['L', 29.5273, 16],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -46.1,
+    top: -10.5375,
+    width: 18.5869,
+    height: 10.9372,
+    fill: 'white',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 21.8972, 23.0625],
+      ['L', 38.5869, 27.5048],
+      ['L', 37.6746, 28.8773],
+      ['L', 35.579, 32.6272],
+      ['L', 34.6667, 33.9997],
+      ['L', 20, 30.0959],
+      ['L', 21.8972, 23.0625],
+      ['Z'],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -30.5219,
+    top: -4.7211,
+    width: 4.1186,
+    height: 4.5576,
+    fill: '',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 37.6737, 28.8789],
+      ['L', 39.6967, 29.4174],
+      ['L', 38.6126, 33.4365],
+      ['L', 35.5781, 32.6288],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -43.3008,
+    top: -7.6387,
+    width: 4.2123,
+    height: 4.181,
+    fill: '',
+    stroke: '#E80D0D',
+    strokeWidth: 0.5,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 26.6615, 27.7018],
+      ['C', 26.6615, 28.8548, 25.7201, 29.7923, 24.5554, 29.7923],
+      ['C', 23.3906, 29.7923, 22.4492, 28.8548, 22.4492, 27.7018],
+      ['C', 22.4492, 26.5488, 23.3906, 25.6113, 24.5554, 25.6113],
+      ['C', 25.7201, 25.6113, 26.6615, 26.5488, 26.6615, 27.7018],
+      ['Z'],
+    ],
+  },
+];
+export const watchIcon2: Record<string, any>[] = [
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -60,
+    top: -31.5,
+    width: 119,
+    height: 54,
+    fill: 'white',
+    stroke: null,
+    strokeWidth: 1,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'evenodd',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 10, 2],
+      ['C', 7.79086, 2, 6, 3.79086, 6, 6],
+      ['L', 6, 44],
+      ['C', 6, 46.2091, 7.79086, 48, 10, 48],
+      ['L', 58.8, 48],
+      ['L', 66, 56],
+      ['L', 73.2, 48],
+      ['L', 121, 48],
+      ['C', 123.209, 48, 125, 46.2091, 125, 44],
+      ['L', 125, 6],
+      ['C', 125, 3.79086, 123.209, 2, 121, 2],
+      ['L', 10, 2],
+      ['Z'],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -61,
+    top: -32.5,
+    width: 121,
+    height: 56.4948,
+    fill: 'rgba(21,77,221,0.2)',
+    stroke: null,
+    strokeWidth: 1,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 58.8, 48],
+      ['L', 59.5433, 47.331],
+      ['L', 59.2454, 47],
+      ['L', 58.8, 47],
+      ['L', 58.8, 48],
+      ['Z'],
+      ['M', 66, 56],
+      ['L', 65.2567, 56.669],
+      ['L', 66, 57.4948],
+      ['L', 66.7433, 56.669],
+      ['L', 66, 56],
+      ['Z'],
+      ['M', 73.2, 48],
+      ['L', 73.2, 47],
+      ['L', 72.7546, 47],
+      ['L', 72.4567, 47.331],
+      ['L', 73.2, 48],
+      ['Z'],
+      ['M', 7, 6],
+      ['C', 7, 4.34315, 8.34315, 3, 10, 3],
+      ['L', 10, 1],
+      ['C', 7.23858, 1, 5, 3.23857, 5, 6],
+      ['L', 7, 6],
+      ['Z'],
+      ['M', 7, 44],
+      ['L', 7, 6],
+      ['L', 5, 6],
+      ['L', 5, 44],
+      ['L', 7, 44],
+      ['Z'],
+      ['M', 10, 47],
+      ['C', 8.34315, 47, 7, 45.6569, 7, 44],
+      ['L', 5, 44],
+      ['C', 5, 46.7614, 7.23858, 49, 10, 49],
+      ['L', 10, 47],
+      ['Z'],
+      ['M', 58.8, 47],
+      ['L', 10, 47],
+      ['L', 10, 49],
+      ['L', 58.8, 49],
+      ['L', 58.8, 47],
+      ['Z'],
+      ['M', 58.0567, 48.669],
+      ['L', 65.2567, 56.669],
+      ['L', 66.7433, 55.331],
+      ['L', 59.5433, 47.331],
+      ['L', 58.0567, 48.669],
+      ['Z'],
+      ['M', 66.7433, 56.669],
+      ['L', 73.9433, 48.669],
+      ['L', 72.4567, 47.331],
+      ['L', 65.2567, 55.331],
+      ['L', 66.7433, 56.669],
+      ['Z'],
+      ['M', 121, 47],
+      ['L', 73.2, 47],
+      ['L', 73.2, 49],
+      ['L', 121, 49],
+      ['L', 121, 47],
+      ['Z'],
+      ['M', 124, 44],
+      ['C', 124, 45.6569, 122.657, 47, 121, 47],
+      ['L', 121, 49],
+      ['C', 123.761, 49, 126, 46.7614, 126, 44],
+      ['L', 124, 44],
+      ['Z'],
+      ['M', 124, 6],
+      ['L', 124, 44],
+      ['L', 126, 44],
+      ['L', 126, 6],
+      ['L', 124, 6],
+      ['Z'],
+      ['M', 121, 3],
+      ['C', 122.657, 3, 124, 4.34315, 124, 6],
+      ['L', 126, 6],
+      ['C', 126, 3.23858, 123.761, 1, 121, 1],
+      ['L', 121, 3],
+      ['Z'],
+      ['M', 10, 3],
+      ['L', 121, 3],
+      ['L', 121, 1],
+      ['L', 10, 1],
+      ['L', 10, 3],
+      ['Z'],
+    ],
+  },
+  {
+    type: 'rect',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -52,
+    top: -24.5,
+    width: 32,
+    height: 32,
+    fill: '#52C41A',
+    stroke: null,
+    strokeWidth: 1,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    rx: 2,
+    ry: 2,
+    selectable: true,
+    hasControls: true,
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -45.9945,
+    top: -17.6,
+    width: 19.8963,
+    height: 0,
+    fill: '',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 40.0018, 16],
+      ['L', 29.5301, 16],
+      ['L', 20.1055, 16],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -36.5727,
+    top: -17.6,
+    width: 0,
+    height: 8.8419,
+    fill: '',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 29.5273, 24.8419],
+      ['L', 29.5273, 16],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -46.1,
+    top: -10.5375,
+    width: 18.5869,
+    height: 10.9372,
+    fill: 'white',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 21.8972, 23.0625],
+      ['L', 38.5869, 27.5048],
+      ['L', 37.6746, 28.8773],
+      ['L', 35.579, 32.6272],
+      ['L', 34.6667, 33.9997],
+      ['L', 20, 30.0959],
+      ['L', 21.8972, 23.0625],
+      ['Z'],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -30.5219,
+    top: -4.7211,
+    width: 4.1186,
+    height: 4.5576,
+    fill: '',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 37.6737, 28.8789],
+      ['L', 39.6967, 29.4174],
+      ['L', 38.6126, 33.4365],
+      ['L', 35.5781, 32.6288],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -43.3008,
+    top: -7.6387,
+    width: 4.2123,
+    height: 4.181,
+    fill: '',
+    stroke: '#52C41A',
+    strokeWidth: 0.5,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 26.6615, 27.7018],
+      ['C', 26.6615, 28.8548, 25.7201, 29.7923, 24.5554, 29.7923],
+      ['C', 23.3906, 29.7923, 22.4492, 28.8548, 22.4492, 27.7018],
+      ['C', 22.4492, 26.5488, 23.3906, 25.6113, 24.5554, 25.6113],
+      ['C', 25.7201, 25.6113, 26.6615, 26.5488, 26.6615, 27.7018],
+      ['Z'],
+    ],
+  },
+];
+export const watchIcon3: Record<string, any>[] = [
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -60,
+    top: -31.5,
+    width: 119,
+    height: 54,
+    fill: 'white',
+    stroke: null,
+    strokeWidth: 1,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'evenodd',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 10, 2],
+      ['C', 7.79086, 2, 6, 3.79086, 6, 6],
+      ['L', 6, 44],
+      ['C', 6, 46.2091, 7.79086, 48, 10, 48],
+      ['L', 58.8, 48],
+      ['L', 66, 56],
+      ['L', 73.2, 48],
+      ['L', 121, 48],
+      ['C', 123.209, 48, 125, 46.2091, 125, 44],
+      ['L', 125, 6],
+      ['C', 125, 3.79086, 123.209, 2, 121, 2],
+      ['L', 10, 2],
+      ['Z'],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -61,
+    top: -32.5,
+    width: 121,
+    height: 56.4948,
+    fill: 'rgba(21,77,221,0.2)',
+    stroke: null,
+    strokeWidth: 1,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 58.8, 48],
+      ['L', 59.5433, 47.331],
+      ['L', 59.2454, 47],
+      ['L', 58.8, 47],
+      ['L', 58.8, 48],
+      ['Z'],
+      ['M', 66, 56],
+      ['L', 65.2567, 56.669],
+      ['L', 66, 57.4948],
+      ['L', 66.7433, 56.669],
+      ['L', 66, 56],
+      ['Z'],
+      ['M', 73.2, 48],
+      ['L', 73.2, 47],
+      ['L', 72.7546, 47],
+      ['L', 72.4567, 47.331],
+      ['L', 73.2, 48],
+      ['Z'],
+      ['M', 7, 6],
+      ['C', 7, 4.34315, 8.34315, 3, 10, 3],
+      ['L', 10, 1],
+      ['C', 7.23858, 1, 5, 3.23857, 5, 6],
+      ['L', 7, 6],
+      ['Z'],
+      ['M', 7, 44],
+      ['L', 7, 6],
+      ['L', 5, 6],
+      ['L', 5, 44],
+      ['L', 7, 44],
+      ['Z'],
+      ['M', 10, 47],
+      ['C', 8.34315, 47, 7, 45.6569, 7, 44],
+      ['L', 5, 44],
+      ['C', 5, 46.7614, 7.23858, 49, 10, 49],
+      ['L', 10, 47],
+      ['Z'],
+      ['M', 58.8, 47],
+      ['L', 10, 47],
+      ['L', 10, 49],
+      ['L', 58.8, 49],
+      ['L', 58.8, 47],
+      ['Z'],
+      ['M', 58.0567, 48.669],
+      ['L', 65.2567, 56.669],
+      ['L', 66.7433, 55.331],
+      ['L', 59.5433, 47.331],
+      ['L', 58.0567, 48.669],
+      ['Z'],
+      ['M', 66.7433, 56.669],
+      ['L', 73.9433, 48.669],
+      ['L', 72.4567, 47.331],
+      ['L', 65.2567, 55.331],
+      ['L', 66.7433, 56.669],
+      ['Z'],
+      ['M', 121, 47],
+      ['L', 73.2, 47],
+      ['L', 73.2, 49],
+      ['L', 121, 49],
+      ['L', 121, 47],
+      ['Z'],
+      ['M', 124, 44],
+      ['C', 124, 45.6569, 122.657, 47, 121, 47],
+      ['L', 121, 49],
+      ['C', 123.761, 49, 126, 46.7614, 126, 44],
+      ['L', 124, 44],
+      ['Z'],
+      ['M', 124, 6],
+      ['L', 124, 44],
+      ['L', 126, 44],
+      ['L', 126, 6],
+      ['L', 124, 6],
+      ['Z'],
+      ['M', 121, 3],
+      ['C', 122.657, 3, 124, 4.34315, 124, 6],
+      ['L', 126, 6],
+      ['C', 126, 3.23858, 123.761, 1, 121, 1],
+      ['L', 121, 3],
+      ['Z'],
+      ['M', 10, 3],
+      ['L', 121, 3],
+      ['L', 121, 1],
+      ['L', 10, 1],
+      ['L', 10, 3],
+      ['Z'],
+    ],
+  },
+  {
+    type: 'rect',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -52,
+    top: -24.5,
+    width: 32,
+    height: 32,
+    fill: '#CCCCCC',
+    stroke: null,
+    strokeWidth: 1,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    rx: 2,
+    ry: 2,
+    selectable: true,
+    hasControls: true,
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -45.9945,
+    top: -17.6,
+    width: 19.8963,
+    height: 0,
+    fill: '',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 40.0018, 16],
+      ['L', 29.5301, 16],
+      ['L', 20.1055, 16],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -36.5727,
+    top: -17.6,
+    width: 0,
+    height: 8.8419,
+    fill: '',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 29.5273, 24.8419],
+      ['L', 29.5273, 16],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -46.1,
+    top: -10.5375,
+    width: 18.5869,
+    height: 10.9372,
+    fill: 'white',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 21.8972, 23.0625],
+      ['L', 38.5869, 27.5048],
+      ['L', 37.6746, 28.8773],
+      ['L', 35.579, 32.6272],
+      ['L', 34.6667, 33.9997],
+      ['L', 20, 30.0959],
+      ['L', 21.8972, 23.0625],
+      ['Z'],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -30.5219,
+    top: -4.7211,
+    width: 4.1186,
+    height: 4.5576,
+    fill: '',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 37.6737, 28.8789],
+      ['L', 39.6967, 29.4174],
+      ['L', 38.6126, 33.4365],
+      ['L', 35.5781, 32.6288],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -43.3008,
+    top: -7.6387,
+    width: 4.2123,
+    height: 4.181,
+    fill: '',
+    stroke: '#CCCCCC',
+    strokeWidth: 0.5,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 26.6615, 27.7018],
+      ['C', 26.6615, 28.8548, 25.7201, 29.7923, 24.5554, 29.7923],
+      ['C', 23.3906, 29.7923, 22.4492, 28.8548, 22.4492, 27.7018],
+      ['C', 22.4492, 26.5488, 23.3906, 25.6113, 24.5554, 25.6113],
+      ['C', 25.7201, 25.6113, 26.6615, 26.5488, 26.6615, 27.7018],
+      ['Z'],
+    ],
+  },
+];
+export const watchIcon4: Record<string, any>[] = [
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -60,
+    top: -31.5,
+    width: 119,
+    height: 54,
+    fill: 'white',
+    stroke: null,
+    strokeWidth: 1,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'evenodd',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 10, 2],
+      ['C', 7.79086, 2, 6, 3.79086, 6, 6],
+      ['L', 6, 44],
+      ['C', 6, 46.2091, 7.79086, 48, 10, 48],
+      ['L', 58.8, 48],
+      ['L', 66, 56],
+      ['L', 73.2, 48],
+      ['L', 121, 48],
+      ['C', 123.209, 48, 125, 46.2091, 125, 44],
+      ['L', 125, 6],
+      ['C', 125, 3.79086, 123.209, 2, 121, 2],
+      ['L', 10, 2],
+      ['Z'],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -61,
+    top: -32.5,
+    width: 121,
+    height: 56.4948,
+    fill: 'rgba(21,77,221,0.2)',
+    stroke: null,
+    strokeWidth: 1,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 58.8, 48],
+      ['L', 59.5433, 47.331],
+      ['L', 59.2454, 47],
+      ['L', 58.8, 47],
+      ['L', 58.8, 48],
+      ['Z'],
+      ['M', 66, 56],
+      ['L', 65.2567, 56.669],
+      ['L', 66, 57.4948],
+      ['L', 66.7433, 56.669],
+      ['L', 66, 56],
+      ['Z'],
+      ['M', 73.2, 48],
+      ['L', 73.2, 47],
+      ['L', 72.7546, 47],
+      ['L', 72.4567, 47.331],
+      ['L', 73.2, 48],
+      ['Z'],
+      ['M', 7, 6],
+      ['C', 7, 4.34315, 8.34315, 3, 10, 3],
+      ['L', 10, 1],
+      ['C', 7.23858, 1, 5, 3.23857, 5, 6],
+      ['L', 7, 6],
+      ['Z'],
+      ['M', 7, 44],
+      ['L', 7, 6],
+      ['L', 5, 6],
+      ['L', 5, 44],
+      ['L', 7, 44],
+      ['Z'],
+      ['M', 10, 47],
+      ['C', 8.34315, 47, 7, 45.6569, 7, 44],
+      ['L', 5, 44],
+      ['C', 5, 46.7614, 7.23858, 49, 10, 49],
+      ['L', 10, 47],
+      ['Z'],
+      ['M', 58.8, 47],
+      ['L', 10, 47],
+      ['L', 10, 49],
+      ['L', 58.8, 49],
+      ['L', 58.8, 47],
+      ['Z'],
+      ['M', 58.0567, 48.669],
+      ['L', 65.2567, 56.669],
+      ['L', 66.7433, 55.331],
+      ['L', 59.5433, 47.331],
+      ['L', 58.0567, 48.669],
+      ['Z'],
+      ['M', 66.7433, 56.669],
+      ['L', 73.9433, 48.669],
+      ['L', 72.4567, 47.331],
+      ['L', 65.2567, 55.331],
+      ['L', 66.7433, 56.669],
+      ['Z'],
+      ['M', 121, 47],
+      ['L', 73.2, 47],
+      ['L', 73.2, 49],
+      ['L', 121, 49],
+      ['L', 121, 47],
+      ['Z'],
+      ['M', 124, 44],
+      ['C', 124, 45.6569, 122.657, 47, 121, 47],
+      ['L', 121, 49],
+      ['C', 123.761, 49, 126, 46.7614, 126, 44],
+      ['L', 124, 44],
+      ['Z'],
+      ['M', 124, 6],
+      ['L', 124, 44],
+      ['L', 126, 44],
+      ['L', 126, 6],
+      ['L', 124, 6],
+      ['Z'],
+      ['M', 121, 3],
+      ['C', 122.657, 3, 124, 4.34315, 124, 6],
+      ['L', 126, 6],
+      ['C', 126, 3.23858, 123.761, 1, 121, 1],
+      ['L', 121, 3],
+      ['Z'],
+      ['M', 10, 3],
+      ['L', 121, 3],
+      ['L', 121, 1],
+      ['L', 10, 1],
+      ['L', 10, 3],
+      ['Z'],
+    ],
+  },
+  {
+    type: 'rect',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -52,
+    top: -24.5,
+    width: 32,
+    height: 32,
+    fill: '#FAAD14',
+    stroke: null,
+    strokeWidth: 1,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    rx: 2,
+    ry: 2,
+    selectable: true,
+    hasControls: true,
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -45.9945,
+    top: -17.6,
+    width: 19.8963,
+    height: 0,
+    fill: '',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 40.0018, 16],
+      ['L', 29.5301, 16],
+      ['L', 20.1055, 16],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -36.5727,
+    top: -17.6,
+    width: 0,
+    height: 8.8419,
+    fill: '',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 29.5273, 24.8419],
+      ['L', 29.5273, 16],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -46.1,
+    top: -10.5375,
+    width: 18.5869,
+    height: 10.9372,
+    fill: 'white',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 21.8972, 23.0625],
+      ['L', 38.5869, 27.5048],
+      ['L', 37.6746, 28.8773],
+      ['L', 35.579, 32.6272],
+      ['L', 34.6667, 33.9997],
+      ['L', 20, 30.0959],
+      ['L', 21.8972, 23.0625],
+      ['Z'],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -30.5219,
+    top: -4.7211,
+    width: 4.1186,
+    height: 4.5576,
+    fill: '',
+    stroke: 'white',
+    strokeWidth: 1.2,
+    strokeDashArray: null,
+    strokeLineCap: 'round',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'round',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 37.6737, 28.8789],
+      ['L', 39.6967, 29.4174],
+      ['L', 38.6126, 33.4365],
+      ['L', 35.5781, 32.6288],
+    ],
+  },
+  {
+    type: 'path',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: -43.3008,
+    top: -7.6387,
+    width: 4.2123,
+    height: 4.181,
+    fill: '',
+    stroke: '#FAAD14',
+    strokeWidth: 0.5,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    selectable: true,
+    hasControls: true,
+    path: [
+      ['M', 26.6615, 27.7018],
+      ['C', 26.6615, 28.8548, 25.7201, 29.7923, 24.5554, 29.7923],
+      ['C', 23.3906, 29.7923, 22.4492, 28.8548, 22.4492, 27.7018],
+      ['C', 22.4492, 26.5488, 23.3906, 25.6113, 24.5554, 25.6113],
+      ['C', 25.7201, 25.6113, 26.6615, 26.5488, 26.6615, 27.7018],
+      ['Z'],
+    ],
+  },
+];
+
+
+export const fetchWatchGroupObjects: Record<string, any> = (record: {
+  status: string;
+  deviceName: string;
+}) => {
+  const { status, deviceName } = record;
+  let watchIconObject = watchIcon1;
+  switch (status) {
+    case 'watchError':
+      watchIconObject = watchIcon1;
+      break;
+    case 'watchOnline':
+      watchIconObject = watchIcon2;
+      break;
+    case 'watchOutline':
+      watchIconObject = watchIcon3;
+      break;
+    case 'watchWarn':
+      watchIconObject = watchIcon4;
+      break;
+  }
+  console.log(deviceName, 'deviceName');
+  return {
+    type: 'group',
+    version: '5.3.0',
+    originX: 'left',
+    originY: 'top',
+    left: 20.9866,
+    top: 16.4716,
+    width: 131,
+    height: 66,
+    fill: 'rgb(0,0,0)',
+    stroke: null,
+    strokeWidth: 0,
+    strokeDashArray: null,
+    strokeLineCap: 'butt',
+    strokeDashOffset: 0,
+    strokeLineJoin: 'miter',
+    strokeUniform: false,
+    strokeMiterLimit: 4,
+    scaleX: 1,
+    scaleY: 1,
+    angle: 0,
+    flipX: false,
+    flipY: false,
+    opacity: 1,
+    shadow: null,
+    visible: true,
+    backgroundColor: '',
+    fillRule: 'nonzero',
+    paintFirst: 'fill',
+    globalCompositeOperation: 'source-over',
+    skewX: 0,
+    skewY: 0,
+    id: '160e5a54-0126-473e-908a-5f74a2a8a14a',
+    selectable: true,
+    hasControls: true,
+    objects: [
+      {
+        type: 'group',
+        version: '5.3.0',
+        originX: 'left',
+        originY: 'top',
+        left: -65.5,
+        top: -33,
+        width: 131,
+        height: 66,
+        fill: 'rgb(0,0,0)',
+        stroke: null,
+        strokeWidth: 0,
+        strokeDashArray: null,
+        strokeLineCap: 'butt',
+        strokeDashOffset: 0,
+        strokeLineJoin: 'miter',
+        strokeUniform: false,
+        strokeMiterLimit: 4,
+        scaleX: 1,
+        scaleY: 1,
+        angle: 0,
+        flipX: false,
+        flipY: false,
+        opacity: 1,
+        shadow: '',
+        visible: true,
+        backgroundColor: '',
+        fillRule: 'nonzero',
+        paintFirst: 'fill',
+        globalCompositeOperation: 'source-over',
+        skewX: 0,
+        skewY: 0,
+        selectable: true,
+        hasControls: true,
+        objects: watchIconObject,
+      },
+      {
+        type: 'textbox',
+        version: '5.3.0',
+        originX: 'left',
+        originY: 'top',
+        left: -15.709,
+        top: -15.0177,
+        width: 67.6873,
+        height: 13.56,
+        fill: 'rgb(0,0,0)',
+        stroke: null,
+        strokeWidth: 1,
+        strokeDashArray: null,
+        strokeLineCap: 'butt',
+        strokeDashOffset: 0,
+        strokeLineJoin: 'miter',
+        strokeUniform: false,
+        strokeMiterLimit: 4,
+        scaleX: 1,
+        scaleY: 1,
+        angle: 0,
+        flipX: false,
+        flipY: false,
+        opacity: 1,
+        shadow: '',
+        visible: true,
+        backgroundColor: '',
+        fillRule: 'nonzero',
+        paintFirst: 'fill',
+        globalCompositeOperation: 'source-over',
+        skewX: 0,
+        skewY: 0,
+        fontFamily: 'arial',
+        fontWeight: 'normal',
+        fontSize: 14,
+        text: deviceName,
+        underline: false,
+        overline: false,
+        linethrough: false,
+        textAlign: 'left',
+        fontStyle: 'normal',
+        lineHeight: 1.16,
+        textBackgroundColor: '',
+        charSpacing: 0,
+        styles: [],
+        direction: 'ltr',
+        path: null,
+        pathStartOffset: 0,
+        pathSide: 'left',
+        pathAlign: 'baseline',
+        minWidth: 20,
+        splitByGrapheme: true,
+        selectable: true,
+        hasControls: true,
+      },
+    ],
+  };
+};