@sabstravtech/obtservices 0.0.0 → 0.0.2

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

@@ -1,2126 +0,0 @@
-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 { BehaviorSubject } from 'rxjs';
-import { ValueDisplay } from '../interfaces/value-display';
-import { FlightFilters } from '../interfaces/flight-filters.interface';
-import { SelectFilter } from '../interfaces/select-filter.interface';
-import {
-  AddItemToBasketMutationVariables,
-  BasketItem,
-  CurrencyCode,
-  DestinationEntry,
-  FareType,
-  FlightCabinClass,
-  FlightFareTotal,
-  FlightItinerary,
-  FlightJourney,
-  FlightPassengerObject,
-  FlightPassengerType,
-  SearchFlightsV2QueryVariables,
-  ServiceType
-} from '../types/graphql.types';
-import {
-  EurostarQuoteResult,
-  NgbDateStruct,
-  OBTAirportDetails,
-  OBTAirlinesDetails,
-  FlightDirectionEnum,
-  GroupedFlights,
-  FlightItineraryWithSelected,
-  RecentSearch,
-  EurostarGroupedQuoteResult,
-  EurostarResults,
-  EurostarItem,
-  EurostarFare,
-  EurostarClassEnum,
-  EurostarQuoteResultArray
-} from '../types/types';
-import {
-  FullUserDetails,
-  UserServiceInterface
-} from '../interfaces/Iuser.service';
-import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
-import { ICheapestPrice } from '../interfaces/cheapest-price';
-import { EurostarSearchType } from './eurostar-search-type.enum';
-import { IMultiDestination } from '../interfaces/flight-multi-destination.interface';
-import {
-  EnterpriseBasketServiceInterface,
-  InternalBasketInterface
-} from '../interfaces/Ienterprise-basket.service';
-import {
-  BaseEurostarQuoteFetcher,
-  EurostarQuoteFetcherType
-} from '../fetchers/eurostar-quote.fetcher';
-import {
-  EurostarEnterpriseSearchInterface,
-  EurostarTempParams
-} from '../interfaces/Ieurostar-enterprise-search';
-import {
-  FlightGroups,
-  FlightOperator,
-  TimeWindow
-} from './flight-enterprise-search';
-export interface AllowedClassEurostar {
-  name: string;
-  type: EurostarClassEnum | null;
-}
-
-export type AllowedClassesEurostar = AllowedClassEurostar[];
-
-export type EurostarStation = {
-  gateway: string;
-  destination: string;
-};
-
-export enum SortTypesEurostar {
-  CheapestFirst = 'C',
-  EarliestFirst = 'E'
-}
-
-export enum SortMethod {
-  sortByPrice = 'sortByPrice',
-  sortByDate = 'sortByDate'
-}
-
-export interface SortTypeEurostar {
-  /** Title displayed on dropdown */
-  title: string;
-  /** Method name used by component to sort results */
-  method: SortMethod;
-  /** Icon displayed on drop down */
-  icon: string;
-  /** Sorting direction true for asc, false for dsc */
-  dir: boolean;
-  // this is what we will use to sort
-  code: SortTypesEurostar;
-}
-
-export type EurostarGroups = 'Standard' | 'StandardPremier' | 'BusinessPremier';
-
-interface EurostarSessionType {
-  results: EurostarQuoteResultArray;
-  groupData: { [key: number]: number[] };
-  grouped: GroupedFlights;
-  query: SearchFlightsV2QueryVariables;
-}
-
-export class EurostarEnterpriseSearch<SE_Q extends EurostarQuoteFetcherType>
-  extends BaseEnterpriseSearch<
-  EurostarTempParams,
-  EurostarQuoteResult,
-  EurostarQuoteResultArray
-  >
-  implements EurostarEnterpriseSearchInterface {
-  static readonly STORAGE_SESSION_PARAMS = 'search_eurostar';
-  static readonly STORAGE_SESSION_RESULTS = 'results_eurostar';
-
-  public type: ServiceType = ServiceType.Eurostar;
-
-  avaliableClasses: BehaviorSubject<AllowedClassesEurostar> =
-    new BehaviorSubject<AllowedClassesEurostar>([]);
-  timeCriteriaOptions: BehaviorSubject<TimeWindow[]> = new BehaviorSubject<
-    TimeWindow[]
-  >([]);
-  flightOperators: BehaviorSubject<FlightOperator[]> = new BehaviorSubject<
-    FlightOperator[]
-  >([]);
-
-  private _negotiated: boolean = false;
-  private _nearby_airports: boolean = false;
-
-  private _timeArray: ValueDisplay[];
-  private _sortArray: SortTypeEurostar[] = [
-    {
-      title: 'Price',
-      method: SortMethod.sortByPrice,
-      icon: 'ico-dollar',
-      dir: true,
-      code: SortTypesEurostar.CheapestFirst
-    },
-    {
-      title: 'Time',
-      method: SortMethod.sortByDate,
-      icon: 'ico-calendar',
-      dir: true,
-      code: SortTypesEurostar.EarliestFirst
-    }
-  ];
-
-  private _fareTypeArray: ValueDisplay[] = [
-    { value: FareType.Flexible, display: 'Flexible' },
-    { value: FareType.Leisure, display: 'Leisure' },
-    { value: FareType.Lowest, display: 'Lowest' },
-    { value: FareType.Negotiated, display: 'Negotiated' },
-    { value: FareType.NonNegotiated, display: 'Non-Negotiated' },
-    { value: FareType.RequestFareRules, display: 'Request Fare Rules' },
-    { value: FareType.SelectAndPro, display: 'Select & Pro' }
-  ];
-
-  public minimumOutBoundDate = {
-    year: moment().year(),
-    month: moment().month() + 1,
-    day: moment().date()
-  };
-
-  public minimumInBoundDate = {
-    year: moment().year(),
-    month: moment().month() + 1,
-    day: moment().date()
-  };
-
-  public searchTypes: ValueDisplay[] = [
-    {value: EurostarSearchType.return, display: 'Return'},
-    {value: EurostarSearchType.oneWay, display: 'One-way'},
-  ]
-
-  private _outDate: NgbDateStruct;
-  private _outTime: string;
-  private _inDate: NgbDateStruct;
-  private _inTime: string;
-  private _destinationAirport: any;
-  private _originAirport: any;
-  private _passengers: any;
-  private groupedObject: FlightItineraryWithSelected[];
-  protected flightsToGroup: { [key: number]: number[] } = {};
-  protected resultQuery: SearchFlightsV2QueryVariables;
-  protected grouped: GroupedFlights = null;
-  travellers: Traveller[] = null;
-  protected resultsSessionName =
-    EurostarEnterpriseSearch.STORAGE_SESSION_RESULTS;
-  selectedGroupFlight: FlightItineraryWithSelected;
-  private _displayAddHotel: boolean = false;
-
-  public get displayAddHotel(): boolean {
-    return this._displayAddHotel;
-  }
-
-  public set displayAddHotel(newVal: boolean) {
-    this._displayAddHotel = newVal;
-  }
-  selectedGroupEurostar: EurostarItem;
-  selectedEurostarFare: EurostarFare;
-
-  public get timeArray() {
-    this._timeArray =
-      this._timeArray ||
-      Array(96)
-        .fill(0)
-        .map((_, index: number) => {
-          return {
-            value:
-              Math.floor(index / 4)
-                .toString()
-                .padStart(2, '0') +
-              ':' +
-              ((index % 4) * 15).toString().padStart(2, '0'),
-            display:
-              Math.floor(index / 4)
-                .toString()
-                .padStart(2, '0') +
-              ':' +
-              ((index % 4) * 15).toString().padStart(2, '0')
-          };
-        });
-    return this._timeArray;
-  }
-
-  public get preferredCarriers(): OBTAirlinesDetails[] {
-    return this.tempParams.preferredCarriers;
-  }
-
-  public set preferredCarriers(value: OBTAirlinesDetails[]) {
-    this.tempParams.preferredCarriers = value;
-    this._isValid();
-  }
-
-  public get operator1(): OBTAirlinesDetails {
-    return this.tempParams.preferredCarriers[0];
-  }
-
-  public set operator1(value: OBTAirlinesDetails) {
-    this.tempParams.preferredCarriers[0] = value;
-    this._isValid();
-  }
-  public get operator2(): OBTAirlinesDetails {
-    return this.tempParams.preferredCarriers[1];
-  }
-
-  public set operator2(value: OBTAirlinesDetails) {
-    this.tempParams.preferredCarriers[1] = value;
-    this._isValid();
-  }
-  public get operator3(): OBTAirlinesDetails {
-    return this.tempParams.preferredCarriers[2];
-  }
-
-  public set operator3(value: OBTAirlinesDetails) {
-    this.tempParams.preferredCarriers[2] = value;
-    this._isValid();
-  }
-  public get operator4(): OBTAirlinesDetails {
-    return this.tempParams.preferredCarriers[3];
-  }
-
-  public set operator4(value: OBTAirlinesDetails) {
-    this.tempParams.preferredCarriers[3] = value;
-    this._isValid();
-  }
-
-  private _minDate: NgbDateStruct;
-  public get minDate(): NgbDateStruct {
-    this._minDate = this._minDate || this.helpers.momentToNgDate(moment());
-    return this._minDate;
-  }
-
-  public get adults(): number {
-    return this.tempParams.adults;
-  }
-
-  public set adults(value: number) {
-    this.tempParams.adults = Number(value);
-    this.updateTravellers();
-  }
-
-  public get children(): number {
-    return this.tempParams.children;
-  }
-
-  public set children(value: number) {
-    this.tempParams.children = Number(value);
-    this.updateTravellers();
-  }
-
-  public get departLocation(): string | OBTAirportDetails {
-    return this.tempParams.departLocation;
-  }
-
-  public set departLocation(value: string | OBTAirportDetails) {
-    this.tempParams.departLocation = value;
-    if (typeof value === 'string') {
-      this._originAirport = '';
-    } else if (value && value.gateway) {
-      this._originAirport = value.gateway;
-    } else {
-      this._originAirport = null;
-    }
-    this._isValid();
-  }
-
-  public get queryOriginAiport(): string {
-    return this._originAirport;
-  }
-
-  public get queryDestinationAiport(): string {
-    return this._destinationAirport;
-  }
-
-  public get departDate(): NgbDateStruct {
-    return this._outDate;
-  }
-
-  public set departDate(value: NgbDateStruct) {
-    this._outDate = value;
-    this.outBoundDate = this.helpers.ngDateToMoment(
-      this._outDate,
-      this._outTime
-    );
-  }
-
-  public get departTime(): string {
-    return this._outTime;
-  }
-
-  public set departTime(value: string) {
-    this._outTime = value;
-    this.outBoundDate = this.helpers.ngDateToMoment(
-      this._outDate,
-      this._outTime
-    );
-  }
-
-  public get outBoundDate(): moment.Moment {
-    return this.tempParams.outBoundDate;
-  }
-
-  public set outBoundDate(value: moment.Moment) {
-    value = moment(value);
-    this.tempParams.outBoundDate = value.isValid() ? value : null;
-    this.minimumInBoundDate = {
-      year: value.year(),
-      month: value.month() + 1,
-      day: value.date()
-    };
-
-    if (
-      this.tempParams.outBoundDate &&
-      this.tempParams.inboundDate &&
-      this.tempParams.outBoundDate.isAfter(this.tempParams.inboundDate)
-    ) {
-      this.inboundDate = moment(this.tempParams.outBoundDate).add(1, 'day');
-    }
-    this._outDate = this.helpers.momentToNgDate(value);
-    this._outTime = this.helpers.formatTimeColon(value);
-    this._isValid();
-  }
-
-  public get returnDate(): NgbDateStruct {
-    return this._inDate;
-  }
-
-  public set returnDate(value: NgbDateStruct) {
-    this._inDate = value;
-    this.inboundDate = this.helpers.ngDateToMoment(this._inDate, this._inTime);
-  }
-
-  public get arriveTime(): string {
-    return this._inTime;
-  }
-
-  public set arriveTime(value: string) {
-    this._inTime = value;
-    this.inboundDate = this.helpers.ngDateToMoment(this._inDate, this._inTime);
-  }
-
-  public get inboundDate(): moment.Moment {
-    return this.tempParams.inboundDate;
-  }
-
-  public set inboundDate(value: moment.Moment) {
-    value = moment(value);
-    this.tempParams.inboundDate = value.isValid() ? value : null;
-    this._inDate = this.helpers.momentToNgDate(value);
-    this._inTime = this.helpers.formatTimeColon(value);
-    this._isValid();
-  }
-
-  public get arriveLocation(): string | OBTAirportDetails {
-    return this.tempParams.arriveLocation;
-  }
-
-  public set arriveLocation(value: string | OBTAirportDetails) {
-    this.tempParams.arriveLocation = value;
-    if (typeof value === 'string') {
-      this._destinationAirport = '';
-    } else if (value && value.gateway) {
-      this._destinationAirport = value.gateway;
-    } else {
-      this._destinationAirport = null;
-    }
-    this._isValid();
-  }
-
-  get cabinClass(): FlightCabinClass | null {
-    return this.tempParams.cabinClass;
-  }
-
-  set cabinClass(value: FlightCabinClass | null) {
-    this.tempParams.cabinClass = value;
-    this._isValid();
-  }
-
-  get returnCabinClass(): FlightCabinClass | null {
-    return this.tempParams.returnCabinClass;
-  }
-
-  set returnCabinClass(value: FlightCabinClass | null) {
-    this.tempParams.returnCabinClass = value;
-    this._isValid();
-  }
-
-  get chosenSearchType(): EurostarSearchType {
-    return this.tempParams.chosenSearchType;
-  }
-
-  set chosenSearchType(type: EurostarSearchType) {
-    this.tempParams.chosenSearchType = type;
-    this._isValid();
-  }
-
-  get isReturn(): boolean {
-    return this.tempParams.chosenSearchType === EurostarSearchType.return;
-  }
-
-  get outTimeCriteria(): TimeWindow {
-    return this.tempParams.outTimeCriteria;
-  }
-
-  set outTimeCriteria(value: TimeWindow) {
-    this.tempParams.outTimeCriteria = value;
-    this._isValid();
-  }
-
-  get inTimeCriteria(): TimeWindow {
-    return this.tempParams.inTimeCriteria;
-  }
-
-  set inTimeCriteria(value: TimeWindow) {
-    this.tempParams.inTimeCriteria = value;
-    this._isValid();
-  }
-  get maxConnections(): number {
-    return this.tempParams.maxConnections;
-  }
-
-  set maxConnections(value: number) {
-    this.tempParams.maxConnections = value;
-  }
-
-  private _multiDestination: DestinationEntry[] = [];
-  get multiDestination(): IMultiDestination[] {
-    return this.tempParams.multiDestination;
-  }
-
-  set multiDestination(valueArray: IMultiDestination[]) {
-    this.tempParams.multiDestination = valueArray;
-    this._isValid();
-  }
-
-  setMultiDestinationQuery(multiDestination: IMultiDestination[]) {
-    const newMultiDestination = this.helpers.clone(multiDestination);
-    return newMultiDestination.reduce(
-      (destinationArray: DestinationEntry[], item: IMultiDestination) => {
-        const destinationObject = {} as DestinationEntry;
-        destinationObject.orig = item.orig.gateway;
-        destinationObject.dest = item.dest.gateway;
-        destinationObject.date = this.helpers.formatIsoDate(item.date);
-        destinationArray.push(destinationObject);
-        return destinationArray;
-      },
-      [] as DestinationEntry[]
-    );
-  }
-
-  // get only
-  get sortDropdownValues(): SortTypeEurostar[] {
-    return this._sortArray;
-  }
-
-  get fareTypesValues(): ValueDisplay[] {
-    return this._fareTypeArray;
-  }
-
-  get fareType(): FareType {
-    return this.tempParams.fareType;
-  }
-
-  set fareType(value: FareType) {
-    this.tempParams.fareType = value;
-    this._isValid();
-  }
-
-  get negotiated(): boolean {
-    return this._negotiated;
-  }
-
-  set negotiated(value: boolean) {
-    this._negotiated = value;
-  }
-
-  get includeNearbyAirports(): boolean {
-    return this.tempParams.includeNearbyAirports;
-  }
-
-  set includeNearbyAirports(value: boolean) {
-    this.tempParams.includeNearbyAirports = value;
-  }
-  constructor(
-    private eurostarFetcher: BaseEurostarQuoteFetcher<SE_Q>,
-    private helpers: BaseHelperRoutines,
-    userService: UserServiceInterface,
-    private basketService: EnterpriseBasketServiceInterface,
-    storageService: BaseStorageService,
-    private searchService: EnterpriseSearchServiceInterface
-  ) {
-    super(
-      storageService,
-
-      (results1: EurostarQuoteResult): EurostarQuoteResultArray => {
-        this.resultQuery = this.getSearchQuery();
-        delete this.resultQuery.withGrouped;
-        if(results1 && this.searchService.isFlightsGrouped()){
-          const returndata = (results1.journeys || []).reduce(
-            (acc: EurostarResults, result: FlightItinerary): EurostarResults => {
-              if (result.outboundFlights.length) {
-                const euroResult = this.formatEurostarResults(
-                  result.outboundFlights,
-                  result.total
-                );
-                euroResult.co2PerPassenger = result.co2PerPassenger;
-                euroResult.co2PerItem = result.co2PerItem;
-                euroResult.sourceId = result.sourceId;
-                euroResult.total = result.total;
-                euroResult.duration = this.minToHour(result.outboundTotalDuration);
-                if (
-                  !acc.outbound.find(
-                    (item: EurostarItem) =>
-                      item.dateDeparture === euroResult.dateDeparture
-                  )
-                ) {
-                  acc.outbound.push(euroResult);
-                }
-              }
-
-              if (result.inboundFlights.length) {
-                const euroResult = this.formatEurostarResults(
-                  result.inboundFlights,
-                  result.total
-                );
-                euroResult.co2PerPassenger = result.co2PerPassenger;
-                euroResult.co2PerItem = result.co2PerItem;
-                euroResult.sourceId = result.sourceId;
-                euroResult.total = result.total;
-                euroResult.duration = this.minToHour(result.inboundTotalDuration);
-                if (
-                  !acc.inbound.find(
-                    (item: EurostarItem) =>
-                      item.dateDeparture === euroResult.dateDeparture
-                  )
-                ) {
-                  acc.inbound.push(euroResult);
-                }
-              }
-              return acc;
-            }, { outbound: [], inbound: [] } as EurostarResults);
-          return [returndata];
-        } else {
-          return results1 ? [results1] : [];
-        }
-
-      }
-    );
-
-    const data: {
-      tempParams: EurostarTempParams;
-      originalUserSearch: EurostarTempParams;
-    } = storageService.getSessionItem(
-      EurostarEnterpriseSearch.STORAGE_SESSION_PARAMS
-    ) || {
-        tempParams: {} as EurostarTempParams,
-        originalUserSearch: {} as EurostarTempParams
-      };
-    // data.tempParams.adults = 1;
-    // data.tempParams.cabinClass = [FlightCabinClass.Economy];
-    const query = searchService.makeEurostarQuery(data.tempParams);
-    this.updateTempParams(query);
-    this._originalUserSearch = data.originalUserSearch;
-    if (searchService.shouldAddTravellerSubscription()) {
-      searchService.travellerInformation.subscribe(
-        (travellers: Traveller[]) => {
-          this.travellers = travellers;
-          const splitTravellers = this.helpers.selectedTravellers(
-            travellers,
-            ServiceType.Eurostar
-          );
-          this.tempParams.adults = splitTravellers.adults.length;
-          this.tempParams.children = splitTravellers.children.length;
-          // this.tempParams.infants = splitTravellers.infants.length;
-
-          this.updateTravellers();
-          this._isValid();
-        }
-      );
-    }
-
-    userService.changeUser.subscribe((user: FullUserDetails) => {
-      this.timeCriteriaOptions.next([
-        TimeWindow.Anytime,
-        TimeWindow.Arrive,
-        TimeWindow.Depart
-      ]); // TODO update with any UFs
-      this.updateAvaliableClasses();
-    });
-
-    this.updateTravellers();
-    const results: EurostarSessionType = storageService.getSessionItem(
-      this.resultsSessionName
-    ) || {
-      results: [],
-      groupData: {},
-      grouped: [],
-      query: {} as SearchFlightsV2QueryVariables
-    };
-    this.fullResults = this.helpers.clone(results.results);
-    this.flightsToGroup = results.groupData || {};
-    this.resultQuery = results.query;
-    this.results.next(results.results || ([] as EurostarQuoteResultArray));
-    this._isValid();
-    this.negotiated =
-      this.tempParams.fareType === FareType.Negotiated ? true : false;
-  }
-  formatEurostarResults(
-    results: FlightJourney[],
-    total: FlightFareTotal
-  ): EurostarItem {
-    const returnObject: EurostarItem = {
-      dateArrival: null,
-      dateDeparture: null,
-      duration: null,
-      timeArrival: null,
-      timeDeparture: null,
-      co2PerItem: 0,
-      co2PerPassenger: 0,
-      sourceId: null,
-      total: null,
-      uid: null,
-
-      businessPremierFare: {
-        class: null,
-        fare: null,
-        isDisabled: true,
-        price: NaN,
-        currency: 'GBP'
-      },
-      standardFare: {
-        class: null,
-        fare: null,
-        isDisabled: true,
-        price: NaN,
-        currency: 'GBP'
-      },
-      standardPremierFare: {
-        class: null,
-        fare: null,
-        isDisabled: true,
-        price: NaN,
-        currency: 'GBP'
-      }
-    };
-    // returnObject.duration = results.outboundTotalDuration;
-    results.forEach((flight, index) => {
-      returnObject.dateArrival = flight.dateTimeArriving;
-      returnObject.dateDeparture = flight.dateTimeDeparting;
-      returnObject.duration = this.minToHour(flight.totalDuration);
-      returnObject.timeArrival = moment(flight.dateTimeArriving).format(
-        'HH:mm'
-      );
-      returnObject.timeDeparture = moment(flight.dateTimeDeparting).format(
-        'HH:mm'
-      );
-      returnObject.uid = index;
-      switch (flight.fareInfo.title) {
-        case EurostarClassEnum.STANDARD:
-          returnObject.standardFare.isDisabled = false;
-          returnObject.standardFare.fare = flight;
-          returnObject.standardFare.price = total.price;
-          returnObject.standardFare.currency = total.currency;
-          returnObject.standardFare.class = flight.cabinClass;
-          break;
-        case EurostarClassEnum.STANDARD_PREMIER:
-          returnObject.standardPremierFare.isDisabled = false;
-          returnObject.standardPremierFare.fare = flight;
-          returnObject.standardPremierFare.price = total.price;
-          returnObject.standardPremierFare.currency = total.currency;
-          returnObject.standardPremierFare.class = flight.cabinClass;
-          break;
-        case EurostarClassEnum.BUSINESS_PREMIER:
-          returnObject.businessPremierFare.isDisabled = false;
-          returnObject.businessPremierFare.fare = flight;
-          returnObject.businessPremierFare.price = total.price;
-          returnObject.businessPremierFare.currency = total.currency;
-          returnObject.businessPremierFare.class = flight.cabinClass;
-          break;
-        default:
-          console.log('new class to be implemented: ', flight.fareInfo.title);
-      }
-    });
-    return returnObject;
-  }
-
-  protected resetQuery(checkIsValid: boolean = true): void {
-    this.updateTempParams(this.searchService.makeEurostarQuery());
-    if (checkIsValid) {
-      this._isValid();
-    }
-  }
-
-  public resetParams(): void {
-    this.reset();
-    this.resetQuery();
-  }
-
-  private _isValid() {
-    if (!this.doChecks) {
-      return;
-    }
-    this.storageService.setSessionItem(
-      EurostarEnterpriseSearch.STORAGE_SESSION_PARAMS,
-      {
-        tempParams: this.tempParams,
-        originalUserSearch: this.originalUserSearch
-      }
-    );
-
-    this.validationMessages = [];
-    if (!this._originAirport) {
-      this.validationMessages.push('Please add in a departutre location');
-    }
-    if (!this._destinationAirport) {
-      this.validationMessages.push('Please add in a arrival destination');
-    }
-    if (!this.tempParams.outBoundDate.isAfter(moment())) {
-      this.validationMessages.push('Departure date can not be in the past');
-    }
-
-    if (
-      this._originAirport &&
-      this._destinationAirport &&
-      this._destinationAirport === this._originAirport
-    ) {
-      this.validationMessages.push(
-        'Origin and destination station cannot be the same'
-      );
-    }
-    if (this.isReturn) {
-      // TODO check that return details are set
-      if (
-        this.tempParams.outBoundDate.isSameOrAfter(
-          this.tempParams.inTimeCriteria
-        )
-      ) {
-        this.validationMessages.push(
-          'Return date must be after the departure date'
-        );
-      }
-    }
-    this.isValid.next(this.validationMessages.length === 0);
-    this.messages.next(this.validationMessages);
-  }
-
-  startSearch(): Promise<boolean> {
-    this.results.next([]);
-    this._isValid();
-
-    if (this.isValid.value) {
-      this._originalUserSearch = Object.freeze({ ...this.tempParams });
-      this.storageService.setSessionItem(
-        EurostarEnterpriseSearch.STORAGE_SESSION_PARAMS,
-        {
-          tempParams: this.tempParams,
-          originalUserSearch: this.originalUserSearch
-        }
-      );
-      return this._startSearch(
-        this.eurostarFetcher.fetchList(this.getSearchQuery())
-      );
-    } else {
-      return Promise.resolve(false);
-    }
-  }
-
-  public startRecentSearch(recentSearch: RecentSearch): void { }
-
-  private makeDepartureTimeWindow(
-    dateTime: moment.Moment,
-    window: TimeWindow
-  ): string {
-    return window === TimeWindow.Depart
-      ? this.helpers.makeTimeWindow(dateTime, -2, 2)
-      : null;
-  }
-
-  private makeArrivalTimeWindow(
-    dateTime: moment.Moment,
-    window: TimeWindow
-  ): string {
-    if (window !== TimeWindow.Arrive) {
-      return null;
-    }
-
-    return this.helpers.makeTimeWindow(dateTime, -2, 2);
-  }
-
-  getSearchQuery(): SearchFlightsV2QueryVariables {
-    return this.helpers.removeNulls<SearchFlightsV2QueryVariables>(
-      Object.assign(
-        {},
-        {
-          originAirport: this._originAirport,
-          destinationAirport: this._destinationAirport,
-          outboundDate: this.helpers.formatIsoDate(
-            this.tempParams.outBoundDate
-          ),
-          outboundDepartureTimeWindow: this.makeDepartureTimeWindow(
-            this.tempParams.outBoundDate,
-            this.tempParams.outTimeCriteria
-          ),
-          outboundArrivalTimeWindow: this.makeArrivalTimeWindow(
-            this.tempParams.outBoundDate,
-            this.tempParams.outTimeCriteria
-          )
-        },
-        {
-          passengers: this._passengers,
-          returnTrip: this.isReturn,
-          outboundCabinClass: this.tempParams.cabinClass
-            ? [this.tempParams.cabinClass]
-            : null,
-          requireFreeBag: null,
-          maxConnections: this.tempParams.maxConnections,
-          includeNearbyAirports: this.tempParams.includeNearbyAirports,
-          preferredCarriers: this.tempParams.preferredCarriers.map(
-            (carrier: OBTAirlinesDetails) =>
-              carrier?.code ? carrier.code : null
-          ),
-          fareType: this.tempParams.fareType,
-          withGrouped: null
-        },
-        this.isReturn
-          ? {
-            returnDate: this.helpers.formatIsoDate(
-              this.tempParams.inboundDate
-            ),
-            returnDepartureTimeWindow: this.makeDepartureTimeWindow(
-              this.tempParams.inboundDate,
-              this.tempParams.inTimeCriteria
-            ),
-            returnArrivalTimeWindow: this.makeArrivalTimeWindow(
-              this.tempParams.inboundDate,
-              this.tempParams.inTimeCriteria
-            ),
-            returnCabinClass: this.tempParams.returnCabinClass
-              ? [this.tempParams.returnCabinClass]
-              : null
-          }
-          : {}
-      )
-    );
-  }
-
-  private updateTravellers() {
-    const travellers: FlightPassengerObject[] = [];
-    for (let loop = 0; loop < this.tempParams.adults; loop += 1) {
-      travellers.push({ type: FlightPassengerType.Adult });
-    }
-    for (let loop = 0; loop < this.tempParams.children; loop += 1) {
-      travellers.push({ type: FlightPassengerType.Child });
-    }
-
-    this._passengers = travellers;
-    this._isValid();
-  }
-
-  private updateAvaliableClasses() {
-    this.avaliableClasses.next([
-      {
-        name: 'Any',
-        type: EurostarClassEnum.ANY
-      },
-      {
-        name: 'Standard (semi flexible)',
-        type: EurostarClassEnum.STANDARD
-      },
-      {
-        name: 'Standard premier (semi flexible)',
-        type: EurostarClassEnum.STANDARD_PREMIER
-      },
-      {
-        name: 'Business premier (fully flexible)',
-        type: EurostarClassEnum.BUSINESS_PREMIER
-      }
-    ]);
-  }
-
-  /**
-   * @description - sort the flight results
-   * @todo - Fill out Preferred and Co2 sorting when we have that data
-   */
-  public sortResults(
-    sortMethodValue: SortTypesEurostar,
-    givenResults?: EurostarResults[]
-  ): void {
-    let results = this.helpers.clone(
-      givenResults
-        ? givenResults
-        : <EurostarResults[]>(<unknown>this.fullResults)
-    );
-
-    switch (sortMethodValue) {
-      case SortTypesEurostar.CheapestFirst:
-        results = this.sortByPrice(results);
-        break;
-      case SortTypesEurostar.EarliestFirst:
-        results = this.sortByDate(results);
-        break;
-      default:
-        console.error(`+++ Unknown sorting method: ${sortMethodValue} +++`);
-    }
-
-    this.results.next(results);
-  }
-
-  /**
-   * Sort results by departure time
-   *
-   * @param {EurostarResults[]} results
-   * @returns
-   * @memberof EurostarInfo
-   */
-  sortByDate(results: EurostarResults[]): EurostarResults[] {
-    const byDate = (a: EurostarItem, b: EurostarItem) => {
-      return (
-        moment(a.timeDeparture, 'HH:mm').unix() -
-        moment(b.timeDeparture, 'HH:mm').unix()
-      );
-    };
-
-    const sortedResults = {
-      outbound: results[0].outbound.sort(byDate),
-      inbound: results[0].inbound.sort(byDate)
-    };
-    return [sortedResults];
-  }
-
-  /**
-   * Sort results by price
-   *
-   * @param {EurostarResults[]} results
-   * @returns
-   * @memberof EurostarInfo
-   */
-  sortByPrice(results: EurostarResults[], dir?: boolean): EurostarResults[] {
-    const byPrice = (a: EurostarItem, b: EurostarItem) => {
-      const aPrice =
-        +a.standardFare.price ||
-        +a.standardPremierFare.price ||
-        +a.businessPremierFare.price;
-      const bPrice =
-        +b.standardFare.price ||
-        +b.standardPremierFare.price ||
-        +b.businessPremierFare.price;
-      if (dir) {
-        return bPrice - aPrice;
-      }
-      return aPrice - bPrice;
-    };
-
-    const sortedResults = {
-      outbound: results[0].outbound.sort(byPrice),
-      inbound: results[0].inbound.sort(byPrice)
-    };
-    return [sortedResults];
-  }
-
-  updateFromPreviousSearches(
-    previousItems: Record<ServiceType, BasketItem>
-  ): void {
-    const flightItem: SearchFlightsV2QueryVariables =
-      previousItems[ServiceType.Flight]?.searchQuery;
-    if (flightItem) {
-      // TODO flights haven't been done yet.
-    }
-  }
-
-  getTotalBaggage(result: FlightItinerary): number {
-    let total = 0;
-
-    const parsedAdditional = JSON.parse(result.additional);
-    if (parsedAdditional && parsedAdditional.outboundFlights) {
-      parsedAdditional.outboundFlights.forEach((flight: any) => {
-        flight.baggage.forEach((bag: any) => {
-          if (bag.allowance && bag.allowance > total) {
-            total = bag.allowance;
-          }
-        });
-      });
-    } else if (parsedAdditional && parsedAdditional.baggageAllowance) {
-      parsedAdditional.baggageAllowance.forEach((baggageAllow: any) => {
-        if (
-          baggageAllow.baggage.qty &&
-          Number(baggageAllow.baggage.qty) > total
-        ) {
-          total = Number(baggageAllow.baggage.qty);
-        }
-      });
-    }
-
-    return total;
-  }
-
-  /**
-   * @description - give the correct format for transfering minuetes on the sliders
-   * @param min - the min in 100th's to transform onto 60th's
-   */
-  transformMin(min: number): string {
-    let num = (Number(min) * 60) / 100;
-    // console.log('+++ Num Copy: ', _.clone(num), ' +++');
-    if (num % 1 < 0.5) {
-      num = Math.floor(num);
-    } else {
-      num = Math.ceil(num);
-    }
-
-    return num.toString().padStart(2, '0');
-  }
-
-  filterByDuration(
-    minDuration: number,
-    maxDuration: number,
-    results: FlightItinerary[],
-    isReturn = false
-  ): FlightItinerary[] {
-    results = results.filter((result) => {
-      let dur = 0;
-      if (!isReturn) {
-        result.outboundFlights.forEach((out: FlightJourney) => {
-          dur += out.totalDuration;
-        });
-      }
-
-      if (result.inboundFlights?.length && isReturn) {
-        result.inboundFlights.forEach((inb: FlightJourney) => {
-          dur += inb.totalDuration;
-        });
-      }
-
-      return dur >= minDuration && dur <= maxDuration;
-    });
-
-    return results;
-  }
-
-  filterByDepartureTime(
-    minDep: number,
-    maxDep: number,
-    results: FlightItinerary[]
-  ): FlightItinerary[] {
-    results = results.filter((result) => {
-      const departureTime = Number(
-        moment(result.outboundFlights[0].dateTimeDeparting).format('HHmm')
-      );
-      const newNumString1 = Number(
-        Math.floor(Number(minDep / 100)).toString() +
-        this.transformMin(Math.ceil(Number(minDep % 100)))
-      );
-      const newNumString2 = Number(
-        Math.floor(Number(maxDep / 100)).toString() +
-        this.transformMin(Math.ceil(Number(maxDep % 100)))
-      );
-
-      return departureTime >= newNumString1 && departureTime <= newNumString2;
-    });
-
-    return results;
-  }
-
-  filterByReturnDepartureTime(
-    minDep: number,
-    maxDep: number,
-    results: FlightItinerary[]
-  ): FlightItinerary[] {
-    if (!minDep && !maxDep) {
-      return results;
-    }
-
-    const newNumString1 = Number(
-      Math.floor(Number(minDep / 100)).toString() +
-      this.transformMin(Math.ceil(Number(minDep % 100)))
-    );
-    const newNumString2 = Number(
-      Math.floor(Number(maxDep / 100)).toString() +
-      this.transformMin(Math.ceil(Number(maxDep % 100)))
-    );
-
-    results = results.filter((result) => {
-      if (!result.inboundFlights || !result.inboundFlights[0]) {
-        return true;
-      }
-
-      const departureTime = Number(
-        moment(result.inboundFlights[0].dateTimeDeparting).format('HHmm')
-      );
-      return departureTime >= newNumString1 && departureTime <= newNumString2;
-    });
-
-    return results;
-  }
-
-  filterByReturnArrivalTime(
-    minArr: number,
-    maxArr: number,
-    results: FlightItinerary[]
-  ): FlightItinerary[] {
-    if (!minArr && !maxArr) {
-      return results;
-    }
-
-    const newNumString1 = Number(
-      Math.floor(Number(minArr / 100)).toString() +
-      this.transformMin(Math.ceil(Number(minArr % 100)))
-    );
-    const newNumString2 = Number(
-      Math.floor(Number(maxArr / 100)).toString() +
-      this.transformMin(Math.ceil(Number(maxArr % 100)))
-    );
-
-    results = results.filter((result) => {
-      if (!result.inboundFlights || !result.inboundFlights[0]) {
-        return true;
-      }
-
-      const arrivalTime = Number(
-        moment(
-          result.inboundFlights[result.inboundFlights.length - 1]
-            .dateTimeArriving
-        ).format('HHmm')
-      );
-      const retVal =
-        arrivalTime >= newNumString1 && arrivalTime <= newNumString2;
-
-      // for debugging
-      // if (!retVal) {
-      //   console.warn(`+++ Filtering Out: ${arrivalTime} +++`);
-      // }
-
-      return retVal;
-    });
-
-    return results;
-  }
-
-  filterByArrivalTime(
-    minArr: number,
-    maxArr: number,
-    results: FlightItinerary[]
-  ): FlightItinerary[] {
-    const newNumString1 = Number(
-      Math.floor(Number(minArr / 100)).toString() +
-      this.transformMin(Math.ceil(Number(minArr % 100)))
-    );
-    const newNumString2 = Number(
-      Math.floor(Number(maxArr / 100)).toString() +
-      this.transformMin(Math.ceil(Number(maxArr % 100)))
-    );
-
-    results = results.filter((result) => {
-      const arrivalTime = Number(
-        moment(
-          result.outboundFlights[result.outboundFlights.length - 1]
-            .dateTimeArriving
-        ).format('HHmm')
-      );
-
-      return arrivalTime >= newNumString1 && arrivalTime <= newNumString2;
-    });
-
-    return results;
-  }
-
-  filterByBaggage(
-    baggageFilters: SelectFilter[],
-    results: FlightItinerary[]
-  ): FlightItinerary[] {
-    const selected = baggageFilters.filter((x) => x.selected);
-
-    if (selected?.length >= 1 && selected.length !== baggageFilters.length) {
-      results = results.filter((result) => {
-        try {
-          const totalBags = this.getTotalBaggage(result);
-
-          return selected.find((x) => x.value === totalBags);
-        } catch (error) {
-          console.error('+++ Error determening baggage: ${error} +++');
-          return false;
-        }
-      });
-    }
-
-    return results;
-  }
-
-  filterByPrice(
-    minPrice: number,
-    maxPrice: number,
-    results: FlightItinerary[]
-  ): FlightItinerary[] {
-    results = results.filter((result) => {
-      // console.log(`+++ Price: ${result.total.price} is between: ${minPrice} and ${maxPrice}: ${result.total.price >= minPrice && result.total.price <= maxPrice} +++`)
-
-      return result.total.price >= minPrice && result.total.price <= maxPrice;
-    });
-
-    return results;
-  }
-
-  /**
-   * @description - filter the results by the number of stops
-   * @param stopFilters - the selected stops
-   * @param fullResults - all of our results so far
-   */
-  filterResultsByStops(
-    stopFilters: SelectFilter[],
-    fullResults: FlightItinerary[]
-  ): FlightItinerary[] {
-    const selected = stopFilters.filter((x) => x.selected);
-
-    if (selected?.length >= 1 && selected.length !== stopFilters.length) {
-      fullResults = fullResults.filter((result) => {
-        const totalStops = result.outboundFlights.length - 1;
-
-        const haveStop = selected.find(
-          (selected1: SelectFilter) => selected1.value === totalStops
-        );
-
-        return haveStop;
-      });
-    }
-
-    return fullResults;
-  }
-
-  filterResultsByAirline(
-    airlineFilters: SelectFilter[],
-    results: FlightItinerary[]
-  ): FlightItinerary[] {
-    const selected = airlineFilters.filter((x) => x.selected);
-
-    if (selected?.length >= 1 && selected.length !== airlineFilters.length) {
-      results = results.filter((result) => {
-        return selected.find(
-          (x) => x.value === result.outboundFlights[0].operatingCarrier
-        );
-      });
-    }
-
-    return results;
-  }
-
-  filterResultsByClass(
-    classFilters: SelectFilter[],
-    results: FlightItinerary[]
-  ): FlightItinerary[] {
-    const selected = classFilters.filter((x) => x.selected);
-
-    if (selected?.length >= 1 && selected.length !== classFilters.length) {
-      results = results.filter((result) => {
-        return selected.find(
-          (x) => x.value === result.outboundFlights[0].cabinClass
-        );
-      });
-    }
-
-    return results;
-  }
-
-  filterByDepartureAirport(
-    departureAirports: SelectFilter[],
-    results: FlightItinerary[]
-  ): FlightItinerary[] {
-    const selected = departureAirports.filter((x) => x.selected);
-
-    if (selected?.length >= 1 && selected.length !== departureAirports.length) {
-      results = results.filter((result) => {
-        return selected.find(
-          (x) => x.value === result.outboundFlights[0].originAirport
-        );
-      });
-    }
-
-    return results;
-  }
-
-  filterByArrivalAirport(
-    arrivalAirports: SelectFilter[],
-    results: FlightItinerary[]
-  ): FlightItinerary[] {
-    const selected = arrivalAirports.filter((x) => x.selected);
-
-    if (selected?.length >= 1 && selected.length !== arrivalAirports.length) {
-      results = results.filter((result) => {
-        const destinationAirport =
-          result.outboundFlights[result.outboundFlights.length - 1]
-            .destinationAirport;
-        return selected.find((x) => x.value === destinationAirport);
-      });
-    }
-
-    return results;
-  }
-
-  filterByDepartureReturnAirport(
-    departureAirports: SelectFilter[],
-    results: FlightItinerary[]
-  ): FlightItinerary[] {
-    const selected = departureAirports.filter((x) => x.selected);
-
-    if (selected?.length >= 1 && selected.length !== departureAirports.length) {
-      results = results.filter((result) => {
-        if (!result.inboundFlights?.length) {
-          return true;
-        }
-
-        return selected.find(
-          (x) => x.value === result.inboundFlights[0].originAirport
-        );
-      });
-    }
-
-    return results;
-  }
-
-  filterByArrivalReturnAirport(
-    arrivalAirports: SelectFilter[],
-    results: FlightItinerary[]
-  ): FlightItinerary[] {
-    const selected = arrivalAirports.filter((x) => x.selected);
-
-    if (selected?.length >= 1 && selected.length !== arrivalAirports.length) {
-      results = results.filter((result) => {
-        if (!result.inboundFlights?.length) {
-          return true;
-        }
-
-        const destinationAirport =
-          result.inboundFlights[result.inboundFlights.length - 1]
-            .destinationAirport;
-        return selected.find((x) => x.value === destinationAirport);
-      });
-    }
-
-    return results;
-  }
-
-  createFilters(results: FlightItinerary[] = []): FlightFilters {
-    const minPrice = this.getMinPrice(results);
-    const maxPrice = this.getMaxPrice(results);
-
-    const newFilters: FlightFilters = {
-      stops: this.getAllStops(results),
-      mustInclude: [],
-      classes: this.getAllClasses(results),
-      airlines: this.getAllAirlines(results),
-      travelPolicy: [],
-      depatureAirport: this.getAllDepartureAirports(results),
-      arrivalAirport: this.getAllArrivalAirports(results),
-      minPrice,
-      maxPrice,
-      depatureReturnAirport: this.getAllDepartureAirports(results, true),
-      arrivalReturnAirport: this.getAllArrivalAirports(results, true),
-      baggage: this.getBaggage(results),
-      fareTypes: [],
-      minDuration: this.getMinDuration(results),
-      maxDuration: this.getMaxDuration(results),
-      minReturnDuration: this.getMinDuration(results, true),
-      maxReturnDuration: this.getMaxDuration(results, true),
-      minDepartureTime: this.getMinDepartureTime(results),
-      maxDepartureTime: this.getMaxDepartureTime(results),
-      minArrivalTime: this.getMinArrivalTime(results),
-      maxArrivalTime: this.getMaxArrivalTime(results),
-      minReturnDepartureTime: this.getMinReturnDepartureTime(results),
-      maxReturnDepartureTime: this.getMaxReturnDepartureTime(results),
-      maxReturnArrivalTime: this.getMaxReturnArrivalTime(results),
-      minReturnArrivalTime: this.getMinReturnArrivalTime(results),
-      flightNumber: ''
-    };
-
-    return newFilters;
-  }
-
-  getMinDuration(results: FlightItinerary[], isReturn = false): number {
-    let min = 0;
-
-    results.forEach((result) => {
-      let dur = 0;
-
-      if (!isReturn) {
-        result.outboundFlights.forEach((out: FlightJourney) => {
-          dur += out.totalDuration;
-        });
-      }
-
-      if (result.inboundFlights?.length && isReturn) {
-        result.inboundFlights.forEach((inb: FlightJourney) => {
-          dur += inb.totalDuration;
-        });
-      }
-
-      if (!min || dur < min) {
-        min = dur;
-      }
-    });
-
-    return min;
-  }
-
-  getMaxDuration(results: FlightItinerary[], isReturn = false): number {
-    let max = 0;
-
-    results.forEach((result) => {
-      let dur = 0;
-      if (!isReturn) {
-        result.outboundFlights.forEach((out: FlightJourney) => {
-          dur += out.totalDuration;
-        });
-      }
-
-      if (result.inboundFlights?.length && isReturn) {
-        result.inboundFlights.forEach((inb: FlightJourney) => {
-          dur += inb.totalDuration;
-        });
-      }
-
-      if (!max || dur > max) {
-        max = dur;
-      }
-    });
-
-    return max;
-  }
-
-  getMinArrivalTime(results: FlightItinerary[]): number {
-    let min: number;
-
-    results.forEach((result) => {
-      let minDepTime = Number(
-        moment(
-          result.outboundFlights[result.outboundFlights.length - 1]
-            .dateTimeArriving
-        ).format('HHmm')
-      );
-      minDepTime = Math.floor(minDepTime / 100) * 100;
-      if (!min || minDepTime < min) {
-        min = minDepTime;
-      }
-    });
-
-    return min;
-  }
-
-  getMinReturnArrivalTime(results: FlightItinerary[]): number {
-    let min: number;
-
-    results.forEach((result) => {
-      if (result.inboundFlights && result.inboundFlights.length) {
-        let minDepTime = Number(
-          moment(
-            result.inboundFlights[result.inboundFlights.length - 1]
-              .dateTimeArriving
-          ).format('HHmm')
-        );
-        minDepTime = Math.floor(minDepTime / 100) * 100;
-        if (!min || minDepTime < min) {
-          min = minDepTime;
-        }
-      }
-    });
-
-    return min;
-  }
-
-  getMaxReturnArrivalTime(results: FlightItinerary[]): number {
-    let max: number;
-
-    results.forEach((result) => {
-      if (result.inboundFlights && result.inboundFlights.length) {
-        let maxDepTime = Number(
-          moment(
-            result.inboundFlights[result.inboundFlights.length - 1]
-              .dateTimeArriving
-          ).format('HHmm')
-        );
-        maxDepTime = Math.ceil(maxDepTime / 100) * 100;
-        if (!max || maxDepTime > max) {
-          max = maxDepTime;
-        }
-      }
-    });
-
-    return max;
-  }
-
-  getMaxArrivalTime(results: FlightItinerary[]): number {
-    let max: number;
-
-    results.forEach((result) => {
-      let maxDepTime = Number(
-        moment(
-          result.outboundFlights[result.outboundFlights.length - 1]
-            .dateTimeArriving
-        ).format('HHmm')
-      );
-
-      maxDepTime = Math.ceil(maxDepTime / 100) * 100;
-      if (!max || maxDepTime > max) {
-        max = maxDepTime;
-      }
-    });
-    return max;
-  }
-
-  getMinDepartureTime(results: FlightItinerary[]): number {
-    let min: number;
-
-    results.forEach((result) => {
-      let minDepTime = Number(
-        moment(result.outboundFlights[0].dateTimeDeparting).format('HHmm')
-      );
-      minDepTime = Math.floor(minDepTime / 100) * 100;
-      if (!min || minDepTime < min) {
-        min = minDepTime;
-      }
-    });
-
-    return min;
-  }
-
-  getMinReturnDepartureTime(results: FlightItinerary[]): number {
-    let min: number;
-
-    results.forEach((result) => {
-      if (result.inboundFlights && result.inboundFlights[0]) {
-        let minDepTime = Number(
-          moment(result.inboundFlights[0].dateTimeDeparting).format('HHmm')
-        );
-        minDepTime = Math.floor(minDepTime / 100) * 100;
-        if (!min || minDepTime < min) {
-          min = minDepTime;
-        }
-      }
-    });
-
-    return min;
-  }
-
-  getMaxReturnDepartureTime(results: FlightItinerary[]): number {
-    let max: number;
-
-    results.forEach((result) => {
-      if (result.inboundFlights && result.inboundFlights[0]) {
-        let maxDepTime = Number(
-          moment(result.inboundFlights[0].dateTimeDeparting).format('HHmm')
-        );
-
-        maxDepTime = Math.ceil(maxDepTime / 100) * 100;
-
-        if (!max || maxDepTime > max) {
-          max = maxDepTime;
-        }
-      }
-    });
-
-    return max;
-  }
-
-  getMaxDepartureTime(results: FlightItinerary[]): number {
-    let max: number;
-
-    results.forEach((result) => {
-      let maxDepTime = Number(
-        moment(result.outboundFlights[0].dateTimeDeparting).format('HHmm')
-      );
-
-      maxDepTime = Math.ceil(maxDepTime / 100) * 100;
-
-      if (!max || maxDepTime > max) {
-        max = maxDepTime;
-      }
-    });
-
-    return max;
-  }
-
-  getBaggage(results: FlightItinerary[]): SelectFilter[] {
-    const baggage: any = {};
-
-    results.forEach((result) => {
-      try {
-        const parsedAdditional = JSON.parse(result.additional);
-
-        let total = 0;
-
-        if (parsedAdditional && parsedAdditional.outboundFlights) {
-          parsedAdditional.outboundFlights.forEach((flight: any) => {
-            flight.baggage.forEach((bag: any) => {
-              if (bag.allowance && bag.allowance > total) {
-                total = bag.allowance;
-              }
-            });
-          });
-        } else if (parsedAdditional && parsedAdditional.baggageAllowance) {
-          parsedAdditional.baggageAllowance.forEach((baggageAllow: any) => {
-            if (
-              baggageAllow.baggage.qty &&
-              Number(baggageAllow.baggage.qty) > total
-            ) {
-              total = Number(baggageAllow.baggage.qty);
-            }
-          });
-        }
-
-        baggage[total] = {
-          selected: false,
-          value: total,
-          display: `${total} bag${total !== 1 ? 's' : ''}`
-        };
-      } catch (error) {
-        console.error(`+++ Error parsing additional flight data: ${error} +++`);
-      }
-    });
-
-    return Object.values(baggage);
-  }
-
-  getMinPrice(results: FlightItinerary[]): number {
-    let minPrice: number;
-
-    results.forEach((result) => {
-      if (!minPrice || result.total.price < minPrice) {
-        minPrice = result.total.price;
-      }
-    });
-
-    return minPrice;
-  }
-
-  getMaxPrice(results: FlightItinerary[]): number {
-    let maxPrice: any;
-
-    results.forEach((result) => {
-      if (!maxPrice || result.total.price > maxPrice) {
-        maxPrice = result.total.price;
-      }
-    });
-
-    return maxPrice;
-  }
-
-  getAllStops(results: FlightItinerary[]): SelectFilter[] {
-    const allStops: any = {};
-
-    results.forEach((result) => {
-      const totalStops = result.outboundFlights.length - 1; // might have to recalculate this
-      allStops[totalStops] = {
-        value: totalStops,
-        display: `${totalStops} stop` + (totalStops !== 1 ? 's' : ''),
-        selected: false
-      };
-    });
-
-    return Object.values(allStops);
-  }
-
-  getAllClasses(results: FlightItinerary[]): SelectFilter[] {
-    const allClasses: any = [];
-
-    results.forEach((result) => {
-      result.outboundFlights.forEach((outFlight: FlightJourney) => {
-        allClasses[outFlight.cabinClass] = {
-          value: outFlight.cabinClass,
-          display: outFlight.cabinClass,
-          selected: false
-        } as SelectFilter;
-      });
-
-      if (result.inboundFlights) {
-        result.inboundFlights.forEach((inFlight: FlightJourney) => {
-          allClasses[inFlight.cabinClass] = {
-            value: inFlight.cabinClass,
-            display: inFlight.cabinClass,
-            selected: false
-          } as SelectFilter;
-        });
-      }
-    });
-
-    return Object.values(allClasses);
-  }
-
-  /**
-   * @description - create select filters for all unique departure airports returned in the search
-   * @param results - the flight results
-   */
-  getAllDepartureAirports(
-    results: FlightItinerary[],
-    inbound = false
-  ): SelectFilter[] {
-    const allAirports: any = {};
-
-    results.forEach((result) => {
-      if (result.outboundFlights.length && !inbound) {
-        allAirports[result.outboundFlights[0].originAirport] = {
-          value: result.outboundFlights[0].originAirport,
-          display: result.outboundFlights[0].originAirportName,
-          selected: false
-        };
-      }
-
-      if (result.inboundFlights?.length && inbound) {
-        allAirports[result.inboundFlights[0].originAirport] = {
-          value: result.inboundFlights[0].originAirport,
-          display: result.inboundFlights[0].originAirportName,
-          selected: false
-        };
-      }
-    });
-
-    return Object.values(allAirports);
-  }
-
-  /**
-   * @description - create select filters for all unique departure airports returned in the search
-   * @param results - the flight results
-   */
-  getAllArrivalAirports(
-    results: FlightItinerary[],
-    inbound = false
-  ): SelectFilter[] {
-    const allAirports: any = {};
-
-    results.forEach((result) => {
-      if (result.outboundFlights.length && !inbound) {
-        allAirports[
-          result.outboundFlights[
-            result.outboundFlights.length - 1
-          ].destinationAirport
-        ] = {
-          value:
-            result.outboundFlights[result.outboundFlights.length - 1]
-              .destinationAirport,
-          display:
-            result.outboundFlights[result.outboundFlights.length - 1]
-              .destinationAirportName,
-          selected: false
-        };
-      }
-
-      if (result.inboundFlights?.length && inbound) {
-        allAirports[
-          result.inboundFlights[
-            result.inboundFlights.length - 1
-          ].destinationAirport
-        ] = {
-          value:
-            result.inboundFlights[result.inboundFlights.length - 1]
-              .destinationAirport,
-          display:
-            result.inboundFlights[result.inboundFlights.length - 1]
-              .destinationAirportName,
-          selected: false
-        };
-      }
-    });
-
-    return Object.values(allAirports);
-  }
-
-  /**
-   * @description - create select filters for all unique airlines returned in the search
-   * @param results - the flight results
-   */
-  getAllAirlines(results: FlightItinerary[]): SelectFilter[] {
-    const allAirlines: any = {};
-
-    results.forEach((result: FlightItinerary) => {
-      result.outboundFlights.forEach((outFlight: FlightJourney) => {
-        allAirlines[outFlight.operatingCarrier] = {
-          value: outFlight.operatingCarrier,
-          display: outFlight.operatingCarrierName,
-          selected: false
-        } as SelectFilter;
-      });
-
-      if (result.inboundFlights) {
-        result.inboundFlights.forEach((inFlight: FlightJourney) => {
-          allAirlines[inFlight.operatingCarrier] = {
-            value: inFlight.operatingCarrier,
-            display: inFlight.operatingCarrierName,
-            selected: false
-          } as SelectFilter;
-        });
-      }
-    });
-
-    return Object.values(allAirlines);
-  }
-
-  async selectGroupedEurostar(
-    selectedEurostar: EurostarItem,
-    fare: EurostarFare,
-    direction: FlightDirectionEnum
-  ) {
-    const intBasket: InternalBasketInterface =
-      await this.basketService.getDefaultBasket();
-    const basket = intBasket?.subject.value;
-
-    if (
-      basket &&
-      this.originalUserSearch.chosenSearchType === EurostarSearchType.oneWay &&
-      direction === FlightDirectionEnum.Outbound
-    ) {
-      this.doBooking(
-        intBasket,
-        selectedEurostar,
-        {
-          outboundFlights:
-            [this.makeSchemaFlights(fare.fare, 'outbound', 0)],
-          inboundFlights: [],
-          journeyType: 'single'
-        },
-        selectedEurostar.dateDeparture
-      );
-      return;
-    }
-    if (
-      basket &&
-      this.originalUserSearch.chosenSearchType === EurostarSearchType.return &&
-      direction === FlightDirectionEnum.Outbound
-    ) {
-      this.selectedGroupEurostar = selectedEurostar;
-      this.selectedEurostarFare = fare;
-      const index = selectedEurostar.uid;
-
-      this.results.next(
-        (this.fullResults as EurostarResults[]).map((result:EurostarResults) => {
-          const outbound = result.outbound.filter((item:EurostarItem, groupIndex) => index === groupIndex);
-          return { inbound: result.inbound, outbound }
-        })
-      );
-    }
-    if (
-      basket &&
-      this.originalUserSearch.chosenSearchType === EurostarSearchType.return &&
-      direction === FlightDirectionEnum.Inbound &&
-      this.selectedGroupEurostar
-    ) {
-      this.doBooking(
-        intBasket,
-        selectedEurostar,
-        {
-          outboundFlights: [
-            this.makeSchemaFlights(this.selectedEurostarFare.fare, 'outbound', 0)
-          ],
-          inboundFlights: [
-            this.makeSchemaFlights(fare.fare, 'inbound', 0)
-
-          ],
-          journeyType: 'roundtrip'
-        },
-        selectedEurostar.dateDeparture,
-        this.selectedGroupEurostar.dateArrival
-      );
-      this.results.next(this.fullResults);
-    }
-  }
-  updateLowestPrice(results: EurostarResults[]): ICheapestPrice {
-    return null;
-    // add in once filght result is updated///
-    // const results = this.storageService.getSessionItemAsList<FlightQuoteResultArray>(this.resultsSessionName) || [] as FlightQuoteResultArray;
-    // if(!results.length) return;
-    // this._cheapestResultPrice.currencyCode = results[0].total.currency;
-    // results.map(result => {
-    //   const price = result.total.price;
-    //   if( this._cheapestResultPrice.amount > price ||  this._cheapestResultPrice.amount === null){
-    //     this._cheapestResultPrice.amount = price;
-    //   }
-    // })
-  }
-
-  doBooking(
-    intBasket: InternalBasketInterface,
-    selectedFlight: EurostarItem,
-    schemaDetails: any,
-    outboundDate: string,
-    inboundDate?: string
-  ): void {
-    const { sourceId, co2PerItem, co2PerPassenger, total } = selectedFlight;
-    const booking: AddItemToBasketMutationVariables = {
-      adults: this.adults,
-      basket: intBasket.id,
-      children: this.children,
-      co2PerItem,
-      co2PerPassenger,
-      currency: total.currency as CurrencyCode,
-      detail: schemaDetails,
-      price: total.price,
-      searchQuery: this.resultQuery,
-      service: sourceId.toString(),
-      outboundDate
-    };
-    if (inboundDate) {
-      booking.inboundDate = inboundDate;
-    }
-    this.basketService.addToBasket(
-      booking,
-      intBasket,
-      this.searchService,
-      this.travellers
-    );
-  }
-
-  makeSchemaFlights(
-    selectedFlight: FlightJourney,
-    flightGroup: 'outbound' | 'inbound',
-    groupIndex: number,
-    segmentIndex?: number
-  ): any {
-    return {
-      cabinClass: selectedFlight.cabinClass,
-      dateTimeArriving: selectedFlight.dateTimeArriving,
-      dateTimeArrivingUTC: selectedFlight.dateTimeArrivingUTC,
-      dateTimeDeparting: selectedFlight.dateTimeDeparting,
-      dateTimeDepartingUTC: selectedFlight.dateTimeDepartingUTC,
-      destinationAirport: selectedFlight.destinationAirport,
-      journeyInfo: {
-        flightGroup,
-        groupIndex,
-        segmentIndex
-      },
-      marketingCarrier: selectedFlight.marketingCarrier,
-      marketingFlightNumber: selectedFlight.marketingFlightNumber,
-      operatingCarrier: selectedFlight.operatingCarrier,
-      operatingFlightNumber: selectedFlight.operatingFlightNumber,
-      originAirport: selectedFlight.originAirport,
-      totalDuration: selectedFlight.totalDuration,
-      fareType: selectedFlight.fareInfo.title
-    };
-  }
-
-  private createGroupedItem(
-    returnObject: EurostarGroupedQuoteResult,
-    source: string,
-    outboundFlights: FlightJourney[],
-    outboundTotalDuration: number,
-    inboundFlights: FlightJourney[],
-    inboundTotalDuration: number
-  ) {
-    if (outboundFlights?.length && !returnObject.departDateTime) {
-      const first = outboundFlights[0];
-      const last = outboundFlights[outboundFlights.length - 1];
-      returnObject.originAirport = first.originAirport;
-      returnObject.originAirportName = first.originAirportName;
-      returnObject.destinationAirport = last.destinationAirport;
-      returnObject.destinationAirportName = last.destinationAirportName;
-      returnObject.departDateTime = first.dateTimeDeparting;
-      returnObject.arrivalDateTime = last.dateTimeArriving;
-      returnObject.outboundTotalDuration = outboundTotalDuration;
-      returnObject.dataSource = source;
-      returnObject.operator = first.operatingCarrier;
-      returnObject.operatorFull = first.operatingCarrierName;
-      returnObject.outlegsCount = outboundFlights.length;
-      returnObject.outlegs = outboundFlights;
-      returnObject.outboundFlightNumber =
-        this.helpers.joinFromAttribute<FlightJourney>(
-          '-',
-          'operatingFlightNumber',
-          outboundFlights
-        );
-
-      returnObject.isReturn = false;
-    }
-
-    if (inboundFlights?.length && !returnObject.inboundTotalDuration) {
-      returnObject.inboundTotalDuration = inboundTotalDuration;
-      returnObject.inlegsCount = inboundFlights.length;
-      returnObject.inlegs = inboundFlights;
-      returnObject.inboundFlightNumber =
-        this.helpers.joinFromAttribute<FlightJourney>(
-          '-',
-          'operatingFlightNumber',
-          inboundFlights
-        );
-
-      returnObject.isReturn = true;
-    }
-  }
-
-  protected makeSessionResults(
-    data: EurostarQuoteResultArray
-  ): EurostarSessionType {
-    return {
-      results: data,
-      groupData: this.flightsToGroup,
-      grouped: this.grouped,
-      query: this.resultQuery
-    };
-  }
-
-  getMinFlightPriceForBrand(matchingBrandFlights: FlightItinerary[]): number {
-    let min = Number.MAX_SAFE_INTEGER;
-    matchingBrandFlights.forEach((flight) => {
-      if (min > flight?.total?.price) {
-        min = flight.total.price;
-      }
-    });
-    return min;
-  }
-
-  getMaxFlightPriceForBrand(matchingBrandFlights: FlightItinerary[]): number {
-    let max = 0;
-    matchingBrandFlights.forEach((flight) => {
-      if (max < flight?.total?.price) {
-        max = flight.total.price;
-      }
-    });
-    return max;
-  }
-
-  isOverNight(): boolean {
-    const outwardDay = this.outBoundDate.date();
-    const returnDay = this.inboundDate.date();
-    if (returnDay - outwardDay >= 1) {
-      return true;
-    }
-    return false;
-  }
-
-  minToHour = (dur: number): string => `${Math.floor(dur / 60)}h ${dur % 60}m`;
-
-  async addEurostarJourneysToBasket(
-    eurostarQuote: FlightItinerary
-  ): Promise<boolean> {
-    if (eurostarQuote.unavailable) {
-      return Promise.resolve(false);
-    }
-    const intBasket: InternalBasketInterface =
-      await this.basketService.getDefaultBasket();
-    const basket = intBasket?.subject.value;
-    if (basket) {
-
-      const { sourceId, co2PerItem, co2PerPassenger, total } = eurostarQuote;
-      const outboundDate: any = moment(eurostarQuote.outboundFlights[0].dateTimeDeparting);
-      const inboundDate: any = eurostarQuote.inboundFlights.length ? moment(eurostarQuote.inboundFlights[0].dateTimeDeparting) : null;
-
-      const schemaDetails = {
-        outboundFlights: [
-          ...eurostarQuote.outboundFlights.map(
-            (flight: FlightJourney, segmentIndex: number) =>
-              this.makeSchemaFlights(flight, 'outbound', 0, segmentIndex)
-          )],
-        inboundFlights: [
-          ...eurostarQuote.inboundFlights.map(
-            (flight: FlightJourney, segmentIndex: number) =>
-              this.makeSchemaFlights(flight, 'inbound', 0, segmentIndex)
-          )
-        ],
-        journeyType: 'single'
-      }
-      const booking: AddItemToBasketMutationVariables = {
-        adults: this.adults,
-        basket: intBasket.id,
-        children: this.children,
-        co2PerItem,
-        co2PerPassenger,
-        currency: total.currency as CurrencyCode,
-        detail: schemaDetails,
-        price: total.price,
-        searchQuery: this.resultQuery,
-        service: sourceId.toString(),
-        outboundDate: outboundDate.format()
-      };
-      if (inboundDate) {
-        booking.inboundDate = inboundDate.format();
-        schemaDetails.journeyType = 'roundtrip';
-      }
-
-      return this.basketService.addToBasket(
-        booking,
-        intBasket,
-        this.searchService,
-        this.travellers
-      );
-    }
-    return Promise.resolve(false); // TODO should this throw an error?
-  }
-}