@leapdev/app-platform 0.0.10-beta.0 → 0.1.0-beta.4

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

@@ -0,0 +1,32 @@
+export const leap_liveb_au = {
+  envName: 'liveb',
+  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-liveb.leapaws.com.au',
+  docsApi: 'https://api-docs-liveb.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-liveb.leapaws.com.au',
+    local: 'http://localhost:9092',
+  },
+  pubSubApi: '',
+  pubSubNotificationPublishKey: '',
+};

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

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

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

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

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

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

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

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

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

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

package/src/lib/functions/helpers.ts

@@ -0,0 +1,100 @@
+// String helpers
+/*
+ * Function to convert from UTF8 to Base64 solving the Unicode Problem
+ * Requires: window.btoa and window.encodeURIComponent functions
+ * More info: http://stackoverflow.com/questions/30106476/using-javascripts-atob-to-decode-base64-doesnt-properly-decode-utf-8-strings
+ * Samples:
+ *      b64EncodeUnicode('✓ à la mode'); // "4pyTIMOgIGxhIG1vZGU="
+ *      b64EncodeUnicode('\n'); // "Cg=="
+ */
+export function b64EncodeUnicode(str: string): string | null {
+  if (window && 'btoa' in window && 'encodeURIComponent' in window) {
+    return window.btoa(
+      encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (match, p1) => {
+        return String.fromCharCode(('0x' + p1) as any);
+      })
+    );
+  } else {
+    console.warn(
+      'b64EncodeUnicode requirements: window.btoa and window.encodeURIComponent functions'
+    );
+    return null;
+  }
+}
+
+/*
+ * Function to convert from Base64 to UTF8 solving the Unicode Problem
+ * Requires window.atob and window.decodeURIComponent functions
+ * More info: http://stackoverflow.com/questions/30106476/using-javascripts-atob-to-decode-base64-doesnt-properly-decode-utf-8-strings
+ * Samples:
+ *      b64DecodeUnicode('4pyTIMOgIGxhIG1vZGU='); // "✓ à la mode"
+ *      b64DecodeUnicode('Cg=='); // "\n"
+ */
+export function b64DecodeUnicode(str: string): string | null {
+  if (!str) {
+    return null;
+  }
+  if (window && 'atob' in window && 'decodeURIComponent' in window) {
+    return decodeURIComponent(
+      Array.prototype.map
+        .call(window.atob(str), (c) => {
+          return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
+        })
+        .join('')
+    );
+  } else {
+    console.warn(
+      'b64DecodeUnicode requirements: window.atob and window.decodeURIComponent functions'
+    );
+    return null;
+  }
+}
+
+// Object helpers 
+export function isNullOrUndefined(val: any): boolean {
+  return val == null || ['null', 'undefined'].includes(val.toString());
+}
+
+//LEAP office async helpers
+declare let Office: any;
+declare let Word: any;
+
+export type PromisifiedFunction<T> = (...args: any[]) => Promise<T>;
+
+export function promisifyAsync<T>(fn: Function): PromisifiedFunction<T> {
+  return function promisified(...args: any[]) {
+    return new Promise<T>((resolve, reject) => {
+      try {
+        Promise.resolve()
+          .then(() => {
+            // console.log('WORD CONTEXT SYNC BEFORE');
+            // Word context sync
+            Word.run((context: any) => {
+              return context.sync();
+            });
+          })
+          .then(() => {
+            fn(...args, (asyncResult: any): void => {
+              if (asyncResult.status === Office.AsyncResultStatus.Failed || asyncResult.error) {
+                reject(asyncResult.error);
+              } else {
+                resolve(asyncResult.value as T);
+              }
+            });
+          })
+          .catch((error) => {
+            reject(error);
+          })
+          .then(() => {
+            // console.log('WORD CONTEXT SYNC AFTER');
+            // Word context sync
+            Word.run((context: any) => {
+              return context.sync();
+            });
+          });
+      } catch (error) {
+        reject(error);
+      }
+    });
+  };
+}

package/src/lib/functions/xml.ts

@@ -0,0 +1,41 @@
+import { Builder, Parser, ParserOptions } from 'xml2js';
+
+const getParser = (options?: ParserOptions): Parser => {
+  let defaultParserOptions: ParserOptions = {
+    explicitArray: false,
+    explicitRoot: false,
+    ignoreAttrs: true,
+    trim: true,
+  };
+  let parser = new Parser(options || defaultParserOptions);
+  return parser;
+};
+
+export const toObj = (xml: string): Promise<any> => {
+  return new Promise((resolve, reject) => {
+    if (xml) {
+      getParser()
+        .parseStringPromise(xml)
+        .then((result) => {
+          resolve(result);
+        })
+        .catch((error) => {
+          reject(error);
+        });
+    } else {
+      reject('XML is not supplied');
+    }
+  });
+};
+
+export const toXml = (
+  data: any,
+  rootTagName: string,
+  options?: any
+): string => {
+  const builder = new Builder(options);
+  const xmlObject = { [rootTagName]: data };
+  let xml = builder.buildObject(xmlObject);
+  xml = xml.replace(new RegExp(' & ', 'g'), ' &amp; ');
+  return xml;
+};

package/src/lib/models/calc-api.model.ts

@@ -0,0 +1,74 @@
+export class CreateSessionRequest {
+  executionContext!: {
+    firmGUID: string;
+    firmJSON?: any;
+    matterGUID: string;
+    matterJSON?: any;
+    cardGUID?: string;
+    cardJSON?: any;
+    documentGUID?: string;
+    documentJSON?: any;
+    defaultFileId?: string;
+    trace?: boolean;
+  };
+
+  constructor(init?: Partial<CreateSessionRequest>) {
+    if (init) {
+      // noinspection TypeScriptValidateTypes
+      Object.assign(this, init);
+    }
+  }
+}
+
+export class EvaluatePathsRequest {
+  executionContext!: {
+    sessionId?: string;
+    transactionId?: string;
+    firmGUID?: string;
+    firmJSON?: any;
+    matterGUID?: string;
+    matterJSON?: any;
+    cardGUID?: string;
+    cardJSON?: any;
+    documentGUID?: string;
+    documentJSON?: any;
+    defaultFileId?: string;
+  };
+  paths!: string[];
+  parameters!: {
+    firmId: string;
+    matterId: string;
+    region: string;
+    paths: Array<string>;
+  };
+  objectId?: string;
+  includeDefaults: boolean = true; // Required
+
+  constructor(init?: Partial<EvaluatePathsRequest>) {
+    if (init) {
+      // noinspection TypeScriptValidateTypes
+      Object.assign(this, init);
+    }
+  }
+}
+
+export class EvaluatePathsResponse {
+  path!: string;
+  result: any;
+  status!: string;
+  error?: { name: string; code: string; message: string; };
+
+  constructor(init?: Partial<EvaluatePathsResponse>) {
+    if (init) {
+      // noinspection TypeScriptValidateTypes
+      Object.assign(this, init);
+    }
+  }
+}
+
+export enum AppPlatformId {
+  Word = 'word',
+  Web = 'web',
+  Desktop = 'desktop',
+  AppFirst = 'app-first'
+}

package/src/lib/models/constants/index.ts

@@ -0,0 +1,29 @@
+export const constants = {
+  LeapWordCustomPartNamespace: 'http://LEAPWordCustomPart.com',
+  LeapWordCustomPartTagName: 'LEAPWordCustomPart',
+  LeapDocumentDataNamespace: 'http://LeapDocumentData.com',
+  LeapDocumentDataRootTagName: 'LeapDocumentData',
+  LeapModelDataNamespace: 'http://LeapModelData.com',
+  LeapModelDataRootTagName: 'LeapModelData',
+  LeapTemplateDataNamespace: 'http://LeapTemplateData.com',
+  LeapTemplateDataRootTagName: 'LeapTemplateData',
+  LeapAppDataNamespace: 'http://LeapAppData.com',
+  LeapAppDataRootTagName: 'LeapAppData',
+  LeapEventsNamespace: 'http://LeapEvents.com',
+  LeapEventsRootTagName: 'LeapEvents',
+  LeapFieldsNamespace: 'http://LEAPDocumentFields.com',
+  LeapFieldsRootTagName: 'LEAPFields',
+  LeapTableFieldsNamespace: 'http://LEAPWordTableFields.com',
+  LeapTableFieldsRootTagName: 'LEAPWordTableFields',
+  LeapAsksNamespace: 'http://LEAPAsks.com',
+  LeapAsksRootTagName: 'LEAPAsks',
+  LeapConditionalFieldsNamespace: 'http://LEAPConditionalFields.com',
+  LeapConditionalFieldsRootTagName: 'LEAPConditionalFields',
+  LeapFunctionsNamespace: 'http://LEAPFunctions.com',
+  LeapFunctionsRootTagName: 'LEAPFunctions',
+  LeapAddInNamespace: 'http://LeapAddIn.com',
+  LeapAddInRootTagName: 'LeapAddIn',
+
+  fourdRedirectUrl: 'fourd://authcallback.com',
+  tokenSecondsBeforeExpire: 30,
+};

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

@@ -1 +1 @@
-export * from './calc-api.model';
+export * from './calc-api.model';

package/src/lib/models/leap-events.model.ts

@@ -0,0 +1,79 @@
+export class LeapEvents {
+  LeapEvent: (LeapEvent | string)[] = [];
+  currentEventId?: string;
+  xmlns!: string;
+
+  constructor(init?: Partial<LeapEvents>) {
+    if (init) {
+      Object.assign(this, init);
+    }
+
+    if (!Array.isArray(this.LeapEvent)) {
+      this.LeapEvent = [];
+    }
+  }
+}
+
+export class LeapEvent {
+  id!: string; // Guid
+  correlationId!: string | null; // Guid
+  eventType: LeapEventType = LeapEventType.Unknown;
+  action: LeapEventAction = LeapEventAction.Unknown;
+  data: any = {};
+
+  constructor(init?: Partial<LeapEvent>) {
+    if (init) {
+      Object.assign(this, init);
+    }
+  }
+}
+
+export enum LeapEventType {
+  Unknown = 0,
+  VstoEvent = 1,
+  WordAppEvent = 2,
+  DocumentBuilderRequest = 3,
+  DocumentBuilderResponse = 4,
+  CalcApiRequest = 5,
+  CalcApiResponse = 6,
+  WordAppEventResponse = 7,
+}
+
+export enum LeapEventAction {
+  Unknown = 0,
+
+  Vsto_ClearDirtyFields = 10,
+  Vsto_UpdateDocument = 11,
+
+  WordApp_DeleteProcessedEvents = 21,
+  WordApp_GetMode = 22,
+  WordApp_GetToken = 23,
+  WordApp_ResetTemplate = 24,
+  WordApp_FindField = 25,
+  WordApp_InsertField = 26,
+  WordApp_CreateDocument = 27,
+
+  DocumentBuilder_UpdateFields = 31,
+  DocumentBuilder_UpdateFieldsPartial = 32,
+  DocumentBuilder_SetValue = 33,
+  DocumentBuilder_NewDefinableTable = 34,
+  DocumentBuilder_UpdateDefinableTable = 35,
+  DocumentBuilder_UpdateDefinableTableBatch = 36,
+  DocumentBuilder_DeleteDefinableTable = 37,
+
+  DocumentBuilder_UpdateFieldsResponse = 41,
+  DocumentBuilder_UpdateFieldsPartialResponse = 42,
+  DocumentBuilder_SetValueResponse = 43,
+  DocumentBuilder_NewDefinableTableResponse = 44,
+  DocumentBuilder_UpdateDefinableTableResponse = 45,
+  DocumentBuilder_UpdateDefinableTableBatchResponse = 46,
+  DocumentBuilder_DeleteDefinableTableResponse = 47,
+
+  Calc_EvaluatePaths = 51,
+  Calc_EvaluatePathsResponse = 61,
+
+  WordApp_GetModeResponse = 71,
+  WordApp_UpdateIfStatements = 72,
+  WordApp_GetTokenResponse = 73,
+  WordApp_ResetTemplateResponse = 74,
+}

package/src/lib/models/leap.model.ts

@@ -0,0 +1,78 @@
+export class LeapDocumentData {
+  appId: string | undefined;
+  documentId: string | undefined;
+  templateId: string | undefined;
+  firmId: string | undefined;
+  matterId: string | undefined;
+  isCustom: string | undefined;
+  isPrecedent: string | undefined; // '1' | '0'
+  isReady?: string; // 'true' | 'false' - detect whether initModel has been triggered when creating document
+  action: string | undefined;
+  apiToken: string | undefined;
+  defaultTableId: string | undefined;
+  defaultTableOrder: string | undefined;
+  region: string | undefined;
+  mode: string | undefined; // 0 = Online, 1 = Offline
+  xmlns: string | undefined;
+  precedentClass: string | undefined;
+  usedByPrecedentId?: string | undefined;
+  usedByPrecedentName?: string | undefined;
+  wordStyleId?: string | undefined;
+  appliedWordStyleVersionId?: string | undefined;
+
+  sessionId: string | undefined;
+  transactionId?: string;
+  matterTypeId?: string; // Deprecated - to be removed when phoenix frontend changes
+  state?: string; // Deprecated - to be removed when phoenix frontend changes
+  states?: string[];
+  params?: any;
+  instanceId?: string;
+
+  requireLogout?: boolean; // Only to bypass Microsoft Approval - to be removed once ByLawyers word app gets approved
+
+  constructor(init?: Partial<LeapDocumentData>) {
+    if (init) {
+      Object.assign(this, init);
+    }
+  }
+}
+
+export enum PreviewMode {
+  WebPreview = 'preview-web',
+  DesktopPreview = 'preview-desktop',
+}
+
+export enum LeapRegion {
+  AU = 'au',
+  UK = 'uk',
+  US = 'us',
+}
+
+export class LeapModelData {
+  xmlns: string | undefined;
+}
+
+export class LeapTemplateData {
+  xmlns: string | undefined;
+  definitions: any;
+  settings: any;
+  caMatter?: any;
+  eNotes: any;
+  activeENotes: ActiveENote[] | undefined;
+  activeENotesCount: number | undefined;
+}
+
+export interface ActiveENote {
+  index: string;
+  note: string;
+}
+
+export type LEAPUser = {
+  userId: string;
+  email: string;
+  firstName: string;
+  lastName: string;
+  env: string;
+  countryCode: number;
+  region: string;
+};

package/src/lib/models/signalr.model.ts

@@ -0,0 +1,22 @@
+export type SignalRMessage<T> = {
+  action: string;
+  payload: T;
+  sessionId: string;
+  requestId: string;
+  source: string;
+}
+
+export type SignalRInitData = {
+  code: string;
+  codeChallenge: string;
+  contentModeEnabled: boolean;
+  country: string;
+  countryCode: number;
+  hostType: string;
+  hostVersion: string;
+  environment: string;
+  firmId: string;
+  staffId: string;
+  userId: string;
+  userName: string;
+}