@sonoransoftware/sonoran.js 1.0.34 → 1.0.36

package/src/managers/CMSManager.ts

@@ -25,8 +25,7 @@ export class CMSManager extends BaseManager {
   protected async buildManager(instance: Instance) {
     const mutableThis = this as globalTypes.Mutable<CMSManager>;
     try {
-      const versionResp: any = await this.rest?.request('GET_SUB_VERSION');
-      const version = Number.parseInt(versionResp.replace(/(^\d+)(.+$)/i,'$1'));
+      const version = await this.getSubscriptionVersion();
       if (version >= globalTypes.CMSSubscriptionVersionEnum.STANDARD) {
         this.servers = new CMSServerManager(instance, this);
       }
@@ -41,6 +40,15 @@ export class CMSManager extends BaseManager {
     }
   }
 
+  /**
+   * Retrieves the community's CMS subscription version.
+   */
+  public async getSubscriptionVersion(): Promise<number> {
+    const versionResp: any = await this.rest?.request('GET_SUB_VERSION');
+    const versionString = String(versionResp);
+    return Number.parseInt(versionString.replace(/(^\d+)(.+$)/i, '$1'), 10);
+  }
+
   /**
    * Verifies the whitelist of a given account with the given parameters to search of said account.
    * @param {Object | string} data The object or [accId | apiId as a string] that contains data to get a community account to verify if it has whitelist to the specified server. *If given as a string it will default to the set or default cms server id (1).
@@ -328,6 +336,46 @@ export class CMSManager extends BaseManager {
     });
   }
 
+  /**
+   * Triggers promotion flows for the specified users.
+   */
+  public async triggerPromotionFlows(flows: globalTypes.CMSTriggerPromotionFlowPayload[]): Promise<globalTypes.CMSTriggerPromotionFlowsPromiseResult> {
+    if (!Array.isArray(flows) || flows.length === 0) {
+      throw new Error('flows array must include at least one promotion flow payload.');
+    }
+
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('TRIGGER_PROMOTION_FLOWS', flows);
+        resolve({ success: true, data: response });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Retrieves the available promotion flows configured in CMS.
+   */
+  public async getPromotionFlows(): Promise<globalTypes.CMSGetPromotionFlowsPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('GET_PROMOTION_FLOWS');
+        resolve({ success: true, data: response });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
   /**
    * Gets a list of online ERLC players for the given roblox join code.
    * @param {string} robloxJoinCode The roblox join code to get the online players for.
@@ -348,6 +396,152 @@ export class CMSManager extends BaseManager {
     });
   }
 
+  /**
+   * Toggles RSVP for the provided event and account.
+   */
+  public async rsvp(eventId: string, params: { apiId?: string, username?: string, accId?: string, discord?: string, uniqueId?: string } = {}): Promise<globalTypes.CMSRsvpPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('RSVP', eventId, params.apiId, params.accId, params.discord, params.uniqueId);
+        if (typeof response === 'string') {
+          resolve({ success: true, status: response });
+        } else {
+          resolve({ success: true, data: response });
+        }
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Updates the stage of a form for the specified account.
+   */
+  public async changeFormStage(params: { accId?: string, formId: number, newStageId: string, apiId?: string, username?: string, discord?: string, uniqueId: number }): Promise<globalTypes.CMSChangeFormStagePromiseResult> {
+    if (!params.formId || !params.newStageId) {
+      throw new Error('formId and newStageId are required to change a form stage.');
+    }
+    if (params.uniqueId === undefined || Number.isNaN(Number(params.uniqueId))) {
+      throw new Error('uniqueId is required to change a form stage.');
+    }
+
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('CHANGE_FORM_STAGE', params.accId, params.formId, params.newStageId, params.apiId, params.username, params.discord, params.uniqueId);
+        resolve({ success: true, data: response });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Retrieves submissions for a specific form template.
+   */
+  public async getFormSubmissions<T = unknown>(templateId: number, options: { skip?: number, take?: number } = {}): Promise<globalTypes.CMSGetFormSubmissionsPromiseResult<T>> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('GET_FORM_TEMPLATE_SUBMISSIONS', templateId, options.skip, options.take);
+        resolve({ success: true, data: response });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Updates profile fields for the specified account.
+   */
+  public async editAccountProfileFields(params: { apiId?: string, username?: string, accId?: string, discord?: string, uniqueId?: string, profileFields: globalTypes.CMSProfileFieldUpdate[] }): Promise<globalTypes.CMSEditAccountProfileFieldsPromiseResult> {
+    if (!params.profileFields || params.profileFields.length === 0) {
+      throw new Error('profileFields array must include at least one value.');
+    }
+
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('EDIT_ACC_PROFLIE_FIELDS', params.apiId, params.username, params.accId, params.discord, params.uniqueId, params.profileFields);
+        resolve({ success: true, data: response });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Gets the current clock in entry for a community member.
+   * @param {Object} params Identification parameters for the account.
+   */
+  public async getCurrentClockIn(params: { accId?: string, apiId?: string, username?: string, discord?: string, uniqueId?: string }): Promise<globalTypes.CMSGetCurrentClockInPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('GET_CURRENT_CLOCK_IN', params.apiId, params.username, params.accId, params.discord, params.uniqueId);
+        if (typeof response === 'string') {
+          resolve({ success: true, reason: response, data: null });
+        } else {
+          resolve({ success: true, data: response });
+        }
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Retrieves community accounts using optional pagination and status filters.
+   */
+  public async getAccounts(options: { skip?: number, take?: number, sysStatus?: boolean, comStatus?: boolean, banned?: boolean, archived?: boolean } = {}): Promise<globalTypes.CMSGetAccountsPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('GET_ACCOUNTS', options);
+        resolve({ success: true, data: response });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Retrieves configured profile fields for the community.
+   */
+  public async getProfileFields(): Promise<globalTypes.CMSGetProfileFieldsPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('GET_PROFILE_FIELDS');
+        resolve({ success: true, data: response });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
   /**
    * Gets the current ERLC player queue count for the provided roblox join code.
    * @param {string} robloxJoinCode The roblox join code to get the player queue size for.

package/src/managers/CMSServerManager.ts

@@ -1,33 +1,77 @@
 import { Instance } from '../instance/Instance';
-import { CMSServerAPIStruct } from '../libs/rest/src';
+import { APIError, CMSServerAPIStruct } from '../libs/rest/src';
+import * as globalTypes from '../constants';
 import { CMSServer } from '../structures/CMSServer';
 import { CacheManager } from './CacheManager';
 import { CMSManager } from './CMSManager';
 
 export class CMSServerManager extends CacheManager<number, CMSServer, CMSServerAPIStruct> {
-  constructor(instance: Instance, manager: CMSManager) {
+  constructor(instance: Instance, private readonly manager: CMSManager) {
     super(instance, CMSServer, []);
+    void this.initialize();
+  }
+
+  /**
+   * Retrieves the CMS game servers belonging to the community.
+   */
+  public async getGameServers(): Promise<CMSServerAPIStruct[]> {
+    const serversRes: any = await this.manager.rest?.request('GET_GAME_SERVERS');
+    const parsed = typeof serversRes === 'string' ? JSON.parse(serversRes) : serversRes;
+    const servers = Array.isArray(parsed?.servers) ? parsed.servers : [];
+    return servers;
+  }
+
+  private async initialize(): Promise<void> {
+    const managerRef = this.manager;
+    while(!managerRef.ready) {
+      await new Promise((resolve) => {
+        setTimeout(resolve, 100);
+      });
+    }
+    try {
+      const servers = await this.getGameServers();
+      servers.forEach((server: CMSServerAPIStruct) => {
+        const serverStruct = {
+          id: server.id,
+          config: server
+        };
+        this._add(serverStruct, true, server.id);
+      });
+      console.log(`Found ${servers.length} servers`);
+    } catch (err) {
+      throw new Error(String(err));
+    }
+  }
+
+  public async setGameServers(servers: globalTypes.CMSSetGameServerStruct[]): Promise<globalTypes.CMSSetGameServersPromiseResult> {
+    if (!Array.isArray(servers) || servers.length === 0) {
+      throw new Error('servers array must include at least one server configuration.');
+    }
 
-    (async () => {
-      while(!manager.ready) {
-        await new Promise((resolve) => {
-          setTimeout(resolve, 100);
-        });
-      } 
+    return new Promise(async (resolve, reject) => {
       try {
-        const serversRes: any = await manager.rest?.request('GET_GAME_SERVERS');
-        const servers = serversRes.servers;
-        servers.forEach((server: CMSServerAPIStruct) => {
-          const serverStruct = {
-            id: server.id,
-            config: server
-          };
-          this._add(serverStruct, true, server.id);
-        });
-        console.log(`Found ${servers.length} servers`);
+        const response: any = await this.manager.rest?.request('SET_GAME_SERVERS', servers);
+        const updatedServers = (Array.isArray(response?.data) ? response.data : []) as CMSServerAPIStruct[];
+
+        if (updatedServers.length > 0) {
+          this.cache.clear();
+          updatedServers.forEach((server) => {
+            const serverStruct = {
+              id: server.id,
+              config: server
+            };
+            this._add(serverStruct, true, server.id);
+          });
+        }
+
+        resolve({ success: true, data: updatedServers as globalTypes.CMSSetGameServerStruct[] });
       } catch (err) {
-        throw new Error(String(err));
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
       }
-    })();
+    });
   }
-}
+}

package/src/managers/RadioManager.ts

@@ -0,0 +1,187 @@
+import { Instance } from '../instance/Instance';
+import { APIError, DefaultRadioRestOptions, REST } from '../libs/rest/src';
+import { BaseManager } from './BaseManager';
+import * as globalTypes from '../constants';
+import type { Mutable } from '../constants';
+
+/**
+ * Manages all Sonoran Radio API interactions.
+ */
+export class RadioManager extends BaseManager {
+  public readonly ready: boolean = false;
+  public readonly failReason: unknown = null;
+  public rest: REST | undefined;
+
+  constructor(instance: Instance) {
+    super(instance);
+
+    this.rest = new REST(instance, this, globalTypes.productEnums.RADIO, DefaultRadioRestOptions);
+    void this.buildManager(instance);
+  }
+
+  protected async buildManager(instance: Instance) {
+    const mutableThis = this as Mutable<RadioManager>;
+    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.
+   */
+  public async getCommunityChannels(): Promise<globalTypes.RadioGetCommunityChannelsPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('RADIO_GET_COMMUNITY_CHANNELS');
+        resolve({ success: true, data: response });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Retrieves all connected users for the community.
+   */
+  public async getConnectedUsers(): Promise<globalTypes.RadioGetConnectedUsersPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('RADIO_GET_CONNECTED_USERS');
+        resolve({ success: true, data: response });
+      } catch (err) {
+        if (err instanceof 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.
+   */
+  public async getConnectedUser(roomId: number, identity: string): Promise<globalTypes.RadioGetConnectedUserPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('RADIO_GET_CONNECTED_USER', roomId, identity);
+        resolve({ success: true, data: response });
+      } catch (err) {
+        if (err instanceof 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.
+   */
+  public async setUserChannels(identity: string, options: globalTypes.RadioSetUserChannelsOptions = {}): Promise<globalTypes.RadioSetUserChannelsPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('RADIO_SET_USER_CHANNELS', identity, options);
+        resolve({ success: true, result: response?.result ?? response });
+      } catch (err) {
+        if (err instanceof 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.
+   */
+  public async setUserDisplayName(accId: string, displayName: string): Promise<globalTypes.RadioSetUserDisplayNamePromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('RADIO_SET_USER_DISPLAY_NAME', accId, displayName);
+        resolve({ success: true, result: response?.result ?? response });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Retrieves the community subscription level determined by the calling server's IP.
+   */
+  public async getServerSubscriptionFromIp(): Promise<globalTypes.RadioGetServerSubscriptionFromIpPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('RADIO_GET_SERVER_SUBSCRIPTION_FROM_IP');
+        resolve({ success: true, data: response });
+      } catch (err) {
+        if (err instanceof 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.
+   */
+  public async setServerIp(pushUrl: string): Promise<globalTypes.RadioSetServerIpPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('RADIO_SET_SERVER_IP', pushUrl);
+        resolve({ success: true, result: response?.result ?? response });
+      } catch (err) {
+        if (err instanceof 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.
+   */
+  public async setInGameSpeakerLocations(locations: globalTypes.RadioSpeakerLocation[], token?: string): Promise<globalTypes.RadioSetInGameSpeakerLocationsPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const response: any = await this.rest?.request('RADIO_SET_IN_GAME_SPEAKER_LOCATIONS', locations, token);
+        resolve({ success: true, result: response?.result ?? response });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+}