@leapdev/app-platform 0.1.0-beta.3 → 0.1.0-beta.4

package/.eslintrc.json

@@ -0,0 +1,25 @@
+{
+  "extends": ["../../.eslintrc.json"],
+  "ignorePatterns": ["!**/*"],
+  "overrides": [
+    {
+      "files": ["*.ts", "*.tsx", "*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.ts", "*.tsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.js", "*.jsx"],
+      "rules": {}
+    },
+    {
+      "files": ["*.json"],
+      "parser": "jsonc-eslint-parser",
+      "rules": {
+        "@nx/dependency-checks": "error"
+      }
+    }
+  ]
+}

package/package.json

@@ -1,15 +1,15 @@
-{
-  "name": "@leapdev/app-platform",
-  "version": "0.1.0-beta.3",
-  "dependencies": {
-    "tslib": "^2.3.0",
-    "vkbeautify": "^0.99.3",
-    "xml2js": "^0.6.2",
-    "os-browserify": "^0.3.0",
-    "loglevel": "^1.6.3",
-    "rxjs": "7.8.0"
-  },
-  "type": "commonjs",
-  "main": "./src/index.js",
-  "typings": "./src/index.d.ts"
-}
+{
+  "name": "@leapdev/app-platform",
+  "version": "0.1.0-beta.4",
+  "dependencies": {
+    "tslib": "^2.3.0",
+    "vkbeautify": "^0.99.3",
+    "xml2js": "^0.6.2",
+    "os-browserify": "^0.3.0",
+    "loglevel": "^1.6.3",
+    "rxjs": "7.8.0"
+  },
+  "type": "commonjs",
+  "main": "./src/index.js",
+  "typings": "./src/index.d.ts"
+}

package/project.json

@@ -0,0 +1,27 @@
+{
+  "name": "app-platform",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/app-platform/src",
+  "projectType": "library",
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/packages/app-platform",
+        "main": "packages/app-platform/src/index.ts",
+        "tsConfig": "packages/app-platform/tsconfig.lib.json",
+        "assets": ["packages/app-platform/*.md"]
+      }
+    },
+    "publish": {
+      "command": "node tools/scripts/publish.mjs app-platform {args.ver} {args.tag}",
+      "dependsOn": ["build"]
+    },
+    "lint": {
+      "executor": "@nx/eslint:lint",
+      "outputs": ["{options.outputFile}"]
+    }
+  },
+  "tags": []
+}

package/src/index.ts

@@ -0,0 +1,44 @@
+export * from './lib/environment';
+export * from './lib/models';
+export * from './lib/services';
+
+import { AppPlatform } from './lib/app-platform';
+import { EvaluatePathsRequest } from './lib/models';
+
+const appPlatform = new AppPlatform();
+
+export const initAppPlatform = () => {
+  return appPlatform.init();
+};
+
+export const getDocumentData = () => {
+  return appPlatform.getDocumentData();
+};
+
+export const evaluatePaths = (request: EvaluatePathsRequest) => {
+  return appPlatform.evaluatePaths(request);
+};
+
+export const createDocument = (params: {
+  precedentId: string;
+  body: string;
+  closeExisting?: boolean;
+}) => {
+  return appPlatform.createDocument(params);
+};
+
+export const getLEAPTokenViaSignalR = (forceRefresh?: boolean) => {
+  return appPlatform.getLEAPTokenViaSignalR(forceRefresh);
+};
+
+export const getLEAPUserViaSignalR = () => {
+  return appPlatform.getLEAPUserViaSignalR();
+};
+
+export const getInitDataViaSignalR = () => {
+  return appPlatform.getInitDataViaSignalR();
+};
+
+export const connectSignalR = (params: { clientId: string }) => {
+  return appPlatform.connectToSignalR(params);
+};

package/src/lib/app-platform.ts

@@ -0,0 +1,270 @@
+import { EvaluatePathsRequest, EvaluatePathsResponse } from './models';
+import { constants } from './models/constants';
+import {
+  LeapEvent,
+  LeapEventAction,
+  LeapEventType,
+} from './models/leap-events.model';
+import { LeapDocumentData, LEAPUser } from './models/leap.model';
+import { SignalRInitData } from './models/signalr.model';
+import { CalcWordService, DocumentService, LoggerService } from './services';
+import { AuthService } from './services/auth/auth.service';
+import { timeout } from './services/calc-api/promise-helper.function';
+import { getDataByNamespace } from './services/custom-xml-part.service';
+import { LeapEventsService } from './services/leap-events.service';
+import { SignalRService } from './services/signalr/signalr.service';
+
+export class AppPlatform {
+  private leapEventsService: LeapEventsService;
+  private loggerService: LoggerService;
+  private calcWordService: CalcWordService;
+  private documentService: DocumentService;
+  private signalRService: SignalRService;
+  private _openViaLEAP: boolean = false;
+  #authService: AuthService | null = null;
+  #signalRInitData: SignalRInitData | null = null;
+
+  constructor() {
+    this.loggerService = new LoggerService(false);
+    this.leapEventsService = new LeapEventsService();
+    this.calcWordService = new CalcWordService(
+      this.leapEventsService,
+      this.loggerService
+    );
+    this.documentService = new DocumentService(
+      this.leapEventsService,
+      this.loggerService
+    );
+    this.signalRService = new SignalRService();
+  }
+
+  public async init(): Promise<{done: boolean; openViaLEAP: boolean}> {
+    try {
+      const data = await this.getWordCustomPart();
+      if (data) {
+        this._openViaLEAP = true;
+        this.loggerService.log(
+          `[INIT] Setup LEAP Events and set token in custom xml part`
+        );
+        await this.setupLeapEvents();
+        await this.setTokenInCustomXml();
+        return { done: true, openViaLEAP: true };
+      } else {
+        this.loggerService.log(`[INIT] Document not open via LEAP`);
+        this._openViaLEAP = false;
+        return { done: true, openViaLEAP: false };
+      }
+    } catch (_) {
+      return { done: false, openViaLEAP: false };
+    }
+  }
+
+  public async connectToSignalR(params: { clientId: string }): Promise<boolean> {
+    const { clientId } = params;
+    await this.signalRService.connectToSignalR();
+    this.#signalRInitData = await this.signalRService.getInitData({ clientId });
+    if (this.#signalRInitData) {
+      const { code, codeChallenge, environment } = this.#signalRInitData;
+      this.#authService = new AuthService({
+        code,
+        codeVerifier: codeChallenge,
+        clientId,
+        env: environment,
+      });
+      const done = await this.#authService.init();
+      return done;
+    } else {
+      return false;
+    }
+  }
+
+  public getLEAPTokenViaSignalR(forceRefresh?: boolean): Promise<string> {
+    if (this.#authService) {
+      return this.#authService.getRefreshedAccessToken(forceRefresh);
+    } else {
+      return new Promise((resolve) => resolve(''));
+    }
+  }
+
+  public getLEAPUserViaSignalR(): Promise<LEAPUser | undefined> {
+    if (this.#authService) {
+      const user = this.#authService.getLEAPUser();
+      return new Promise((resolve) => resolve(user));
+    } else {
+      return new Promise((resolve) => resolve(undefined));
+    }
+  }
+
+  public getInitDataViaSignalR(): Promise<Omit<
+    SignalRInitData,
+    'code' | 'codeChallenge'
+  > | null> {
+    return new Promise((resolve) => {
+      if (this.#signalRInitData) {
+        const data: Omit<SignalRInitData, 'code' | 'codeChallenge'> = {
+          contentModeEnabled: this.#signalRInitData.contentModeEnabled,
+          country: this.#signalRInitData.country,
+          countryCode: this.#signalRInitData.countryCode,
+          hostType: this.#signalRInitData.hostType,
+          hostVersion: this.#signalRInitData.hostVersion,
+          environment: this.#signalRInitData.environment,
+          firmId: this.#signalRInitData.firmId,
+          staffId: this.#signalRInitData.staffId,
+          userId: this.#signalRInitData.userId,
+          userName: this.#signalRInitData.userName,
+        };
+        resolve(data);
+      } else {
+        resolve(null);
+      }
+    });
+  }
+
+  public async getDocumentData(): Promise<LeapDocumentData | null> {
+    try {
+      if (!this._openViaLEAP) {
+        this.loggerService.log(`[getDocumentData] Document not open via LEAP`);
+        return null;
+      }
+      //todo don't use any in getDataByNamespace's response
+      const data = await getDataByNamespace(
+        constants.LeapDocumentDataNamespace
+      );
+      if (data) {
+        return data as LeapDocumentData;
+      }
+      return null;
+    } catch (error) {
+      this.loggerService.error(`[ERROR] Get Document Data: ${error}`);
+      return null;
+    }
+  }
+
+  public async evaluatePaths(
+    request: EvaluatePathsRequest
+  ): Promise<Array<EvaluatePathsResponse> | null> {
+    try {
+      if (!this._openViaLEAP) {
+        this.loggerService.log(`[evaluatePaths] Document not open via LEAP`);
+        return null;
+      }
+      const data = await this.calcWordService.evaluatePaths(request);
+      if (data) {
+        return data;
+      }
+      return null;
+    } catch (error) {
+      this.loggerService.error(`[ERROR] Evaluate Paths: ${error}`);
+      return null;
+    }
+  }
+
+  public async createDocument(params: {
+    precedentId: string;
+    body: string;
+    closeExisting?: boolean;
+  }) {
+    if (!this._openViaLEAP) {
+      this.loggerService.log(`[createDocument] Document not open via LEAP`);
+      return null;
+    }
+    return this.documentService.createDocument(params);
+  }
+
+  private async setupLeapEvents(): Promise<void> {
+    try {
+      await this.leapEventsService.addHandler(
+        Office.EventType.NodeInserted,
+        (result: Office.NodeInsertedEventArgs) => {
+          this.leapEventsService.handleCustomXmlPartNodeEvent(
+            Office.EventType.NodeInserted,
+            result
+          );
+        }
+      );
+    } catch (error) {
+      this.loggerService.error(`[SetupLeapEvents] Failed: ${error}`);
+    }
+  }
+
+  private setTokenInCustomXml(): Promise<void> {
+    let subscriptionId: string;
+    return new Promise((resolve, reject) => {
+      Promise.resolve(() => {
+        this.loggerService.log(`[LEAP Event] WordApp_GetToken`);
+      })
+        .then(() => {
+          const id = new Date().getTime().toString();
+          return this.leapEventsService.addEvent({
+            id,
+            correlationId: null,
+            eventType: LeapEventType.WordAppEvent,
+            action: LeapEventAction.WordApp_GetToken,
+            data: null,
+          });
+        })
+        .then((event) => {
+          this.loggerService.log('[LEAP Event] WordApp_GetToken request sent');
+
+          // Subscribe
+          const leapEventResponseHandlerPromise = new Promise<Array<any>>(
+            (innerResolve, innerReject) => {
+              subscriptionId = this.leapEventsService.subscribe(
+                event.id,
+                LeapEventType.WordAppEventResponse,
+                LeapEventAction.WordApp_GetTokenResponse,
+                (leapEvent: LeapEvent) =>
+                  this.leapEventsService.handleLeapEventResponse<Array<any>>(
+                    leapEvent,
+                    { resolve: innerResolve, reject: innerReject }
+                  )
+              );
+            }
+          );
+
+          return timeout(leapEventResponseHandlerPromise, 1000);
+        })
+        .then(() => {
+          // Return result
+          resolve();
+        })
+        .catch((error: any) => {
+          this.loggerService.error(
+            `[LEAP Event] WordApp_GetToken request failed: ${error}`
+          );
+          reject(error);
+        })
+        .then(() => {
+          // Unsubscribe
+          return this.leapEventsService.unsubscribe(subscriptionId);
+        })
+        .then((unsubscribeSuccess: boolean) => {
+          if (unsubscribeSuccess === true) {
+            this.loggerService.log(
+              `[LEAP Event] WordApp_GetToken request successfully unsubscribed ${subscriptionId}`
+            );
+          } else {
+            this.loggerService.warn(
+              `[LEAP Event] WordApp_GetToken request failed to unsubscribe from ${subscriptionId}`
+            );
+          }
+        });
+    });
+  }
+
+  private async getWordCustomPart(): Promise<{ LEAP_GUID: string } | null> {
+    try {
+      const data = await getDataByNamespace(
+        constants.LeapWordCustomPartNamespace,
+        0
+      );
+      if (data) {
+        return data;
+      }
+      return null;
+    } catch (error) {
+      this.loggerService.error(`[ERROR] Get WordCustomPart: ${error}`);
+      return null;
+    }
+  }
+}

package/src/lib/environment/environment.dictionary.ts

@@ -0,0 +1,28 @@
+import { leap_dev_au } from './leap/env.dev.au.config';
+import { leap_test_au } from './leap/env.test.au.config';
+import { leap_live_au } from './leap/env.live.au.config';
+import { leap_liveb_au } from './leap/env.liveb.au.config';
+import { leap_test_nz } from './leap/env.test.nz.config';
+import { leap_live_nz } from './leap/env.live.nz.config';
+import { leap_test_us } from './leap/env.test.us.config';
+import { leap_live_us } from './leap/env.live.us.config';
+import { leap_test_ca } from './leap/env.test.ca.config';
+import { leap_live_ca } from './leap/env.live.ca.config';
+import { leap_test_uk } from './leap/env.test.uk.config';
+import { leap_live_uk } from './leap/env.live.uk.config';
+import { Environment } from './environment';
+
+export const environment_dictionary: { [key: string]: Environment } = {
+  leap_dev_au,
+  leap_test_au,
+  leap_live_au,
+  leap_liveb_au,
+  leap_test_nz,
+  leap_live_nz,
+  leap_test_uk,
+  leap_live_uk,
+  leap_test_us,
+  leap_live_us,
+  leap_test_ca,
+  leap_live_ca,
+};

package/src/lib/environment/environment.ts

@@ -0,0 +1,44 @@
+export abstract class Environment {
+  abstract envName: string; // Default
+  abstract brand: string;
+  abstract region: string;
+  abstract production: boolean;
+  abstract imports: any[];
+  abstract keys: {
+    pnSubscribe: string;
+  };
+  abstract authApi: {
+    baseUrl: string;
+    clientId: string;
+    redirectPath: string;
+  };
+  abstract automation: string;
+  abstract docsApi: string;
+  abstract schemaApi: string;
+  abstract leapDesignApi: {
+    baseUrl: string;
+    projectId: string;
+  };
+  abstract calcApi: {
+    remote: string;
+    local?: string;
+  };
+  abstract docBuilderApi: {
+    remote: string;
+    local?: string;
+  };
+  abstract pubSubApi: string;
+  abstract pubSubNotificationPublishKey: string;
+}
+
+export class LeapEnvironment {
+  static config: Environment = {} as Environment;
+
+  static getConfig(): Environment {
+    return this.config;
+  }
+
+  static setConfig(newConfig: Environment): void {
+    this.config = newConfig;
+  }
+}

package/src/lib/environment/{index.d.ts → index.ts}

@@ -1,2 +1,2 @@
-export { Environment, LeapEnvironment } from './environment';
-export { environment_dictionary } from './environment.dictionary';
+export { Environment, LeapEnvironment } from './environment';
+export { environment_dictionary } from './environment.dictionary';

package/src/lib/environment/leap/env.dev.au.config.ts

@@ -0,0 +1,33 @@
+export const leap_dev_au = {
+  envName: 'dev',
+  brand: 'LEAP',
+  region: 'au',
+  production: false,
+  imports: [],
+  keys: {
+    pnSubscribe: 'sub-a456f002-0095-11e2-9638-9581afc33ebf',
+  },
+  authApi: {
+    baseUrl: 'https://auth.dev.leap.services',
+    clientId: 'OBIUNINUL9DBSR8F',
+    redirectPath: 'index.html',
+  },
+  automation: 'https://office-automation-api-dev.leapaws.com.au',
+  docsApi: 'https://api-docs-dev.leapaws.com.au',
+  schemaApi: 'https://schema-api.dev.leap.services',
+  leapDesignApi: {
+    baseUrl: 'https://leapdesign.leapaws.com.au',
+    projectId: 'Test',
+  },
+  calcApi: {
+    remote: 'https://leapcalc.dev.leap.services',
+    local: 'http://localhost:9091',
+  },
+  docBuilderApi: {
+    remote: 'https://doc-builder-dev.leapaws.com.au',
+    local: 'http://localhost:9092',
+  },
+  pubSubApi: 'https://leap-pubsub.dev.leapaws.com.au',
+  pubSubNotificationPublishKey:
+    'AOG98zJZyz2akUiK2JID4xK-pvN8PfXz7NYYgwyA3gw5AzFuRMrvqw==',
+};

package/src/lib/environment/leap/env.live.au.config.ts

@@ -0,0 +1,32 @@
+export const leap_live_au = {
+  envName: 'live',
+  brand: 'LEAP',
+  region: 'au',
+  production: true,
+  imports: [],
+  keys: {
+    pnSubscribe: 'sub-a456f002-0095-11e2-9638-9581afc33ebf',
+  },
+  authApi: {
+    baseUrl: 'https://auth.leap.services',
+    clientId: 'XKGMO3JQNSZOYDK2',
+    redirectPath: 'index.html',
+  },
+  automation: 'https://office-automation-api-live.leapaws.com.au',
+  docsApi: 'https://api-docs.leapaws.com.au',
+  schemaApi: 'https://schema-api-au-live.leap.services',
+  leapDesignApi: {
+    baseUrl: 'https://leapdesign.leapaws.com.au',
+    projectId: 'Live',
+  },
+  calcApi: {
+    remote: 'https://leapcalc-au-live.leap.services',
+    local: 'http://localhost:9091',
+  },
+  docBuilderApi: {
+    remote: 'https://doc-builder.leapaws.com.au',
+    local: 'http://localhost:9092',
+  },
+  pubSubApi: '',
+  pubSubNotificationPublishKey: '',
+};

package/src/lib/environment/leap/env.live.ca.config.ts

@@ -0,0 +1,32 @@
+export const leap_live_ca = {
+  envName: 'live',
+  brand: 'LEAP',
+  region: 'ca',
+  production: true,
+  imports: [],
+  keys: {
+    pnSubscribe: 'sub-a456f002-0095-11e2-9638-9581afc33ebf',
+  },
+  authApi: {
+    baseUrl: 'https://auth.leap.services',
+    clientId: 'XKGMO3JQNSZOYDK2',
+    redirectPath: 'index.html',
+  },
+  automation: 'https://office-automation-api.leapaws.ca',
+  docsApi: 'https://api-docs.leapaws.ca',
+  schemaApi: 'https://schema-api.ca.leap.services',
+  leapDesignApi: {
+    baseUrl: 'https://leapdesign.leapaws.ca',
+    projectId: 'Live',
+  },
+  calcApi: {
+    remote: 'https://leapcalc.ca.leap.services',
+    local: 'http://localhost:9091',
+  },
+  docBuilderApi: {
+    remote: 'https://doc-builder.leapaws.ca',
+    local: 'http://localhost:9092',
+  },
+  pubSubApi: '',
+  pubSubNotificationPublishKey: '',
+};

package/src/lib/environment/leap/env.live.nz.config.ts

@@ -0,0 +1,32 @@
+export const leap_live_nz = {
+  envName: 'live',
+  brand: 'LEAP',
+  region: 'au',
+  production: true,
+  imports: [],
+  keys: {
+    pnSubscribe: 'sub-a456f002-0095-11e2-9638-9581afc33ebf',
+  },
+  authApi: {
+    baseUrl: 'https://auth.leap.services',
+    clientId: 'XKGMO3JQNSZOYDK2',
+    redirectPath: 'index.html',
+  },
+  automation: 'https://office-automation-api-live.leapaws.com.au',
+  docsApi: 'https://api-docs.leapaws.com.au',
+  schemaApi: 'https://schema-api-au-live.leap.services',
+  leapDesignApi: {
+    baseUrl: 'https://leapdesign.leapaws.com.au',
+    projectId: 'Live',
+  },
+  calcApi: {
+    remote: 'https://leapcalc-au-live.leap.services',
+    local: 'http://localhost:9091',
+  },
+  docBuilderApi: {
+    remote: 'https://doc-builder.leapaws.com.au',
+    local: 'http://localhost:9092',
+  },
+  pubSubApi: '',
+  pubSubNotificationPublishKey: '',
+};

package/src/lib/environment/leap/env.live.uk.config.ts

@@ -0,0 +1,32 @@
+export const leap_live_uk = {
+  envName: 'live',
+  brand: 'LEAP',
+  region: 'uk',
+  production: true,
+  imports: [],
+  keys: {
+    pnSubscribe: 'sub-a456f002-0095-11e2-9638-9581afc33ebf',
+  },
+  authApi: {
+    baseUrl: 'https://auth.leap.services',
+    clientId: 'XKGMO3JQNSZOYDK2',
+    redirectPath: 'index.html',
+  },
+  automation: 'https://office-automation-api-live.leapaws.co.uk',
+  docsApi: 'https://api-docs.leapaws.co.uk',
+  schemaApi: 'https://schema-api-uk-live.leap.services',
+  leapDesignApi: {
+    baseUrl: 'https://leapdesign.leapaws.co.uk',
+    projectId: 'Live',
+  },
+  calcApi: {
+    remote: 'https://leapcalc-uk-live.leap.services',
+    local: 'http://localhost:9091',
+  },
+  docBuilderApi: {
+    remote: 'https://doc-builder.leapaws.co.uk',
+    local: 'http://localhost:9092',
+  },
+  pubSubApi: '',
+  pubSubNotificationPublishKey: '',
+};

package/src/lib/environment/leap/env.live.us.config.ts

@@ -0,0 +1,32 @@
+export const leap_live_us = {
+  envName: 'live',
+  brand: 'LEAP',
+  region: 'us',
+  production: true,
+  imports: [],
+  keys: {
+    pnSubscribe: 'sub-a456f002-0095-11e2-9638-9581afc33ebf',
+  },
+  authApi: {
+    baseUrl: 'https://auth.leap.services',
+    clientId: 'XKGMO3JQNSZOYDK2',
+    redirectPath: 'index.html',
+  },
+  automation: 'https://office-automation-api-live.leapaws.com',
+  docsApi: 'https://api-docs.leapaws.com',
+  schemaApi: 'https://schema-api-us-live.leap.services',
+  leapDesignApi: {
+    baseUrl: 'https://leapdesign.leapaws.com',
+    projectId: 'Live',
+  },
+  calcApi: {
+    remote: 'https://leapcalc-us-live.leap.services',
+    local: 'http://localhost:9091',
+  },
+  docBuilderApi: {
+    remote: 'https://doc-builder.leapaws.com',
+    local: 'http://localhost:9092',
+  },
+  pubSubApi: '',
+  pubSubNotificationPublishKey: '',
+};