@sabstravtech/obtservices 0.0.0

package/projects/obtservices/base/src/lib/vendor/classes/limited-cache.class.ts

@@ -0,0 +1,70 @@
+class Node<T> {
+  next: Node<T> = null;
+  pre: Node<T> = null;
+  constructor(public key: string, public value: T) {}
+}
+
+export class LimitedCache<T> {
+  private cache: { [key: string]: Node<T> } = {};
+  private count: number = 0;
+  private head: Node<T>;
+
+  constructor(private size = 10) {
+    this.head = new Node<T>('', null);
+    const tail = new Node<T>('', null);
+    this.head.next = tail;
+    tail.pre = this.head;
+  }
+
+  get(key: string): T {
+    if (this.cache[key]) {
+      return this.cache[key].value;
+    }
+    return null;
+  }
+
+  set(key: string, value: T) {
+    const item: Node<T> = this.cache[key];
+    if (item) {
+      item.value = value;
+      this.deleteItem(item);
+      this.addToHead(item);
+    } else {
+      this.cache[key] = new Node<T>(key, value);
+      this.addToHead(this.cache[key]);
+    }
+  }
+
+  hasKey(key: string): boolean {
+    return this.cache.hasOwnProperty(key);
+  }
+
+  deleteItem(node: Node<T>): void {
+    node.pre.next = node.next;
+    node.next.pre = node.pre;
+  }
+
+  addToHead(item: Node<T>) {
+    item.next = this.head.next;
+    item.next.pre = item;
+    item.pre = this.head;
+    this.head.next = item;
+  }
+}
+
+export function Memorise() {
+  return (target: any, propertyKey: string, descriptor: PropertyDescriptor) => {
+    const cache = new LimitedCache<any>();
+    const targetMethod = descriptor.value;
+
+    descriptor.value = function (...args: any[]) {
+      const key = JSON.stringify(args);
+
+      if (!cache.hasKey(key)) {
+        cache.set(key, targetMethod.apply(this, args));
+      }
+
+      return cache.get(key);
+    };
+  };
+}

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

@@ -0,0 +1,444 @@
+import { BaseEnterpriseSearch } from './base-enterprise';
+import { BehaviorSubject, Observable } from 'rxjs';
+import moment from 'moment';
+import { BaseStorageService } from '../services/storage.service';
+import { BaseHelperRoutines } from './helpers';
+import { Traveller } from '../models/traveller.object';
+import {
+  LoungeQuoteResult,
+  LoungeQuoteResultArray,
+  NgbDateStruct,
+  OBTAirportDetails,
+  RecentSearch,
+  TerminalsType
+} from '../types/types';
+import {
+  AirportResults,
+  BasketItem,
+  LoungeQuote,
+  SaveRecentSearchMutationVariables,
+  SearchFlightsV2QueryVariables,
+  SearchLoungesQueryVariables,
+  ServiceType
+} from '../types/graphql.types';
+import {
+  BaseLoungeQuoteFetcher,
+  LoungeQuoteFetcherType
+} from '../fetchers/lounge-quote.fetcher';
+import {
+  EnterpriseBasketServiceInterface,
+  InternalBasketInterface
+} from '../interfaces/Ienterprise-basket.service';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+import {
+  LoungesEnterpriseSearchInterface,
+  LoungesTempParams
+} from '../interfaces/Ilounges-enterprise-search';
+import { ICheapestPrice } from '../interfaces/cheapest-price';
+export class LoungesEnterpriseSearch<LQ_Q extends LoungeQuoteFetcherType>
+  extends BaseEnterpriseSearch<
+    LoungesTempParams,
+    LoungeQuoteResultArray,
+    LoungeQuoteResultArray
+  >
+  implements LoungesEnterpriseSearchInterface
+{
+  static readonly STORAGE_SESSION_PARAMS = 'search_lounge';
+  static readonly STORAGE_SESSION_RESULTS = 'results_lounge';
+  public type: ServiceType = ServiceType.Lounge;
+  public terminals = new BehaviorSubject<TerminalsType[]>([]);
+
+  private travellers: Traveller[];
+  private _locationCode: string;
+
+  get adults(): number {
+    return this.tempParams.adults;
+  }
+
+  set adults(value: number) {
+    this.tempParams.adults = value;
+    this._isValid();
+  }
+
+  get children(): number {
+    return this.tempParams.children;
+  }
+
+  set children(value: number) {
+    this.tempParams.children = value;
+    this._isValid();
+  }
+
+  get infants(): number {
+    return this.tempParams.infants;
+  }
+
+  set infants(value: number) {
+    this.tempParams.infants = value;
+  }
+
+  private _flightNumber: string = null;
+
+  get flightNumber(): string {
+    return this._flightNumber;
+  }
+
+  set flightNumber(value: string) {
+    this._flightNumber = value;
+  }
+
+  get locationCode(): string | OBTAirportDetails {
+    return this.tempParams.locationCode;
+  }
+
+  set locationCode(value: string | OBTAirportDetails) {
+    this.tempParams.locationCode = value;
+    const terminalsType: TerminalsType[] = this.terminals?.value;
+    if (typeof value === 'string') {
+      this._locationCode = '';
+      this.terminal = null;
+      this.terminals.next([]);
+      this.selectedTerminal = null;
+      this._isValid();
+    } else if (value && value.gateway) {
+      this._locationCode = value.gateway;
+      this.terminal = null;
+      this.terminals.next(value.terminals);
+      if (terminalsType.length === 1) {
+        this.selectedTerminal = terminalsType[0].key;
+      }
+      this._isValid();
+    } else {
+      this._locationCode = null;
+      this.terminal = null;
+      this.selectedTerminal = null;
+      this.terminals.next([]);
+      this._isValid();
+    }
+  }
+
+  get terminal(): string {
+    return this.tempParams.terminal
+      ? this.tempParams.terminal.toString()
+      : null;
+  }
+
+  set terminal(input: string) {
+    this.tempParams.terminal = input;
+    const found: TerminalsType = this.terminals.value.find(
+      (terminal: TerminalsType, index: number) => {
+        if (terminal.value === input) {
+          return true;
+        }
+      }
+    );
+
+    if (found) {
+      this.selectedTerminal = found.key;
+    } else {
+      if (this.terminals.value && this.terminals.value.length > 0) {
+        this.selectedTerminal = this.terminals.value[0].key;
+      } else {
+        this.selectedTerminal = 'Any Terminal';
+      }
+    }
+    this._isValid();
+  }
+
+  private _selectedTerminal: string = '';
+  set selectedTerminal(value: string) {
+    this._selectedTerminal = value;
+    this._isValid();
+  }
+
+  get selectedTerminal(): string {
+    return this._selectedTerminal;
+  }
+
+  // public variables
+  public min_date = {
+    year: moment().year(),
+    month: moment().month() + 1, // ngbDate months are not 0 indexed
+    day: moment().date()
+  };
+
+  private _date: NgbDateStruct = null;
+  get date(): NgbDateStruct {
+    return this._date;
+  }
+
+  set date(value: NgbDateStruct) {
+    this._date = value;
+    this._updateDateTime();
+  }
+
+  private _time: string = null;
+  get time(): string {
+    return this._time;
+  }
+
+  set time(value: string) {
+    this._time = value;
+    this._updateDateTime();
+  }
+
+  get arrivalDatetime(): moment.Moment {
+    return this.tempParams.arrivalDatetime;
+  }
+
+  set arrivalDatetime(value: moment.Moment) {
+    if (value.isValid()) {
+      this.tempParams.arrivalDatetime = value;
+
+      this._date = this.helpers.momentToNgDate(value);
+      this._time = this.helpers.formatTimeColon(value);
+    } else {
+      this.tempParams.arrivalDatetime = null;
+    }
+    this._isValid();
+  }
+
+  protected resultsSessionName =
+    LoungesEnterpriseSearch.STORAGE_SESSION_RESULTS;
+
+  constructor(
+    private loungefetcher: BaseLoungeQuoteFetcher<LQ_Q>,
+    private helpers: BaseHelperRoutines,
+    private basketService: EnterpriseBasketServiceInterface,
+    storageService: BaseStorageService,
+    private searchService: EnterpriseSearchServiceInterface
+  ) {
+    super(storageService);
+    const data: {
+      tempParams: LoungesTempParams;
+    } = storageService.getSessionItem(
+      LoungesEnterpriseSearch.STORAGE_SESSION_PARAMS
+    ) || {
+      tempParams: {} as LoungesTempParams
+    };
+
+    this.updateTempParams(searchService.makeLoungesQuery(data.tempParams));
+
+    if (searchService.shouldAddTravellerSubscription()) {
+      searchService.travellerInformation.subscribe(
+        (travellers: Traveller[]) => {
+          const splitTravellers = this.helpers.selectedTravellers(
+            travellers,
+            ServiceType.Lounge
+          );
+
+          this.tempParams.adults = splitTravellers.adults.length;
+          this.tempParams.children = splitTravellers.children.length;
+          this.travellers = travellers;
+
+          this._isValid();
+        }
+      );
+    }
+    const results =
+      storageService.getSessionItemAsList<LoungeQuoteResultArray>(
+        this.resultsSessionName
+      ) || [];
+    // if (results == null && this.isValid) {
+    //   searchService.startSearches();
+    // }
+    this._cheapestResultPrice = this.updateLowestPrice(results);
+    this.results.next(results || []);
+  }
+
+  protected resetQuery() {
+    this.updateTempParams(this.searchService.makeLoungesQuery());
+    this._isValid();
+  }
+
+  getSearchQuery(): SearchLoungesQueryVariables {
+    const query: SearchLoungesQueryVariables = {
+      adults: this.tempParams.adults,
+      children: this.tempParams.children,
+      infants: this.tempParams.infants,
+      locationCode: this._locationCode,
+      terminal: this.tempParams.terminal === 'Any' ? null : this.tempParams.terminal,
+      arrivalDatetime: this.tempParams.arrivalDatetime
+    };
+    return this.helpers.removeNulls<SearchLoungesQueryVariables>(query);
+  }
+
+  // Private Methods
+
+  private _isValid() {
+    if (!this.doChecks) {
+      return;
+    }
+    this.storageService.setSessionItem(
+      LoungesEnterpriseSearch.STORAGE_SESSION_PARAMS,
+      {
+        tempParams: this.tempParams,
+        travellers: this.travellers
+      }
+    );
+
+    this.validationMessages = [];
+    if (!this._locationCode || this._locationCode === '') {
+      this.validationMessages.push('You must select airport first.');
+    }
+
+    // if (!this.query.terminal) {
+    //   this.validationMessages.push('Terminal can not be empty.');
+    // }
+
+    if (this.tempParams.arrivalDatetime.unix() < moment().unix()) {
+      this.validationMessages.push('Outward journey cannot be in the past.');
+    }
+
+    this.isValid.next(this.validationMessages.length === 0);
+    this.messages.next(this.validationMessages);
+  }
+
+  private _updateDateTime() {
+    if (this._date && this._time) {
+      const time = this.helpers.ngDateToMoment(this._date, this._time);
+      this.tempParams.arrivalDatetime = time.isValid() ? time : null;
+      this._isValid();
+    }
+  }
+
+  startSearch(): Promise<boolean> {
+    this.results.next([]);
+
+    if (this.isValid.value) {
+      const query = this.getSearchQuery();
+      this.searchService.saveRecentSearch(this.getRecentSearchQuery(query));
+      return this._startSearch(
+        this.loungefetcher.fetchList(
+          this.helpers.removeNulls<SearchLoungesQueryVariables>(
+            query
+          )
+        )
+      );
+    } else {
+      return Promise.resolve(false);
+    }
+  }
+
+  getRecentSearchQuery(query: SearchLoungesQueryVariables): SaveRecentSearchMutationVariables {
+    return {
+      serviceType: ServiceType.Lounge,
+      searchArgs: query,
+      travelDate: this.arrivalDatetime.format(),
+      travellers: this.helpers.getTravellersId(this.travellers)
+    };
+  }
+
+  public startRecentSearch(recentSearch: RecentSearch): void {
+    this.arrivalDatetime = moment(recentSearch.searchArgs.arrivalDatetime);
+    this.terminal = recentSearch.searchArgs.terminal;
+    this.searchService.getAirportByCode(recentSearch.searchArgs.locationCode).subscribe((airport: AirportResults) => {
+      if (airport) {
+        this.locationCode = {
+          country: airport.iataMatch?.locationDetails?.country,
+          countryCode: airport.iataMatch?.locationDetails?.countryCode,
+          destination: airport.iataMatch.name,
+          gateway: airport.iataMatch.iata,
+          postcode: airport.iataMatch?.locationDetails?.postcode,
+          terminals: this.searchService.processTerminals(airport.iataMatch.terminals)
+        };
+      this.searchService.startSearches();
+      }
+    })
+    this.searchService.startSearches();
+  }
+
+  sortByPrice(asc?: boolean, resultArray: LoungeQuote[] = []) {
+    let sortResults = [...this.fullResults] as LoungeQuote[];
+    if (!sortResults.length) {
+      sortResults = resultArray;
+    }
+    sortResults = this.sortResultsPrice(sortResults, asc);
+    this.results.next(sortResults);
+  }
+
+  sortResultsPrice(resultArray: LoungeQuote[], asc?: boolean): LoungeQuote[] {
+    let results = [...resultArray];
+    if (asc) {
+      results = results.sort(
+        (a: LoungeQuoteResult, b: LoungeQuoteResult) => b.price - a.price
+      );
+    } else {
+      results = results.sort(
+        (a: LoungeQuoteResult, b: LoungeQuoteResult) => a.price - b.price
+      );
+    }
+    return results;
+  }
+
+  sortByTerminal(resultArray: LoungeQuote[] = []) {
+    let results = [...this.fullResults];
+    if (!results.length) {
+      results = resultArray;
+    }
+    const terminalSorter = (a: LoungeQuoteResult, b: LoungeQuoteResult) => {
+      return -1; // TODO a.rawData.FlightTermOut > b.rawData.FlightTermOut ? 1 : -1;
+    };
+    this.results.next(results.sort(terminalSorter));
+  }
+
+  updateFromPreviousSearches(
+    previousItems: Record<ServiceType, BasketItem>
+  ): void {
+    const flightItem: SearchFlightsV2QueryVariables =
+      previousItems[ServiceType.Flight]?.searchQuery;
+    if (flightItem) {
+      // TODO flights haven't been done yet.
+    }
+  }
+
+  async addLoungeToBasket(
+    loungeQuote: LoungeQuote,
+    loungeQuery: SearchLoungesQueryVariables
+  ): Promise<boolean> {
+    if (loungeQuote.unavailable) {
+      return Promise.resolve(false);
+    }
+    const intBasket: InternalBasketInterface =
+      await this.basketService.getDefaultBasket();
+    const basket = intBasket?.subject.value;
+    if (basket) {
+      return this.basketService.addToBasket(
+        {
+          adults: loungeQuery.adults,
+          children: loungeQuery.children,
+          infants: loungeQuery.infants,
+          basket: basket.id,
+          service: loungeQuote.sourceId.toString(),
+          detail: {
+            arrivalDatetime: loungeQuery.arrivalDatetime.format(),
+            locationCode: loungeQuote.code,
+            name: loungeQuote.name,
+            airportIata: loungeQuery?.locationCode
+          },
+          price: loungeQuote.price,
+          currency: loungeQuote.currency,
+          searchQuery: loungeQuery,
+          outboundDate: loungeQuery.arrivalDatetime.format()
+        },
+        intBasket,
+        this.searchService,
+        this.travellers
+      );
+    }
+    return Promise.resolve(false); // TODO should this throw an error?
+  }
+
+  updateLowestPrice(results: LoungeQuote[]): ICheapestPrice {
+    if (!results.length) return null;
+    const currency = results[0].currency;
+    return results.reduce(
+      (cheapestPrice: ICheapestPrice, result: LoungeQuote) => {
+        const price = result.price;
+        if (cheapestPrice.amount > price) cheapestPrice.amount = price;
+        return cheapestPrice;
+      },
+      { amount: Number.MAX_SAFE_INTEGER, currencyCode: currency }
+    );
+  }
+}