@sabstravtech/obtservices 0.0.0 → 0.0.1

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

@@ -1,2399 +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, combineLatest } 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,
-  FlightItinerary,
-  FlightJourney,
-  FlightPassengerObject,
-  FlightPassengerType,
-  GroupedFieldsFragment,
-  ItinerarySummary,
-  MatchingFlights,
-  SaveRecentSearchMutationVariables,
-  SearchFlightsV2QueryVariables,
-  ServiceType
-} from '../types/graphql.types';
-import {
-  FlightAllQuoteResult,
-  FlightGroupedQuoteResult,
-  FlightItineraryClass,
-  FlightQuoteResultArray,
-  NgbDateStruct,
-  OBTAirportDetails,
-  OBTAirlinesDetails,
-  FlightDirectionEnum,
-  GroupedFlights,
-  FlightItineraryWithSelected,
-  RecentSearch
-} from '../types/types';
-import {
-  BaseFlightQuoteFetcher,
-  FlightQuoteFetcherType
-} from '../fetchers/flight-quote.fetcher';
-import {
-  FullUserDetails,
-  UserServiceInterface
-} from '../interfaces/Iuser.service';
-import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
-import {
-  FlightEnterpriseSearchInterface,
-  FlightTempParams
-} from '../interfaces/Iflight-enterprise-search';
-import { ICheapestPrice } from '../interfaces/cheapest-price';
-import { FlightSearchType } from './flight-search-type.enum';
-import { IMultiDestination } from '../interfaces/flight-multi-destination.interface';
-import {
-  EnterpriseBasketServiceInterface,
-  InternalBasketInterface
-} from '../interfaces/Ienterprise-basket.service';
-export interface AllowedClass {
-  name: string;
-  type: FlightCabinClass | null;
-}
-
-export interface FlightOperator {
-  code: string;
-  name: string;
-}
-
-export type AllowedClasses = AllowedClass[];
-
-export enum TimeWindow {
-  Anytime = 'Anytime',
-  Depart = 'Depart By',
-  Arrive = 'Arrive By'
-}
-
-export enum SortTypes {
-  CheapestFirst = 'C',
-  MostExpensiveFirst = 'M',
-  FastestFirst = 'F',
-  PreferredFirst = 'P',
-  LowestEmissions = 'L'
-}
-
-export type FlightGroups =
-  | 'LiteEconomy'
-  | 'Economy'
-  | 'EconomyNoBags'
-  | 'EconomyRestricted'
-  | 'PremiumEconomy'
-  | 'Business'
-  | 'PremiumBusiness'
-  | 'First'
-  | 'PremiumFirst';
-
-export type RestrictedFlightGroups =
-  | 'Economy'
-  | 'EconomyNoBags'
-  | 'EconomyRestricted'
-  | 'PremiumEconomy'
-  | 'Business'
-  | 'First';
-
-interface FlightSessionType {
-  results: FlightQuoteResultArray;
-  groupData: { [key: number]: number[] };
-  grouped: GroupedFlights;
-  query: SearchFlightsV2QueryVariables;
-}
-
-export class FlightEnterpriseSearch<FQ_Q extends FlightQuoteFetcherType>
-  extends BaseEnterpriseSearch<
-    FlightTempParams,
-    FlightAllQuoteResult,
-    FlightQuoteResultArray
-  >
-  implements FlightEnterpriseSearchInterface
-{
-  static readonly STORAGE_SESSION_PARAMS = 'search_flight';
-  static readonly STORAGE_SESSION_RESULTS = 'results_flight';
-
-  public type: ServiceType = ServiceType.Flight;
-
-  avaliableClasses: BehaviorSubject<AllowedClasses> =
-    new BehaviorSubject<AllowedClasses>([]);
-  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: ValueDisplay[] = [
-    { display: 'Cheapest First', value: SortTypes.CheapestFirst },
-    { display: 'Most Expensive First', value: SortTypes.MostExpensiveFirst },
-    { display: 'Fastest First', value: SortTypes.FastestFirst },
-    { display: 'Preferred Fares First', value: SortTypes.PreferredFirst },
-    { display: 'Lowest Co2 Emissions First', value: SortTypes.LowestEmissions }
-  ];
-
-  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()
-  };
-  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 = FlightEnterpriseSearch.STORAGE_SESSION_RESULTS;
-  selectedGroupFlight: FlightItineraryWithSelected;
-  private _showHotelForm: boolean = false;
-  private _hotelSearchRequested: boolean = false;
-
-  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) {
-    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) {
-    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(): FlightSearchType {
-    return this.tempParams.chosenSearchType;
-  }
-
-  set chosenSearchType(type: FlightSearchType) {
-    this.tempParams.chosenSearchType = type;
-  }
-
-  get isReturn(): boolean {
-    return this.tempParams.chosenSearchType === FlightSearchType.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();
-  }
-
-  public get showHotelForm(): boolean {
-    return this._showHotelForm;
-  }
-
-  public set showHotelForm(newVal: boolean) {
-    this._showHotelForm = newVal;
-  }
-
-  public get hotelSearchRequested(): boolean {
-    return this._hotelSearchRequested;
-  }
-
-  public set hotelSearchRequested(newVal: boolean) {
-    this._hotelSearchRequested = newVal;
-  }
-
-  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(): ValueDisplay[] {
-    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 flightfetcher: BaseFlightQuoteFetcher<FQ_Q>,
-    private helpers: BaseHelperRoutines,
-    userService: UserServiceInterface,
-    private basketService: EnterpriseBasketServiceInterface,
-    storageService: BaseStorageService,
-    private searchService: EnterpriseSearchServiceInterface
-  ) {
-    super(
-      storageService,
-      (results: FlightAllQuoteResult): FlightQuoteResultArray => {
-        this.flightsToGroup = {};
-        this.grouped = results.grouped || [];
-        this.resultQuery = this.getSearchQuery();
-        delete this.resultQuery.withGrouped;
-
-        if (results && this.searchService.isFlightsGrouped()) {
-          this.groupedObject = (results.multi || [])
-            .reduce(
-              (
-                previousItems: FlightItineraryWithSelected[],
-                nextItem: ItinerarySummary
-              ) => {
-                return previousItems.concat(nextItem.results);
-              },
-              results.journeys as unknown as FlightItineraryWithSelected[]
-            )
-            .map((flight: FlightItineraryWithSelected) => {
-              return Object.assign(flight, { seleced: false, canSelect: true });
-            });
-
-          const returnData = (results.grouped || []).reduce(
-            (
-              acc: FlightGroupedQuoteResult[],
-              item: GroupedFieldsFragment,
-              groupNumber: number
-            ): FlightGroupedQuoteResult[] => {
-              const isOutBound =
-                item.boundIndicator === FlightDirectionEnum.Outbound;
-              const returnObject: FlightGroupedQuoteResult = {
-                direction: item.boundIndicator,
-                classes: {
-                  [FlightCabinClass.EconomyNoBags]:
-                    null as FlightItineraryClass,
-                  [FlightCabinClass.EconomyRestricted]:
-                    null as FlightItineraryClass,
-                  [FlightCabinClass.Economy]: null as FlightItineraryClass,
-                  [FlightCabinClass.Business]: null as FlightItineraryClass,
-                  [FlightCabinClass.First]: null as FlightItineraryClass,
-                  [FlightCabinClass.PremiumEconomy]:
-                    null as FlightItineraryClass
-                },
-                originAirport: '',
-                originAirportName: '',
-                destinationAirport: '',
-                destinationAirportName: '',
-                departDateTime: '',
-                arrivalDateTime: '',
-                outboundTotalDuration: 0,
-                inboundTotalDuration: 0,
-                outlegs: null,
-                inlegs: null,
-                outlegsCount: 0,
-                inlegsCount: 0,
-                dataSource: '',
-                preferred: false,
-                outboundFlightNumber: '',
-                operator: '',
-                operatorFull: '',
-                inboundFlightNumber: '',
-                isReturn: false
-              };
-              const brands: MatchingFlights = item.flights;
-
-              Object.keys(brands)
-                .filter((key: string) => key[0] !== '_')
-                .forEach((brand: FlightGroups) => {
-                  if (!brands[brand].length) {
-                    return;
-                  }
-                  // ! using a reduce because not all flights actually exist and we were seeing undefined in the flight list
-                  const matchingBrandFlights: FlightItinerary[] = brands[
-                    brand
-                  ].reduce((acc1: FlightItinerary[], flightNum: number, i) => {
-                    (this.flightsToGroup[flightNum] =
-                      this.flightsToGroup[flightNum] || []).push(groupNumber);
-                    const flight = this.groupedObject[flightNum];
-                    if (isOutBound) {
-                      this.createGroupedItem(
-                        returnObject,
-                        flight.source,
-                        flight.outboundFlights,
-                        flight.outboundTotalDuration,
-                        flight.inboundFlights,
-                        flight.inboundTotalDuration
-                      );
-                    } else {
-                      this.createGroupedItem(
-                        returnObject,
-                        flight.source,
-                        flight.inboundFlights,
-                        flight.inboundTotalDuration,
-                        flight.outboundFlights,
-                        flight.outboundTotalDuration
-                      );
-                    }
-                    if (flight) {
-                      acc1.push(flight);
-                    }
-                    return acc1;
-                  }, []);
-                  let correctBrand: RestrictedFlightGroups;
-
-                  switch (brand) {
-                    case FlightCabinClass.LiteEconomy:
-                    case FlightCabinClass.Economy:
-                      correctBrand = FlightCabinClass.Economy;
-                      break;
-                    case FlightCabinClass.EconomyNoBags:
-                      correctBrand = FlightCabinClass.EconomyNoBags;
-                      break;
-                    case FlightCabinClass.EconomyRestricted:
-                      correctBrand = FlightCabinClass.EconomyRestricted;
-                      break;
-                    case FlightCabinClass.PremiumBusiness:
-                    case FlightCabinClass.Business:
-                      correctBrand = FlightCabinClass.Business;
-                      break;
-                    case FlightCabinClass.PremiumFirst:
-                    case FlightCabinClass.First:
-                      correctBrand = FlightCabinClass.First;
-                      break;
-                    case FlightCabinClass.PremiumEconomy:
-                      correctBrand = FlightCabinClass.PremiumEconomy;
-                      break;
-                    default:
-                      console.log('something went wrong');
-                      break;
-                  }
-
-                  const minprice =
-                    this.getMinFlightPriceForBrand(matchingBrandFlights);
-                  const maxprice =
-                    this.getMaxFlightPriceForBrand(matchingBrandFlights);
-                  if (returnObject.classes[correctBrand]?.flights?.length) {
-                    returnObject.classes[correctBrand].flights.concat(
-                      matchingBrandFlights
-                    );
-                    returnObject.classes[correctBrand].minprice = Math.min(
-                      returnObject.classes[correctBrand].minprice,
-                      minprice
-                    );
-                    returnObject.classes[correctBrand].maxprice = Math.max(
-                      returnObject.classes[correctBrand].maxprice,
-                      maxprice
-                    );
-                  } else {
-                    returnObject.classes[correctBrand] = {
-                      flights: matchingBrandFlights,
-                      minprice,
-                      maxprice,
-                      currency: matchingBrandFlights[0].total.currency
-                    };
-                  }
-                });
-              if (returnObject) {
-                acc.push(returnObject);
-              }
-              return acc;
-            },
-            []
-          );
-
-          console.log('Processed Grouped data', returnData);
-          return returnData;
-        } else {
-          return results ? [results] : [];
-        }
-      }
-    );
-
-    const data: {
-      tempParams: FlightTempParams;
-      originalUserSearch: FlightTempParams;
-    } = storageService.getSessionItem(
-      FlightEnterpriseSearch.STORAGE_SESSION_PARAMS
-    ) || {
-      tempParams: {} as FlightTempParams,
-      originalUserSearch: {} as FlightTempParams
-    };
-    // data.tempParams.adults = 1;
-    // data.tempParams.cabinClass = [FlightCabinClass.Economy];
-    const query = searchService.makeFlightQuery(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.Flight
-          );
-          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.flightOperators.next([{ code: 'BA', name: 'British Airways' }]); // Fetch these from DB
-      this.updateAvaliableClasses();
-    });
-
-    this.updateTravellers();
-
-    if (this.isValid.value) {
-      const results: FlightSessionType = 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;
-      // if (results == null && this.isValid) {
-      //   searchService.startSearches();
-      // }
-      // this._cheapestResultPrice = this.updateLowestPrice(results);
-      this.results.next(results.results || ([] as FlightQuoteResultArray));
-    }
-
-    this.negotiated =
-      this.tempParams.fareType === FareType.Negotiated ? true : false;
-  }
-  private createGroupedItem(
-    returnObject: FlightGroupedQuoteResult,
-    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.marketingCarrier;
-      returnObject.operatorFull = first.marketingCarrierName;
-      returnObject.outlegsCount = outboundFlights.length;
-      returnObject.outlegs = outboundFlights;
-      returnObject.outboundFlightNumber =
-        this.helpers.joinFromAttribute<FlightJourney>(
-          '-',
-          'marketingFlightNumber',
-          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: FlightQuoteResultArray
-  ): FlightSessionType {
-    return {
-      results: data,
-      groupData: this.flightsToGroup,
-      grouped: this.grouped,
-      query: this.resultQuery
-    };
-  }
-
-  getMaxFlightPriceForBrand(matchingBrandFlights: FlightItinerary[]): number {
-    let max = 0;
-    matchingBrandFlights.forEach((flight) => {
-      if (max < flight?.total?.price) {
-        max = flight.total.price;
-      }
-    });
-    return max;
-  }
-  getMinFlightPriceForBrand(matchingBrandFlights: FlightItinerary[]): number {
-    let min = Number.MAX_SAFE_INTEGER;
-    matchingBrandFlights.forEach((flight) => {
-      if (min > flight?.total?.price) {
-        min = flight.total.price;
-      }
-    });
-    return min;
-  }
-
-  protected resetQuery(checkIsValid: boolean = true): void {
-    this.updateTempParams(this.searchService.makeFlightQuery());
-    if (checkIsValid) {
-      this._isValid();
-    }
-  }
-
-  public resetParams(): void {
-    this.reset();
-    this.resetQuery();
-  }
-
-  private _isValid() {
-    if (!this.doChecks) {
-      return;
-    }
-    this.storageService.setSessionItem(
-      FlightEnterpriseSearch.STORAGE_SESSION_PARAMS,
-      {
-        tempParams: this.tempParams,
-        originalUserSearch: this.originalUserSearch
-      }
-    );
-
-    this.validationMessages = [];
-    if (this.tempParams.chosenSearchType === FlightSearchType.multiCity) {
-      this.multiCityValidation();
-    } else {
-      if (!this._originAirport) {
-        this.validationMessages.push('Please add in a departure location');
-      }
-      if (!this._destinationAirport) {
-        this.validationMessages.push('Please add in an 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 airport 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);
-    }
-  }
-
-  multiCityValidation() {
-    let isemptyValue = false;
-    let isemptyLanding = false;
-    let isSameValue = false;
-    this.tempParams.multiDestination.map((element, i) => {
-      if (!element.orig) {
-        isemptyValue = true;
-        if (i < 2) {
-          isemptyLanding = true;
-        }
-      }
-      if (element.orig === element.dest) isSameValue = true;
-    });
-    if (!moment(this.tempParams.multiDestination[0].date).isAfter(moment())) {
-      this.validationMessages.push('Departure date can not be in the past');
-    }
-    if (isemptyLanding)
-      this.validationMessages.push('Please select landing airport(s)');
-    if (isemptyValue)
-      this.validationMessages.push('Please select take off airport(s)');
-    if (isSameValue)
-      this.validationMessages.push(
-        'Take off and landing location(s) cannot be the same'
-      );
-  }
-  startSearch(): Promise<boolean> {
-    this.results.next([]);
-    this._isValid();
-
-    if (this.isValid.value) {
-      this._originalUserSearch = Object.freeze({ ...this.tempParams });
-      this.storageService.setSessionItem(
-        FlightEnterpriseSearch.STORAGE_SESSION_PARAMS,
-        {
-          tempParams: this.tempParams,
-          originalUserSearch: this.originalUserSearch
-        }
-      );
-      const query = this.getSearchQuery();
-      this.searchService.saveRecentSearch(this.getRecentSearchQuery(query));
-
-      return this._startSearch(this.flightfetcher.fetchList(query));
-    } else {
-      return Promise.resolve(false);
-    }
-  }
-
-  getRecentSearchQuery(
-    query: SearchFlightsV2QueryVariables
-  ): SaveRecentSearchMutationVariables {
-    return {
-      serviceType: ServiceType.Flight,
-      searchArgs: query,
-      travelDate: this.outBoundDate.format(),
-      travellers: this.helpers.getTravellersId(this.travellers)
-    };
-  }
-
-  public startRecentSearch(recentSearch: RecentSearch): void {
-    if (recentSearch.searchArgs.outboundDate) {
-      this.outBoundDate = this.convertRecentSearchDateTime(
-        recentSearch.searchArgs.outboundDate,
-        recentSearch.searchArgs.outboundDepartureTimeWindow
-      );
-    }
-
-    if (recentSearch.searchArgs.returnDate) {
-      this.inboundDate = this.convertRecentSearchDateTime(
-        recentSearch.searchArgs.returnDate,
-        recentSearch.searchArgs.returnDepartureTimeWindow
-      );
-    }
-
-    this.fareType = recentSearch.searchArgs.fareType;
-    this.maxConnections = recentSearch.searchArgs.maxConnections;
-
-    if (recentSearch.searchArgs.outboundCabinClass) {
-      this.cabinClass = recentSearch.searchArgs.outboundCabinClass[0];
-    }
-    if (recentSearch.searchArgs.returnCabinClass) {
-      this.returnCabinClass = recentSearch.searchArgs.returnCabinClass[0];
-    }
-
-    this.includeNearbyAirports = recentSearch.searchArgs.includeNearbyAirports
-      ? true
-      : false;
-
-    this.chosenSearchType = recentSearch.searchArgs.returnTrip
-      ? FlightSearchType.return
-      : FlightSearchType.oneWay;
-
-    if (recentSearch.searchArgs.outboundDepartureTimeWindow) {
-      this.outTimeCriteria = TimeWindow.Depart;
-    } else if (recentSearch.searchArgs.outboundArrivalTimeWindow) {
-      this.outTimeCriteria = TimeWindow.Arrive;
-    } else {
-      this.outTimeCriteria = TimeWindow.Anytime;
-    }
-
-    if (recentSearch.searchArgs.returnDepartureTimeWindow) {
-      this.inTimeCriteria = TimeWindow.Depart;
-    } else if (recentSearch.searchArgs.returnArrivalTimeWindow) {
-      this.inTimeCriteria = TimeWindow.Arrive;
-    } else {
-      this.inTimeCriteria = TimeWindow.Anytime;
-    }
-
-    combineLatest([
-      this.searchService.getAirportByCode(
-        recentSearch.searchArgs.originAirport
-      ),
-      this.searchService.getAirportByCode(
-        recentSearch.searchArgs.destinationAirport
-      )
-    ]).subscribe(([departLocation, arriveLocation]) => {
-      if (departLocation && arriveLocation) {
-        this.departLocation = {
-          destination: departLocation.iataMatch.name,
-          gateway: departLocation.iataMatch.iata,
-          terminals: this.searchService.processTerminals(
-            departLocation.iataMatch.terminals
-          ),
-          country: departLocation.iataMatch?.locationDetails?.country,
-          postcode: departLocation.iataMatch?.locationDetails?.postcode,
-          countryCode: departLocation.iataMatch?.locationDetails?.countryCode
-        };
-        this.arriveLocation = {
-          destination: arriveLocation.iataMatch.name,
-          gateway: arriveLocation.iataMatch.iata,
-          terminals: this.searchService.processTerminals(
-            arriveLocation.iataMatch.terminals
-          ),
-          country: arriveLocation.iataMatch?.locationDetails?.country,
-          postcode: arriveLocation.iataMatch?.locationDetails?.postcode,
-          countryCode: arriveLocation.iataMatch?.locationDetails?.countryCode
-        };
-
-        if (recentSearch.searchArgs.preferredCarriers) {
-          let preferredCarriers: OBTAirlinesDetails[] = [];
-          recentSearch.searchArgs.preferredCarriers.map(
-            (preferredCarry: string) => {
-              this.searchService
-                .getAirlinesList(preferredCarry)
-                .subscribe((items: OBTAirlinesDetails[]) => {
-                  items.map((item: OBTAirlinesDetails) => {
-                    if (item.code === preferredCarry) {
-                      preferredCarriers.push(item);
-                    }
-                  });
-                  this.preferredCarriers = preferredCarriers;
-                  this.searchService.startSearches();
-                });
-            }
-          );
-        }
-        this.searchService.startSearches();
-      }
-    });
-    this.searchService.startSearches();
-  }
-
-  private makeDepartureTimeWindow(
-    dateTime: moment.Moment,
-    window: TimeWindow,
-    isFlightsGrouped: boolean
-  ): string {
-    return window === TimeWindow.Depart
-      ? isFlightsGrouped
-        ? this.helpers.makeTimeWindow(dateTime, -2, 2)
-        : this.helpers.makeTimeWindow(dateTime, 0, 4)
-      : null;
-  }
-
-  private makeArrivalTimeWindow(
-    dateTime: moment.Moment,
-    window: TimeWindow,
-    isFlightsGrouped: boolean
-  ): string {
-    if (window !== TimeWindow.Arrive) return null;
-    return isFlightsGrouped
-      ? this.helpers.makeTimeWindow(dateTime, -2, 2)
-      : this.helpers.makeTimeWindow(dateTime, 0, 4);
-  }
-
-  convertRecentSearchDateTime(
-    date: string,
-    timeWindow?: string
-  ): moment.Moment {
-    if (timeWindow) {
-      const flightTime = timeWindow.split('-');
-      let timeAndDate = moment(date).add(
-        moment.duration(this.helpers.hhmmToTime(flightTime[0]))
-      );
-      // add 2 hour
-      return timeAndDate.clone().add(2, 'hour');
-    } else {
-      return moment(date);
-    }
-  }
-
-  getSearchQuery(): SearchFlightsV2QueryVariables {
-    const isMultiCityActive =
-      this.tempParams.chosenSearchType === FlightSearchType.multiCity;
-    this._multiDestination = isMultiCityActive
-      ? this.setMultiDestinationQuery(this.tempParams.multiDestination)
-      : null;
-
-    this._multiDestination =
-      this.tempParams.chosenSearchType === FlightSearchType.multiCity
-        ? this.setMultiDestinationQuery(this.tempParams.multiDestination)
-        : [];
-    const isFlightsGrouped = this.searchService.isFlightsGrouped();
-    return this.helpers.removeNulls<SearchFlightsV2QueryVariables>(
-      Object.assign(
-        {},
-        isMultiCityActive
-          ? {
-              multiDestination: this._multiDestination
-            }
-          : {
-              originAirport: this._originAirport,
-              destinationAirport: this._destinationAirport,
-              outboundDate: this.helpers.formatIsoDate(
-                this.tempParams.outBoundDate
-              ),
-              outboundDepartureTimeWindow: this.makeDepartureTimeWindow(
-                this.tempParams.outBoundDate,
-                this.tempParams.outTimeCriteria,
-                isFlightsGrouped
-              ),
-              outboundArrivalTimeWindow: this.makeArrivalTimeWindow(
-                this.tempParams.outBoundDate,
-                this.tempParams.outTimeCriteria,
-                isFlightsGrouped
-              )
-            },
-        {
-          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: isFlightsGrouped
-        },
-        this.isReturn
-          ? {
-              returnDate: this.helpers.formatIsoDate(
-                this.tempParams.inboundDate
-              ),
-              returnDepartureTimeWindow: this.makeDepartureTimeWindow(
-                this.tempParams.inboundDate,
-                this.tempParams.inTimeCriteria,
-                isFlightsGrouped
-              ),
-              returnArrivalTimeWindow: this.makeArrivalTimeWindow(
-                this.tempParams.inboundDate,
-                this.tempParams.inTimeCriteria,
-                isFlightsGrouped
-              ),
-              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: FlightCabinClass.Any },
-      { name: 'Economy', type: FlightCabinClass.Economy },
-      { name: 'Premium', type: FlightCabinClass.PremiumEconomy },
-      { name: 'Business', type: FlightCabinClass.Business },
-      { name: 'First', type: FlightCabinClass.First }
-    ]);
-  }
-
-  /**
-   * @description - sort the flight results
-   * @todo - Fill out Preferred and Co2 sorting when we have that data
-   */
-  public sortResults(
-    sortMethodValue: SortTypes,
-    givenResults?: FlightItinerary[]
-  ): FlightItinerary[] {
-    let results = this.helpers.clone(
-      givenResults
-        ? givenResults
-        : <FlightItinerary[]>(<unknown>this.fullResults)
-    );
-
-    switch (sortMethodValue) {
-      case SortTypes.CheapestFirst:
-        results = results.sort((a: FlightItinerary, b: FlightItinerary) => {
-          return a.total.price - b.total.price;
-        });
-        break;
-      case SortTypes.MostExpensiveFirst:
-        results = results.sort((a: FlightItinerary, b: FlightItinerary) => {
-          return b.total.price - a.total.price;
-        });
-        break;
-      case SortTypes.FastestFirst:
-        results = results.sort((a: FlightItinerary, b: FlightItinerary) => {
-          return (
-            a.outboundTotalDuration +
-            (a.inboundTotalDuration ? a.inboundTotalDuration : 0) -
-            (b.outboundTotalDuration +
-              (b.inboundTotalDuration ? b.inboundTotalDuration : 0))
-          );
-        });
-        break;
-      case SortTypes.LowestEmissions:
-        results = results.sort((a: FlightItinerary, b: FlightItinerary) => {
-          return a.co2PerItem - b.co2PerItem;
-        });
-        break;
-      default:
-        console.error(`+++ Unknown sorting method: ${sortMethodValue} +++`);
-    }
-
-    return results;
-  }
-
-  updateFromPreviousSearches(
-    previousItems: Record<ServiceType, BasketItem>
-  ): void {
-    // Flights can not be search after other products so no defaults can be set.
-  }
-
-  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 - filter the results, then sort the remainder
-   * @todo - Add filters for travel policy, fare types and ancilliaries
-   */
-  filterResults(
-    filters: FlightFilters,
-    sortValue: SortTypes,
-    givenResults?: FlightItinerary[]
-  ): FlightItinerary[] {
-    console.log('+++ Applying Filters to flights: ', filters, ' +++');
-    let results: FlightItinerary[] = this.helpers.clone(givenResults);
-
-    if (this.isReturn) {
-      results = results.filter(
-        (result: FlightItinerary) =>
-          result.inboundFlights && result.inboundFlights.length
-      );
-    }
-
-    // Add In Filters Here
-    // filter stops
-    results = this.filterResultsByStops(filters.stops, results);
-    results = this.filterResultsByAirline(filters.airlines, results);
-    results = this.filterResultsByClass(filters.classes, results);
-    results = this.filterByDepartureAirport(filters.depatureAirport, results);
-    results = this.filterByDepartureReturnAirport(
-      filters.depatureReturnAirport,
-      results
-    );
-    results = this.filterByArrivalAirport(filters.arrivalAirport, results);
-    results = this.filterByArrivalReturnAirport(
-      filters.arrivalReturnAirport,
-      results
-    );
-    results = this.filterByPrice(filters.minPrice, filters.maxPrice, results);
-    results = this.filterByFlightNumber(filters.flightNumber, results);
-    results = this.filterByBaggage(filters.baggage, results);
-    results = this.filterByDepartureTime(
-      filters.minDepartureTime,
-      filters.maxDepartureTime,
-      results
-    );
-    results = this.filterByReturnDepartureTime(
-      filters.minReturnDepartureTime,
-      filters.maxReturnDepartureTime,
-      results
-    );
-    results = this.filterByArrivalTime(
-      filters.minArrivalTime,
-      filters.maxArrivalTime,
-      results
-    );
-    results = this.filterByReturnArrivalTime(
-      filters.minReturnArrivalTime,
-      filters.maxReturnArrivalTime,
-      results
-    );
-    results = this.filterByDuration(
-      filters.minDuration,
-      filters.maxDuration,
-      results
-    );
-    results = this.filterByDuration(
-      filters.minReturnDuration,
-      filters.maxReturnDuration,
-      results,
-      true
-    ); // return duration
-
-    results = this.sortResults(sortValue, results);
-    return results;
-  }
-
-  /**
-   * @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;
-  }
-
-  filterByFlightNumber(
-    flightNumber: string,
-    results: FlightItinerary[]
-  ): FlightItinerary[] {
-    if (flightNumber) {
-      // make sure to check both outbound and inbound
-
-      results = results.filter((result: FlightItinerary) => {
-        const inOutbound = result.outboundFlights.find((out: FlightJourney) => {
-          return out.operatingFlightNumber
-            .toUpperCase()
-            .includes(flightNumber.toUpperCase());
-        });
-
-        let inInbound;
-
-        if (result.inboundFlights?.length) {
-          inInbound = result.inboundFlights.find((inB: FlightJourney) => {
-            return inB.operatingFlightNumber
-              .toUpperCase()
-              .includes(flightNumber.toUpperCase());
-          });
-        }
-
-        return inOutbound || inInbound;
-      });
-    }
-
-    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 {
-        if (result.baggageAllowance.length) {
-          let total = +result.baggageAllowance[0]?.qty;
-          if (result.inboundFlights.length) {
-            // ! assuming second item is inbound if the airlines are different, steven said he would sort this out
-            if (
-              result.baggageAllowance[1] &&
-              +result.baggageAllowance[1].qty > total
-            ) {
-              total = +result.baggageAllowance[1]?.qty;
-            } else if (+result.baggageAllowance[0]?.qty > total) {
-              total = +result.baggageAllowance[0]?.qty;
-            }
-          }
-          if (+result.baggageAllowance[0]?.qty > total) {
-            total = +result.baggageAllowance[0]?.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);
-  }
-
-  updateLowestPrice(results: FlightQuoteResultArray): 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;
-    //   }
-    // })
-  }
-
-  async selectGroupedFlight(
-    selectedFlight: FlightItineraryWithSelected,
-    direction: FlightDirectionEnum
-  ) {
-    const intBasket: InternalBasketInterface =
-      await this.basketService.getDefaultBasket();
-    const basket = intBasket?.subject.value;
-
-    if (
-      basket &&
-      this.originalUserSearch.chosenSearchType === FlightSearchType.oneWay &&
-      direction === FlightDirectionEnum.Outbound
-    ) {
-      this.doBooking(
-        intBasket,
-        selectedFlight,
-        {
-          outboundFlights: selectedFlight.outboundFlights.map(
-            (flight: FlightJourney, segmentIndex: number) =>
-              this.makeSchemaFlights(flight, 'outbound', 0, segmentIndex)
-          ),
-          inboundFlights: [],
-          journeyType: 'single'
-        },
-        selectedFlight.outboundFlights[0].dateTimeDeparting
-      );
-      return;
-    }
-    if (
-      basket &&
-      this.originalUserSearch.chosenSearchType === FlightSearchType.return &&
-      direction === FlightDirectionEnum.Outbound
-    ) {
-      if (selectedFlight.selected) {
-        this.results.next(this.fullResults);
-        this.selectedGroupFlight = null;
-      } else {
-        this.selectedGroupFlight = selectedFlight;
-        const groupsToShow = this.flightsToGroup[selectedFlight.uid];
-        // const relatedFlights = this.grouped[groupsToShow[0]].flights;
-        // const filter = (flight: FlightItinerary, segmentIndex: number) => {
-        //   return true;
-        // };
-        this.results.next(
-          (this.fullResults as FlightGroupedQuoteResult[]).filter(
-            (result: FlightGroupedQuoteResult, groupIndex: number) => {
-              return groupsToShow.includes(groupIndex);
-            }
-          )
-        );
-      }
-      selectedFlight.selected = !selectedFlight.selected;
-    }
-    if (
-      basket &&
-      this.originalUserSearch.chosenSearchType === FlightSearchType.return &&
-      direction === FlightDirectionEnum.Inbound &&
-      this.selectedGroupFlight
-    ) {
-      this.doBooking(
-        intBasket,
-        selectedFlight,
-        {
-          outboundFlights: [
-            ...selectedFlight.outboundFlights.map(
-              (flight: FlightJourney, segmentIndex: number) =>
-                this.makeSchemaFlights(flight, 'outbound', 0, segmentIndex)
-            )
-          ],
-          inboundFlights: [
-            ...selectedFlight.inboundFlights.map(
-              (flight: FlightJourney, segmentIndex: number) =>
-                this.makeSchemaFlights(flight, 'inbound', 0, segmentIndex)
-            )
-          ],
-          journeyType: 'roundtrip'
-        },
-        selectedFlight.outboundFlights[0].dateTimeDepartingUTC,
-        selectedFlight.inboundFlights[0].dateTimeDepartingUTC
-      );
-      this.selectedGroupFlight.selected = false;
-      this.results.next(this.fullResults);
-    }
-  }
-
-  doBooking(
-    intBasket: InternalBasketInterface,
-    selectedFlight: FlightItinerary,
-    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
-    };
-  }
-
-  async addFlightJourneysToBasket(
-    flightQuote: FlightItinerary
-  ): Promise<boolean> {
-    if (flightQuote.unavailable) {
-      return Promise.resolve(false);
-    }
-    const intBasket: InternalBasketInterface =
-      await this.basketService.getDefaultBasket();
-    const basket = intBasket?.subject.value;
-    if (basket) {
-      const { sourceId, co2PerItem, co2PerPassenger, total } = flightQuote;
-      const outboundDate: any = moment(
-        flightQuote.outboundFlights[0].dateTimeDeparting
-      );
-      const inboundDate: any = flightQuote.inboundFlights.length
-        ? moment(flightQuote.inboundFlights[0].dateTimeDeparting)
-        : null;
-
-      const schemaDetails = {
-        outboundFlights: [
-          ...flightQuote.outboundFlights.map(
-            (flight: FlightJourney, segmentIndex: number) =>
-              this.makeSchemaFlights(flight, 'outbound', 0, segmentIndex)
-          )
-        ],
-        inboundFlights: [
-          ...flightQuote.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?
-  }
-}