@sabstravtech/obtservices 0.0.0

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

@@ -0,0 +1,2126 @@
+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?
+  }
+}