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

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

@@ -1,22 +0,0 @@
-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;
-}

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

@@ -1,219 +0,0 @@
-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

@@ -1,12 +0,0 @@
-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

@@ -1,117 +0,0 @@
-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

@@ -1,26 +0,0 @@
-/*
-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]);
-  }
-}