@sabstravtech/obtservices 0.0.0 → 0.0.2

package/projects/obtservices/angular/src/lib/vendor/services/enterprise-basket.service.ts

@@ -1,133 +0,0 @@
-import { Injectable } from '@angular/core';
-import * as moment_ from 'moment';
-import { GetUserBasketsFetcher } from '../fetchers/get-users-baskets-fetcher';
-import { AddItemToBasketUpdater } from '../updaters/add-item-to-basket.updater';
-import { RemoveItemFromBasketUpdater } from '../updaters/remove-item-from-basket.updater';
-import { UserService } from './user.service';
-import { CreateBasketUpdater } from '../updaters/create-basket-updater';
-import { SetBasketItemMiGroupUpdater } from '../updaters/set-basket-item-mi-group';
-import { AddUserToBasketItemUpdater } from '../updaters/addUserToBasketItem';
-import { DeleteBasketUpdater } from '../updaters/remove-basket-updater';
-import { AcceptNewPriceUpdater } from '../updaters/accept-new-price.updater';
-import { ValidateMiFreeValueTester } from '../testers/validate-mi-free-value.tester';
-import { GetBasketFetcher } from '../fetchers/basket-fetcher';
-import { RevalidateBasketUpdater } from '../updaters/revalidate-basket-updater';
-import { SetBasketItemMiValueUpdater } from '../updaters/set-basket-item-mi-value-updater';
-import { SendBasketForApprovalUpdater } from '../updaters/send-basket-for-approval.updater';
-import { GetMiAutoSugestionFetcher } from '../fetchers/getMiAutoSugestions.fetcher';
-import { GetUserFetcher } from '../fetchers/user-fetcher';
-import { BookBasketUpdater } from '../updaters/book-basket-updater';
-import { SetBasketItemLeadPassengerUpdater } from '../updaters/set-basket-item-lead-passenger.updater';
-
-import { BaseEnterpriseBasketService } from 'obtservices/base';
-import { HelperRoutines } from '../classes/helpers';
-import {
-  AcceptNewPriceGQL,
-  AddItemToBasketGQL,
-  AddUsersToBasketItemGQL,
-  BookBasketGQL,
-  CreateBasketGQL,
-  DeleteBasketGQL,
-  GetUserBasketGQL,
-  GetUserBasketsGQL,
-  GetUserGQL,
-  GetUserMiAutoSuggestValuesGQL,
-  MoveItemToADifferentBasketGQL,
-  RemoveItemFromBasketGQL,
-  RevalidateBasketGQL,
-  SendBasketForApprovalGQL,
-  SetBasketItemLeadPassengerGQL,
-  SetBasketItemMiGroupGQL,
-  SetBasketItemMiValueGQL,
-  SetBasketItemPaymentMethodGQL,
-  UpdateBasketNotesGQL,
-  UpdateBasketTitleGQL,
-  ValidateUserMiFreeValueGQL
-} from '../types/graphql.angular.types';
-import { ModalOpenerService } from './modal-opener.service';
-import { MoveBasketItemToBasketUpdater } from '../updaters/move-basket-item-to-basket';
-import { UpdateBasketTitleUpdater } from '../updaters/update-basket-title-updater';
-import { UpdateBasketNotesUpdater } from '../updaters/update-basket-notes-updater';
-import { SetPaymentOptionUpdater } from '../updaters/set-payment-option.updater';
-
-const moment = moment_;
-const TEMPID = 'TEMPID_';
-
-@Injectable({ providedIn: 'root' })
-export class EnterpriseBasketService extends BaseEnterpriseBasketService<
-  AcceptNewPriceGQL,
-  AddItemToBasketGQL,
-  AddUsersToBasketItemGQL,
-  CreateBasketGQL,
-  GetUserBasketGQL,
-  BookBasketGQL,
-  DeleteBasketGQL,
-  GetUserMiAutoSuggestValuesGQL,
-  RemoveItemFromBasketGQL,
-  RevalidateBasketGQL,
-  SetBasketItemMiGroupGQL,
-  SetBasketItemMiValueGQL,
-  ValidateUserMiFreeValueGQL,
-  SendBasketForApprovalGQL,
-  GetUserGQL,
-  GetUserBasketsGQL,
-  SetBasketItemLeadPassengerGQL,
-  MoveItemToADifferentBasketGQL,
-  UpdateBasketNotesGQL,
-  UpdateBasketTitleGQL,
-  SetBasketItemPaymentMethodGQL
-> {
-  constructor(
-    acceptNewPriceUpdater: AcceptNewPriceUpdater,
-    addItemToBasketUpdater: AddItemToBasketUpdater,
-    addUserToBasketItem: AddUserToBasketItemUpdater,
-    basketCreator: CreateBasketUpdater,
-    basketFetcher: GetBasketFetcher,
-    bookBasketUpdater: BookBasketUpdater,
-    deleteBasketUpdater: DeleteBasketUpdater,
-    getMiAutoSugestionFetcher: GetMiAutoSugestionFetcher,
-    helpers: HelperRoutines,
-    removeItemFromBasketUpdater: RemoveItemFromBasketUpdater,
-    revalidateBasketUpdater: RevalidateBasketUpdater,
-    setBasketItemMiGroupUpdater: SetBasketItemMiGroupUpdater,
-    setBasketItemMiValueUpdater: SetBasketItemMiValueUpdater,
-    validateMiFreeValue: ValidateMiFreeValueTester,
-    sendBasketForApprovalUpdater: SendBasketForApprovalUpdater,
-    getUserFetcher: GetUserFetcher,
-    getUserBasketsFetcher: GetUserBasketsFetcher,
-    setBasketItemLeadPassengerUpdater: SetBasketItemLeadPassengerUpdater,
-    moveItemToADifferentBasket: MoveBasketItemToBasketUpdater,
-    updateBasketNotes: UpdateBasketNotesUpdater,
-    updateBasketTitle: UpdateBasketTitleUpdater,
-    userService: UserService,
-    modalService: ModalOpenerService,
-    setBasketItemPaymentOption: SetPaymentOptionUpdater
-  ) {
-    super(
-      acceptNewPriceUpdater,
-      addItemToBasketUpdater,
-      addUserToBasketItem,
-      basketCreator,
-      basketFetcher,
-      bookBasketUpdater,
-      deleteBasketUpdater,
-      getMiAutoSugestionFetcher,
-      helpers,
-      removeItemFromBasketUpdater,
-      revalidateBasketUpdater,
-      setBasketItemMiGroupUpdater,
-      setBasketItemMiValueUpdater,
-      validateMiFreeValue,
-      sendBasketForApprovalUpdater,
-      getUserFetcher,
-      getUserBasketsFetcher,
-      setBasketItemLeadPassengerUpdater,
-      moveItemToADifferentBasket,
-      updateBasketNotes,
-      updateBasketTitle,
-      setBasketItemPaymentOption,
-      userService,
-      modalService
-    );
-  }
-}

package/projects/obtservices/angular/src/lib/vendor/services/hotel-avallibility.service.ts

@@ -1,19 +0,0 @@
-import { Injectable } from '@angular/core';
-import { Environment } from '../classes/environment';
-import { HelperRoutines } from '../classes/helpers';
-import { HotelAvalibilityQuoteFetcher } from '../fetchers/hotel-avaliability-fetcher';
-import { StorageService } from './storage.service';
-import { BaseHotelAvalibilityService } from 'obtservices/base';
-import { GetMultipleHotelsAvailabilityGQL } from '../../../types';
-
-@Injectable({ providedIn: 'root' })
-export class HotelAvalibilityService extends BaseHotelAvalibilityService<GetMultipleHotelsAvailabilityGQL> {
-  constructor(
-    avalibilityFethcer: HotelAvalibilityQuoteFetcher,
-    sessionStorage: StorageService,
-    helpers: HelperRoutines,
-    environment: Environment
-  ) {
-    super(avalibilityFethcer, sessionStorage, helpers, environment);
-  }
-}

package/projects/obtservices/angular/src/lib/vendor/services/http-call.service.ts

@@ -1,252 +0,0 @@
-import { Inject, Injectable } from '@angular/core';
-import { map, timeout, catchError } from 'rxjs/operators';
-import jwt_decode from 'jwt-decode';
-import { WebTokenService } from './webtoken.service';
-import { StorageService } from './storage.service';
-import { AbstractHttpCallService, URLS } from 'obtservices/base';
-import { Observable, of, throwError } from 'rxjs';
-import { Environment } from '../classes/environment';
-import { HttpClient, HttpHeaders } from '@angular/common/http';
-import { Router } from '@angular/router';
-
-@Injectable({ providedIn: 'root' })
-abstract class BaseHttpCallService extends AbstractHttpCallService {
-  constructor(
-    private http: HttpClient,
-    private router: Router,
-    private storageSession: StorageService,
-    protected environment: Environment
-  ) {
-    super();
-  }
-
-  formEncodedPost(url: URLS, body: any = null, responseType = 'json'): Observable<any> {
-    // console.log('--- Form Encoded Posting: ', body);
-
-    return this.http
-      .post(this.makeUrl(url), body, {
-        headers: this.getHeaders(),
-        withCredentials: true,
-        responseType: responseType as 'json'
-      })
-      .pipe(
-        timeout(this.environment.httpCallTimeout),
-        map((data) => {
-          return this.handleResponse(data);
-        }),
-        catchError((error: any) => {
-          return this.handleError(error);
-        })
-      );
-  }
-
-  /*
-   *	@desc - form encoded post, but with a timeout - default 30 seconds
-   * if timeout occurs it is handled like a normal error (caught in the catch block)
-   **/
-  timeoutFormEncodedPost(
-    url: URLS,
-    body: any = null,
-    reTimeout = 300
-  ): Observable<any> {
-    return this.http
-      .post(this.makeUrl(url), body, {
-        headers: this.getHeaders(),
-        withCredentials: true
-      })
-      .pipe(
-        timeout(reTimeout * 1000),
-        map(
-          (data) => {
-            return this.handleResponse(data);
-          }
-          /*(error) => {console.log(error);return false;}*/
-        ),
-        catchError((error: any) => {
-          console.log(error);
-          return this.handleError(error, true);
-        })
-      );
-  }
-
-  formEncodedPostNoErrorHandling(url: URLS, body: any = null): Observable<any> {
-    return this.http
-      .post(this.makeUrl(url), body, {
-        headers: this.getHeaders(),
-        withCredentials: true
-      })
-      .pipe(
-        timeout(this.environment.httpCallTimeout),
-        map(
-          (data) => {
-            return this.handleResponse(data);
-          }
-          /*(error) => {console.log(error);return false;}*/
-        ),
-        catchError((error: any) => {
-          console.log(error);
-          return throwError(error);
-        })
-      );
-  }
-
-  /*
-		@desc - call a url through post, with a Json Object as data (angular default)
-	**/
-  post(url: URLS, data: any = null): Observable<any> {
-    return this.http
-      .post(this.makeUrl(url), data, {
-        headers: this.getHeaders(),
-        withCredentials: true
-      })
-      .pipe(
-        timeout(this.environment.httpCallTimeout),
-        map(
-          (response) => {
-            return this.handleResponse(response);
-          }
-          /*(error) => {console.log(error);return false;}*/
-        ),
-        catchError((error: any) => {
-          return this.handleError(error);
-        })
-      );
-  }
-
-  /*
-		@desc - call a Angular standard get request (application/json headers)
-	**/
-  get(url: URLS, params = {}): Observable<any> {
-    console.log('+++ Get Called With Params +++', params);
-    return this.http.get(this.makeUrl(url), params).pipe(
-      timeout(this.environment.httpCallTimeout),
-      map((response) => {
-        return this.handleResponse(response);
-      }),
-      catchError((error: any) => {
-        return throwError(error);
-      })
-    );
-  }
-
-  /*
-		@desc - this will determine if there is a login error for the request or not, since this is a potential error for every call
-	**/
-  handleResponse(data: any): any {
-    // console.log('Handle Response Called');
-    /*console.log('received %O', data);*/
-    return data;
-  }
-
-  resetLogout() {
-    this.storageSession.clearSessionData();
-    this.router.navigate(['logon']);
-  }
-  /*
-		@desc - handle any fatal errors 404's 500's other generic http errors
-	**/
-  handleError(errorVal: any, skipTimeoutMessage: boolean = false): any {
-    console.log('Handle Error Called');
-    return throwError(errorVal);
-  }
-
-  /*
-   * Using the keys of the given object as parameter names create a parameter string url encoding the values.
-   * The function expects the values to be strings.
-   * @param obj
-   */
-  public serialize(obj: { [key: string]: string }): string {
-    return Object.keys(obj).reduce((toReturn: string, key: string) => {
-      return (
-        (toReturn.length ? toReturn + '&' : '') +
-        key +
-        '=' +
-        encodeURIComponent(
-          typeof obj[key] === 'object' ? JSON.stringify(obj[key]) : obj[key]
-        )
-      );
-    }, '');
-  }
-
-  abstract getHeaders(): HttpHeaders;
-  abstract makeUrl(url: URLS): string;
-}
-
-/*
-  TODO REMOVE HttpCallService, as it's only used to let the system compile during transition.
-*/
-
-@Injectable({ providedIn: 'root' })
-export class HttpCallService extends BaseHttpCallService {
-  getHeaders(): HttpHeaders {
-    return new HttpHeaders().set(
-      'Content-Type',
-      'application/x-www-form-urlencoded'
-    );
-  }
-  makeUrl(url: URLS): string {
-    return url.toString();
-  }
-  get(url: string, params = {}): Observable<any> {
-    return of({});
-  }
-  post(url: string, data: any = null): Observable<any> {
-    return of({});
-  }
-  formEncodedPostNoErrorHandling(url: URLS, body: any = null): Observable<any> {
-    return of({});
-  }
-  timeoutFormEncodedPost(
-    url: URLS,
-    body: any = null,
-    reTimeout = 300
-  ): Observable<any> {
-    return of({});
-  }
-  formEncodedPost(url: URLS, body: any = null): Observable<any> {
-    return of({});
-  }
-}
-
-@Injectable({ providedIn: 'root' })
-export class ExternalHttpService extends BaseHttpCallService {
-  getHeaders() {
-    return new HttpHeaders().set(
-      'Content-Type',
-      'application/x-www-form-urlencoded'
-    );
-  }
-  makeUrl(url: URLS): string {
-    return url.toString();
-  }
-}
-
-@Injectable({ providedIn: 'root' })
-export class AuthHttpService extends BaseHttpCallService {
-  constructor(
-    http: HttpClient,
-    router: Router,
-    storageSession: StorageService,
-    @Inject(Environment) environment: Environment,
-    private webTokenService: WebTokenService
-  ) {
-    super(http, router, storageSession, environment);
-  }
-  getHeaders() {
-    return new HttpHeaders().set('Content-Type', 'application/json');
-  }
-  makeUrl(url: URLS): string {
-    return this.environment.authURL + url.toString();
-  }
-
-  /*
-		@desc - this will determine if there is a login error for the request or not, since this is a potential error for every call
-	**/
-  handleResponse(data: any): any {
-    if (typeof data === 'object' && data.jwt) {
-      this.webTokenService.jwtToken = data.jwt;
-      data.jwtObject = jwt_decode(data.jwt);
-    }
-    return data;
-  }
-}

package/projects/obtservices/angular/src/lib/vendor/services/logon.service.ts

@@ -1,40 +0,0 @@
-import { Router } from '@angular/router';
-import { AuthHttpService } from './http-call.service';
-import { Injectable } from '@angular/core';
-import { UserService } from './user.service';
-import { ModalOpenerService } from './modal-opener.service';
-import { StorageService } from './storage.service';
-import { AuthInfo, LoginResponse, BaseLogonService } from 'obtservices/base';
-import { Environment } from '../classes/environment';
-import { EventMessenager } from '../classes/event-messenager';
-
-@Injectable({ providedIn: 'root' })
-export class LogonService extends BaseLogonService {
-  loading = false;
-  isLoggedIn = false;
-  redirectUrl = '';
-  authInfo: AuthInfo;
-  loginResponse: LoginResponse;
-  timeoutSubscription: number;
-  refreshPromise: Promise<boolean> = null;
-
-  constructor(
-    userService: UserService,
-    modalService: ModalOpenerService,
-    http: AuthHttpService,
-    router: Router,
-    eventMessenager: EventMessenager,
-    storageService: StorageService,
-    environment: Environment
-  ) {
-    super(
-      userService,
-      modalService,
-      http,
-      router,
-      eventMessenager,
-      storageService,
-      environment
-    );
-  }
-}

package/projects/obtservices/angular/src/lib/vendor/services/modal-opener.service.ts

@@ -1,9 +0,0 @@
-import { Injectable } from '@angular/core';
-import { BaseModalOpenerService } from 'obtservices/base';
-
-@Injectable({ providedIn: 'root' })
-export class ModalOpenerService extends BaseModalOpenerService {
-  constructor() {
-    super();
-  }
-}

package/projects/obtservices/angular/src/lib/vendor/services/my-bookings.service.ts

@@ -1,21 +0,0 @@
-import { Injectable } from '@angular/core';
-import { GetUserBasketsGQL, SearchUserCanBookForGQL } from '../types/graphql.angular.types';
-import { GetUserBasketsFetcher } from '../fetchers/get-users-baskets-fetcher';
-import { SearchUsersCanBookForFetcher } from '../fetchers/search-users-can-book-for-fetcher';
-import { BaseEnterpriseMyBookingsService } from 'obtservices/base';
-
-@Injectable({ providedIn: 'root' })
-export class EnterpriseMyBookingsService extends BaseEnterpriseMyBookingsService<
-  GetUserBasketsGQL,
-  SearchUserCanBookForGQL
-> {
-  constructor(
-    getUserBasketsFetcher: GetUserBasketsFetcher,
-    searchUsersCanBookForFetcher: SearchUsersCanBookForFetcher
-  ) {
-    super(
-      getUserBasketsFetcher,
-      searchUsersCanBookForFetcher
-    );
-  }
-}

package/projects/obtservices/angular/src/lib/vendor/services/route-happy.service.ts

@@ -1,11 +0,0 @@
-import { Injectable } from '@angular/core';
-import { BaseRouteHappyService } from 'obtservices/base';
-import { HelperRoutines } from '../classes/helpers';
-import { HttpCallService } from './http-call.service';
-
-@Injectable({ providedIn: 'root' })
-export class RouteHappyService extends BaseRouteHappyService {
-  constructor(httpService: HttpCallService, helpers: HelperRoutines) {
-    super(httpService, helpers);
-  }
-}