@sonoransoftware/sonoran.js 1.0.34 → 1.0.36

package/dist/managers/CADManager.js

@@ -41,12 +41,11 @@ class CADManager extends BaseManager_1.BaseManager {
         this.buildManager(instance);
     }
     async buildManager(instance) {
-        var _a;
         const mutableThis = this;
         try {
-            const versionResp = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('GET_VERSION'));
-            mutableThis.version = Number.parseInt(versionResp.replace(/(^\d+)(.+$)/i, '$1'));
-            if (this.version >= globalTypes.CADSubscriptionVersionEnum.STANDARD) {
+            const version = await this.getVersion();
+            mutableThis.version = version;
+            if (version >= globalTypes.CADSubscriptionVersionEnum.STANDARD) {
                 this.servers = new CADServerManager_1.CADServerManager(instance, this);
             }
             instance.isCADSuccessful = true;
@@ -58,6 +57,33 @@ class CADManager extends BaseManager_1.BaseManager {
             throw err;
         }
     }
+    getRest() {
+        if (!this.rest) {
+            throw new Error('CAD REST client is not initialized.');
+        }
+        return this.rest;
+    }
+    async executeCadRequest(type, ...args) {
+        try {
+            const response = await this.getRest().request(type, ...args);
+            return { success: true, data: response };
+        }
+        catch (err) {
+            if (err instanceof src_1.APIError) {
+                return { success: false, reason: err.response };
+            }
+            throw err;
+        }
+    }
+    /**
+     * Retrieves the community's CAD subscription version.
+     */
+    async getVersion() {
+        var _a;
+        const versionResp = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('GET_VERSION'));
+        const versionString = String(versionResp);
+        return Number.parseInt(versionString.replace(/(^\d+)(.+$)/i, '$1'), 10);
+    }
     /**
      * Gets a community account by `accId` or `apiId`.
      * @param {Object} params The object that contains parameters to get a community account.
@@ -82,5 +108,488 @@ class CADManager extends BaseManager_1.BaseManager {
             }
         });
     }
+    /**
+     * Updates the CAD clock to match in-game time.
+     */
+    async setClockTime(data) {
+        return new Promise(async (resolve, reject) => {
+            var _a;
+            try {
+                const response = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('SET_CLOCK', data));
+                resolve({ success: true, data: response });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Adds accounts to the community via the join community endpoint.
+     * NOTE: This endpoint is intended for internal CMS use and requires an internal key.
+     */
+    async joinCommunity(internalKey, accounts) {
+        if (!internalKey) {
+            throw new Error('internalKey is required to join a community.');
+        }
+        const normalizedAccounts = this.normalizeAccountEntries(accounts);
+        if (normalizedAccounts.length === 0) {
+            throw new Error('At least one account must be provided to join the community.');
+        }
+        return new Promise(async (resolve, reject) => {
+            var _a;
+            try {
+                const response = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('JOIN_COMMUNITY', { internalKey, accounts: normalizedAccounts }));
+                resolve({ success: true, data: response });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Removes accounts from the community via the leave community endpoint.
+     * NOTE: This endpoint is intended for internal CMS use and requires an internal key.
+     */
+    async leaveCommunity(internalKey, accounts) {
+        if (!internalKey) {
+            throw new Error('internalKey is required to leave a community.');
+        }
+        const normalizedAccounts = this.normalizeAccountEntries(accounts);
+        if (normalizedAccounts.length === 0) {
+            throw new Error('At least one account must be provided to leave the community.');
+        }
+        return new Promise(async (resolve, reject) => {
+            var _a;
+            try {
+                const response = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('LEAVE_COMMUNITY', { internalKey, accounts: normalizedAccounts }));
+                resolve({ success: true, data: response });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Updates the penal code configuration for the community.
+     */
+    async setPenalCodes(codes) {
+        if (!Array.isArray(codes) || codes.length === 0) {
+            throw new Error('codes array must include at least one penal code entry.');
+        }
+        return this.executeCadRequest('SET_PENAL_CODES', codes);
+    }
+    /**
+     * Assigns API IDs to a community account.
+     */
+    async setAccountApiIds(data) {
+        if (!(data === null || data === void 0 ? void 0 : data.username) || !Array.isArray(data.apiIds)) {
+            throw new Error('username and apiIds are required to set account API IDs.');
+        }
+        return this.executeCadRequest('SET_API_ID', data);
+    }
+    /**
+     * Retrieves record templates filtered by a specific record type.
+     */
+    async getRecordTemplates(recordTypeId) {
+        if (typeof recordTypeId === 'number') {
+            return this.executeCadRequest('GET_TEMPLATES', recordTypeId);
+        }
+        return this.executeCadRequest('GET_TEMPLATES');
+    }
+    /**
+     * Creates a new record entry.
+     */
+    async createRecord(data) {
+        return this.executeCadRequest('NEW_RECORD', data);
+    }
+    /**
+     * Updates an existing record entry.
+     */
+    async updateRecord(data) {
+        return this.executeCadRequest('EDIT_RECORD', data);
+    }
+    /**
+     * Removes a record by its identifier.
+     */
+    async removeRecord(id) {
+        if (!Number.isInteger(id)) {
+            throw new Error('id must be an integer when removing a record.');
+        }
+        return this.executeCadRequest('REMOVE_RECORD', id);
+    }
+    /**
+     * Performs an internal lookup using the CAD lookup by identifier endpoint.
+     */
+    async lookupByInt(data) {
+        if (!data || !('searchType' in data) || !('value' in data)) {
+            throw new Error('searchType and value are required for lookupByInt.');
+        }
+        return this.executeCadRequest('LOOKUP_INT', data);
+    }
+    /**
+     * Executes a CAD lookup using first/last name, plate, or other values.
+     */
+    async lookupRecords(data) {
+        return this.executeCadRequest('LOOKUP', data);
+    }
+    /**
+     * Checks whether the provided API ID exists.
+     */
+    async checkApiId(apiId) {
+        if (!apiId) {
+            throw new Error('apiId is required to check for existence.');
+        }
+        return this.executeCadRequest('CHECK_APIID', apiId);
+    }
+    /**
+     * Applies a permission key to an account.
+     */
+    async applyPermissionKey(apiId, permissionKey) {
+        if (!permissionKey) {
+            throw new Error('permissionKey is required when applying a permission key.');
+        }
+        return this.executeCadRequest('APPLY_PERMISSION_KEY', apiId, permissionKey);
+    }
+    /**
+     * Sets account permissions for a CAD user.
+     */
+    async setAccountPermissions(data) {
+        if (!data || (!Array.isArray(data.add) && !Array.isArray(data.remove))) {
+            throw new Error('At least one permission change is required.');
+        }
+        return this.executeCadRequest('SET_ACCOUNT_PERMISSIONS', data);
+    }
+    /**
+     * Bans or kicks a CAD user.
+     */
+    async banUser(data) {
+        if (!(data === null || data === void 0 ? void 0 : data.apiId)) {
+            throw new Error('apiId is required when banning or kicking a user.');
+        }
+        return this.executeCadRequest('BAN_USER', data);
+    }
+    /**
+     * Verifies a secret string against CAD configuration.
+     */
+    async verifySecret(secret) {
+        if (!secret) {
+            throw new Error('secret is required to verify.');
+        }
+        return this.executeCadRequest('VERIFY_SECRET', secret);
+    }
+    /**
+     * Authorizes street sign changes for a CAD server.
+     */
+    async authorizeStreetSigns(serverId) {
+        if (!Number.isInteger(serverId)) {
+            throw new Error('serverId must be an integer when authorizing street signs.');
+        }
+        return this.executeCadRequest('AUTH_STREETSIGNS', serverId);
+    }
+    /**
+     * Replaces the community postal list.
+     */
+    async setPostals(data) {
+        if (!Array.isArray(data) || data.length === 0) {
+            throw new Error('data must include at least one postal entry.');
+        }
+        return this.executeCadRequest('SET_POSTALS', data);
+    }
+    /**
+     * Sends a photo to CAD for the provided API ID.
+     */
+    async sendPhoto(apiId, url) {
+        if (!url) {
+            throw new Error('url is required to send a CAD photo.');
+        }
+        return this.executeCadRequest('SEND_PHOTO', apiId, url);
+    }
+    /**
+     * Retrieves characters belonging to an API ID.
+     */
+    async getCharacters(apiId) {
+        if (!apiId) {
+            throw new Error('apiId is required to fetch characters.');
+        }
+        return this.executeCadRequest('GET_CHARACTERS', apiId);
+    }
+    /**
+     * Creates a new civilian character.
+     */
+    async createCharacter(data) {
+        return this.executeCadRequest('NEW_CHARACTER', data);
+    }
+    /**
+     * Updates an existing civilian character.
+     */
+    async updateCharacter(data) {
+        return this.executeCadRequest('EDIT_CHARACTER', data);
+    }
+    /**
+     * Removes a civilian character by identifier.
+     */
+    async removeCharacter(id) {
+        if (!Number.isInteger(id)) {
+            throw new Error('id must be an integer when removing a character.');
+        }
+        return this.executeCadRequest('REMOVE_CHARACTER', id);
+    }
+    /**
+     * Retrieves identifiers assigned to an API ID.
+     */
+    async getIdentifiers(apiId) {
+        if (!apiId) {
+            throw new Error('apiId is required to fetch identifiers.');
+        }
+        return this.executeCadRequest('GET_IDENTIFIERS', apiId);
+    }
+    /**
+     * Modifies identifiers for an account.
+     */
+    async modifyIdentifier(data) {
+        if (!(data === null || data === void 0 ? void 0 : data.apiId)) {
+            throw new Error('apiId is required when modifying an identifier.');
+        }
+        return this.executeCadRequest('MODIFY_IDENTIFIER', data);
+    }
+    /**
+     * Sets the active identifier by identifier ID.
+     */
+    async setIdentifier(apiId, identId) {
+        if (!Number.isInteger(identId)) {
+            throw new Error('identId must be an integer when setting an identifier.');
+        }
+        return this.executeCadRequest('SET_IDENTIFIER', apiId, identId);
+    }
+    /**
+     * Toggles panic state for a unit.
+     */
+    async setUnitPanic(apiId, isPanic) {
+        return this.executeCadRequest('UNIT_PANIC', apiId, isPanic);
+    }
+    /**
+     * Updates a unit's status.
+     */
+    async setUnitStatus(apiId, status, serverId) {
+        if (!Number.isInteger(serverId)) {
+            throw new Error('serverId must be an integer when updating unit status.');
+        }
+        return this.executeCadRequest('UNIT_STATUS', apiId, status, serverId);
+    }
+    /**
+     * Retrieves live map blips for a CAD server.
+     */
+    async getBlips(serverId) {
+        if (!Number.isInteger(serverId)) {
+            throw new Error('serverId must be an integer when retrieving blips.');
+        }
+        return this.executeCadRequest('GET_BLIPS', serverId);
+    }
+    /**
+     * Adds blips to the CAD map.
+     */
+    async addBlips(blips) {
+        const payload = Array.isArray(blips) ? blips : [blips];
+        if (payload.length === 0) {
+            throw new Error('At least one blip must be provided when adding blips.');
+        }
+        return this.executeCadRequest('ADD_BLIP', payload);
+    }
+    /**
+     * Updates existing CAD map blips.
+     */
+    async updateBlips(blips) {
+        const payload = Array.isArray(blips) ? blips : [blips];
+        if (payload.length === 0) {
+            throw new Error('At least one blip must be provided when updating blips.');
+        }
+        return this.executeCadRequest('MODIFY_BLIP', payload);
+    }
+    /**
+     * Removes a CAD map blip.
+     */
+    async removeBlip(id) {
+        if (!Number.isInteger(id)) {
+            throw new Error('id must be an integer when removing a blip.');
+        }
+        return this.executeCadRequest('REMOVE_BLIP', id);
+    }
+    /**
+     * Creates a new 911 call entry.
+     */
+    async create911Call(params) {
+        const { serverId, isEmergency, caller, location, description, metaData = {} } = params;
+        if (!Number.isInteger(serverId)) {
+            throw new Error('serverId must be an integer when creating a 911 call.');
+        }
+        return this.executeCadRequest('911_CALL', serverId, isEmergency, caller, location, description, metaData);
+    }
+    /**
+     * Removes a 911 call by its identifier.
+     */
+    async remove911Call(callId) {
+        if (!Number.isInteger(callId)) {
+            throw new Error('callId must be an integer when removing a 911 call.');
+        }
+        return this.executeCadRequest('REMOVE_911', callId);
+    }
+    /**
+     * Retrieves dispatch calls with optional pagination.
+     */
+    async getCalls(options) {
+        return this.executeCadRequest('GET_CALLS', options);
+    }
+    /**
+     * Retrieves active units for the provided filters.
+     */
+    async getActiveUnits(options) {
+        return this.executeCadRequest('GET_ACTIVE_UNITS', options);
+    }
+    /**
+     * Kicks an active unit from the CAD.
+     */
+    async kickUnit(apiId, reason, serverId) {
+        if (!reason) {
+            throw new Error('reason is required when kicking a unit.');
+        }
+        if (!Number.isInteger(serverId)) {
+            throw new Error('serverId must be an integer when kicking a unit.');
+        }
+        return this.executeCadRequest('KICK_UNIT', apiId, reason, serverId);
+    }
+    /**
+     * Creates a new dispatch call.
+     */
+    async createDispatch(data) {
+        return this.executeCadRequest('NEW_DISPATCH', data);
+    }
+    /**
+     * Attaches units to an existing dispatch call.
+     */
+    async attachUnits(serverId, callId, units) {
+        if (!Number.isInteger(serverId) || !Number.isInteger(callId)) {
+            throw new Error('serverId and callId must be integers when attaching units.');
+        }
+        if (!Array.isArray(units) || units.length === 0) {
+            throw new Error('units must include at least one entry when attaching.');
+        }
+        return this.executeCadRequest('ATTACH_UNIT', serverId, callId, units);
+    }
+    /**
+     * Detaches units from dispatch calls.
+     */
+    async detachUnits(serverId, units) {
+        if (!Number.isInteger(serverId)) {
+            throw new Error('serverId must be an integer when detaching units.');
+        }
+        if (!Array.isArray(units) || units.length === 0) {
+            throw new Error('units must include at least one entry when detaching.');
+        }
+        return this.executeCadRequest('DETACH_UNIT', serverId, units);
+    }
+    /**
+     * Updates the postal code on a call.
+     */
+    async setCallPostal(serverId, callId, postal) {
+        if (!Number.isInteger(serverId) || !Number.isInteger(callId)) {
+            throw new Error('serverId and callId must be integers when setting a call postal.');
+        }
+        if (!postal) {
+            throw new Error('postal is required when setting a call postal.');
+        }
+        return this.executeCadRequest('SET_CALL_POSTAL', serverId, callId, postal);
+    }
+    /**
+     * Updates a call's primary unit.
+     */
+    async setCallPrimary(serverId, callId, primary, trackPrimary) {
+        if (!Number.isInteger(serverId) || !Number.isInteger(callId)) {
+            throw new Error('serverId and callId must be integers when setting a call primary.');
+        }
+        return this.executeCadRequest('SET_CALL_PRIMARY', serverId, callId, primary, trackPrimary);
+    }
+    /**
+     * Adds a note to an active call.
+     */
+    async addCallNote(serverId, callId, note) {
+        if (!Number.isInteger(serverId) || !Number.isInteger(callId)) {
+            throw new Error('serverId and callId must be integers when adding a call note.');
+        }
+        if (!note) {
+            throw new Error('note is required when adding a call note.');
+        }
+        return this.executeCadRequest('ADD_CALL_NOTE', serverId, callId, note);
+    }
+    /**
+     * Closes a CAD call.
+     */
+    async closeCall(serverId, callId) {
+        if (!Number.isInteger(serverId) || !Number.isInteger(callId)) {
+            throw new Error('serverId and callId must be integers when closing a call.');
+        }
+        return this.executeCadRequest('CLOSE_CALL', serverId, callId);
+    }
+    /**
+     * Updates live unit locations on the CAD map.
+     */
+    async updateUnitLocations(locations) {
+        if (!Array.isArray(locations) || locations.length === 0) {
+            throw new Error('locations must include at least one entry when updating unit locations.');
+        }
+        return this.executeCadRequest('UNIT_LOCATION', locations);
+    }
+    /**
+     * Replaces the street sign configuration for a server.
+     */
+    async setStreetSignConfig(serverId, signConfig) {
+        if (!Number.isInteger(serverId)) {
+            throw new Error('serverId must be an integer when setting street sign config.');
+        }
+        if (!Array.isArray(signConfig) || signConfig.length === 0) {
+            throw new Error('signConfig must include at least one entry when setting street sign config.');
+        }
+        return this.executeCadRequest('SET_STREETSIGN_CONFIG', serverId, signConfig);
+    }
+    /**
+     * Updates an existing street sign's text.
+     */
+    async updateStreetSign(serverId, signData) {
+        if (!Number.isInteger(serverId)) {
+            throw new Error('serverId must be an integer when updating a street sign.');
+        }
+        if (!signData || !Array.isArray(signData.ids) || signData.ids.length === 0) {
+            throw new Error('signData.ids must include at least one identifier when updating a street sign.');
+        }
+        return this.executeCadRequest('UPDATE_STREETSIGN', serverId, signData);
+    }
+    normalizeAccountEntries(input) {
+        const entries = Array.isArray(input) ? input : [input];
+        return entries
+            .filter((entry) => entry !== undefined && entry !== null)
+            .map((entry) => {
+            if (typeof entry === 'string') {
+                return { account: entry };
+            }
+            if ('account' in entry) {
+                return { account: entry.account };
+            }
+            throw new Error('Invalid account entry provided.');
+        });
+    }
 }
 exports.CADManager = CADManager;

package/dist/managers/CADServerManager.d.ts

@@ -1,8 +1,19 @@
 import { Instance } from '../instance/Instance';
+import * as globalTypes from '../constants';
 import { CADServerAPIStruct } from '../libs/rest/src';
 import { CADServer } from '../structures/CADServer';
 import { CacheManager } from './CacheManager';
 import { CADManager } from './CADManager';
 export declare class CADServerManager extends CacheManager<number, CADServer, CADServerAPIStruct> {
+    private readonly manager;
     constructor(instance: Instance, manager: CADManager);
+    /**
+     * Retrieves the CAD servers belonging to the community.
+     */
+    getServers(): Promise<CADServerAPIStruct[]>;
+    /**
+     * Updates the CAD server configuration.
+     */
+    setServers(servers: CADServerAPIStruct[], deployMap?: boolean): Promise<globalTypes.CADStandardResponse<CADServerAPIStruct[]>>;
+    private initialize;
 }

package/dist/managers/CADServerManager.js

@@ -1,28 +1,71 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CADServerManager = void 0;
+const src_1 = require("../libs/rest/src");
 const CADServer_1 = require("../structures/CADServer");
 const CacheManager_1 = require("./CacheManager");
 class CADServerManager extends CacheManager_1.CacheManager {
     constructor(instance, manager) {
         super(instance, CADServer_1.CADServer, []);
-        (async () => {
-            var _a;
-            try {
-                const serversRes = await ((_a = manager.rest) === null || _a === void 0 ? void 0 : _a.request('GET_SERVERS'));
-                const servers = JSON.parse(serversRes).servers;
-                servers.forEach((server) => {
-                    const serverStruct = {
-                        id: server.id,
-                        config: server
-                    };
+        this.manager = manager;
+        void this.initialize();
+    }
+    /**
+     * Retrieves the CAD servers belonging to the community.
+     */
+    async getServers() {
+        if (!this.manager.rest) {
+            throw new Error('CAD REST client is not initialized.');
+        }
+        const serversRes = await this.manager.rest.request('GET_SERVERS');
+        const parsed = typeof serversRes === 'string' ? JSON.parse(serversRes) : serversRes;
+        const servers = Array.isArray(parsed === null || parsed === void 0 ? void 0 : parsed.servers) ? parsed.servers : [];
+        return servers;
+    }
+    /**
+     * Updates the CAD server configuration.
+     */
+    async setServers(servers, deployMap = false) {
+        if (!Array.isArray(servers) || servers.length === 0) {
+            throw new Error('servers array must include at least one server configuration.');
+        }
+        if (!this.manager.rest) {
+            throw new Error('CAD REST client is not initialized.');
+        }
+        try {
+            const response = await this.manager.rest.request('SET_SERVERS', servers, deployMap);
+            const parsed = typeof response === 'string' ? JSON.parse(response) : response;
+            const updated = Array.isArray(parsed === null || parsed === void 0 ? void 0 : parsed.servers) ? parsed.servers : Array.isArray(parsed) ? parsed : [];
+            if (updated.length > 0) {
+                this.cache.clear();
+                updated.forEach((server) => {
+                    const serverStruct = { id: server.id, config: server };
                     this._add(serverStruct, true, server.id);
                 });
             }
-            catch (err) {
-                throw new Error(String(err));
+            return { success: true, data: updated };
+        }
+        catch (err) {
+            if (err instanceof src_1.APIError) {
+                return { success: false, reason: err.response };
             }
-        })();
+            throw err;
+        }
+    }
+    async initialize() {
+        try {
+            const servers = await this.getServers();
+            servers.forEach((server) => {
+                const serverStruct = {
+                    id: server.id,
+                    config: server
+                };
+                this._add(serverStruct, true, server.id);
+            });
+        }
+        catch (err) {
+            throw new Error(String(err));
+        }
     }
 }
 exports.CADServerManager = CADServerManager;