nayota-show-sdk 1.3.88 → 1.3.90

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nayota-show-sdk",
-  "version": "1.3.88",
+  "version": "1.3.90",
   "description": "nayota-show-server rest-api",
   "type": "module",
   "main": "index.js",

package/utils/iot-module-specs.js

@@ -257,6 +257,40 @@ function normalizeHierarchyField(data = {}, field) {
   return getNestedValue(data, `relationInfo.${field}`)
 }
 
+function normalizeHierarchyFloorPlanForWrite(data = {}) {
+  const relationInfo = data.relationInfo
+  const hasLegacyImage = hasOwn(relationInfo, 'image')
+
+  if (hasLegacyImage) {
+    const image = relationInfo.image
+
+    if (image == null) {
+      return null
+    }
+
+    if (typeof image !== 'object') {
+      return image
+    }
+
+    const hasImagePath = Boolean(image.imagePath || image.url)
+    const hasDimensions = Number(image.width || 0) > 0 && Number(image.height || 0) > 0
+    const hasCorners = Array.isArray(image.corners) && image.corners.length > 0
+    const hasImageIdentity = Boolean(image.id)
+
+    if (!hasImagePath && !hasDimensions && !hasCorners && !hasImageIdentity) {
+      return null
+    }
+
+    return image
+  }
+
+  if (hasOwn(data, 'floorPlan')) {
+    return data.floorPlan
+  }
+
+  return undefined
+}
+
 function normalizeLegacyHierarchyRelationInfo(item = {}) {
   const relationInfo = removeUndefinedFields({
     ...(item.relationInfo || {}),
@@ -314,7 +348,7 @@ function mapDepartsToIotBody(data = {}) {
     latlng: normalizeHierarchyField(data, 'latlng'),
     zooms: normalizeHierarchyField(data, 'zooms'),
     powers: normalizeHierarchyField(data, 'powers'),
-    floorPlan: data.floorPlan,
+    floorPlan: normalizeHierarchyFloorPlanForWrite(data),
     metadata: Object.keys(metadata).length ? metadata : undefined
   })
 }
@@ -477,6 +511,90 @@ function normalizeLegacyValueStr(value, fallback = '') {
   return ''
 }
 
+function normalizeLegacyEasyListPropTypeValue(value) {
+  if (value == null || value === '') {
+    return undefined
+  }
+
+  const normalized = String(value).trim().replace(/[\s_-]/g, '').toLowerCase()
+
+  if (['operate', 'operation', 'control', 'controller', 'write', 'writable', 'readwrite', 'writeonly', 'rw', 'wr', 'w'].includes(normalized)) {
+    return 'Operate'
+  }
+
+  if (['check', 'monitor', 'sensor', 'read', 'readonly', 'ro', 'r'].includes(normalized)) {
+    return 'Check'
+  }
+
+  if (['控制', '控制器', '读写', '只写', '可写'].includes(normalized)) {
+    return 'Operate'
+  }
+
+  if (['监测', '监测器', '只读'].includes(normalized)) {
+    return 'Check'
+  }
+
+  if ((normalized.includes('write') || normalized.includes('写')) && normalized !== 'readonly' && normalized !== '只读') {
+    return 'Operate'
+  }
+
+  if (normalized.includes('read') || normalized.includes('读') || normalized.includes('check')) {
+    return 'Check'
+  }
+
+  return undefined
+}
+
+function resolveLegacyEasyListPropType(source = {}, prop = {}) {
+  const explicitCandidates = [
+    source.propType,
+    source.type,
+    source.propertyType,
+    prop.propType,
+    prop.type,
+    prop.propertyType,
+    getNestedValue(source, 'metadata.propType'),
+    getNestedValue(prop, 'metadata.propType')
+  ]
+
+  const explicitPropType = explicitCandidates
+    .map(normalizeLegacyEasyListPropTypeValue)
+    .find(Boolean)
+
+  if (explicitPropType) {
+    return explicitPropType
+  }
+
+  const accessCandidates = [
+    source.access,
+    source.propertyAccess,
+    source.accessMode,
+    source.permission,
+    source.permissions,
+    source.accessPermission,
+    prop.access,
+    prop.propertyAccess,
+    prop.accessMode,
+    prop.permission,
+    prop.permissions,
+    prop.accessPermission,
+    getNestedValue(source, 'metadata.access'),
+    getNestedValue(source, 'metadata.propertyAccess'),
+    getNestedValue(source, 'typeProperty.access'),
+    getNestedValue(source, 'deviceProperty.access'),
+    getNestedValue(source, 'deviceTypeProperty.access'),
+    getNestedValue(prop, 'metadata.access'),
+    getNestedValue(prop, 'metadata.propertyAccess'),
+    getNestedValue(prop, 'typeProperty.access'),
+    getNestedValue(prop, 'deviceProperty.access'),
+    getNestedValue(prop, 'deviceTypeProperty.access')
+  ]
+
+  return accessCandidates
+    .map(normalizeLegacyEasyListPropTypeValue)
+    .find(Boolean)
+}
+
 function normalizeLegacyPropLine(source = {}, prop = {}, row = {}) {
   if (typeof source.line === 'boolean') {
     return source.line
@@ -630,10 +748,12 @@ function normalizeLegacyEasyListProp(source = {}, row = {}) {
   const isStatus = Boolean(source.isStatus)
   const isNumber = Boolean(source.isNumber)
   const isImport = Boolean(source.isImport || isMain || isStatus || isNumber)
+  const propType = resolveLegacyEasyListPropType(source, prop)
 
   const legacyProp = removeUndefinedFields({
     ...prop,
     _id: propId,
+    propType,
     deviceId: prop.deviceId || source.deviceId || '',
     key: prop.key || source.propertyKey,
     name: prop.name || source.propName || source.name || source.code || source.propertyKey,
@@ -664,6 +784,7 @@ function normalizeLegacyEasyListProp(source = {}, row = {}) {
     isMain,
     isStatus,
     isNumber,
+    propType,
     line,
     value,
     valueStr,

package/utils/iot-module-specs.test.js

@@ -233,6 +233,47 @@ describe('iotModuleSpecs departs hierarchy compatibility', () => {
     expect(request.data.metadata).toEqual({ keep: 'value' })
   })
 
+  test('clears official floorPlan when legacy relationInfo image is explicitly removed', () => {
+    const request = departs.updateOne.toRequest({
+      _id: 'e245a3f6-d2c7-4ce1-9e02-ba9bbb347ed7',
+      floorPlan: {
+        imagePath: 'stale.svg',
+        width: 100,
+        height: 80
+      },
+      relationInfo: {
+        image: null
+      }
+    })
+
+    expect(request.data.relationInfo).toEqual({
+      image: null
+    })
+    expect(request.data.floorPlan).toBeNull()
+  })
+
+  test('clears official floorPlan when legacy relationInfo image is emptied by old BMS editor', () => {
+    const request = departs.updateOne.toRequest({
+      _id: 'e245a3f6-d2c7-4ce1-9e02-ba9bbb347ed7',
+      floorPlan: {
+        imagePath: 'stale.svg',
+        width: 100,
+        height: 80
+      },
+      relationInfo: {
+        image: {
+          imagePath: '',
+          width: 0,
+          height: 0,
+          zIndex: 0,
+          corners: []
+        }
+      }
+    })
+
+    expect(request.data.floorPlan).toBeNull()
+  })
+
   test('rebuilds legacy relationInfo from official hierarchy fields and ignores metadata fallbacks', () => {
     const response = departs.list.fromResponse({
       code: 0,
@@ -595,6 +636,60 @@ describe('iotModuleSpecs devices easyList legacy compatibility', () => {
       })
     )
   })
+
+  test('maps writable access permissions to legacy BMS Operate props', () => {
+    const response = easyList.fromResponse({
+      code: 0,
+      data: {
+        total: 1,
+        rows: [
+          {
+            id: 'twin-1',
+            props: [
+              {
+                id: 'write-only-prop',
+                propertyKey: 'reset',
+                name: '复位',
+                access: 'write_only',
+                interval: '[["复位"],[1]]',
+                prop: {
+                  id: 'device-prop-reset'
+                }
+              },
+              {
+                id: 'read-write-prop',
+                propertyKey: 'reply',
+                name: '回复',
+                propertyAccess: '读写',
+                interval: '[["确认"],[1]]',
+                prop: {
+                  id: 'device-prop-reply'
+                }
+              },
+              {
+                id: 'read-only-prop',
+                propertyKey: 'version',
+                name: '版本',
+                access: 'read_only',
+                prop: {
+                  id: 'device-prop-version'
+                }
+              }
+            ]
+          }
+        ]
+      }
+    })
+
+    const [writeOnlyProp, readWriteProp, readOnlyProp] = response.data.rows[0].props
+
+    expect(writeOnlyProp).toEqual(expect.objectContaining({ propType: 'Operate' }))
+    expect(writeOnlyProp.prop).toEqual(expect.objectContaining({ propType: 'Operate' }))
+    expect(readWriteProp).toEqual(expect.objectContaining({ propType: 'Operate' }))
+    expect(readWriteProp.prop).toEqual(expect.objectContaining({ propType: 'Operate' }))
+    expect(readOnlyProp).toEqual(expect.objectContaining({ propType: 'Check' }))
+    expect(readOnlyProp.prop).toEqual(expect.objectContaining({ propType: 'Check' }))
+  })
 })
 
 describe('iotModuleSpecs devices getPropHistoryData legacy compatibility', () => {