@sabstravtech/obtservices 0.0.0

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

@@ -0,0 +1,541 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import moment from 'moment';
+import { BaseEnterpriseSearch } from './base-enterprise';
+import { BaseStorageService } from '../services/storage.service';
+import { BaseHelperRoutines } from './helpers';
+import { Traveller } from '../models/traveller.object';
+import {
+  NgbDateStruct,
+  OBTAirportDetails,
+  ParkingQuoteResultArray,
+  TerminalsType,
+  ParkingFiltersInterface,
+  RecentSearch
+} from '../types/types';
+import {
+  AirportResults,
+  BasketItem,
+  ParkingQuote,
+  SaveRecentSearchMutationVariables,
+  SearchFlightsV2QueryVariables,
+  SearchParkingQueryVariables,
+  ServiceType
+} from '../types/graphql.types';
+import {
+  BaseParkingQuoteFetcher,
+  ParkingQuoteFetcherType
+} from '../fetchers/parking-quote-fetcher';
+import {
+  EnterpriseBasketServiceInterface,
+  InternalBasketInterface
+} from '../interfaces/Ienterprise-basket.service';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+import {
+  ParkingEnterpriseSearchInterface,
+  ParkingTempParams
+} from '../interfaces/Iparking-enterprise-search';
+import { ICheapestPrice } from '../interfaces/cheapest-price';
+export const defaultValidations = {
+  AirportFirst: `You must select airport first.`,
+  InvardJourney: `Inward journey cannot be in the past.`,
+  OutwardJourney: `Outward journey cannot be in the past.`,
+  DateOverlapped: `Inward Journey can not be before outward journey`
+};
+
+export class ParkingEnterpriseSearch<Q extends ParkingQuoteFetcherType>
+  extends BaseEnterpriseSearch<
+    ParkingTempParams,
+    ParkingQuoteResultArray,
+    ParkingQuoteResultArray
+  >
+  implements ParkingEnterpriseSearchInterface
+{
+  static readonly STORAGE_SESSION_PARAMS = 'search_parking';
+  static readonly STORAGE_SESSION_RESULTS = 'results_parking';
+
+  public type: ServiceType = ServiceType.Parking;
+  public terminals = new BehaviorSubject<TerminalsType[]>([]);
+
+  public listViewToggle = new BehaviorSubject<ParkingQuote>(null);
+
+  public parkingFiltersText: ParkingFiltersInterface = {
+    onAirport: 'On Airport',
+    meetAndGreet: 'Meet and greet',
+    parkAndRide: 'Park and ride',
+    parkAndStroll: 'Park and stroll',
+    carParkedForYou: 'Car parked for you'
+  };
+
+  private _locationCode: string;
+
+  get outdate(): NgbDateStruct {
+    return this._outdate;
+  }
+
+  set outdate(value: NgbDateStruct) {
+    this._outdate = value;
+    if (this._outdate && this._outdate) {
+      this.arrivalDatetime = this.helpers.ngDateToMoment(
+        this._outdate,
+        this._outtime
+      );
+    }
+  }
+
+  get outtime(): string {
+    return this._outtime;
+  }
+
+  set outtime(value: string) {
+    this._outtime = value;
+    if (this._outdate && this._outtime) {
+      this.arrivalDatetime = this.helpers.ngDateToMoment(
+        this._outdate,
+        this._outtime
+      );
+    }
+  }
+
+  /**
+   * The date you need the parking till
+   */
+  get departDatetime(): moment.Moment {
+    return this.tempParams.departDatetime;
+  }
+
+  /**
+   * The date you need the parking till
+   */
+  set departDatetime(value: moment.Moment) {
+    this.tempParams.departDatetime = value.isValid() ? value : null;
+    if (value && value.isValid()) {
+      this._indate = this.helpers.momentToNgDate(value);
+      this._intime = this.helpers.formatTimeColon(value);
+    }
+    this._isValid();
+  }
+
+  get indate(): NgbDateStruct {
+    return this._indate;
+  }
+
+  set indate(value: NgbDateStruct) {
+    this._indate = value;
+    if (this._indate && this._intime) {
+      this.departDatetime = this.helpers.ngDateToMoment(
+        this._indate,
+        this._intime
+      );
+    }
+  }
+  get intime(): string {
+    return this._intime;
+  }
+
+  set intime(value: string) {
+    this._intime = value;
+    this.departDatetime = this.helpers.ngDateToMoment(
+      this._indate,
+      this._intime
+    );
+  }
+
+  /**
+   * The date you need the parking from
+   */
+  get arrivalDatetime(): moment.Moment {
+    return this.tempParams?.arrivalDatetime;
+  }
+
+  /**
+   * The date you need the parking from
+   */
+  set arrivalDatetime(value: moment.Moment) {
+    this.tempParams.arrivalDatetime = value.isValid ? value : null;
+    if (value && value.isValid()) {
+      this._outdate = this.helpers.momentToNgDate(value);
+      this._outtime = this.helpers.formatTimeColon(value);
+
+      if (
+        this.departDatetime &&
+        this.departDatetime.isSameOrBefore(this.arrivalDatetime)
+      ) {
+        const dayAfterArrivalDateTime = this.arrivalDatetime.clone();
+        this.departDatetime = dayAfterArrivalDateTime;
+      }
+    }
+    this._isValid();
+  }
+
+  get outFlightNumber(): string {
+    return this.tempParams?.outFlightNumber;
+  }
+
+  set outFlightNumber(value: string) {
+    this.tempParams.outFlightNumber = value || null;
+    this._isValid();
+  }
+
+  get recommended(): boolean | null {
+    return !!this.tempParams?.recommended;
+  }
+  set recommended(value: boolean) {
+    this.tempParams.recommended = value || null;
+    this._isValid();
+  }
+  get onAirport(): boolean {
+    return !!this.tempParams?.onAirport;
+  }
+
+  set onAirport(value: boolean) {
+    this.tempParams.onAirport = value || null;
+    this._isValid();
+  }
+
+  get meetAndGreet(): boolean {
+    return !!this.tempParams?.meetAndGreet;
+  }
+
+  set meetAndGreet(value: boolean) {
+    this.tempParams.meetAndGreet = value || null;
+    this._isValid();
+  }
+
+  get parkAndRide(): boolean {
+    return !!this.tempParams?.parkAndRide;
+  }
+
+  set parkAndRide(value: boolean) {
+    this.tempParams.parkAndRide = value || null;
+    this._isValid();
+  }
+
+  get parkAndStroll(): boolean {
+    return !!this.tempParams?.parkAndStroll;
+  }
+
+  set parkAndStroll(value: boolean) {
+    this.tempParams.parkAndStroll = value || null;
+    this._isValid();
+  }
+
+  get carParkedForYou(): boolean {
+    return !!this.tempParams?.carParkedForYou;
+  }
+
+  set carParkedForYou(value: boolean) {
+    this.tempParams.carParkedForYou = value || null;
+    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();
+  }
+
+  get locationCode(): string | OBTAirportDetails {
+    return this.tempParams.locationCode;
+  }
+
+  set locationCode(value: string | OBTAirportDetails) {
+    this.tempParams.locationCode = value;
+
+    if (typeof value === 'string') {
+      this._locationCode = null;
+      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 (value.terminals.length === 1) {
+        this.selectedTerminal = value.terminals[0].key;
+      }
+      this._isValid();
+    } else {
+      this._locationCode = null;
+      this.terminal = null;
+      this.terminals.next([]);
+      this.selectedTerminal = null;
+      this._isValid();
+    }
+  }
+
+  private _selectedTerminal: string = '';
+  set selectedTerminal(value: string) {
+    this._selectedTerminal = value;
+  }
+
+  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()
+  };
+
+  public min_return_date = {
+    year: moment().year(),
+    month: moment().month() + 1, // ngbDate months are not 0 indexed
+    day: moment().date() + 1 // min 1 night stay
+  };
+
+  private travellers: Traveller[];
+
+  constructor(
+    private parkingfetcher: BaseParkingQuoteFetcher<Q>,
+    private helpers: BaseHelperRoutines,
+    private basketService: EnterpriseBasketServiceInterface,
+    storageService: BaseStorageService,
+    private searchService: EnterpriseSearchServiceInterface
+  ) {
+    super(storageService);
+
+    const data: {
+      tempParams: ParkingTempParams;
+    } = storageService.getSessionItem(
+      ParkingEnterpriseSearch.STORAGE_SESSION_PARAMS
+    ) || {
+      tempParams: {} as ParkingTempParams
+    };
+
+    this.updateTempParams(searchService.makeParkingQuery(data.tempParams));
+
+    const results =
+      storageService.getSessionItemAsList<ParkingQuoteResultArray>(
+        this.resultsSessionName
+      ) || [];
+
+    this.results.next(results);
+    this._cheapestResultPrice = this.updateLowestPrice(results);
+    if (searchService.shouldAddTravellerSubscription()) {
+      searchService.travellerInformation.subscribe(
+        (travellers: Traveller[]) => {
+          this.travellers = travellers;
+          this._isValid();
+        }
+      );
+    }
+  }
+
+  protected resultsSessionName =
+    ParkingEnterpriseSearch.STORAGE_SESSION_RESULTS;
+
+  private _outdate: NgbDateStruct = null;
+
+  private _outtime: string = null;
+
+  private _indate: NgbDateStruct = null;
+
+  private _intime: string = null;
+
+  protected resetQuery(): void {
+    this.updateTempParams(this.searchService.makeParkingQuery());
+    this._isValid();
+  }
+
+  private _isValid() {
+    if (!this.doChecks) {
+      return;
+    }
+    this.storageService.setSessionItem(
+      ParkingEnterpriseSearch.STORAGE_SESSION_PARAMS,
+      {
+        location: this._locationCode,
+        travellers: this.travellers,
+        tempParams: this.tempParams
+      }
+    );
+
+    this.validationMessages = [];
+    if (!this._locationCode || this._locationCode === '') {
+      this.validationMessages.push(defaultValidations.AirportFirst);
+    }
+
+    // if (!this.query?.terminal) {
+    //   this.validationMessages.push('Terminal can not be empty.');
+    // }
+
+    if (this.tempParams?.arrivalDatetime.unix() < moment().unix()) {
+      this.validationMessages.push(defaultValidations.InvardJourney);
+    }
+
+    if (this.tempParams?.departDatetime.unix() < moment().unix()) {
+      this.validationMessages.push(defaultValidations.OutwardJourney);
+    }
+
+    if (
+      this.tempParams.departDatetime?.isBefore(this.tempParams.arrivalDatetime)
+    ) {
+      this.validationMessages.push(defaultValidations.DateOverlapped);
+    }
+    this.isValid.next(this.validationMessages.length === 0);
+    this.messages.next(this.validationMessages);
+  }
+
+  startSearch(): Promise<boolean> {
+    this.results.next([]);
+    if (this.isValid.value) {
+      const query = this.getSearchQuery();
+      this.searchService.saveRecentSearch(this.getRecentSearchQuery(query));
+      return this._startSearch(
+        this.parkingfetcher.fetchList(
+          this.helpers.removeNulls<SearchParkingQueryVariables>(
+            query
+          )
+        )
+      );
+    } else {
+      return Promise.resolve(false);
+    }
+  }
+
+  getRecentSearchQuery(query: SearchParkingQueryVariables): SaveRecentSearchMutationVariables {
+    return {
+      serviceType: ServiceType.Parking,
+      searchArgs: query,
+      travelDate: this.arrivalDatetime.format(),
+      travellers: this.helpers.getTravellersId(this.travellers)
+    };
+  }
+
+  public startRecentSearch(recentSearch: RecentSearch): void {
+    this.arrivalDatetime= moment(recentSearch.searchArgs.arrivalDatetime);
+    this.departDatetime = moment(recentSearch.searchArgs.departDatetime);
+    this.outFlightNumber = recentSearch.searchArgs.outFlightNumber;
+    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();
+  }
+
+  getSearchQuery(): SearchParkingQueryVariables {
+    const query: SearchParkingQueryVariables = {
+      arrivalDatetime: this.tempParams.arrivalDatetime,
+      departDatetime: this.tempParams.departDatetime,
+      locationCode: this._locationCode,
+      outFlightNumber: this.tempParams.outFlightNumber,
+      recommended: this.tempParams.recommended,
+      onAirport: this.tempParams.onAirport,
+      meetAndGreet: this.tempParams.meetAndGreet,
+      parkAndRide: this.tempParams.parkAndRide,
+      parkAndStroll: this.tempParams.parkAndStroll,
+      carParkedForYou: this.tempParams.carParkedForYou,
+      terminal: this.tempParams.terminal === 'Any' ? null : this.tempParams.terminal
+    };
+    return this.helpers.removeNulls<SearchParkingQueryVariables>(query);
+  }
+
+  sortByPrice(asc?: boolean) {
+    let results = this.helpers.clone(this.results.value) || [];
+    if (asc) {
+      results = results.sort(
+        (a: ParkingQuote, b: ParkingQuote) => b.price - a.price
+      );
+    } else {
+      results = results.sort(
+        (a: ParkingQuote, b: ParkingQuote) => a.price - b.price
+      );
+    }
+    this.results.next(results);
+  }
+
+  updateFromPreviousSearches(
+    previousItems: Record<ServiceType, BasketItem>
+  ): void {
+    const flightItem: SearchFlightsV2QueryVariables =
+      previousItems[ServiceType.Flight]?.searchQuery;
+    if (flightItem) {
+      // TODO flights haven't been done yet.
+    }
+  }
+
+  async addParkingToBasket(
+    parkingQuote: ParkingQuote,
+    parkingQuery: SearchParkingQueryVariables
+  ): Promise<boolean> {
+    const intBasket: InternalBasketInterface =
+      await this.basketService.getDefaultBasket();
+    const basket = intBasket?.subject.value;
+    if (basket) {
+      return this.basketService.addToBasket(
+        {
+          adults: 1,
+          basket: basket.id,
+          service: parkingQuote.sourceId.toString(),
+          detail: {
+            arrivalDatetime: parkingQuery.arrivalDatetime.format(),
+            departDatetime: parkingQuery.departDatetime.format(),
+            locationCode: parkingQuote.carPark.code,
+            name: parkingQuote.carPark.name,
+            requiredInfo: parkingQuote.requiredInfo,
+            airportIata: parkingQuery.locationCode
+          },
+          price: parkingQuote.price,
+          currency: parkingQuote.currency,
+          searchQuery: parkingQuery,
+          outboundDate: parkingQuery.arrivalDatetime.format(),
+          inboundDate: parkingQuery.departDatetime.format()
+        },
+        intBasket,
+        this.searchService,
+        this.travellers
+      );
+    }
+    return Promise.resolve(false);
+  }
+
+  updateLowestPrice(results: ParkingQuote[]): ICheapestPrice {
+    if (!results.length) return null;
+    const currency = results[0].currency;
+    return results.reduce(
+      (cheapestPrice: ICheapestPrice, result: ParkingQuote) => {
+        const price = result.price;
+        if (cheapestPrice.amount > price) cheapestPrice.amount = price;
+        return cheapestPrice;
+      },
+      { amount: Number.MAX_SAFE_INTEGER, currencyCode: currency }
+    );
+  }
+}

package/projects/obtservices/base/src/lib/vendor/classes/rail-direction.enum.ts

@@ -0,0 +1,4 @@
+export enum RailDirection {
+  Outbound = 'out',
+  Inbound = 'in'
+}