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

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

@@ -0,0 +1,219 @@
+import { constants } from '../../models/constants';
+import { LEAPUser } from '../../models/leap.model';
+
+export class AuthService {
+  readonly #code: string;
+  readonly #codeVerifier: string;
+  readonly #clientId: string;
+  readonly #env: string;
+  readonly #authHost: string;
+
+  #user: LEAPUser | undefined;
+  #accessToken: string | undefined;
+  #refreshToken: string | undefined;
+
+  constructor(data: {
+    code: string;
+    codeVerifier;
+    clientId: string;
+    env: string;
+  }) {
+    this.#code = data.code;
+    this.#codeVerifier = data.codeVerifier;
+    this.#clientId = data.clientId;
+    this.#env = data.env.toLowerCase();
+    this.#authHost =
+      this.#env === 'live'
+        ? 'https://auth.leap.services'
+        : 'https://auth-test.leap.services';
+  }
+
+  async init(): Promise<boolean> {
+    try {
+      const data = await this.#exchangeAuthCodeForAccessToken();
+      this.#accessToken = data.access_token;
+      this.#refreshToken = data.refresh_token;
+      this.#user = await this.#getUserInfo();
+      return true;
+    } catch (e) {
+      console.log('[AuthService] unable to init');
+      return true;
+    }
+  }
+
+  async getRefreshedAccessToken(force?: boolean) {
+    if (this.#accessToken === undefined || !this.#accessToken) {
+      return '';
+    } else {
+      const decoded = this.#decodeAccessToken(this.#accessToken);
+
+      if (
+        force ||
+        (!!decoded &&
+          (decoded.exp - constants.tokenSecondsBeforeExpire) * 1000 <
+            Date.now())
+      ) {
+        const data = await this.#exchangeRefreshTokenForAccessToken();
+
+        if (data) {
+          this.#accessToken = data.access_token;
+          this.#refreshToken = data.refresh_token;
+        }
+        return this.#accessToken;
+      } else {
+        return this.#accessToken;
+      }
+    }
+  }
+
+  getLEAPUser() {
+    return this.#user;
+  }
+
+  async #exchangeAuthCodeForAccessToken(): Promise<{
+    access_token: string;
+    refresh_token: string;
+  }> {
+    return new Promise<{ access_token: string; refresh_token: string }>(
+      (resolve, reject) => {
+        this.#xhr<{ access_token: string; refresh_token: string }>(
+          {
+            method: 'POST',
+            endpoint: `${this.#authHost}/oauth/token`,
+            options: {
+              body: {
+                grant_type: 'authorization_code',
+                code: this.#code,
+                code_verifier: this.#codeVerifier,
+                client_id: this.#clientId,
+                redirect_uri: constants.fourdRedirectUrl,
+              },
+            },
+            accessToken: undefined,
+          },
+          (response, status) => {
+            if (status === 200) {
+              return resolve(response);
+            } else return reject(response);
+          }
+        );
+      }
+    );
+  }
+
+  async #getUserInfo(): Promise<LEAPUser> {
+    return new Promise<LEAPUser>((resolve, reject) => {
+      this.#xhr<LEAPUser>(
+        {
+          method: 'GET',
+          endpoint: `${this.#authHost}/api/userinfo`,
+          options: {},
+          accessToken: this.#accessToken,
+        },
+        (response, status) => {
+          if (status === 200) {
+            return resolve(response);
+          } else return reject(response);
+        }
+      );
+    });
+  }
+
+  async #exchangeRefreshTokenForAccessToken(): Promise<{
+    access_token: string;
+    refresh_token: string;
+  } | null> {
+    return new Promise<{ access_token: string; refresh_token: string } | null>(
+      (resolve, reject) => {
+        if (!this.#refreshToken) {
+          resolve(null);
+        } else {
+          this.#xhr<{ access_token: string; refresh_token: string }>(
+            {
+              method: 'POST',
+              endpoint: `${this.#authHost}/oauth/token`,
+              options: {
+                body: {
+                  grant_type: 'refresh_token',
+                  refresh_token: this.#refreshToken,
+                  code_verifier: this.#codeVerifier,
+                  client_id: this.#clientId,
+                },
+              },
+              accessToken: undefined,
+            },
+            (response, status) => {
+              if (status === 200) {
+                return resolve(response);
+              } else return reject(response);
+            }
+          );
+        }
+      }
+    );
+  }
+
+  #xhr<T>(
+    params: {
+      method: string;
+      endpoint: string;
+      options: any;
+      accessToken: string | undefined;
+    },
+    onload: (resp: T, status: number) => any
+  ): void {
+    const { method, endpoint, accessToken } = params;
+    let { options } = params;
+    options = {
+      ...{
+        contentType: 'application/json',
+        accessControlAllowOrigin: '*',
+        body: undefined,
+      },
+      ...options,
+    };
+
+    const xhr = new XMLHttpRequest();
+    xhr.open(method, endpoint, true);
+    xhr.setRequestHeader('Content-type', options.contentType);
+    xhr.setRequestHeader(
+      'Access-Control-Allow-Origin',
+      options.accessControlAllowOrigin
+    );
+
+    if (accessToken)
+      xhr.setRequestHeader('Authorization', 'Bearer ' + accessToken);
+
+    xhr.onload = () => {
+      try {
+        let resp;
+        if (xhr.response) resp = JSON.parse(xhr.response);
+        onload(resp, xhr.status);
+      } catch (e) {
+        onload(xhr.response, xhr.status);
+      }
+    };
+
+    if (options.body) options.body = JSON.stringify(options.body);
+
+    xhr.send(options.body);
+  }
+
+  #decodeAccessToken(accessToken: string | undefined) {
+    if (!accessToken) {
+      return undefined;
+    }
+
+    const payload = accessToken.split('.')[1];
+    if (payload) {
+      try {
+        const result = window.atob(payload);
+        return JSON.parse(result);
+      } catch (e) {
+        throw Error('Fail to decode access token.');
+      }
+    }
+
+    return undefined;
+  }
+}

package/src/lib/services/calc-api/calc-api-service.interface.ts

@@ -0,0 +1,12 @@
+import {
+  CreateSessionRequest,
+  EvaluatePathsRequest,
+} from '../../models/calc-api.model';
+
+export interface ICalcApiService {
+  createSession(request: CreateSessionRequest): Promise<string>;
+
+  destroySession(sessionId: string): Promise<void>;
+
+  evaluatePaths(request: EvaluatePathsRequest): Promise<Array<any> | null>;
+}

package/src/lib/services/calc-api/calc-word.service.ts

@@ -0,0 +1,117 @@
+import { v4 as uuid } from 'uuid';
+
+import { ICalcApiService } from './calc-api-service.interface';
+import { CreateSessionRequest, EvaluatePathsRequest, EvaluatePathsResponse } from '../../models/calc-api.model';
+import { LeapEventsService } from '../leap-events.service';
+import { LoggerService } from '../logger/logger.service';
+import { LeapEvent, LeapEventAction, LeapEventType } from '../../models/leap-events.model';
+import { timeout } from './promise-helper.function';
+
+export class CalcWordService implements ICalcApiService {
+
+  constructor(
+    private leapEventsService: LeapEventsService,
+    private loggerService: LoggerService
+  ) { }
+
+  createSession(request: CreateSessionRequest): Promise<string> {
+    return new Promise((resolve, reject) => {
+      Promise.resolve(() => {
+        this.loggerService.log('[CalcApiOfflineService] (createSession) Creating CalcApi session');
+      })
+        .then(() => {
+          // TODO: Get Calc API sessionId from LEAP Desktop and return that
+        })
+        .then(() => {
+          this.loggerService.log('[CalcApiOfflineService] (createSession) LeapEvent CreateSession request sent');
+          resolve('');
+        })
+        .catch((error: any) => {
+          this.loggerService.error(`[CalcApiOfflineService] createSession() failed: ${error}`);
+          reject(error);
+        });
+    });
+  }
+
+  destroySession(sessionId: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      Promise.resolve(() => {
+        this.loggerService.log('[CalcApiOfflineService] (destroySession) Destroying CalcApi session');
+      })
+        .then(() => {
+          // TODO: Should we just fall through here?
+        })
+        .then(() => {
+          this.loggerService.log('[DocumentBuilderService] (destroySession) LeapEvent DestroySession request sent');
+          resolve();
+        })
+        .catch((error: any) => {
+          this.loggerService.error(`[DocumentBuilderService] destroySession() failed: ${error}`);
+          reject(error);
+        });
+    });
+  }
+
+  evaluatePaths(request: EvaluatePathsRequest): Promise<Array<EvaluatePathsResponse> | null> {
+    let subscriptionId: string;
+
+    // Check for empty matterFields - don't bother hitting the Local DocBuilder API in this case
+    if (request == null || (request.paths && request.paths.length === 0)) {
+      return Promise.resolve(null);
+    }
+
+    return new Promise((resolve, reject) => {
+      Promise.resolve(() => {
+        this.loggerService.log(
+          '[CalcApiWordService] (evaluatePaths) Evaluating paths on Local Calc API'
+        );
+      })
+      .then(() => {
+        const id = new Date().getTime().toString();
+        return this.leapEventsService.addEvent({
+          id,
+          correlationId: null,
+          eventType: LeapEventType.CalcApiRequest,
+          action: LeapEventAction.Calc_EvaluatePaths,
+          data: request
+        });
+      })
+      .then(event => {
+        this.loggerService.log('[CalcApiWordService] LeapEvent EvaluatePaths request sent');
+
+        // Subscribe
+        const leapEventResponseHandlerPromise = new Promise<Array<EvaluatePathsResponse>>((innerResolve, innerReject) => {
+          subscriptionId = this.leapEventsService.subscribe(
+            event.id,
+            LeapEventType.CalcApiResponse,
+            LeapEventAction.Calc_EvaluatePathsResponse,
+            (leapEvent: LeapEvent) => this.leapEventsService.handleLeapEventResponse<Array<EvaluatePathsResponse>>(
+              leapEvent, { resolve: innerResolve, reject: innerReject }
+            )
+          );
+        });
+
+        return timeout(leapEventResponseHandlerPromise, 5000);
+      })
+      .then((result) => {
+        // Return result
+        resolve(result);
+      })
+      .catch((error: any) => {
+        this.loggerService.error(`[CalcApiWordService] evaluatePaths() failed: ${error}`);
+        reject(error);
+      })
+      .then(() => {
+        // Unsubscribe
+        return this.leapEventsService.unsubscribe(subscriptionId);
+      })
+      .then((unsubscribeSuccess: boolean) => {
+        if (unsubscribeSuccess === true) {
+          this.loggerService.log(`[CalcApiWordService] (evaluatePaths) Successfully unsubscribed ${subscriptionId}`);
+        } else {
+          this.loggerService.warn(`[CalcApiWordService] (evaluatePaths) Failed to unsubscribe from ${subscriptionId}`);
+        }
+      });
+    });
+  }
+}

package/src/lib/services/calc-api/promise-helper.function.ts

@@ -0,0 +1,26 @@
+/*
+Return a promise that resolves after duration milliseconds
+*/
+export function sleep(duration: number) {
+  return new Promise<void>(function (resolve) {
+    setTimeout(() => {
+      resolve();
+    }, duration);
+  });
+}
+
+/*
+Return a promise that rejects after duration milliseconds
+*/
+export function timeout<T>(promise: Promise<T>, duration: number): Promise<T> {
+  if (duration === null || duration <= 0) {
+    return promise;
+  } else {
+    const timeoutPromise = new Promise<T>((resolve, reject) => {
+      setTimeout(() => {
+        reject(`Timed out after ${duration}ms`);
+      }, duration);
+    });
+    return Promise.race<T>([promise, timeoutPromise]);
+  }
+}

package/src/lib/services/custom-xml-part.service.ts

@@ -0,0 +1,340 @@
+/// <reference types="office-js" />
+
+import { promisifyAsync } from '../functions/helpers';
+import { toObj, toXml } from '../functions/xml';
+const retryTimes = 5;
+
+const getCustomXmlPartsByNamespace = (
+  namespace: string
+): Promise<Array<Office.CustomXmlPart> | null> => {
+  const officeDocument: Office.Document = Office.context.document;
+  if (officeDocument) {
+    const officeCustomXmlParts = officeDocument.customXmlParts;
+    //todo: use this format instead of promisifyAsync
+    return new Promise((resolve) => {
+      officeCustomXmlParts.getByNamespaceAsync(namespace, (result)=> {
+        resolve(result.value)
+      })
+    } )
+  } else {
+    return Promise.resolve(null);
+  }
+};
+
+//todo: remove all "any" reference in the project
+const getCustomXmlPartByNamespace = (namespace: string): Promise<any> => {
+  return getCustomXmlPartsByNamespace(namespace)
+    .then((customXmlParts: any) => {
+      if (customXmlParts != null) {
+        // We have something
+        if (Array.isArray(customXmlParts)) {
+          if (customXmlParts.length > 0) {
+            return customXmlParts[0]; // Happy path
+          } else {
+            return null; // No error, but no matching custom XML part either
+          }
+        } else {
+          // We have something, but it's not an array
+          return customXmlParts;
+        }
+      }
+      return null; // No error, but no matching custom XML part either
+    })
+    .catch((error) => {
+      console.error(
+        error,
+        `[CustomXmlPartService] (getCustomXmlPartByNamespace) Failed to get custom XML part by namespace`
+      );
+      return null;
+    });
+};
+
+const getCustomXmlPartData = (partOrNamespace: string): Promise<any> => {
+  return new Promise((resolve, reject) => {
+    return new Promise((innerResolve) => {
+      if (typeof partOrNamespace === 'string') {
+        innerResolve(getCustomXmlPartByNamespace(partOrNamespace));
+      } else {
+        return innerResolve(partOrNamespace);
+      }
+    })
+      .then((customXmlPart: any) => {
+        if (customXmlPart != null) {
+          const getXmlAsync = promisifyAsync(
+            customXmlPart.getXmlAsync.bind(customXmlPart)
+          );
+          return getXmlAsync({});
+        } else {
+          return null;
+        }
+      })
+      .then((result) => {
+        resolve(toObj(result as string));
+      })
+      .catch((error) => {
+        console.error(
+          error,
+          `[CustomXmlPartService] (getCustomXmlPartData) Failed to get custom XML part data`
+        );
+        reject(error);
+      });
+  });
+};
+
+const getNodes = (
+  customXmlPart: Office.CustomXmlPart,
+  xPath: string = '/*'
+): Promise<Array<Office.CustomXmlNode>> => {
+  const getNodes = promisifyAsync<Array<Office.CustomXmlNode>>(
+    customXmlPart.getNodesAsync.bind(customXmlPart)
+  );
+  return getNodes(xPath);
+};
+
+const setNodeXml = (node: Office.CustomXmlNode, xml: string): Promise<void> => {
+  const setXml = promisifyAsync<void>(node.setXmlAsync.bind(node));
+  return setXml(xml, {});
+};
+
+const updateCustomXmlPart = (
+  customXmlPart: any,
+  xml: string,
+  rootTagName: string
+): Promise<void> => {
+  rootTagName = rootTagName || '';
+  const promises: Array<Promise<void>> = [];
+  // If custom XML part exists, replace it
+  return getNodes(customXmlPart)
+    .then((nodes: Array<Office.CustomXmlNode>) => {
+      for (let i = 0; i < nodes.length; i++) {
+        const node: any = nodes[i] as Office.CustomXmlNode;
+
+        if (
+          node &&
+          node.baseName &&
+          node.baseName.toUpperCase() === rootTagName.toUpperCase()
+        ) {
+          // Case-insensitive match
+          const promise = setNodeXml(node, xml)
+            .then(() => {
+              console.log(
+                '[CustomXmlPartService] updateCustomXmlPart succeeded'
+              );
+            })
+            .catch((error) => {
+              console.error(
+                error,
+                '[CustomXmlPartService] updateCustomXmlPart failed'
+              );
+              return Promise.reject(error);
+            });
+
+          promises.push(promise);
+        } else {
+          console.log(`Could not find ${rootTagName} in the custom XML part`);
+        }
+      }
+    })
+    .then(() => {
+      return Promise.all(promises);
+    })
+    .then(() => {
+      return Promise.resolve();
+    });
+};
+
+const addCustomXmlPart = (objOrXml: any, options?: any): Promise<void> => {
+  return new Promise<void>((resolve, reject) => {
+    Promise.resolve()
+      .then(() => {
+        // Setup values
+        let obj: any; //todo: check this obj
+        let xml: string;
+        options = options || { rootTagName: '' };
+        if (typeof objOrXml === 'string' || objOrXml instanceof String) {
+          obj = toObj(objOrXml as string);
+          xml = objOrXml as string;
+        } else {
+          obj = objOrXml;
+          xml = toXml(objOrXml, options.rootTagName, options);
+        }
+
+        const officeDocument: Office.Document = Office.context.document;
+        const officeCustomXmlParts = officeDocument.customXmlParts;
+        const add = promisifyAsync<Office.CustomXmlPart>(
+          officeCustomXmlParts.addAsync.bind(officeCustomXmlParts)
+        );
+        return add(xml, {});
+      })
+      .then((customXmlPart) => {
+        if (customXmlPart == null) {
+          // TODO
+        }
+        resolve();
+      })
+      .catch((error) => {
+        console.error(
+          error,
+          `[CustomXmlPartService] (addCustomXmlPart) Failed to add custom XML part`
+        );
+        reject(error);
+      });
+  });
+};
+
+const updateCustomXmlPartData = (
+  partOrNamespace: Office.CustomXmlPart | string,
+  objOrXml: any,
+  options?: any
+): Promise<boolean> => {
+  return new Promise<boolean>((resolve, reject) => {
+    return new Promise<Office.CustomXmlPart | null>((innerResolve) => {
+      if (typeof partOrNamespace === 'string' || partOrNamespace instanceof String) {
+        innerResolve(getCustomXmlPartByNamespace(partOrNamespace as string));
+      } else {
+        return innerResolve(partOrNamespace);
+      }
+    })
+      .then((customXmlPart) => {
+        // Setup values
+        let obj: any;
+        let xml: string;
+        options = options || { rootTagName: '' };
+        if (typeof objOrXml === 'string' || objOrXml instanceof String) {
+          obj = toObj(objOrXml as string);
+          xml = objOrXml as string;
+        } else {
+          obj = objOrXml;
+          xml = toXml(objOrXml, options.rootTagName, options);
+        }
+
+        if (customXmlPart != null) {
+          return updateCustomXmlPart(customXmlPart, xml, options.rootTagName);
+        } else {
+          return addCustomXmlPart(xml, options);
+        }
+      })
+      .then(() => {
+        resolve(true);
+      })
+      .catch((error) => {
+        console.error(
+          error,
+          `[CustomXmlPartService] (updateCustomXmlPartData) Failed to update ` +
+            `${
+              typeof partOrNamespace === 'string' ? partOrNamespace : ''
+            } custom XML part`
+        );
+        reject(error);
+      });
+  });
+};
+
+const retryUpdateCustomXmlPartData = (
+  namespace: string,
+  data: string,
+  options: { rootTagName: string } & { [key: string]: any },
+  retries = retryTimes
+): Promise<void> => {
+  const { rootTagName } = options;
+  return new Promise<void>((resolve, reject) => {
+    console.log(
+      `[CustomXmlPartService] Updating ${namespace} tag ${rootTagName}`
+    );
+    updateCustomXmlPartData(namespace, data, options)
+      .then(() => {
+        resolve();
+      })
+      .catch((error) => {
+        if (retries > 0) {
+          console.log(
+            `[CustomXmlPartService] Update ${namespace} tag ${rootTagName} failed - Retrying ${
+              retryTimes - retries + 1
+            }...`
+          );
+          setTimeout(() => {
+            retryUpdateCustomXmlPartData(namespace, data, options, retries - 1)
+              .then(resolve)
+              .catch(reject);
+          }, 2000);
+        } else {
+          reject(error);
+        }
+      });
+  });
+};
+
+export const getDataByNamespace = (
+  namespace: string,
+  retries = 6
+): Promise<any> => {
+  return new Promise((resolve, reject) => {
+    getCustomXmlPartData(namespace)
+      .then((data) => {
+        resolve(data);
+      })
+      .catch((_) => {
+        if (retries > 0) {
+          console.log(
+            `[CustomXmlPartService] Get data from ${namespace} failed - Retrying ${
+              retryTimes - retries + 1
+            }...`
+          );
+          setTimeout(() => {
+            getDataByNamespace(namespace, retries - 1)
+              .then(resolve)
+              .catch(reject);
+          }, 2000);
+        } else {
+          reject(`Unable to get custom XML part using namespace ${namespace}`);
+        }
+      });
+  });
+};
+
+export const updateXmlDataByNamespace = (
+  namespace: string,
+  data: string,
+  rootTagName: string
+): Promise<void> => {
+  const options = { rootTagName };
+  return retryUpdateCustomXmlPartData(namespace, data, options);
+};
+
+export const addHandlerForCustomXmlPart = (
+  namespace: string,
+  eventType: Office.EventType,
+  handler: any
+): Promise<void | null> => {
+  return getCustomXmlPartByNamespace(namespace).then((customXmlPart: any) => {
+    if (customXmlPart != null) {
+      const addHandler = promisifyAsync<void>(
+        customXmlPart.addHandlerAsync.bind(customXmlPart)
+      );
+      return addHandler(eventType, handler, {});
+    } else {
+      return null;
+    }
+  });
+};
+
+export const getChildNodes = (
+  node: Office.CustomXmlNode,
+  xPath: string = '*'
+): Promise<Array<Office.CustomXmlNode>> => {
+  const getNodes = promisifyAsync<Array<Office.CustomXmlNode>>(
+    node.getNodesAsync.bind(node)
+  );
+  return getNodes(xPath);
+};
+
+export const getNodeText = (
+  node: Office.CustomXmlNode | null
+): Promise<string> => {
+  if (node) {
+    const getText = promisifyAsync<string>(node.getTextAsync.bind(node));
+    return getText({});
+  } else {
+    return Promise.resolve('');
+  }
+};