@sonoransoftware/sonoran.js 1.0.34 → 1.0.36

package/dist/managers/RadioManager.js

@@ -0,0 +1,224 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RadioManager = void 0;
+const src_1 = require("../libs/rest/src");
+const BaseManager_1 = require("./BaseManager");
+const globalTypes = __importStar(require("../constants"));
+/**
+ * Manages all Sonoran Radio API interactions.
+ */
+class RadioManager extends BaseManager_1.BaseManager {
+    constructor(instance) {
+        super(instance);
+        this.ready = false;
+        this.failReason = null;
+        this.rest = new src_1.REST(instance, this, globalTypes.productEnums.RADIO, src_1.DefaultRadioRestOptions);
+        void this.buildManager(instance);
+    }
+    async buildManager(instance) {
+        const mutableThis = this;
+        try {
+            mutableThis.ready = true;
+            instance.isRadioSuccessful = true;
+            instance.emit('RADIO_SETUP_SUCCESSFUL');
+        }
+        catch (err) {
+            mutableThis.failReason = err;
+            instance.emit('RADIO_SETUP_UNSUCCESSFUL', err);
+            throw err;
+        }
+    }
+    /**
+     * Retrieves the configured community channel groups and channels.
+     */
+    async getCommunityChannels() {
+        return new Promise(async (resolve, reject) => {
+            var _a;
+            try {
+                const response = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('RADIO_GET_COMMUNITY_CHANNELS'));
+                resolve({ success: true, data: response });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Retrieves all connected users for the community.
+     */
+    async getConnectedUsers() {
+        return new Promise(async (resolve, reject) => {
+            var _a;
+            try {
+                const response = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('RADIO_GET_CONNECTED_USERS'));
+                resolve({ success: true, data: response });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Retrieves a specific connected user by room id and identity.
+     * @param {number} roomId Multi-server room id.
+     * @param {string} identity User account UUID.
+     */
+    async getConnectedUser(roomId, identity) {
+        return new Promise(async (resolve, reject) => {
+            var _a;
+            try {
+                const response = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('RADIO_GET_CONNECTED_USER', roomId, identity));
+                resolve({ success: true, data: response });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Updates a user's transmit and scanned channel configuration.
+     * @param {string} identity The user's UUID.
+     * @param {RadioSetUserChannelsOptions} options Transmit and scan channel configuration.
+     */
+    async setUserChannels(identity, options = {}) {
+        return new Promise(async (resolve, reject) => {
+            var _a, _b;
+            try {
+                const response = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('RADIO_SET_USER_CHANNELS', identity, options));
+                resolve({ success: true, result: (_b = response === null || response === void 0 ? void 0 : response.result) !== null && _b !== void 0 ? _b : response });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Updates a user's display name.
+     * @param {string} accId The user's account UUID.
+     * @param {string} displayName The new display name.
+     */
+    async setUserDisplayName(accId, displayName) {
+        return new Promise(async (resolve, reject) => {
+            var _a, _b;
+            try {
+                const response = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('RADIO_SET_USER_DISPLAY_NAME', accId, displayName));
+                resolve({ success: true, result: (_b = response === null || response === void 0 ? void 0 : response.result) !== null && _b !== void 0 ? _b : response });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Retrieves the community subscription level determined by the calling server's IP.
+     */
+    async getServerSubscriptionFromIp() {
+        return new Promise(async (resolve, reject) => {
+            var _a;
+            try {
+                const response = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('RADIO_GET_SERVER_SUBSCRIPTION_FROM_IP'));
+                resolve({ success: true, data: response });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Sets the push event URL for the community.
+     * @param {string} pushUrl The server push URL.
+     */
+    async setServerIp(pushUrl) {
+        return new Promise(async (resolve, reject) => {
+            var _a, _b;
+            try {
+                const response = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('RADIO_SET_SERVER_IP', pushUrl));
+                resolve({ success: true, result: (_b = response === null || response === void 0 ? void 0 : response.result) !== null && _b !== void 0 ? _b : response });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+    /**
+     * Sets the available in-game speaker locations for tone dispatching.
+     * @param {RadioSpeakerLocation[]} locations Collection of speaker locations.
+     * @param {string} [token] Optional bearer token for authorization. Defaults to the community API key.
+     */
+    async setInGameSpeakerLocations(locations, token) {
+        return new Promise(async (resolve, reject) => {
+            var _a, _b;
+            try {
+                const response = await ((_a = this.rest) === null || _a === void 0 ? void 0 : _a.request('RADIO_SET_IN_GAME_SPEAKER_LOCATIONS', locations, token));
+                resolve({ success: true, result: (_b = response === null || response === void 0 ? void 0 : response.result) !== null && _b !== void 0 ? _b : response });
+            }
+            catch (err) {
+                if (err instanceof src_1.APIError) {
+                    resolve({ success: false, reason: err.response });
+                }
+                else {
+                    reject(err);
+                }
+            }
+        });
+    }
+}
+exports.RadioManager = RadioManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sonoransoftware/sonoran.js",
-  "version": "1.0.34",
+  "version": "1.0.36",
   "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

@@ -3,7 +3,7 @@ Sonoran.js is a library that allows you to interact with the [Sonoran CAD](https
 
 ## Example Instance Setup
 
-Utilizing both Sonoran CMS & Sonoran CAD
+Utilizing Sonoran CMS, Sonoran CAD & Sonoran Radio
 ```js
 const Sonoran = require('sonoran.js');
 const instance = Sonoran.instance({
@@ -11,6 +11,8 @@ const instance = Sonoran.instance({
   cadApiKey: 'DF58F1E-FD8A-44C5-BA',
   cmsCommunityId: 'mycommunity',
   cmsApiKey: 'e6ba9d68-ca7a-4e59-a9e2-93e275b4e0bf'
+  radioCommunityId: 'mycommunity'
+  radioApiKey: 'e6ba9d68-ca7a-4e59-a9e2-93e275b4e0bf'
 });
 ```
 
@@ -51,20 +53,117 @@ instance.cms.verifyWhitelist({
 ```
 
 ## CAD Functions
-### getAccount
-Returns the user's account object.
-#### Argument `params`
-##### Type: `object` `{apiId?, username?}`
+Most CAD manager helpers return a `CADStandardResponse<T>` of `{ success, data?, reason? }`. Legacy helpers (`getAccount`, `setClockTime`, `joinCommunity`, `leaveCommunity`) keep their original response shapes.
+
+### Account & Configuration
+- **`getVersion()`** - resolves to the numeric CAD subscription level.
+- **`getAccount({ apiId?, username? })`** - fetches account details.
+- **`setClockTime({ serverId, currentUtc, currentGame, secondsPerHour })`** - synchronizes in-game time.
+- **`joinCommunity(internalKey, accounts)`** / **`leaveCommunity(internalKey, accounts)`** - manages community membership (requires an internal key).
+- **`setPenalCodes(codes)`** - replaces the penal code configuration.
+- **`setAccountApiIds(data)`** - assigns API IDs to a username.
+- **`checkApiId(apiId)`** - confirms whether an API ID exists.
+- **`applyPermissionKey(apiId?, permissionKey)`** - applies a permission key to an account.
+- **`setAccountPermissions(changes)`** - bulk add/remove CAD permissions.
+- **`banUser(data)`** - kicks or bans an account via the CAD API.
+- **`verifySecret(secret)`** - validates a configured secret.
+- **`authorizeStreetSigns(serverId)`** - authorizes map street-sign updates.
+- **`setPostals(entries)`** - overwrites the postal table.
+- **`sendPhoto(apiId?, url)`** - attaches a photo to an account.
+
 ```js
-const params = {
- apiId: '',
- username: 'SomeUser',
-};
-// Get user account object
-const account = await instance.cad.getAccount(params);
+const account = await instance.cad.getAccount({ apiId: '1234567890' });
+const penalCodes = await instance.cad.setPenalCodes([
+  { code: '1A', type: 'Felony', title: 'Example', bondType: 'None', jailTime: '0', bondAmount: 0 }
+]);
+await instance.cad.setAccountApiIds({ username: 'SomeUser', apiIds: ['1234567890'], pushNew: true });
+const permissionUpdate = await instance.cad.setAccountPermissions({ apiId: '1234567890', add: ['admin'], remove: [] });
+```
+
+### Records & Lookups
+- **`getRecordTemplates(recordTypeId?)`**
+- **`createRecord(data)`** / **`updateRecord(data)`** / **`removeRecord(id)`**
+- **`lookupByInt(criteria)`** - identifier-based lookup.
+- **`lookupRecords(query)`** - plate/name-based lookup.
+
+```js
+await instance.cad.createRecord({ user: '1234567890', useDictionary: true, recordTypeId: 2, replaceValues: { NAME: 'Jane Doe' } });
+const lookup = await instance.cad.lookupRecords({ apiId: '1234567890', types: [2], first: 'Jane', last: 'Doe', mi: '', plate: '', partial: false });
+```
+
+### Civilian Tools
+- **`getCharacters(apiId)`** - lists civilian characters for an API ID.
+- **`createCharacter(data)`** / **`updateCharacter(data)`** / **`removeCharacter(id)`** - CRUD helpers for civilian profiles.
+
+### Identifiers & Units
+- **`getIdentifiers(apiId)`**
+- **`modifyIdentifier(change)`** / **`setIdentifier(apiId?, identId)`**
+- **`setUnitPanic(apiId?, isPanic)`** / **`setUnitStatus(apiId?, status, serverId)`**
+- **`getActiveUnits(options)`** - direct CAD fetch for active units.
+- **`kickUnit(apiId?, reason, serverId)`**
+- **`updateUnitLocations(locations)`**
+
+### Map & Streetsigns
+- **`getBlips(serverId)`**
+- **`addBlips(blips)`** / **`updateBlips(blips)`** / **`removeBlip(id)`**
+- **`setStreetSignConfig(serverId, signConfig)`**
+- **`updateStreetSign(serverId, signData)`**
+
+### Calls & Dispatch
+- **`create911Call(details)`** / **`remove911Call(callId)`**
+- **`getCalls(options)`**
+- **`createDispatch(data)`**
+- **`attachUnits(serverId, callId, units)`** / **`detachUnits(serverId, units)`**
+- **`setCallPostal(serverId, callId, postal)`** / **`setCallPrimary(serverId, callId, primary, trackPrimary)`**
+- **`addCallNote(serverId, callId, note)`**
+- **`closeCall(serverId, callId)`**
+
+```js
+const dispatch = await instance.cad.createDispatch({
+  serverId: 1,
+  origin: Sonoran.CADDispatchOriginEnums.Caller,
+  status: Sonoran.CADDispatchStatusEnums.Active,
+  priority: 1,
+  block: '123',
+  address: 'Main St',
+  postal: '100',
+  title: 'Traffic Stop',
+  code: 'TS',
+  primary: 42,
+  trackPrimary: true,
+  description: 'Blue sedan headed north',
+  metaData: {},
+  units: ['unit-1']
+});
+await instance.cad.attachUnits(1, 1001, ['unit-2']);
+```
+
+## CAD Server Functions
+- **`getServers()`** - fetches configured CAD servers.
+- **`setServers(servers, deployMap?)`** - updates server configuration and refreshes the cache.
+
+```js
+const servers = await instance.cad.servers?.getServers();
+await instance.cad.servers?.setServers(servers ?? [], false);
+```
+
+## CAD Active Unit Functions
+`CADActiveUnitsManager#getActiveUnits(options?)` proxies the CAD endpoint and returns a `CADStandardResponse`.
+
+```js
+const activeUnits = await cadActiveUnitsManager.getActiveUnits({ includeOffline: true, limit: 25 });
+if (activeUnits.success) {
+  console.log(activeUnits.data);
+}
 ```
 
 ## CMS Functions
+### getSubscriptionVersion()
+Returns the community's CMS subscription version.
+```js
+const version = await instance.cms.getSubscriptionVersion();
+```
+
 ### verifyWhitelist(obj)
 Verifies that a user is whitelisted in the specified server.
 #### Arugment `params`
@@ -158,7 +257,7 @@ const getDepts = await instance.cms.getDepartments();
 ```
 
 ### setAccountRanks(obj, apiId, accId, username, discord, uniqueId)
-Gets all department information for a CMS community
+Updates the CMS account's ranks using the identifiers provided.
 #### Arugment `params`
 ##### Type `object` `{set?: string[]; add?: string[]; remove?: string[]}`
 #### Arguments `apiId`, `accId`, `username`, `discord`, `uniqueId`
@@ -176,5 +275,188 @@ const params = {
 const setRanks = await instance.cms.setAccountRanks(params, undefined, undefined, undefined, '12345678', undefined);
 ```
 
+### setAccountName(apiId, username, accId, discord, uniqueId, newName)
+Sets the display name used in CMS for an account.
+```js
+await instance.cms.setAccountName(undefined, undefined, 'account-uuid', undefined, undefined, 'New Display Name');
+```
+
+### cmsBanAccount(params)
+Adds a ban flag to the targeted account.
+```js
+await instance.cms.cmsBanAccount({ apiId: '1234' });
+```
+
+### cmsKickAccount(params)
+Performs a CMS kick request for the targeted account.
+```js
+await instance.cms.cmsKickAccount({ discord: '1234567890' });
+```
+
+### forceSync(params)
+Manually triggers a CMS force-sync for the targeted identifiers.
+```js
+await instance.cms.forceSync({ username: 'SomeUser' });
+```
+
+### getPromotionFlows()
+Fetches the configured promotion flows.
+```js
+const flows = await instance.cms.getPromotionFlows();
+```
+
+### triggerPromotionFlows(flows)
+Executes promotion or demotion flows for one or more users.
+```js
+await instance.cms.triggerPromotionFlows([{
+  userId: 'u-123',
+  flowId: 'flow-abc',
+  users: ['u-123', 'u-456'],
+  promote: true
+}]);
+```
+
+### getCurrentClockIn(params)
+Fetches the current clock-in entry for the account if one exists.
+```js
+const currentEntry = await instance.cms.getCurrentClockIn({ apiId: '1234' });
+```
+
+### getAccounts(options)
+Retrieves CMS accounts with optional pagination and status filters.
+```js
+const accounts = await instance.cms.getAccounts({ take: 50, banned: false });
+```
+
+### getProfileFields()
+Returns profile field definitions configured for the community.
+```js
+const profileFields = await instance.cms.getProfileFields();
+```
+
+### rsvp(eventId, params)
+Toggles RSVP for an event for the provided account identifiers.
+```js
+await instance.cms.rsvp('event-id', { accId: 'account-uuid' });
+```
+
+### getFormSubmissions(templateId, options)
+Retrieves form submissions with optional pagination.
+```js
+const submissions = await instance.cms.getFormSubmissions(42, { skip: 0, take: 25 });
+```
+
+### changeFormStage(params)
+Moves a form to the specified stage for an account.
+```js
+await instance.cms.changeFormStage({
+  formId: 42,
+  newStageId: 'approved',
+  accId: 'account-uuid',
+  uniqueId: 1234
+});
+```
+
+### editAccountProfileFields(params)
+Updates profile fields for an account.
+```js
+await instance.cms.editAccountProfileFields({
+  accId: 'account-uuid',
+  profileFields: [
+    { fieldId: 10, value: 'Value' }
+  ]
+});
+```
+
+### erlcGetOnlinePlayers(robloxJoinCode)
+Returns the current ERLC player list for the join code.
+```js
+const players = await instance.cms.erlcGetOnlinePlayers('join-code');
+```
+
+### erlcGetPlayerQueue(robloxJoinCode)
+Returns the current ERLC player queue count for the join code.
+```js
+const queue = await instance.cms.erlcGetPlayerQueue('join-code');
+```
+
+### erlcAddNewRecord(data)
+Adds a moderation record for a player in ERLC.
+```js
+await instance.cms.erlcAddNewRecord({
+  robloxJoinCode: 'join-code',
+  executerDiscordId: '1234567890',
+  type: 'Warning',
+  reason: 'Reckless driving'
+});
+```
+
+## CMS Server Functions
+### getGameServers()
+Fetches the configured CMS game servers. Returns an array of server objects.
+```js
+const cmsServers = await instance.cms.servers?.getGameServers();
+```
+
+### setGameServers(servers)
+Replaces the configured CMS game servers and refreshes the cache with the response payload.
+```js
+await instance.cms.servers?.setGameServers([
+  { name: 'Server 1', description: 'Primary server', allowedRanks: ['admin'] }
+]);
+```
+
+## Radio Functions
+### getCommunityChannels()
+Retrieves configured community channel groups and channels.
+```js
+const channels = await instance.radio.getCommunityChannels();
+```
+
+### getConnectedUsers()
+Lists all connected radio users in the community.
+```js
+const users = await instance.radio.getConnectedUsers();
+```
+
+### getConnectedUser(roomId, identity)
+Fetches a specific connected radio user by room and identity.
+```js
+const user = await instance.radio.getConnectedUser(1, 'account-uuid');
+```
+
+### setUserChannels(identity, options)
+Updates a user's transmit or scan channels.
+```js
+await instance.radio.setUserChannels('account-uuid', { transmit: 12, scan: [10, 11, 12] });
+```
+
+### setUserDisplayName(accId, displayName)
+Sets the user's radio display name.
+```js
+await instance.radio.setUserDisplayName('account-uuid', 'Dispatch 101');
+```
+
+### getServerSubscriptionFromIp()
+Resolves the community's subscription level for the calling server IP.
+```js
+const subscription = await instance.radio.getServerSubscriptionFromIp();
+```
+
+### setServerIp(pushUrl)
+Registers the push event URL for radio webhooks.
+```js
+await instance.radio.setServerIp('https://example.com/sonoran-radio');
+```
+
+### setInGameSpeakerLocations(locations, token?)
+Publishes available in-game speaker locations for tone routing.
+```js
+await instance.radio.setInGameSpeakerLocations(
+  [{ name: 'Station 1', x: 123.4, y: 567.8, z: 90.1 }],
+  'optional-bearer-token'
+);
+```
+
 ## Further Documentation
 More documentation for Sonoran CAD specific methods and usage can be found [here](/docs/CAD-Methods-and-Usage.md), Sonoran CMS specific methods and usage can be found [here](/docs/CMS-Methods-and-Usage.md), and usage information for the REST class [here](/docs/REST-Methods-and-Usage.md).