@sabstravtech/obtservices 0.0.0

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

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

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

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

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

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

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

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