@sonoransoftware/sonoran.js 1.0.62 → 1.0.64

package/dist/libs/rest/src/lib/REST.js

@@ -251,24 +251,26 @@ class REST extends events_1.EventEmitter {
             case 'UNIT_STATUS': {
                 const payload = args[0];
                 if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
-                    const { apiId, account, status, serverId } = payload;
-                    return { apiId, account, status, serverId };
+                    const { apiId, account, status, serverId, identIds } = payload;
+                    return { apiId, account, status, serverId, identIds };
                 }
                 return {
                     apiId: args[0],
                     status: args[1],
-                    serverId: args[2]
+                    serverId: args[2],
+                    identIds: args[3]
                 };
             }
             case 'UNIT_PANIC': {
                 const payload = args[0];
                 if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
-                    const { apiId, account, isPanic } = payload;
-                    return { apiId, account, isPanic };
+                    const { apiId, account, isPanic, identIds } = payload;
+                    return { apiId, account, isPanic, identIds };
                 }
                 return {
                     apiId: args[0],
-                    isPanic: args[1]
+                    isPanic: args[1],
+                    identIds: args[2]
                 };
             }
             case 'IDENTS_TO_GROUP': {

package/dist/libs/rest/src/lib/utils/constants.d.ts

@@ -273,6 +273,7 @@ export interface CADUnitPanicStruct {
     apiId?: string;
     account?: string;
     isPanic: boolean;
+    identIds?: number[];
 }
 export declare enum CADDispatchOriginEnums {
     Caller = 0,
@@ -324,6 +325,7 @@ export interface CADUnitStatusStruct {
     account?: string;
     status: number;
     serverId: number;
+    identIds?: number[];
 }
 export interface RESTTypedAPIDataStructs {
     GET_SERVERS: [];
@@ -395,14 +397,16 @@ export interface RESTTypedAPIDataStructs {
     IDENTS_TO_GROUP: [data: CADIdentsToGroupStruct[]];
     UNIT_PANIC: [
         apiId: string | undefined,
-        isPanic: boolean
+        isPanic: boolean,
+        identIds?: number[]
     ] | [
         data: CADUnitPanicStruct
     ];
     UNIT_STATUS: [
         apiId: string | undefined,
         status: number,
-        serverId: number
+        serverId: number,
+        identIds?: number[]
     ] | [
         data: CADUnitStatusStruct
     ];

package/dist/managers/CADManager.d.ts

@@ -160,17 +160,18 @@ export declare class CADManager extends BaseManager {
     /**
      * Toggles panic state for a unit.
      */
-    setUnitPanic(apiId: string | undefined, isPanic: boolean): Promise<globalTypes.CADStandardResponse>;
+    setUnitPanic(apiId: string | undefined, isPanic: boolean, identIds?: number[]): Promise<globalTypes.CADStandardResponse>;
     setUnitPanic(params: CADUnitPanicStruct): Promise<globalTypes.CADStandardResponse>;
     /**
      * Updates a unit's status.
      */
-    setUnitStatus(apiId: string | undefined, status: number, serverId: number): Promise<globalTypes.CADStandardResponse>;
+    setUnitStatus(apiId: string | undefined, status: number, serverId: number, identIds?: number[]): Promise<globalTypes.CADStandardResponse>;
     setUnitStatus(params: {
         apiId?: string;
         account?: string;
         status: number;
         serverId: number;
+        identIds?: number[];
     }): Promise<globalTypes.CADStandardResponse>;
     /**
      * Retrieves live map blips for a CAD server.

package/dist/managers/CADManager.js

@@ -407,47 +407,67 @@ class CADManager extends BaseManager_1.BaseManager {
         });
         return this.executeCadRequest('IDENTS_TO_GROUP', payload);
     }
-    async setUnitPanic(apiIdOrParams, isPanic) {
+    async setUnitPanic(apiIdOrParams, isPanic, identIds) {
         let payload;
         if (apiIdOrParams && typeof apiIdOrParams === 'object') {
             payload = { ...apiIdOrParams };
         }
         else {
-            payload = { apiId: apiIdOrParams, isPanic: isPanic };
+            payload = { apiId: apiIdOrParams, isPanic: isPanic, identIds };
         }
-        const { apiId, account, isPanic: resolvedPanic } = payload;
+        const { apiId, account, isPanic: resolvedPanic, identIds: resolvedIdentIds } = payload;
         if (resolvedPanic === undefined) {
             throw new Error('isPanic is required when setting unit panic.');
         }
-        if (!apiId && !account) {
-            throw new Error('Either apiId or account is required when setting unit panic.');
+        if (resolvedIdentIds !== undefined && (!Array.isArray(resolvedIdentIds) || resolvedIdentIds.some((id) => !Number.isInteger(id)))) {
+            throw new Error('identIds must be an array of integers when setting unit panic.');
+        }
+        const hasIdentIds = Array.isArray(resolvedIdentIds) && resolvedIdentIds.length > 0;
+        if (!apiId && !account && !hasIdentIds) {
+            throw new Error('Either apiId, account, or identIds is required when setting unit panic.');
         }
-        return this.executeCadRequest('UNIT_PANIC', { apiId, account, isPanic: resolvedPanic });
+        return this.executeCadRequest('UNIT_PANIC', {
+            apiId,
+            account,
+            isPanic: resolvedPanic,
+            identIds: hasIdentIds ? resolvedIdentIds : undefined
+        });
     }
-    async setUnitStatus(apiIdOrParams, status, serverId) {
+    async setUnitStatus(apiIdOrParams, status, serverId, identIds) {
         let payload;
         if (apiIdOrParams && typeof apiIdOrParams === 'object' && !Array.isArray(apiIdOrParams)) {
             payload = {
                 apiId: apiIdOrParams.apiId,
                 account: apiIdOrParams.account,
                 status: apiIdOrParams.status,
-                serverId: apiIdOrParams.serverId
+                serverId: apiIdOrParams.serverId,
+                identIds: apiIdOrParams.identIds
             };
         }
         else {
-            payload = { apiId: apiIdOrParams, status: status, serverId: serverId };
+            payload = { apiId: apiIdOrParams, status: status, serverId: serverId, identIds };
         }
-        const { apiId, account, status: resolvedStatus, serverId: resolvedServerId } = payload;
+        const { apiId, account, status: resolvedStatus, serverId: resolvedServerId, identIds: resolvedIdentIds } = payload;
         if (!Number.isInteger(resolvedServerId)) {
             throw new Error('serverId must be an integer when updating unit status.');
         }
         if (resolvedStatus === undefined) {
             throw new Error('status is required when updating unit status.');
         }
-        if (!apiId && !account) {
-            throw new Error('Either apiId or account is required when updating unit status.');
+        if (resolvedIdentIds !== undefined && (!Array.isArray(resolvedIdentIds) || resolvedIdentIds.some((id) => !Number.isInteger(id)))) {
+            throw new Error('identIds must be an array of integers when updating unit status.');
         }
-        return this.executeCadRequest('UNIT_STATUS', { apiId, account, status: resolvedStatus, serverId: resolvedServerId });
+        const hasIdentIds = Array.isArray(resolvedIdentIds) && resolvedIdentIds.length > 0;
+        if (!apiId && !account && !hasIdentIds) {
+            throw new Error('Either apiId, account, or identIds is required when updating unit status.');
+        }
+        return this.executeCadRequest('UNIT_STATUS', {
+            apiId,
+            account,
+            status: resolvedStatus,
+            serverId: resolvedServerId,
+            identIds: hasIdentIds ? resolvedIdentIds : undefined
+        });
     }
     /**
      * Retrieves live map blips for a CAD server.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sonoransoftware/sonoran.js",
-  "version": "1.0.62",
+  "version": "1.0.64",
   "description": "Sonoran.js is a library that allows you to interact with the Sonoran CAD and Sonoran CMS API. Based off of and utilizes several Discord.js library techniques for ease of use.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/readme.md

@@ -105,7 +105,7 @@ const lookupByAccount = await instance.cad.lookupRecords({ account: 'd5663516-ee
 - **`getIdentifiers(apiId)`**
 - **`modifyIdentifier(change)`** / **`setIdentifier(apiId?, identId)`**
 - **`setIdentifiersToGroup(entries)`** - assigns identifiers to a group name (empty string clears).
-- **`setUnitPanic({ apiId?, account?, isPanic })`** / **`setUnitStatus({ status, serverId, apiId?, account? })`**
+- **`setUnitPanic({ apiId?, account?, isPanic, identIds? })`** / **`setUnitStatus({ status, serverId, apiId?, account?, identIds? })`**
 - **`getActiveUnits(options)`** - direct CAD fetch for active units.
 - **`kickUnit(apiId?, reason, serverId)`**
 - **`updateUnitLocations(locations)`**
@@ -115,8 +115,12 @@ const lookupByAccount = await instance.cad.lookupRecords({ account: 'd5663516-ee
 await instance.cad.setUnitStatus({ account: 'd5663516-ee35-11e9-9714-5600023b2434', status: 2, serverId: 1 });
 // Legacy positional call using an API ID
 await instance.cad.setUnitStatus('1234567890', 2, 1);
+// Update status by identifier IDs
+await instance.cad.setUnitStatus({ identIds: [101, 102], status: 2, serverId: 1 });
 // Trigger panic using account UUID
 await instance.cad.setUnitPanic({ account: '91de0ce8-c571-11e9-9714-5600023b2434', isPanic: true });
+// Trigger panic by identifier IDs
+await instance.cad.setUnitPanic({ identIds: [101, 102], isPanic: true });
 ```
 
 ### Map & Streetsigns

package/src/libs/rest/src/lib/REST.ts

@@ -355,29 +355,32 @@ export class REST extends EventEmitter {
 			case 'UNIT_STATUS': {
 				const payload = args[0];
 				if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
-					const { apiId, account, status, serverId } = payload as {
+					const { apiId, account, status, serverId, identIds } = payload as {
 						apiId?: string;
 						account?: string;
 						status: number;
 						serverId: number;
+						identIds?: number[];
 					};
-					return { apiId, account, status, serverId };
+					return { apiId, account, status, serverId, identIds };
 				}
 				return {
 					apiId: args[0],
 					status: args[1],
-					serverId: args[2]
+					serverId: args[2],
+					identIds: args[3]
 				};
 			}
 			case 'UNIT_PANIC': {
 				const payload = args[0];
 				if (payload && typeof payload === 'object' && !Array.isArray(payload)) {
-					const { apiId, account, isPanic } = payload as { apiId?: string; account?: string; isPanic: boolean };
-					return { apiId, account, isPanic };
+					const { apiId, account, isPanic, identIds } = payload as { apiId?: string; account?: string; isPanic: boolean; identIds?: number[] };
+					return { apiId, account, isPanic, identIds };
 				}
 				return {
 					apiId: args[0],
-					isPanic: args[1]
+					isPanic: args[1],
+					identIds: args[2]
 				};
 			}
 			case 'IDENTS_TO_GROUP': {

package/src/libs/rest/src/lib/utils/constants.ts

@@ -970,6 +970,7 @@ export interface CADUnitPanicStruct {
 	apiId?: string;
 	account?: string;
 	isPanic: boolean;
+	identIds?: number[];
 }
 
 export enum CADDispatchOriginEnums {
@@ -1024,6 +1025,7 @@ export interface CADUnitStatusStruct {
 	account?: string;
 	status: number;
 	serverId: number;
+	identIds?: number[];
 }
 
 export interface RESTTypedAPIDataStructs {
@@ -1095,14 +1097,16 @@ export interface RESTTypedAPIDataStructs {
 	IDENTS_TO_GROUP: [data: CADIdentsToGroupStruct[]];
 	UNIT_PANIC: [
 		apiId: string | undefined,
-		isPanic: boolean
+		isPanic: boolean,
+		identIds?: number[]
 	] | [
 		data: CADUnitPanicStruct
 	];
 	UNIT_STATUS: [
 		apiId: string | undefined,
 		status: number,
-		serverId: number
+		serverId: number,
+		identIds?: number[]
 	] | [
 		data: CADUnitStatusStruct
 	];

package/src/managers/CADManager.ts

@@ -437,34 +437,44 @@ export class CADManager extends BaseManager {
   /**
    * Toggles panic state for a unit.
    */
-  public async setUnitPanic(apiId: string | undefined, isPanic: boolean): Promise<globalTypes.CADStandardResponse>;
+  public async setUnitPanic(apiId: string | undefined, isPanic: boolean, identIds?: number[]): Promise<globalTypes.CADStandardResponse>;
   public async setUnitPanic(params: CADUnitPanicStruct): Promise<globalTypes.CADStandardResponse>;
-  public async setUnitPanic(apiIdOrParams: string | CADUnitPanicStruct | undefined, isPanic?: boolean): Promise<globalTypes.CADStandardResponse> {
+  public async setUnitPanic(apiIdOrParams: string | CADUnitPanicStruct | undefined, isPanic?: boolean, identIds?: number[]): Promise<globalTypes.CADStandardResponse> {
     let payload: CADUnitPanicStruct;
     if (apiIdOrParams && typeof apiIdOrParams === 'object') {
       payload = { ...apiIdOrParams };
     } else {
-      payload = { apiId: apiIdOrParams as string | undefined, isPanic: isPanic as boolean };
+      payload = { apiId: apiIdOrParams as string | undefined, isPanic: isPanic as boolean, identIds };
     }
-    const { apiId, account, isPanic: resolvedPanic } = payload;
+    const { apiId, account, isPanic: resolvedPanic, identIds: resolvedIdentIds } = payload;
     if (resolvedPanic === undefined) {
       throw new Error('isPanic is required when setting unit panic.');
     }
-    if (!apiId && !account) {
-      throw new Error('Either apiId or account is required when setting unit panic.');
+    if (resolvedIdentIds !== undefined && (!Array.isArray(resolvedIdentIds) || resolvedIdentIds.some((id) => !Number.isInteger(id)))) {
+      throw new Error('identIds must be an array of integers when setting unit panic.');
+    }
+    const hasIdentIds = Array.isArray(resolvedIdentIds) && resolvedIdentIds.length > 0;
+    if (!apiId && !account && !hasIdentIds) {
+      throw new Error('Either apiId, account, or identIds is required when setting unit panic.');
     }
-    return this.executeCadRequest('UNIT_PANIC', { apiId, account, isPanic: resolvedPanic });
+    return this.executeCadRequest('UNIT_PANIC', {
+      apiId,
+      account,
+      isPanic: resolvedPanic,
+      identIds: hasIdentIds ? resolvedIdentIds : undefined
+    });
   }
 
   /**
    * Updates a unit's status.
    */
-  public async setUnitStatus(apiId: string | undefined, status: number, serverId: number): Promise<globalTypes.CADStandardResponse>;
-  public async setUnitStatus(params: { apiId?: string; account?: string; status: number; serverId: number }): Promise<globalTypes.CADStandardResponse>;
+  public async setUnitStatus(apiId: string | undefined, status: number, serverId: number, identIds?: number[]): Promise<globalTypes.CADStandardResponse>;
+  public async setUnitStatus(params: { apiId?: string; account?: string; status: number; serverId: number; identIds?: number[] }): Promise<globalTypes.CADStandardResponse>;
   public async setUnitStatus(
-    apiIdOrParams: string | undefined | { apiId?: string; account?: string; status: number; serverId: number },
+    apiIdOrParams: string | undefined | { apiId?: string; account?: string; status: number; serverId: number; identIds?: number[] },
     status?: number,
-    serverId?: number
+    serverId?: number,
+    identIds?: number[]
   ): Promise<globalTypes.CADStandardResponse> {
     let payload: CADUnitStatusStruct;
     if (apiIdOrParams && typeof apiIdOrParams === 'object' && !Array.isArray(apiIdOrParams)) {
@@ -472,22 +482,33 @@ export class CADManager extends BaseManager {
         apiId: apiIdOrParams.apiId,
         account: apiIdOrParams.account,
         status: apiIdOrParams.status,
-        serverId: apiIdOrParams.serverId
+        serverId: apiIdOrParams.serverId,
+        identIds: apiIdOrParams.identIds
       };
     } else {
-      payload = { apiId: apiIdOrParams as string | undefined, status: status as number, serverId: serverId as number };
+      payload = { apiId: apiIdOrParams as string | undefined, status: status as number, serverId: serverId as number, identIds };
     }
-    const { apiId, account, status: resolvedStatus, serverId: resolvedServerId } = payload;
+    const { apiId, account, status: resolvedStatus, serverId: resolvedServerId, identIds: resolvedIdentIds } = payload;
     if (!Number.isInteger(resolvedServerId)) {
       throw new Error('serverId must be an integer when updating unit status.');
     }
     if (resolvedStatus === undefined) {
       throw new Error('status is required when updating unit status.');
     }
-    if (!apiId && !account) {
-      throw new Error('Either apiId or account is required when updating unit status.');
+    if (resolvedIdentIds !== undefined && (!Array.isArray(resolvedIdentIds) || resolvedIdentIds.some((id) => !Number.isInteger(id)))) {
+      throw new Error('identIds must be an array of integers when updating unit status.');
     }
-    return this.executeCadRequest('UNIT_STATUS', { apiId, account, status: resolvedStatus, serverId: resolvedServerId });
+    const hasIdentIds = Array.isArray(resolvedIdentIds) && resolvedIdentIds.length > 0;
+    if (!apiId && !account && !hasIdentIds) {
+      throw new Error('Either apiId, account, or identIds is required when updating unit status.');
+    }
+    return this.executeCadRequest('UNIT_STATUS', {
+      apiId,
+      account,
+      status: resolvedStatus,
+      serverId: resolvedServerId,
+      identIds: hasIdentIds ? resolvedIdentIds : undefined
+    });
   }
 
   /**