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

package/src/lib/services/document/document.service.ts

@@ -0,0 +1,33 @@
+import { LeapEventAction, LeapEventType } from '../../models/leap-events.model';
+import { LeapEventsService } from '../leap-events.service';
+import { LoggerService } from '../logger/logger.service';
+
+export class DocumentService {
+  constructor(
+    private leapEventsService: LeapEventsService,
+    private loggerService: LoggerService
+  ) {}
+
+  createDocument(params: {precedentId: string, body: string, closeExisting?: boolean}): Promise<{precedentId: string, body: string, closeExisting?: boolean}> {
+    return new Promise((resolve) => {
+      Promise.resolve(() => {
+        this.loggerService.log(
+          '[DocumentService] (createDocument) Creating a document based on the precedent and generated body'
+        );
+      })
+      .then(() => {
+        const id = new Date().getTime().toString();
+        return this.leapEventsService.addEvent({
+          id,
+          correlationId: null,
+          eventType: LeapEventType.WordAppEvent,
+          action: LeapEventAction.WordApp_CreateDocument,
+          data: params
+        });
+      })
+      .then(() =>{
+        return resolve(params)
+      })
+    })
+  }
+}

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

@@ -1,5 +1,10 @@
-export * from './calc-api/calc-word.service';
-export * from './custom-xml-part.service';
-export * from './leap-events.service';
-export * from './logger/logger.service';
-export * from './document/document.service';
+
+export * from './calc-api/calc-word.service';
+
+export * from './custom-xml-part.service';
+
+export * from './leap-events.service';
+
+export * from './logger/logger.service';
+
+export * from './document/document.service';

package/src/lib/services/leap-events.service.ts

@@ -0,0 +1,489 @@
+/// <reference types="office-js" />
+import {
+  Observable,
+  Subject,
+  Subscription,
+  catchError,
+  filter,
+  of,
+} from 'rxjs';
+import {
+  LeapEvent,
+  LeapEventAction,
+  LeapEventType,
+  LeapEvents,
+} from '../models/leap-events.model';
+import {
+  addHandlerForCustomXmlPart,
+  getChildNodes,
+  getDataByNamespace,
+  getNodeText,
+  updateXmlDataByNamespace,
+} from './custom-xml-part.service';
+import { b64DecodeUnicode, b64EncodeUnicode } from '../functions/helpers';
+import { LoggerService } from './logger/logger.service';
+import { constants } from '../models/constants';
+import { toXml } from '../functions/xml';
+
+interface IAddEventQueueItem {
+  data: LeapEvent;
+  resolve: (res: LeapEvent) => void;
+  reject: (err: any) => void;
+}
+
+export class LeapEventsService {
+  private eventSubject$: Subject<LeapEvent> = new Subject<LeapEvent>();
+  private readonly event$: Observable<LeapEvent> =
+    this.eventSubject$.asObservable();
+  private addEventLock = false;
+  private addEventQueue: Array<IAddEventQueueItem> = [];
+  private subscriptions: { id: string; subscription: Subscription }[] = [];
+  private loggerService: LoggerService;
+
+  constructor() {
+    this.loggerService = new LoggerService(false);
+  }
+
+  public addHandler<
+    TEventArgs extends
+      | Office.NodeInsertedEventArgs
+      | Office.NodeDeletedEventArgs
+      | Office.NodeReplacedEventArgs
+  >(eventType: Office.EventType, handler: (result: TEventArgs) => void) {
+    return addHandlerForCustomXmlPart(
+      constants.LeapEventsNamespace,
+      eventType,
+      handler
+    );
+  }
+
+  // A default handler. The caller MUST wrap this in a new Promise
+  // NOTE: some voodoo passing over the encompassing Promise's resolve/reject functions
+  public handleLeapEventResponse<T>(event: LeapEvent, { resolve, reject }): T {
+    this.loggerService.log(
+      `[LeapEventsService] (handleLeapEventResponse) Handling ${
+        LeapEventType[event.eventType]
+      }::${LeapEventAction[event.action]}`
+    );
+    this.loggerService.log(
+      `[LeapEventsService] (handleLeapEventResponse): ${JSON.stringify(
+        event.data
+      )}`
+    );
+
+    type responseObj = {
+      status: string;
+      error: string;
+    };
+
+    let response: responseObj = {} as responseObj;
+    if (Array.isArray(event.data)) {
+      response = event.data as any;
+      resolve(response);
+    } else {
+      Object.assign(response, event.data);
+      if (response.status === 'ok') {
+        resolve(response);
+      } else {
+        reject(response.error);
+      }
+    }
+
+    return response as T;
+  }
+
+  public handleCustomXmlPartNodeEvent(
+    eventType: Office.EventType,
+    eventArgs: Office.NodeInsertedEventArgs | Office.NodeReplacedEventArgs
+  ): Promise<void> {
+    return Promise.resolve(`Handle custom XML part event`)
+      .then(() => {
+        this.loggerService.log(
+          `[LeapEventsService] (handleCustomXmlPartNodeEvent) Handling ${eventType} event on the LEAP Events custom XML part`
+        );
+      })
+      .then(() => {
+        return this.getLeapEventFromNode(eventType, eventArgs);
+      })
+      .then((result: LeapEvent | null) => {
+        const leapEvent: LeapEvent | null = result;
+
+        if (!leapEvent || !leapEvent.eventType) {
+          this.loggerService.log(
+            `[LeapEventsService] (handleCustomXmlPartNodeEvent) This LeapEvent of type ${eventType} is no longer valid: ${eventArgs} `
+          );
+          return;
+        }
+
+        switch (leapEvent.eventType) {
+          case LeapEventType.CalcApiRequest:
+          case LeapEventType.DocumentBuilderRequest:
+            this.loggerService.log(
+              `[LeapEventsService] (handleCustomXmlPartNodeEvent) This LeapEvent is a request: ` +
+                `${leapEvent.id} | ${LeapEventType[leapEvent.eventType]} | ${
+                  LeapEventAction[leapEvent.action]
+                }`
+            );
+            break;
+
+          case LeapEventType.VstoEvent:
+            this.loggerService.log(
+              `[LeapEventsService] (handleCustomXmlPartNodeEvent) This LeapEvent is fire-and-forget: ` +
+                `${leapEvent.id} | ${LeapEventType[leapEvent.eventType]} | ${
+                  LeapEventAction[leapEvent.action]
+                }`
+            );
+            this.notify(leapEvent);
+            break;
+
+          case LeapEventType.WordAppEvent:
+            this.loggerService.log(
+              `[LeapEventsService] (handleCustomXmlPartNodeEvent) This LeapEvent is fire-and-forget: ` +
+                `${leapEvent.id} | ${LeapEventType[leapEvent.eventType]} | ${
+                  LeapEventAction[leapEvent.action]
+                }`
+            );
+            if (leapEvent.action === LeapEventAction.WordApp_ResetTemplate) {
+              this.notify(leapEvent);
+            }
+            break;
+
+          case LeapEventType.CalcApiResponse:
+          case LeapEventType.DocumentBuilderResponse:
+          case LeapEventType.WordAppEventResponse:
+            this.loggerService.log(
+              `[LeapEventsService] (handleCustomXmlPartNodeEvent) This LeapEvent is a response: ` +
+                `${leapEvent.id} | ${LeapEventType[leapEvent.eventType]} | ${
+                  LeapEventAction[leapEvent.action]
+                }`
+            );
+            this.notify(leapEvent);
+            break;
+        }
+      })
+      .catch((error) => {
+        this.loggerService.error(
+          `[LeapEventsService] (handleCustomXmlPartNodeEvent) Could not handle ${eventType} event on the LEAP Events custom XML part: ${error}`
+        );
+      });
+  }
+
+  public addEvent(event: LeapEvent): Promise<LeapEvent> {
+    return new Promise<LeapEvent>((resolve, reject) => {
+      this.addEventQueue.push({ data: event, resolve, reject });
+      const e = this.addEventQueue.shift();
+      if (!this.addEventLock && e) {
+        this.processAddEvent(e);
+      }
+    });
+  }
+
+  public subscribe(
+    correlationId: string,
+    eventType: LeapEventType,
+    action: LeapEventAction,
+    handler
+  ): string {
+    const subscriptionId = [
+      LeapEventType[eventType],
+      LeapEventAction[action],
+      correlationId,
+    ]
+      .filter((e) => !!e)
+      .join('::');
+    const subscription = this.event$
+      .pipe(
+        catchError((error: any) => {
+          this.loggerService.error(
+            `[LeapEventsService] (subscribe) Subscription observable error: ${error}`
+          );
+          return of(null);
+        }),
+        filter((event) => {
+          return (
+            event !== null &&
+            event.eventType === eventType &&
+            (Array.isArray(action)
+              ? action.includes(event.action)
+              : event.action === action) &&
+            (!event.correlationId || event.correlationId === correlationId)
+          );
+        })
+      )
+      .subscribe((event) => {
+        handler(event);
+      });
+
+    if (this.subscriptions.find((s) => s.id === subscriptionId)) {
+      this.loggerService.warn(
+        `[LeapEventsService] (subscribe) ${subscriptionId} already subscribed (handler already exists)`
+      );
+    } else {
+      this.subscriptions.push({ id: subscriptionId, subscription });
+    }
+
+    return subscriptionId;
+  }
+
+  public unsubscribe(subscriptionId: string): Promise<boolean> {
+    return new Promise((resolve) => {
+      const idx = this.subscriptions.findIndex((s) => s.id === subscriptionId);
+      if (idx >= 0) {
+        this.loggerService.log(
+          `[LeapEventsService] (unsubscribe) Removing ${subscriptionId} subscription (handler)`
+        );
+
+        const matchingSubscription = this.subscriptions[idx];
+        matchingSubscription.subscription.unsubscribe();
+
+        this.subscriptions.splice(idx, 1);
+      } else {
+        const message = `Could not find subscription ${subscriptionId}`;
+        this.loggerService.warn(`[LeapEventsService] (unsubscribe) ${message}`);
+        resolve(false);
+      }
+      resolve(true);
+    });
+  }
+
+  public getEvents(): Promise<LeapEvents | null> {
+    this.loggerService.log('[LeapEventsService] Get data from custom XML part');
+    return getDataByNamespace(constants.LeapEventsNamespace)
+      .then((result) => {
+        const r = result as LeapEvents;
+
+        const eventArray: LeapEvent[] = [];
+
+        if (!r || r.xmlns === null) {
+          const events = new LeapEvents({
+            xmlns: constants.LeapEventsNamespace,
+            currentEventId: '',
+            LeapEvent: eventArray,
+          });
+          return events;
+        }
+
+        if (r.LeapEvent != null) {
+          if (Array.isArray(r.LeapEvent)) {
+            for (let i = 0; i < r.LeapEvent.length; i++) {
+              const eventBase64String = r.LeapEvent[i] as string;
+              if (eventBase64String != null && eventBase64String !== '') {
+                const eventJsonString = b64DecodeUnicode(
+                  eventBase64String as string
+                );
+                if (eventJsonString) {
+                  eventArray.push(JSON.parse(eventJsonString));
+                }
+              }
+            }
+          } else {
+            const eventBase64String = r.LeapEvent as string;
+            if (eventBase64String != null && eventBase64String !== '') {
+              const eventJsonString = b64DecodeUnicode(
+                eventBase64String as string
+              );
+              if (eventJsonString) {
+                eventArray.push(JSON.parse(eventJsonString));
+              }
+            }
+          }
+        }
+
+        const events = new LeapEvents({
+          xmlns: r.xmlns,
+          currentEventId: r.currentEventId,
+          LeapEvent: eventArray,
+        });
+
+        return events;
+      })
+      .catch((error) => {
+        this.loggerService.error(
+          `[LeapEventsService] (getEvents) Unable to retrieve LeapEvents: ${error}`
+        );
+        return null;
+      });
+  }
+
+  private processAddEvent({
+    data: event,
+    resolve,
+    reject,
+  }: IAddEventQueueItem): void {
+    this.addEventLock = true;
+    let events: LeapEvents;
+    this.getEvents()
+      .then((result) => {
+        if (result != null) {
+          events = new LeapEvents({
+            xmlns: constants.LeapEventsNamespace,
+            currentEventId: event.id,
+            LeapEvent: (result.LeapEvent as LeapEvent[]).map(
+              (evt: LeapEvent) => b64EncodeUnicode(JSON.stringify(evt)) || ''
+            ),
+          });
+          const e = b64EncodeUnicode(JSON.stringify(event));
+          if (e) {
+            (events.LeapEvent as string[]).push(e);
+          }
+
+          const leapEventsObject = {
+            $: {
+              xmlns: constants.LeapEventsNamespace,
+              currentEventId: event.id,
+            },
+            LeapEvent: events.LeapEvent,
+          };
+          const xml = toXml(leapEventsObject, constants.LeapEventsRootTagName, {
+            headless: true,
+          });
+          return xml;
+        } else {
+          throw new Error(`LeapEvents array is null`);
+        }
+      })
+      .then((initialXml) => {
+        // Rewrite XML to add the id attribute to the newly-added <LeapEvent>
+        const xml = this.addIdAttributeToLeapEvent(initialXml, event.id);
+
+        // Write raw XML string to custom XML part
+        return updateXmlDataByNamespace(
+          constants.LeapEventsNamespace,
+          xml,
+          constants.LeapEventsRootTagName
+        );
+      })
+      .then(() => {
+        resolve(event);
+      })
+      .catch((error) => {
+        this.loggerService.error(
+          `[LeapEventsService] (getEvents) Unable to add LeapEvent: ${error}`
+        );
+        reject(error);
+      })
+      .finally(() => {
+        this.addEventLock = false; // Release template data lock to allow other mutations to be processed
+        if (this.addEventQueue.length > 0) {
+          const e = this.addEventQueue.shift();
+          if (e) {
+            this.processAddEvent(e);
+          }
+        }
+      });
+  }
+
+  private notify(event: LeapEvent) {
+    this.eventSubject$.next(event);
+  }
+
+  private getLeapEventFromNode(
+    eventType: Office.EventType,
+    eventArgs: Office.NodeInsertedEventArgs | Office.NodeReplacedEventArgs
+  ): Promise<LeapEvent | null> {
+    return Promise.resolve(`Get LeapEvent from node`)
+      .then(() => {
+        if (eventArgs.isUndoRedo || (eventArgs as any).inUndoRedo) {
+          // OfficeJS API runtime quirk/bug
+          this.loggerService.log(
+            `[LeapEventsService] (getLeapEventFromNode) IGNORING ${eventType} event since this is an Undo/Redo`
+          );
+          return Promise.resolve('');
+        } else {
+          if ((eventArgs as any).oldNode != null) {
+            // Office.NodeReplacedEventArgs - contains all child nodes
+            return getChildNodes((eventArgs as any).newNode)
+              .then((childNodes: Array<Office.CustomXmlNode>) => {
+                if (Array.isArray(childNodes) && childNodes.length > 0) {
+                  return childNodes[0];
+                } else {
+                  return null;
+                }
+              })
+              .then((firstNode: Office.CustomXmlNode | null) => {
+                return getNodeText(firstNode);
+              });
+          } else {
+            // Office.NodeInsertedEventArgs - contains just the one inserted node
+            return getNodeText((eventArgs as any).newNode);
+          }
+        }
+      })
+      .then((nodeText: string) => {
+        let leapEvent: LeapEvent;
+        if (nodeText == null) {
+          return Promise.resolve(null);
+        } else {
+          let jsonString: string;
+          // TODO: How to handle an invalid LEAP Event?
+          try {
+            jsonString = b64DecodeUnicode(nodeText) || '';
+          } catch (error) {
+            // Just ignore and pass through
+            return Promise.resolve(null);
+          }
+
+          const obj = JSON.parse(jsonString, this.leapEventJsonReviver);
+          leapEvent = new LeapEvent({
+            id: obj.id,
+            correlationId: obj.correlationId,
+            eventType: obj.eventType as LeapEventType,
+            action: obj.action as LeapEventAction,
+            data: obj.data,
+          });
+        }
+        return leapEvent;
+      })
+      .catch((error) => {
+        this.loggerService.error(
+          `[LeapEventsService] (getLeapEventFromNode) Unable to get LeapEvent from node: ${error}`
+        );
+        return null;
+      });
+  }
+
+  private leapEventJsonReviver(key: any, value: any): any {
+    let result: any;
+    switch (key) {
+      case 'eventType':
+        const eventTypeAsNumber = Number.parseInt(value, 10);
+        if (!Number.isNaN(eventTypeAsNumber)) {
+          result = eventTypeAsNumber;
+        } else {
+          result = LeapEventType[value];
+        }
+        break;
+      case 'action':
+        const actionAsNumber = Number.parseInt(value, 10);
+        if (!Number.isNaN(actionAsNumber)) {
+          result = actionAsNumber;
+        } else {
+          result = LeapEventAction[value];
+        }
+        break;
+      default:
+        result = value;
+        break;
+    }
+
+    return result;
+  }
+
+  // Rewrites the newly-added <LeapEvent> element to include the id attribute
+  private addIdAttributeToLeapEvent(initialXml: string, leapEventId: string) {
+    // 1. Create an XmlDocument in order to edit the XML
+    const parser = new DOMParser();
+    const xmlDoc = parser.parseFromString(initialXml, 'text/xml');
+
+    // 2. Get the newly-added <LeapEvent> element, and append the id attribute to it
+    const leapEventElements = xmlDoc.getElementsByTagName('LeapEvent');
+    if (leapEventElements.length > 0) {
+      const last = leapEventElements[leapEventElements.length - 1];
+      last.setAttribute('id', leapEventId);
+    }
+
+    // 3. Serialize updated XmlDocument to string
+    const xmlSerializer = new XMLSerializer();
+    return xmlSerializer.serializeToString(xmlDoc);
+  }
+}

package/src/lib/services/logger/logger.service.ts

@@ -0,0 +1,42 @@
+import * as log from 'loglevel';
+
+export class LoggerService {
+  log: (message: any) => void = () => undefined;
+  warn: (message: any) => void = () => undefined;
+  debug: (message: any) => void = () => undefined;
+  error: (message: any) => void = () => undefined;
+  isProduction: boolean;
+
+  constructor(isProduction: boolean) {
+    console.log('LoggerService ctor');
+    this.isProduction = isProduction;
+
+    this.setupLogs();
+  }
+
+  init(name: string): void {
+    this.setupLogs(name);
+  }
+
+  private setupLogs(name?: string): void {
+    console.log('LoggerService init', name);
+
+    log.setDefaultLevel(this.isProduction ? log.levels.ERROR : log.levels.DEBUG);
+
+    this.error = log.error.bind(log);
+    this.warn = log.warn.bind(log);
+
+    if (!this.isProduction) {
+      this.debug = log.debug.bind(log);
+      this.log = log.info.bind(log);
+    } else {
+      this.debug = () => undefined;
+      this.log = () => undefined;
+    }
+
+    // Set logger name (optional)
+    if (name) {
+      log.getLogger(name);
+    }
+  }
+}

package/src/lib/services/signalr/signalr.service.ts

@@ -0,0 +1,88 @@
+import { v4 as uuid } from 'uuid';
+import * as signalR from '@microsoft/signalr';
+import { SignalRInitData, SignalRMessage } from '../../models/signalr.model';
+
+export class SignalRService {
+  readonly #sessionId: string;
+  readonly #automationHubUrl: string;
+  #connection: signalR.HubConnection | undefined;
+
+  constructor() {
+    this.#automationHubUrl = 'http://localhost:7214/automationHub';
+    this.#sessionId = uuid();
+  }
+
+  connectToSignalR(): Promise<string> {
+    if (!this.#connection) {
+      this.#createConnection(this.#sessionId);
+      return new Promise((resolve) => {
+        if (this.#connection) {
+          this.#connection
+            .start()
+            .then(() => {
+              resolve(this.#sessionId);
+            })
+            .catch((error) => {
+              console.log('Unable to connect to signalR', error);
+              resolve('');
+            });
+        } else {
+          console.log('Unable to connect to signalR: no connection');
+          resolve('');
+        }
+      });
+    } else {
+      return new Promise((resolve) => resolve(this.#sessionId));
+    }
+  }
+
+  getInitData(params: {clientId: string}): Promise<SignalRInitData | null> {
+    if (this.#connection) {
+      const { clientId } = params;
+      const requestId = uuid();
+      const payload = {
+        source: 'automationCore',
+        sessionId: this.#sessionId,
+        requestId,
+        action: "init_data",
+        payload: {
+          clientId
+        }
+      }
+      return new Promise(resolve => {
+        if (this.#connection) {
+          this.#connection.invoke("ProcessMessage", payload, true).then(() => {
+            if (this.#connection) {
+              this.#connection.on("ProcessMessage", (message: SignalRMessage<SignalRInitData>) => {
+                if (message.sessionId === this.#sessionId && message.requestId === requestId) {
+                  resolve(message.payload)
+                }
+              })
+            }
+          }).catch((e) => {
+            console.log('SignalR sendMessage error', e);
+            return resolve(null);
+          })
+        }
+      })
+
+    } else {
+      return new Promise(resolve => resolve(null));
+    }
+  }
+
+  #createConnection(sessionId: string) {
+    if (this.#connection) {
+      return;
+    }
+    const url = `${this.#automationHubUrl}?sessionId=${sessionId}`;
+    try {
+      this.#connection = new signalR.HubConnectionBuilder()
+        .withUrl(url)
+        .withAutomaticReconnect()
+        .build();
+    } catch (_) {
+      this.#connection = undefined;
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true
+  },
+  "types": ["node", "office-js"],
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,12 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "esModuleInterop": true,
+    "types": ["node", "office-js", "loglevel"]
+  },
+  "types": ["node", "office-js"],
+  "include": ["src/**/*.ts"],
+  "exclude": ["src/**/*.spec.ts", "src/**/*.test.ts"]
+}