@sabstravtech/obtservices 0.0.0

package/projects/obtservices/base/src/lib/vendor/classes/base-enterprise.ts

@@ -0,0 +1,126 @@
+import { BehaviorSubject, Observable, of } from 'rxjs';
+import { take } from 'rxjs/operators';
+
+import { BaseStorageService } from '../services/storage.service';
+import * as _ from 'lodash';
+import { BasketItem, ServiceType } from '../types/graphql.types';
+import { ICheapestPrice } from '../interfaces/cheapest-price';
+import { RecentSearch } from '../../../types';
+
+export abstract class BaseEnterpriseSearch<P, R, O extends Array<any>> {
+  protected _cheapestResultPrice: ICheapestPrice = {
+    amount: null,
+    currencyCode: null
+  };
+  protected _originalUserSearch: P;
+  public isValid = new BehaviorSubject<boolean>(false);
+  public results: BehaviorSubject<O> = new BehaviorSubject<O>([] as O);
+  public messages: BehaviorSubject<string[]> = new BehaviorSubject<string[]>(
+    []
+  );
+  public messagesInfo: BehaviorSubject<string[]> = new BehaviorSubject<
+    string[]
+  >([]);
+  public validationMessages: string[] = [];
+  public infoMessages: string[] = [];
+  public isLoading: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(
+    false
+  );
+
+  protected abstract resultsSessionName: string;
+  protected tempParams: P = {} as P;
+  protected doChecks: boolean = true;
+  public abstract type: ServiceType;
+  public fullResults: O = [] as O; // should be an array of type specified by O
+
+  private mapper = (results: R): O => {
+    return results as unknown as O;
+  };
+
+  get cheapestPrice(): ICheapestPrice {
+    return this._cheapestResultPrice;
+  }
+
+  get originalUserSearch(): P {
+    return this._originalUserSearch;
+  }
+
+  constructor(
+    protected storageService: BaseStorageService,
+    mapper: (r: R) => O = null
+  ) {
+    if (mapper) {
+      this.mapper = mapper;
+    }
+  }
+
+  protected updateTempParams(tempParams: P): void {
+    this.doChecks = false;
+    Object.assign(this, tempParams);
+    this._cheapestResultPrice = null;
+    this.doChecks = true;
+  }
+
+  protected _startSearch(results: Observable<R>): Promise<boolean> {
+    this.isLoading.next(true);
+    this.fullResults = [] as O;
+    return new Promise((resolve, reject) => {
+      try {
+        results.pipe(take(1)).subscribe(
+          (results1: R) => {
+            console.log('Got results', _.cloneDeep(results1));
+
+            this.fullResults = this.mapper(results1);
+            this._cheapestResultPrice = this.updateLowestPrice(
+              this.fullResults
+            );
+            this.storageService.setSessionItem(
+              this.resultsSessionName,
+              this.makeSessionResults(this.fullResults)
+            );
+            this.results.next(this.fullResults);
+            resolve(this.fullResults.length !== 0);
+          },
+          (error) => {
+            this.results.next([] as O);
+            resolve(false);
+            this.isLoading.next(false);
+          },
+          () => {
+            this.isLoading.next(false);
+          }
+        );
+      } catch (err) {
+        this.storageService.setSessionItem(this.resultsSessionName, []);
+        this.isLoading.next(false);
+        this.results.next([] as O);
+        reject(err);
+      }
+    });
+  }
+  reset(): void {
+    this.storageService.removeSessionItem(this.resultsSessionName);
+    this.fullResults = [] as O;
+    this.results.next([] as O);
+    this.resetQuery();
+  }
+
+  protected makeSessionResults(data: O): any {
+    return data;
+  }
+
+  protected abstract resetQuery(): void;
+
+  abstract startSearch(): Promise<boolean>;
+
+  abstract startRecentSearch(recentSearch: RecentSearch): void;
+
+  abstract updateLowestPrice(results: O): ICheapestPrice;
+  /**
+   *
+   * @param previousItems basketitems that already been added. This can be used to set up the defaults for the search.
+   */
+  abstract updateFromPreviousSearches(
+    previousItems: Record<ServiceType, BasketItem>
+  ): void;
+}

package/projects/obtservices/base/src/lib/vendor/classes/base-network-call.ts

@@ -0,0 +1,40 @@
+import * as Apollo from 'apollo-angular';
+import { ApolloQueryResult, FetchResult } from '@apollo/client/core';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { ModalTypes } from '../classes/modal-types.enum';
+import { Observable, of } from 'rxjs';
+import { map, take, catchError } from 'rxjs/operators';
+
+export abstract class BaseNetworkCall<Q, A, R, P> {
+  constructor(private modelService: BaseModalOpenerService) {}
+
+  checkError(error: any) {
+    if (error) {
+      this.modelService.open(
+        ModalTypes.ModalNetWorkErrorComponent,
+        {},
+        { error }
+      );
+      throw error;
+    }
+  }
+
+  processCall(
+    stream: Observable<
+      FetchResult<{}, Record<string, any>, Record<string, any>>
+    >
+  ): Observable<P> {
+    return stream.pipe(
+      take(1),
+      map((results: ApolloQueryResult<R>) => {
+        this.checkError(results.error);
+        return this.getDataFromResult(results);
+      }),
+      catchError((error: any) => {
+        this.checkError(error);
+        return of({} as P);
+      })
+    );
+  }
+  protected abstract getDataFromResult(results: ApolloQueryResult<R>): P;
+}

package/projects/obtservices/base/src/lib/vendor/classes/basket-info-mi-details.impl.ts

@@ -0,0 +1,68 @@
+import {
+  ManagementInfoAndIsValid,
+  makeManagamentInfo
+} from './management-info-and-valid';
+import { BaseHelperRoutines } from './helpers';
+import { BasketItem, ManagementInfo, User } from '../types/graphql.types';
+import { EnterpriseBasketServiceInterface } from '../interfaces/Ienterprise-basket.service';
+
+interface UserManagementSupplement {
+  [key: string]: {
+    managementInfo: ManagementInfoAndIsValid[];
+  };
+}
+
+export class BasketInfoMiDetailsImpl {
+  miPerItem: ManagementInfoAndIsValid[];
+  miPerUser: UserManagementSupplement;
+  users: string[];
+  basketItem: BasketItem;
+  isValidObservers: ManagementInfoAndIsValid[] = [];
+
+  constructor(
+    item: BasketItem,
+    private basketService: EnterpriseBasketServiceInterface,
+    private helpers: BaseHelperRoutines
+  ) {
+    this.basketItem = item;
+    const { perItem, perUser } = item.managementInfo.reduce(
+      (
+        miAccum: {
+          perItem: ManagementInfoAndIsValid[];
+          perUser: ManagementInfoAndIsValid[];
+        },
+        miItem: ManagementInfo
+      ) => {
+        const miItemObj = makeManagamentInfo(miItem, this.basketService);
+        this.isValidObservers.push(miItemObj);
+
+        if (miItem.perBooking) {
+          miAccum.perItem.push(miItemObj);
+        } else {
+          miAccum.perUser.push(miItemObj);
+        }
+
+        return miAccum;
+      },
+      { perItem: [], perUser: [] }
+    );
+
+    this.miPerItem = perItem;
+    this.miPerUser = item.users.reduce(
+      (userAccum: UserManagementSupplement, user: User) => {
+        userAccum[user.id] = {
+          managementInfo: this.helpers
+            .clone(perUser)
+            .map((miItem: ManagementInfo): ManagementInfoAndIsValid => {
+              const miItemObj = makeManagamentInfo(miItem, this.basketService);
+              this.isValidObservers.push(miItemObj);
+              return miItemObj;
+            })
+        };
+        return userAccum;
+      },
+      {}
+    );
+    this.users = Object.keys(this.miPerUser);
+  }
+}

package/projects/obtservices/base/src/lib/vendor/classes/bookable-basket.ts

@@ -0,0 +1,343 @@
+import { BehaviorSubject } from 'rxjs';
+import { Traveller } from '../models/traveller.object';
+import {
+  BasketDetails,
+  BasketItemManagementInfo,
+  MiGroupDetail
+} from '../services/enterprise-basket.service';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { BookingStatus } from '../types/types';
+import { EnterpriseBasketServiceInterface } from '../interfaces/Ienterprise-basket.service';
+import {
+  BasketItem,
+  BasketStatus,
+  PassengerType,
+  PaymentMethod,
+  SupplementaryBookingInfo,
+  User,
+  UserPassengerType
+} from '../types/graphql.types';
+
+export class BookableBasket {
+  status: BehaviorSubject<BookingStatus> = new BehaviorSubject<BookingStatus>(
+    BookingStatus.Loading
+  );
+
+  basket: BehaviorSubject<BasketDetails> = new BehaviorSubject<BasketDetails>(
+    {} as BasketDetails
+  );
+  needsToViewMi: boolean = true;
+  isUpdating: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(false);
+  private id: string = null;
+  constructor(
+    private basketService: EnterpriseBasketServiceInterface,
+    private helpers: BaseHelperRoutines
+  ) {}
+
+  loadBasket(id: string): void {
+    this.id = id;
+    this.basket = new BehaviorSubject<BasketDetails>({} as BasketDetails);
+    this.status.next(BookingStatus.Loading);
+    this.isUpdating.next(true);
+    this._loadBasket(id);
+  }
+
+  /*
+    Loading,
+  0  AddingItems,
+  1  AddingTravellers,
+  2  AddingLeadPassenger,
+  3  Failed,
+  4  Revalidate,
+  5  RevalidatingError,
+  6  RevalidatingAccepted,
+  7  ChooseMIGroup,
+  8  ProvideMi,
+  9  SendForApproval,
+  10 AwaitingApproval,
+  11 Approved
+  12 PartiallyBooked,
+  13 Complete
+  */
+
+  private _loadBasket(id: string): void {
+    this.basketService.loadBasket(id);
+
+    this.basketService.subsribeToBasket(id, {
+      next: (basket: BasketDetails) => {
+        this.basket.next(basket);
+        this.updateBasket(basket);
+      },
+      error: (error: any) => {
+        this.basket.error(error);
+        console.error(error);
+      },
+      complete: () => {
+        this.basket.complete();
+        console.log('Basket completed');
+      }
+    });
+  }
+
+  updateBasket(basket: BasketDetails): void {
+    this.isUpdating.next(false);
+    switch (basket.status) {
+      case BasketStatus.Open:
+        this.workoutOpenState(basket);
+        break;
+      case BasketStatus.AwaitingApproval:
+        this.status.next(
+          this.workoutState(basket, BookingStatus.AwaitingApproval)
+        );
+        break;
+      case BasketStatus.Approved:
+        this.status.next(this.workoutApprovedState(basket));
+        break;
+      case BasketStatus.Booked:
+        this.status.next(this.workoutState(basket, BookingStatus.Complete));
+        break;
+      case BasketStatus.BookingFailed:
+        this.status.next(this.workoutState(basket, BookingStatus.Failed));
+        break;
+      case BasketStatus.Disapproved:
+        this.status.next(BookingStatus.Failed);
+        break;
+      case BasketStatus.PartiallyBooked:
+        this.status.next(BookingStatus.Failed);
+        break;
+      default:
+        const tmp: never = basket.status;
+        console.log(tmp);
+    }
+  }
+  sendBasketForApproval(): void {
+    this.basketService.sendBasketForApproval(this.id);
+  }
+
+  workoutApprovedState(basket: BasketDetails): BookingStatus {
+    let status = BookingStatus.ApprovedBook;
+
+    if (
+      !!basket.basketItems.find((basketItem: BasketItem): boolean => {
+        return (
+          basketItem.availablePaymentMethods?.length > 0 &&
+          !basketItem.selectedPaymentMethod
+        );
+      })
+    ) {
+      return this.workoutState(basket, BookingStatus.ApprovedPaymentOption);
+    }
+
+    console.log(basket.suppInfo);
+    const haveSuppDetails = basket.suppInfo.find((supp) => supp.hasDetails);
+    console.log(haveSuppDetails);
+    if (haveSuppDetails) {
+      status = BookingStatus.ApprovedSupplemtal;
+    }
+    return this.workoutState(basket, status);
+  }
+
+  workoutState(
+    basket: BasketDetails,
+    defaultState: BookingStatus
+  ): BookingStatus {
+    // Is the basket validated.
+    if (!basket.validated) {
+      if (this._hasInvalidPrice(basket)) {
+        return BookingStatus.Revalidate;
+      }
+      return BookingStatus.Revalidate;
+    }
+    return defaultState;
+  }
+
+  workoutOpenState(basket: BasketDetails): BookingStatus {
+    // If any of the basketItems don't have enough travellers, then we need to add them.
+    if (basket.basketItems.length === 0) {
+      this.status.next(BookingStatus.AddingItems);
+      return;
+    }
+    if (this._needsCorrectTravellers(basket)) {
+      this.status.next(BookingStatus.AddingTravellers);
+      return;
+    }
+
+    if (this._needLeadPassengers(basket)) {
+      this.status.next(BookingStatus.AddingLeadPassenger);
+      return;
+    }
+    // Is the basket validated.
+    if (!basket.validated) {
+      if (this._hasInvalidPrice(basket)) {
+        this.status.next(BookingStatus.Revalidate);
+        return;
+      }
+      this.status.next(BookingStatus.Revalidate);
+      return;
+    }
+
+    if (this._needsMiGroups(basket)) {
+      this.status.next(BookingStatus.ChooseMIGroup);
+      return;
+    }
+
+    if (this.helpers.needsMi(basket, this.needsToViewMi)) {
+      this.status.next(BookingStatus.ProvideMi);
+      return;
+    }
+
+    this.status.next(BookingStatus.SendForApproval);
+  }
+
+  revalidate() {
+    this.basketService.revalidate(this.id);
+  }
+
+  addTravellers(
+    basket: BasketDetails,
+    basketItem: BasketItem,
+    travellers: Traveller[],
+    index: number = 0
+  ): void {
+    this.isUpdating.next(true);
+    this.basketService.addTravellers(basket.id, basketItem, travellers, index);
+  }
+
+  setLeadPassenger(
+    basket: BasketDetails,
+    basketItem: BasketItem,
+    travellers: Traveller,
+    index: number = 0
+  ): void {
+    this.isUpdating.next(true);
+    this.basketService.setLeadPassenger(
+      basket.id,
+      basketItem,
+      travellers,
+      index
+    );
+  }
+
+  setBasketItemMiGroup(basketId: string, groupDetail: MiGroupDetail) {
+    this.isUpdating.next(true);
+    this.basketService.setBasketItemMiGroup(
+      basketId,
+      groupDetail.basketItem.id,
+      groupDetail.value
+    );
+  }
+
+  saveMiGroup(miGroupDetailsResult: MiGroupDetail[]) {
+    this.isUpdating.next(true);
+    miGroupDetailsResult.forEach((groupDetails: MiGroupDetail) => {
+      this.setBasketItemMiGroup(this.id, groupDetails);
+    });
+  }
+
+  saveMi(results: BasketItemManagementInfo[]) {
+    this.needsToViewMi = false;
+    this.isUpdating.next(true);
+    if (results) {
+      this.basketService.saveMiData(this.id, results);
+    }
+  }
+
+  removeExpiredItems() {
+    this.isUpdating.next(true);
+    this.basketService.removeExpiredItems(this.id);
+  }
+
+  setBasketItemPaymentOption(
+    basketItem: BasketItem,
+    paymentMethod: string
+  ): Promise<void> {
+    this.isUpdating.next(true);
+    return this.basketService.setBasketItemPaymentOption(
+      this.basket.value,
+      basketItem,
+      paymentMethod
+    );
+  }
+
+  bookBasket(results: SupplementaryBookingInfo[]): void {
+    this.isUpdating.next(true);
+    if (results) {
+      this.basketService.bookBasket(this.id, results);
+    }
+  }
+
+  private _needsMiGroups(basket: BasketDetails) {
+    return !!basket.basketItems.find((basketItem: BasketItem): boolean => {
+      return (
+        basketItem.miGroupsAvailable.length > 0 && !basketItem.miGroupSelected
+      );
+    });
+  }
+
+  private _needsCorrectTravellers(basket: BasketDetails): boolean {
+    return !!basket.basketItems.find((basketItem: BasketItem) => {
+      const travellers = this._splitTravellers(basketItem);
+      return !(
+        travellers.adults.length === basketItem.adults &&
+        travellers.children.length === basketItem.children &&
+        travellers.infants.length === basketItem.infants
+      );
+    });
+  }
+
+  private _hasInvalidPrice(basket: BasketDetails): boolean {
+    return !!basket.basketItems.find((basketItem: BasketItem) => {
+      return !basketItem.latestValidationPriceDifference || basketItem.expired;
+    });
+  }
+
+  private _needLeadPassengers(basket: BasketDetails): boolean {
+    return !!basket.basketItems.find((basketItem: BasketItem) => {
+      return !basketItem.leadPassenger;
+    });
+  }
+
+  private _splitTravellers(basketItem: BasketItem): {
+    adults: User[];
+    children: User[];
+    infants: User[];
+  } {
+    return (basketItem.userPassengerTypes || []).reduce(
+      (
+        accum: { adults: User[]; children: User[]; infants: User[] },
+        user: UserPassengerType,
+        index: number
+      ) => {
+        switch (user.passengerType) {
+          case PassengerType.Adult:
+            accum.adults.push(
+              this._findUser(basketItem.users, Number(user.id))
+            );
+            break;
+          case PassengerType.Child:
+            accum.children.push(
+              this._findUser(basketItem.users, Number(user.id))
+            );
+            break;
+          case PassengerType.Infant:
+            accum.infants.push(
+              this._findUser(basketItem.users, Number(user.id))
+            );
+            break;
+        }
+        return accum;
+      },
+      { adults: [], children: [], infants: [] }
+    );
+  }
+
+  private _findUser(users: User[], id: number): User {
+    return users.find((user: User) => {
+      return Number(user.id) === id;
+    });
+  }
+
+  getId(): string {
+    return this.id;
+  }
+}