@sabstravtech/obtservices 0.0.0

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

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