@wxcc-desktop/sdk 1.2.6 → 1.2.10

package/src/jsapi/agent-state-info-jsapi.ts

@@ -1,288 +0,0 @@
-import { AgentxService, Service } from "@wxcc-desktop/sdk-types";
-import EventEmitter from "event-emitter";
-import allOff from "event-emitter/all-off";
-import { logger } from "../sdk";
-import { createJsApiLogger } from "./common/_logger";
-import { createServiceChecker } from "./common/_service-checker";
-
-type LatestInfoData = {
-  agentName?: string;
-  agentProfileID?: string;
-  agentSessionId?: string;
-  teamId?: string;
-  teamName?: string;
-  dn?: string;
-  status?: string;
-  subStatus?: string;
-  idleCodes?: Service.Aqm.Configs.Entity[];
-  wrapupCodes?: Service.Aqm.Configs.Entity[];
-  outDialRegex?: string;
-  isOutboundEnabledForTenant?: boolean;
-  isOutboundEnabledForAgent?: boolean;
-};
-
-const INITIAL_INFO_DATA: LatestInfoData = {
-  agentName: undefined,
-  agentProfileID: undefined,
-  agentSessionId: undefined,
-  teamId: undefined,
-  teamName: undefined,
-  dn: undefined,
-  status: undefined,
-  subStatus: undefined,
-  idleCodes: undefined,
-  wrapupCodes: undefined,
-  outDialRegex: undefined,
-  isOutboundEnabledForTenant: undefined,
-  isOutboundEnabledForAgent: undefined
-};
-
-type Listeners = {
-  updated: (p: { name: keyof LatestInfoData; value?: string; oldValue?: string }[]) => void;
-};
-type Events = keyof Listeners;
-
-type Config = {
-  logger: ReturnType<typeof createJsApiLogger>;
-  serviceChecker: ReturnType<typeof createServiceChecker>;
-};
-
-export class AgentStateInfoJsapi {
-  private readonly emitter = EventEmitter();
-  private readonly logger: Config["logger"];
-  private readonly serviceChecker: Config["serviceChecker"];
-
-  private SERVICE?: AgentxService;
-
-  private checkService() {
-    return this.serviceChecker.check(this.SERVICE);
-  }
-
-  private listeners: Set<() => void> = new Set();
-
-  private emit<T extends Events>(eventName: T, ...args: Parameters<Listeners[T]>) {
-    this.emitter.emit(eventName, ...args);
-  }
-
-  private update(p: LatestInfoData) {
-    const keys = Object.keys(p) as (keyof LatestInfoData)[];
-
-    const updatedPayload = keys.reduce((acc, key) => {
-      const value = p[key];
-      const oldValue = this.latestData[key];
-
-      if (JSON.stringify(value) !== JSON.stringify(oldValue)) {
-        acc.push({
-          name: key,
-          value: value,
-          oldValue: oldValue
-        });
-      }
-      return acc;
-    }, [] as { name: keyof LatestInfoData; value: any; oldValue: any }[]);
-
-    if (updatedPayload.length) {
-      updatedPayload.forEach(p => (this.latestData[p.name] = p.value));
-      this.emit("updated", updatedPayload);
-    }
-  }
-
-  private static getOutdialRegex(dialPlan: Service.Aqm.Configs.DialPlan) {
-    if (dialPlan && dialPlan.dialPlanEntity) {
-      const dpe = dialPlan.dialPlanEntity.find(entity => {
-        return entity.name === "Any Format";
-      });
-      if (dpe) {
-        return dpe.regex;
-      }
-    }
-    return "";
-  }
-
-  constructor(config: Config) {
-    this.logger = config.logger;
-    this.serviceChecker = config.serviceChecker;
-  }
-
-  latestData: LatestInfoData = JSON.parse(JSON.stringify(INITIAL_INFO_DATA));
-
-  //Init with ready SERVICE
-  async init(SERVICE?: AgentxService) {
-    if (SERVICE) {
-      this.SERVICE = SERVICE;
-    }
-
-    if (!this.checkService()) {
-      return;
-    }
-
-    // Events
-    this.subscribeSelfDataEvents();
-
-    // Fetch
-    await this.fetchLatestData();
-
-    this.logger.info("Inited");
-  }
-
-  cleanup() {
-    this.unsubscribeSelfDataEvents();
-
-    this.removeAllEventListeners();
-
-    this.SERVICE = undefined;
-
-    this.update(JSON.parse(JSON.stringify(INITIAL_INFO_DATA)) as LatestInfoData);
-
-    this.logger.info("Cleaned");
-  }
-
-  // initial data self watch calls
-  private async fetchLatestData() {
-    const profile = this.SERVICE?.conf.profile ? this.SERVICE?.conf.profile : await this.SERVICE?.conf.fetchProfile();
-
-    if (profile) {
-      const {
-        agentName,
-        agentProfileID,
-        teams,
-        defaultDn,
-        defaultIdleName,
-        agentSubStatus,
-        idleCodes,
-        wrapupCodes,
-        dialPlan,
-        isOutboundEnabledForTenant,
-        isOutboundEnabledForAgent
-      } = profile;
-
-      //
-      const [team] = teams;
-      const { teamId, teamName } = team;
-      const dn = defaultDn;
-      const status = defaultIdleName;
-      const subStatus = agentSubStatus;
-      //
-      const outDialRegex = AgentStateInfoJsapi.getOutdialRegex(dialPlan);
-
-      this.update({
-        agentName,
-        agentProfileID,
-        teamName,
-        teamId,
-        dn,
-        status,
-        subStatus,
-        idleCodes,
-        wrapupCodes,
-        outDialRegex,
-        isOutboundEnabledForTenant,
-        isOutboundEnabledForAgent
-      });
-    }
-  }
-
-  // Self data events
-  private subscribeSelfDataEvents() {
-    if (!this.checkService()) {
-      return;
-    }
-
-    // Relogin
-    {
-      const listenerRef = this.SERVICE?.aqm.agent.eAgentReloginSuccess.listen(({ data }) => {
-        const { agentSessionId, teamId, dn, status, subStatus } = data;
-
-        this.update({ agentSessionId, teamId, dn, status, subStatus });
-      });
-
-      this.listeners.add(() => listenerRef?.stopListen());
-    }
-    // StationLogin
-    {
-      const listenerRef = this.SERVICE?.aqm.agent.eAgentStationLoginSuccess.listen(({ data }) => {
-        const { agentSessionId, teamId, status, subStatus } = data;
-
-        this.update({ agentSessionId, teamId, status, subStatus });
-      });
-
-      this.listeners.add(() => listenerRef?.stopListen());
-    }
-    // StateChange
-    {
-      const listenerRef = this.SERVICE?.aqm.agent.eAgentStateChangeSuccess.listen(({ data }) => {
-        const { agentSessionId, status, subStatus } = data;
-
-        this.update({ agentSessionId, status, subStatus });
-      });
-
-      this.listeners.add(() => listenerRef?.stopListen());
-    }
-    // DN Registered
-    {
-      const listenerRef = this.SERVICE?.aqm.agent.eAgentDNRegistered.listen(({ data }) => {
-        const { dn } = data;
-
-        this.update({ dn });
-      });
-
-      this.listeners.add(() => listenerRef?.stopListen());
-    }
-  }
-
-  private unsubscribeSelfDataEvents() {
-    this.listeners.forEach(u => u());
-
-    this.listeners.clear();
-  }
-
-  // data calls
-  async stateChange(stateData: { state: "Available" | "Idle"; auxCodeIdArray: string }) {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.agent.stateChange({ data: stateData });
-  }
-
-  async mockOutdialAniList() {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.agent.mockOutdialAniList({ p: null });
-  }
-
-  async fetchAddressBooks() {
-    if (!this.checkService()) {
-      return;
-    }
-    return this.SERVICE?.aqm.agent.fetchAddressBooks({ p: null });
-  }
-
-  // data events
-  addEventListener<T extends Events>(eventName: T, listener: Listeners[T]) {
-    if (!this.checkService()) {
-      return;
-    }
-    this.emitter.on(eventName, listener);
-  }
-
-  removeEventListener<T extends Events>(eventName: T, listener: Listeners[T]) {
-    if (!this.checkService()) {
-      return;
-    }
-    this.emitter.off(eventName, listener);
-  }
-
-  removeAllEventListeners() {
-    allOff(this.emitter);
-  }
-}
-
-const agentInfoJsApiLogger = createJsApiLogger(logger, "[AgentInfo JSAPI] =>");
-
-// Standalone init
-export const createAgentStateInfoJsApi = () =>
-  new AgentStateInfoJsapi({
-    logger: agentInfoJsApiLogger,
-    serviceChecker: createServiceChecker({ logger: agentInfoJsApiLogger })
-  });

package/src/jsapi/common/_logger.test.ts

@@ -1,16 +0,0 @@
-import { createJsApiLogger } from "./_logger";
-
-describe("Common Logger", () => {
-  it("creates", () => {
-    const logger = createJsApiLogger(
-      {
-        info: () => {},
-        warn: () => {},
-        error: () => {}
-      },
-      "TEST"
-    );
-
-    expect(logger).toBeDefined();
-  });
-});

package/src/jsapi/common/_logger.ts

@@ -1,9 +0,0 @@
-import { Logger } from "@uuip/unified-ui-platform-sdk";
-
-type SeverityLogger = Pick<Logger.Service, "info" | "warn" | "error">;
-
-export const createJsApiLogger = (logger: SeverityLogger, subPrefix: string): SeverityLogger => ({
-  info: (...args: any[]) => logger.info(subPrefix, ...args),
-  warn: (...args: any[]) => logger.warn(subPrefix, ...args),
-  error: (...args: any[]) => logger.error(subPrefix, ...args)
-});

package/src/jsapi/common/_service-checker.test.ts

@@ -1,44 +0,0 @@
-import { AgentxServices, SERVICE } from "@wxcc-desktop/sdk-types";
-import { createServiceChecker } from "./_service-checker";
-
-jest.mock("@wxcc-desktop/sdk-types", () => {
-  const agentx_services_mock = {
-    SERVICE: {
-      isInited: false,
-      init: async (accessToken: string) => {
-        agentx_services_mock.SERVICE.isInited = true;
-      }
-    } as AgentxServices
-  };
-  return agentx_services_mock;
-});
-
-describe("Common Service Checker", () => {
-  let serviceChecker: ReturnType<typeof createServiceChecker>;
-
-  beforeEach(() => {
-    serviceChecker = createServiceChecker({
-      logger: {
-        info: () => {},
-        warn: () => {},
-        error: () => {}
-      }
-    });
-  });
-
-  it("creates", () => {
-    expect(serviceChecker).toBeDefined();
-  });
-
-  it("checks", async () => {
-    const res1 = serviceChecker.check();
-    expect(res1).toBeFalsy();
-
-    const res2 = serviceChecker.check(SERVICE);
-    expect(res2).toBeFalsy();
-
-    await (SERVICE as AgentxServices).init("fake-token");
-    const res3 = serviceChecker.check(SERVICE);
-    expect(res3).toBeTruthy();
-  });
-});

package/src/jsapi/common/_service-checker.ts

@@ -1,28 +0,0 @@
-import { AgentxService } from "@wxcc-desktop/sdk-types";
-import { createJsApiLogger } from "./_logger";
-
-type Config = { logger: ReturnType<typeof createJsApiLogger> };
-
-export class ServiceChecker {
-  private readonly logger: Config["logger"];
-
-  constructor(config: Config) {
-    this.logger = config.logger;
-  }
-
-  check(SERVICE?: AgentxService) {
-    if (!SERVICE) {
-      this.logger.error("SERVICE is not defined...");
-      return false;
-    }
-
-    if (!SERVICE.isInited) {
-      this.logger.error("SERVICE still not initialized... Await it's init(...) first.");
-      return false;
-    }
-
-    return true;
-  }
-}
-
-export const createServiceChecker = (config: Config) => new ServiceChecker(config);

package/src/jsapi/common/_service-events.test.ts

@@ -1,122 +0,0 @@
-import { Signal } from "@uuip/unified-ui-platform-sdk";
-import { logger } from "../../sdk";
-import { createServiceEvents } from "./_service-events";
-
-describe("Common Service Events", () => {
-  type Listeners = {
-    TEST: (...args: any[]) => void;
-  };
-  const creator = () =>
-    createServiceEvents<Listeners>({
-      logger: logger
-    });
-  let serviceEvents: ReturnType<typeof creator>;
-  let aqmServiceEntity: any;
-
-  beforeEach(() => {
-    serviceEvents = creator();
-    const { signal } = Signal.create.empty();
-    aqmServiceEntity = {
-      TEST: signal
-    };
-  });
-
-  it("creates", () => {
-    expect(serviceEvents).toBeDefined();
-  });
-
-  it("inits", () => {
-    expect(serviceEvents.isInited).toBeFalsy();
-
-    serviceEvents.init({
-      aqmServiceEntity: aqmServiceEntity,
-      aqmServiceEntityString: "ttt"
-    });
-
-    expect(serviceEvents.isInited).toBeTruthy();
-  });
-
-  it("listens", () => {
-    serviceEvents.init({
-      aqmServiceEntity: aqmServiceEntity,
-      aqmServiceEntityString: "ttt"
-    });
-
-    let counter = 0;
-    const listener: Listeners["TEST"] = () => {
-      counter++;
-    };
-
-    serviceEvents.addEventListener("TEST", listener);
-
-    aqmServiceEntity.TEST.send("A");
-    aqmServiceEntity.TEST.send("B");
-
-    serviceEvents.removeEventListener("TEST", listener);
-
-    expect(counter).toBe(2);
-  });
-
-  it("listensOnce", () => {
-    serviceEvents.init({
-      aqmServiceEntity: aqmServiceEntity,
-      aqmServiceEntityString: "ttt"
-    });
-
-    let counter = 0;
-    const listener: Listeners["TEST"] = () => counter++;
-
-    serviceEvents.addOnceEventListener("TEST", listener);
-
-    aqmServiceEntity.TEST.send("C");
-    aqmServiceEntity.TEST.send("D");
-
-    serviceEvents.removeOnceEventListener("TEST", listener);
-
-    expect(counter).toBe(1);
-  });
-
-  it("removes all listeners", () => {
-    serviceEvents.init({
-      aqmServiceEntity: aqmServiceEntity,
-      aqmServiceEntityString: "ttt"
-    });
-
-    let counter1 = 0;
-    let counter2 = 0;
-    const listener1: Listeners["TEST"] = () => counter1++;
-    const listener2: Listeners["TEST"] = () => counter2++;
-
-    serviceEvents.addEventListener("TEST", listener1);
-    serviceEvents.addOnceEventListener("TEST", listener2);
-
-    aqmServiceEntity.TEST.send("E");
-    aqmServiceEntity.TEST.send("F");
-
-    serviceEvents.removeAllEventListeners();
-
-    aqmServiceEntity.TEST.send("G");
-
-    expect(counter1).toBe(2);
-    expect(counter2).toBe(1);
-  });
-
-  it("cleanups", () => {
-    serviceEvents.init({
-      aqmServiceEntity: aqmServiceEntity,
-      aqmServiceEntityString: "ttt"
-    });
-
-    let counter = 0;
-    const listener: Listeners["TEST"] = () => counter++;
-
-    serviceEvents.addEventListener("TEST", listener);
-
-    serviceEvents.cleanup();
-
-    aqmServiceEntity.TEST.send("H");
-
-    expect(counter).toBe(0);
-    expect(serviceEvents.isInited).toBeFalsy();
-  });
-});

package/src/jsapi/common/_service-events.ts

@@ -1,156 +0,0 @@
-import { AgentxService } from "@wxcc-desktop/sdk-types";
-import { createJsApiLogger } from "./_logger";
-
-type AqmServiceEntities =
-  | AgentxService["aqm"]["agent"]
-  | AgentxService["aqm"]["configs"]
-  | AgentxService["aqm"]["contact"]
-  | AgentxService["aqm"]["dialer"]
-  | AgentxService["aqm"]["screenpop"];
-
-type Unlisten = () => void;
-type Events<Listeners> = keyof Listeners;
-type ListenersUnlistenMap<Listeners> = Map<Events<Listeners>, Map<Listeners[Events<Listeners>], Unlisten>>;
-
-type Config = { logger: ReturnType<typeof createJsApiLogger> };
-type InitConfig = { aqmServiceEntity: AqmServiceEntities; aqmServiceEntityString: string };
-
-export class AqmServiceEntityEvents<Listeners> {
-  private readonly logger: Config["logger"];
-
-  private aqmServiceEntity?: AqmServiceEntities;
-  private aqmServiceEntityString?: string;
-
-  isInited = false;
-
-  constructor(config: Config) {
-    this.logger = config.logger;
-  }
-
-  init(config: InitConfig) {
-    this.aqmServiceEntity = config.aqmServiceEntity;
-    this.aqmServiceEntityString = config.aqmServiceEntityString;
-
-    this.isInited = true;
-  }
-
-  cleanup() {
-    this.removeAllEventListeners();
-    this.aqmServiceEntity = undefined;
-    this.aqmServiceEntityString = undefined;
-
-    this.isInited = false;
-  }
-
-  private listeners: ListenersUnlistenMap<Listeners> = new Map();
-  private listenersOnce: ListenersUnlistenMap<Listeners> = new Map();
-
-  // data events
-  private _addEventListener<T extends Events<Listeners>>(eventName: T, listener: Listeners[T], isOnce: boolean) {
-    type MultiListenerRef = { stopListen: () => boolean };
-    type OnceListenerRef = { stopListenOnce: () => boolean };
-    type ListenerRef = MultiListenerRef | OnceListenerRef;
-    const _listeners = !isOnce ? "listeners" : "listenersOnce";
-    if (!this[_listeners].has(eventName)) {
-      this[_listeners].set(eventName, new Map());
-    }
-    const _map = this[_listeners].get(eventName);
-    const _listen = !isOnce ? "listen" : "listenOnce";
-    const createUnlisten = (listenerRef: ListenerRef) => {
-      // Auto-remove outer once listener
-      let onceWatchListenerRef: OnceListenerRef | null = null;
-      if (isOnce) {
-        onceWatchListenerRef = (this.aqmServiceEntity as any)[eventName]["listenOnce"](() =>
-          this.removeOnceEventListener(eventName, listener)
-        );
-      }
-      //
-      return () => {
-        if (listenerRef) {
-          if (!isOnce) {
-            (listenerRef as MultiListenerRef).stopListen();
-          } else {
-            (listenerRef as OnceListenerRef).stopListenOnce();
-            onceWatchListenerRef && onceWatchListenerRef.stopListenOnce();
-          }
-          const logMsgs = [];
-          logMsgs.push(`UnBound "${eventName}"`);
-          if (isOnce) {
-            logMsgs.push(`Once`);
-          }
-          if (this.aqmServiceEntityString) {
-            logMsgs.push(`from "${this.aqmServiceEntityString}"`);
-          }
-          this.logger?.info(logMsgs.join(" "));
-        }
-      };
-    };
-
-    if (this.aqmServiceEntity) {
-      if (eventName in this.aqmServiceEntity && _listen in (this.aqmServiceEntity as any)[eventName]) {
-        const listenerRef: ListenerRef = (this.aqmServiceEntity as any)[eventName][_listen](listener);
-        _map!.set(listener, createUnlisten(listenerRef));
-        const logMsgs = [];
-        logMsgs.push(`Bound "${eventName}"`);
-        if (isOnce) {
-          logMsgs.push(`Once`);
-        }
-        if (this.aqmServiceEntityString) {
-          logMsgs.push(`to "${this.aqmServiceEntityString}"`);
-        }
-
-        this.logger?.info(logMsgs.join(" "));
-      } else {
-        this.logger?.warn(`EventName "${eventName}" is not recognized, so won't be subscribed...`);
-      }
-    } else {
-      this.logger?.error(`"${this.aqmServiceEntityString}" is not ready yet. .init(...) first...`);
-    }
-  }
-
-  private _removeEventListener<T extends Events<Listeners>>(eventName: T, listener: Listeners[T], isOnce: boolean) {
-    const _listeners = !isOnce ? "listeners" : "listenersOnce";
-    if (this[_listeners].has(eventName)) {
-      const _map = this[_listeners].get(eventName);
-      if (_map) {
-        if (_map.has(listener)) {
-          const unlisten = _map!.get(listener);
-          unlisten!();
-          _map!.delete(listener);
-        }
-        if (_map.size < 1) {
-          this[_listeners].delete(eventName);
-        }
-      }
-    }
-  }
-
-  addEventListener<T extends Events<Listeners>>(eventName: T, listener: Listeners[T]) {
-    this._addEventListener(eventName, listener, false);
-  }
-
-  addOnceEventListener<T extends Events<Listeners>>(eventName: T, listener: Listeners[T]) {
-    this._addEventListener(eventName, listener, true);
-  }
-
-  removeEventListener<T extends Events<Listeners>>(eventName: T, listener: Listeners[T]) {
-    this._removeEventListener(eventName, listener, false);
-  }
-
-  removeOnceEventListener<T extends Events<Listeners>>(eventName: T, listener: Listeners[T]) {
-    this._removeEventListener(eventName, listener, true);
-  }
-
-  removeAllEventListeners() {
-    const listeners = ["listeners", "listenersOnce"] as const;
-    listeners.forEach(_listenrs => {
-      this[_listenrs].forEach((_map, eventName) => {
-        _map.forEach((unlisten, listener) => unlisten());
-        _map.clear();
-      });
-      this[_listenrs].clear();
-    });
-  }
-}
-
-export const createServiceEvents = <Listeners>(config: Config) => new AqmServiceEntityEvents<Listeners>(config);