@sabstravtech/obtservices 0.0.0 → 0.0.1

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

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

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

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