@sonoransoftware/sonoran.js 1.0.0

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

@@ -0,0 +1,18 @@
+export function convertSubNumToName(subLevel: number) {
+  switch (subLevel) {
+    case 0:
+      return 'FREE';
+    case 1:
+      return 'STARTER';
+    case 2:
+      return 'STANDARD';
+    case 3:
+      return 'PLUS';
+    case 4:
+      return 'PRO';
+    case 6:
+      return 'ONE';
+    default:
+      return 'FREE';
+  }
+}

package/src/managers/BaseManager.ts

@@ -0,0 +1,15 @@
+import Instance from '../instance/Instance';
+
+/**
+ * Manages the API methods of a data model or a specific product methods.
+ * @abstract
+ */
+export abstract class BaseManager {
+  /**
+   * 
+   * @param {Instance} instance The instance that instantiated this Manager
+   * @readonly
+   */
+  constructor(public readonly instance: Instance) {
+  }
+}

package/src/managers/CADActiveUnitsManager.ts

@@ -0,0 +1,50 @@
+// Work in progress still...
+
+// import { CADActiveUnitFetchOptions } from '../constants';
+import Instance from '../instance/Instance';
+import { CADActiveUnit, CADActiveUnitResolvable, CADActiveUnitStruct } from '../structures/CADActiveUnit';
+import { CacheManager } from './CacheManager';
+
+export class CADActiveUnitsManager extends CacheManager<number, CADActiveUnit, CADActiveUnitResolvable> {
+  public serverId: number;
+  public instance: Instance;
+  constructor(instance: Instance, iterable: Iterable<CADActiveUnitStruct>, serverId: number) {
+    super(instance, CADActiveUnit, iterable);
+    this.instance = instance;
+    this.serverId = serverId;
+  }
+
+  _add(data: any, cache = true) {
+    return super._add(data, cache, data.id);
+  }
+
+  fetch(/*options: CADActiveUnitResolvable | CADActiveUnitFetchOptions**/) {
+    // if (!options) return this._fetchMany();
+    this._fetchSingle({
+      unit: -1,
+      includeOffline: false,
+      force: false
+    });
+  }
+
+  async _fetchSingle({
+    unit,
+    includeOffline = false,
+    force = false
+  }:{
+    unit: CADActiveUnitResolvable;
+    includeOffline: boolean;
+    force: boolean;
+  }) {
+    if (!force) {
+      const existing = this.cache.get(unit);
+      if (existing) return existing;
+    }
+
+    const data = await this.instance.cad?.rest?.request('GET_ACTIVE_UNITS', {
+      serverId: this.serverId,
+      includeOffline
+    });
+    console.log(data);
+  }
+}

package/src/managers/CADManager.ts

@@ -0,0 +1,58 @@
+import Instance from '../instance/Instance';
+import { CADSubscriptionVersionEnum } from '../constants';
+import { APIError, DefaultCADRestOptions, REST } from '../libs/rest/src';
+import { BaseManager } from './BaseManager';
+import * as globalTypes from '../constants';
+import type { Mutable } from '../constants';
+import { CADServerManager } from './CADServerManager';
+
+/**
+ * Manages all Sonoran CAD data and methods to interact with the public API.
+ */
+export class CADManager extends BaseManager {
+  public readonly version: CADSubscriptionVersionEnum = 0;
+  public rest: REST | undefined;
+  public servers: CADServerManager | undefined;
+
+  constructor(instance: Instance) {
+    super(instance);
+
+    this.rest = new REST(instance, this, globalTypes.productEnums.CAD, DefaultCADRestOptions);
+    this.buildManager(instance);
+  }
+
+  protected async buildManager(instance: Instance) {
+    try {
+      const versionResp: any = await this.rest?.request('GET_VERSION');
+      const mutableThis = this as Mutable<CADManager>;
+      mutableThis.version = Number.parseInt(versionResp.replace(/(^\d+)(.+$)/i,'$1'));
+      if (this.version >= globalTypes.CADSubscriptionVersionEnum.STANDARD) {
+        this.servers = new CADServerManager(instance, this);
+      }
+    } catch (err) {
+      console.log(err);
+    }
+  }
+
+  /**
+   * Gets a community account by `accId` or `apiId`.
+   * @param {Object} params The object that contains parameters to get a community account.
+   * @param {string} [data.accId] The account id to find a community account.
+   * @param {string} [data.apiId] The api id to find a community account.
+   * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed and the account data object if found.
+   */
+  public async getAccount(params: { apiId?: string, username?: string }): Promise<globalTypes.CADGetAccountPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const getAccountRequest: any = await this.rest?.request('GET_ACCOUNT', params.apiId, params.username);
+        resolve({ success: true, data: getAccountRequest });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+}

package/src/managers/CADServerManager.ts

@@ -0,0 +1,27 @@
+import Instance from '../instance/Instance';
+import { CADServerAPIStruct } from '../libs/rest/src';
+import { CADServer } from '../structures/CADServer';
+import { CacheManager } from './CacheManager';
+import { CADManager } from './CADManager';
+
+export class CADServerManager extends CacheManager<number, CADServer, CADServerAPIStruct> {
+  constructor(instance: Instance, manager: CADManager) {
+    super(instance, CADServer, []);
+
+    (async () => {
+      try {
+        const serversRes: any = await manager.rest?.request('GET_SERVERS');
+        const servers = JSON.parse(serversRes).servers;
+        servers.forEach((server: CADServerAPIStruct) => {
+          const serverStruct = {
+            id: server.id,
+            config: server
+          };
+          this._add(serverStruct, true, server.id);
+        });
+      } catch (err) {
+        throw new Error(String(err));
+      }
+    })();
+  }
+}

package/src/managers/CMSManager.ts

@@ -0,0 +1,133 @@
+import Instance from '../instance/Instance';
+import { CMSSubscriptionVersionEnum } from '../constants';
+import { APIError, DefaultCMSRestOptions, REST } from '../libs/rest/src';
+import { BaseManager } from './BaseManager';
+import * as globalTypes from '../constants';
+import type { Mutable } from '../constants';
+import { CMSServerManager } from './CMSServerManager';
+
+/**
+ * Manages all Sonoran CMS data and methods to interact with the public API.
+ */
+export class CMSManager extends BaseManager {
+  public readonly ready: boolean = false;
+  public readonly version: CMSSubscriptionVersionEnum = 0;
+  public rest: REST | undefined;
+  public servers: CMSServerManager | undefined;
+
+  constructor(instance: Instance) {
+    super(instance);
+
+    this.rest = new REST(instance, this, globalTypes.productEnums.CMS, DefaultCMSRestOptions);
+    this.buildManager(instance);
+  }
+
+  protected async buildManager(instance: Instance) {
+    try {
+      const versionResp: any = await this.rest?.request('GET_SUB_VERSION');
+      const mutableThis = this as Mutable<CMSManager>;
+      mutableThis.version = Number.parseInt(versionResp.replace(/(^\d+)(.+$)/i,'$1'));
+      if (this.version >= globalTypes.CMSSubscriptionVersionEnum.STANDARD) {
+        this.servers = new CMSServerManager(instance, this);
+      }
+      mutableThis.ready = true;
+    } catch (err) {
+      throw err;
+    }
+  }
+
+  /**
+   * 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).
+   * @param {string} [data.accId] The account id to find a community account.
+   * @param {string} [data.apiId] The api id to find a community account.
+   * @param {string} [data.serverId] The username to find a community account. 
+   * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed and the account data object if found.
+   */
+  public async verifyWhitelist(data: { accId?: string, apiId?: string, serverId?: number } | string): Promise<globalTypes.CMSVerifyWhitelistPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const isString = typeof data === 'string';
+        const whitelistRequest: any = await this.rest?.request('VERIFY_WHITELIST', isString ? data : data.apiId, isString ? data : data.accId, isString ? this.instance.cmsDefaultServerId : data.serverId ?? this.instance.cmsDefaultServerId);
+        if (typeof whitelistRequest === 'string') {
+          resolve({ success: true, reason: whitelistRequest });
+        } else {
+          resolve({ success: false, reason: whitelistRequest });
+        }
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Gets a community account by `accId`, `apiId`, or `username`.
+   * @param {Object} params The object that contains parameters to get a community account.
+   * @param {string} [data.accId] The account id to find a community account.
+   * @param {string} [data.apiId] The api id to find a community account.
+   * @param {string} [data.username] The username to find a community account.
+   * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed and the account data object if found.
+   */
+  public async getComAccount(params: { accId?: string, apiId?: string, username?: string }): Promise<globalTypes.CMSGetComAccountPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const getAccountRequest: any = await this.rest?.request('GET_COM_ACCOUNT', params.apiId, params.username, params.accId);
+        resolve({ success: true, data: getAccountRequest });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Clocks in or out an account by `accId` or `apiId`.
+   * @param {Object} data The object that contains critical data to clock in or out an account.
+   * @param {string} [data.accId] The account id to clock in or out.
+   * @param {string} [data.apiId] The api id to clock in or out.
+   * @param {boolean} [data.forceClockIn] If true, it will override any current clock in with a new clock in at the time of the request.
+   * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed.
+   */
+  public async clockInOut(data: { accId?: string, apiId?: string, forceClockIn?: boolean }): Promise<globalTypes.CMSClockInOutPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const clockInOutRequest: any = await this.rest?.request('CLOCK_IN_OUT', data.apiId, data.accId, !!data.forceClockIn);
+        const clockInOutRequestString: string = clockInOutRequest as string;
+        resolve({ success: true, clockedIn: clockInOutRequestString.includes('CLOCKED IN') });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+
+  /**
+   * Check if a given [apiId] is attached to any account within the community CMS.
+   * @param {string} apiId The api id to check for an account.
+   * @returns {Promise} Promise object represents if the request was successful with reason for failure if needed.
+   */
+  public async checkComApiId(apiId: string): Promise<globalTypes.CMSCheckComApiIdPromiseResult> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const checkComApiIdRequest: any = await this.rest?.request('CHECK_COM_APIID', apiId);
+        resolve({ success: true, username: checkComApiIdRequest as string });
+      } catch (err) {
+        if (err instanceof APIError) {
+          resolve({ success: false, reason: err.response });
+        } else {
+          reject(err);
+        }
+      }
+    });
+  }
+}

package/src/managers/CMSServerManager.ts

@@ -0,0 +1,27 @@
+import Instance from '../instance/Instance';
+import { CMSServerAPIStruct } from '../libs/rest/src';
+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) {
+    super(instance, CMSServer, []);
+
+    (async () => {
+      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);
+        });
+      } catch (err) {
+        throw new Error(String(err));
+      }
+    })();
+  }
+}

package/src/managers/CacheManager.ts

@@ -0,0 +1,38 @@
+import Collection from '@discordjs/collection';
+import Instance from '../instance/Instance';
+import { Constructable } from '../constants';
+import { DataManager } from './DataManager';
+
+export class CacheManager<K, Holds, R> extends DataManager<K, Holds, R> {
+  public _cache: Collection<any, any> | never;
+  protected constructor(instance: Instance, holds: Constructable<Holds>, iterable: Iterable<any>) {
+    super(instance, holds);
+    this._cache = new Collection();
+    if (iterable) {
+      for (const item of iterable) {
+        this._add(item);
+      }
+    }
+  }
+
+  get cache() {
+    return this._cache;
+  }
+
+  _add(data: any, cache: boolean = true, id?: K) {
+    const existing = this.cache.get(id ?? data.id);
+    if (existing) {
+      if (cache) {
+        existing._patch(data);
+        return existing;
+      }
+      const clone = existing._clone();
+      clone._patch(data);
+      return clone;
+    }
+
+    const entry = data;
+    if (cache) this.cache.set(id ?? entry.id, entry);
+    return entry;
+  }
+}

package/src/managers/DataManager.ts

@@ -0,0 +1,64 @@
+import Instance from '../instance/Instance';
+import { BaseManager } from './BaseManager';
+import { GenericError } from '../errors';
+import { Constructable } from '../constants';
+
+import Collection from '@discordjs/collection';
+
+interface DataManagerInstanceObject {
+  id: string;
+}
+
+export class DataManager<_K, Holds, _R> extends BaseManager {
+  public holds: Constructable<Holds>;
+
+  constructor(instance: Instance, holds: any) {
+    super(instance);
+
+    /**
+     * The data structure belonging to this manager.
+     * @name DataManager#holds
+     * @type {Function}
+     * @private
+     * @readonly
+     */
+    this.holds = holds;
+  }
+
+  /**
+   * The cache of items for this manager.
+   * @type {Collection}
+   * @abstract
+   */
+  get cache(): Collection<any, any> {
+    throw new GenericError('NOT_IMPLEMENTED', 'get cache', this.constructor.name);
+  }
+
+  /**
+   * Resolves a data entry to a data Object.
+   * @param idOrInstance The id or instance of something in this Manager
+   * @returns {?Object} An instance from this Manager
+   */
+   public resolve(idOrInstance: string | object): object | null {
+    if (this.cache instanceof Collection) {
+      if (typeof idOrInstance === 'object') return idOrInstance;
+      if (typeof idOrInstance === 'string') return this.cache.get(idOrInstance) ?? null;
+    }
+    return null;
+  }
+
+  /**
+   * Resolves a data entry to an instance id.
+   * @param {string|Object} idOrInstance The id or instance of something in this Manager
+   * @returns {?Snowflake}
+   */
+  resolveId(idOrInstance: string | DataManagerInstanceObject): string | null {
+    if (typeof idOrInstance === 'object') return idOrInstance.id;
+    if (typeof idOrInstance === 'string') return idOrInstance;
+    return null;
+  }
+
+  valueOf() {
+    return this.cache;
+  }
+}

package/src/structures/Base.ts

@@ -0,0 +1,28 @@
+import Instance from '../instance/Instance';
+import { flatten } from '../utils';
+
+export abstract class Base {
+  public instance: Instance;
+  constructor(instance: Instance) {
+    this.instance = instance;
+  }
+
+  public _clone() {
+    return Object.assign(Object.create(this), this);
+
+  }
+
+  public _patch(data: any) {
+    return data;
+  }
+
+  public _update(data: any) {
+    const clone = this._clone();
+    this._patch(data);
+    return clone;
+  }
+
+  public toJSON(...props: Record<string, boolean | string>[]): unknown {
+    return flatten(this, ...props);
+  }
+}

package/src/structures/CADActiveUnit.ts

@@ -0,0 +1,85 @@
+import Instance from '../instance/Instance';
+import { Base } from './Base';
+
+export interface CADActiveUnitStruct {
+  id: number;
+  accId: string;
+  status: number;
+  isPanic: boolean;
+  location: string;
+  aop: string;
+  isDispatch: boolean;
+  data: CADActiveUnitDataStruct;
+}
+
+interface CADActiveUnitStructPartial {
+  id: number;
+  accId: string;
+  status: number;
+  isPanic: boolean;
+  location: string;
+  aop: string;
+  isDispatch: boolean;
+  data: Partial<CADActiveUnitDataStruct>;
+}
+
+export interface CADActiveUnitDataStruct {
+  apiId1: string;
+  apiId2: string;
+  unitNum: string;
+  name: string;
+  district: string;
+  department: string;
+  subdivision: string;
+  rank: string;
+  group: string;
+} 
+
+export type CADActiveUnitResolvable = CADActiveUnit | number;
+
+export class CADActiveUnit extends Base {
+  public id: number = -1;
+  public accId: string = '';
+  public status: number = 0;
+  public isPanic: boolean = false;
+  public location: string = '';
+  public aop: string = '';
+  public isDispatch: boolean = false;
+  public data: CADActiveUnitDataStruct = {
+    apiId1: '',
+    apiId2: '',
+    unitNum: '',
+    name: '',
+    district: '',
+    department: '',
+    subdivision: '',
+    rank: '',
+    group: ''
+  };
+  
+  constructor(instance: Instance, data: any) {
+    super(instance);
+    if (data) this._patch(data);
+  }
+
+  public _patch(data: Partial<CADActiveUnitStructPartial>) {
+    if (data.id !== undefined) this.id = data.id;
+    if (data.accId !== undefined) this.accId = data.accId;
+    if (data.status !== undefined) this.status = data.status;
+    if (data.isPanic !== undefined) this.isPanic = data.isPanic;
+    if (data.location !== undefined) this.location = data.location;
+    if (data.aop !== undefined) this.aop = data.aop;
+    if (data.isDispatch !== undefined) this.isDispatch = data.isDispatch;
+    if (data.data !== undefined) {
+      if (data.data.apiId1 !== undefined) this.data.apiId1 = data.data.apiId1;
+      if (data.data.apiId2 !== undefined) this.data.apiId2 = data.data.apiId2;
+      if (data.data.unitNum !== undefined) this.data.unitNum = data.data.unitNum;
+      if (data.data.name !== undefined) this.data.name = data.data.name;
+      if (data.data.district !== undefined) this.data.district = data.data.district;
+      if (data.data.department !== undefined) this.data.department = data.data.department;
+      if (data.data.subdivision !== undefined) this.data.subdivision = data.data.subdivision;
+      if (data.data.rank !== undefined) this.data.rank = data.data.rank;
+      if (data.data.group !== undefined) this.data.group = data.data.group;
+    }
+  }
+}

package/src/structures/CADServer.ts

@@ -0,0 +1,37 @@
+import Instance from '../instance/Instance';
+// import { CADActiveUnitsManager } from '../managers/CADActiveUnitsManager';
+import { Base } from './Base';
+
+export interface CADServerData {
+  id: number;
+  config: CADServerConfig;
+}
+
+export interface CADServerConfig {
+  id: number;
+  name: string;
+  description: string;
+  signal: null;
+  mapUrl: string;
+  mapIp: string;
+  mapPort: string;
+  differingOutbound: boolean;
+  outboundIp: string;
+  listenerPort: string;
+  enableMap: boolean;
+  mapType: string;
+  isStatic: boolean;
+}
+
+export class CADServer extends Base {
+  public id: number;
+  public config!: CADServerConfig;
+  // public units!: CADActiveUnitsManager; 
+  
+  constructor(instance: Instance, data: CADServerData) {
+    super(instance);
+    this.id = data.id;
+    this.config = data.config;
+    // this.units = new CADActiveUnitsManager(instance, [], this.id);
+  }
+}

package/src/structures/CMSServer.ts

@@ -0,0 +1,26 @@
+import Instance from '../instance/Instance';
+import { Base } from './Base';
+
+export interface CMSServerData {
+  id: number;
+  config: CMSServerConfig;
+}
+
+export interface CMSServerConfig {
+  id: number;
+  name: string;
+  description: string;
+  allowedRanks: string[];
+  blockedRanks: string[];
+}
+
+export class CMSServer extends Base {
+  public id: number;
+  public config!: CMSServerConfig;
+  
+  constructor(instance: Instance, data: CMSServerData) {
+    super(instance);
+    this.id = data.id;
+    this.config = data.config;
+  }
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './utils';