@sabstravtech/obtservices 0.0.0 → 0.0.2

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

@@ -1,1751 +0,0 @@
-import moment from 'moment';
-import { of, Observable, BehaviorSubject, combineLatest } from 'rxjs';
-import { map, take, tap } from 'rxjs/operators';
-import { BaseEnterpriseSearch } from './base-enterprise';
-import { BaseStorageService } from '../services/storage.service';
-import { BaseHelperRoutines } from './helpers';
-import { RailTicketGroups } from '../interfaces/rail-ticket-groups.interface';
-import {
-  RailResultIndifiers,
-  RailTicketGroup,
-  TicketGroups
-} from '../interfaces/rail-ticket-group.interface';
-import { RailDirection } from './rail-direction.enum';
-import { ValueDisplay } from '../interfaces/value-display';
-import {
-  NgbDateStruct,
-  RailQuoteResultArray,
-  RecentSearch,
-  RecursivePartial
-} from '../types/types';
-import {
-  BasketItem,
-  CurrencyCode,
-  RailAccount,
-  RailClass,
-  RailJourneyOption,
-  RailJourneyOptions,
-  RailJourneyType,
-  RailProvider,
-  RailSegment,
-  RailStation,
-  RailTicketOption,
-  RailTicketQueue,
-  ReferenceRailCardQualifier,
-  SaveRecentSearchMutationVariables,
-  SearchRailQueryVariables,
-  ServiceType,
-  RailTicketExtra
-} from '../types/graphql.types';
-import {
-  BaseRailQuoteFetcher,
-  RailQuoteFetcherType
-} from '../fetchers/rail-quote-fetcher';
-import {
-  BaseGetRailStationFetcher,
-  GetRailStationFetcherType
-} from '../fetchers/get-rail-station.fetcher';
-import {
-  EnterpriseBasketServiceInterface,
-  InternalBasketInterface
-} from '../interfaces/Ienterprise-basket.service';
-import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
-import {
-  RailEnterpriseSearchInterface,
-  RailTempParams
-} from '../interfaces/Irail-enterprise-search';
-import { Traveller } from '../models/traveller.object';
-import { ICheapestPrice } from '../interfaces/cheapest-price';
-import { IRailAirportExpressStations } from '../interfaces/rail-airport-express-stations.interface';
-import { RailBasketItem, TicketExtras } from '../interfaces/rail-basket-item.interface';
-import { RailRecentSearchArgs } from '../interfaces/rail-recent-search-args.interface';
-
-export enum RailSearchCriteria {
-  Depart = 'Depart After',
-  Arrive = 'Arrive Before'
-}
-
-export enum RailTicketOptionType { // may need to be expanded for dual/split
-  Return = 'Return',
-  Single = 'Single'
-}
-
-export class RailEnterpriseSearch<
-    Q extends RailQuoteFetcherType,
-    GRS_Q extends GetRailStationFetcherType
-  >
-  extends BaseEnterpriseSearch<
-    RailTempParams,
-    RailQuoteResultArray,
-    RailQuoteResultArray
-  >
-  implements RailEnterpriseSearchInterface
-{
-  static readonly STORAGE_SESSION_PARAMS = 'search_rail';
-  static readonly STORAGE_SESSION_RESULTS = 'rail_results';
-  static readonly PASSING_POINT = 'Passing';
-  private travellers: Traveller[];
-
-  protected resultsSessionName = RailEnterpriseSearch.STORAGE_SESSION_RESULTS;
-
-  public searchTypes = [
-    { display: 'Return', value: RailJourneyType.ReturnJourney },
-    { display: 'One-Way', value: RailJourneyType.SingleJourney }
-    // { display: 'Open Return', value: RailJourneyType.OpenReturnJourney },
-    // { display: 'Dual Singles', value: RailJourneyType.DualSingleJourney },
-  ];
-
-  public classTypes = [
-    { display: 'Any', value: RailClass.All },
-    { display: 'Standard', value: RailClass.Standard },
-    { display: 'First', value: RailClass.First }
-  ];
-
-  public airportExpressStations: IRailAirportExpressStations[] = [
-    { code: 'HP1-3', name: 'Heathrow T1-3 - Paddington' },
-    { code: 'HP4', name: 'Heathrow T4 - Paddington' },
-    { code: 'HP5', name: 'Heathrow T5 - Paddington' },
-    { code: 'PH1-3', name: 'Paddington - Heathrow T1-3' },
-    { code: 'PH4', name: 'Paddington - Heathrow T4' },
-    { code: 'PH5', name: 'Paddington - Heathrow T5' },
-    { code: 'GV', name: 'Gatwick - Victoria' },
-    { code: 'VG', name: 'Victoria - Gatwick' },
-    { code: 'SL', name: 'Stansted - Liverpool Street' },
-    { code: 'LS', name: 'Liverpool Street - Stansted' }
-  ];
-
-  public airportExpressStationsCodes: {
-    [key: string]: { dep: string; arr: string };
-  } = {
-    'HP1-3': { dep: 'HXX', arr: 'PAD' },
-    'PH1-3': { dep: 'PAD', arr: 'HXX' },
-    HP4: { dep: 'HAF', arr: 'PAD' },
-    PH4: { dep: 'PAD', arr: 'HAF' },
-    HP5: { dep: 'HWV', arr: 'PAD' },
-    PH5: { dep: 'PAD', arr: 'HWV' },
-    GV: { dep: 'GTW', arr: 'VIC' },
-    VG: { dep: 'VIC', arr: 'GTW' },
-    SL: { dep: 'SSD', arr: 'LST' },
-    LS: { dep: 'LST', arr: 'SSD' }
-  };
-
-  public railCriteria = [RailSearchCriteria.Depart, RailSearchCriteria.Arrive];
-
-  public travelCards = [
-    { display: 'Young persons railcard', value: 'YNG' },
-    { display: 'Disability railcard', value: 'DIS' },
-    { display: 'Family railcard', value: 'FAM' },
-    { display: 'Forces railcard', value: 'HMF' },
-    { display: 'Travel agency discount', value: 'TAD' }
-  ];
-
-  // YNG: "Young persons railcard",
-  // DIS: "Disability railcard",
-  // FAM: "Family railcard",
-  // HMF: "Forces railcard",
-  // TAD: "Travel agency discount"
-  public removePassingPointsFromResults = true;
-  public type: ServiceType = ServiceType.Rail;
-  public minOutboundDate: NgbDateStruct = {
-    year: moment().year(),
-    month: moment().month() + 1,
-    day: moment().date()
-  };
-  public minInboundDate: NgbDateStruct = {
-    year: moment().year(),
-    month: moment().month() + 1,
-    day: moment().date()
-  };
-  public maxDate: NgbDateStruct = {
-    // ENT-1557 - max Evolvi search date is 6 months in future
-    year: moment().add('month', 6).year(),
-    month: moment().add('month', 6).month(),
-    day: moment().add('month', 6).date()
-  };
-  private _timeArray: ValueDisplay[];
-  private _canCombine: any;
-  private _chosenOutboundTicket: RecursivePartial<RailTicketOption>;
-  private _chosenInboundTicket: RecursivePartial<RailTicketOption>;
-  private _chosenOutboundJourney: RecursivePartial<RailJourneyOption>;
-  private _chosenInboundJourney: RecursivePartial<RailJourneyOption>;
-  private _chosenTicketGroup: RailTicketGroup;
-  private _viaLocation: string;
-  private _travellingFrom: string;
-  private _travellingTo: string;
-  protected _originalUserSearch: RailTempParams;
-
-  get chosenTicketGroup(): RailTicketGroup {
-    return this._chosenTicketGroup;
-  }
-
-  get chosenTotalPrice(): number {
-    if (this._chosenOutboundTicket) {
-      if (this._chosenInboundTicket) {
-        // now check if they are returns or dual
-        if (
-          this._chosenOutboundTicket.singleOrReturn ===
-            RailTicketOptionType.Return &&
-          this._chosenInboundTicket.singleOrReturn ===
-            RailTicketOptionType.Return
-        ) {
-          // they should both have the same price
-          return this._chosenOutboundTicket.price;
-        }
-        return (
-          this._chosenOutboundTicket.price + this._chosenInboundTicket.price
-        );
-      }
-
-      return this._chosenOutboundTicket.price;
-    }
-
-    return 0;
-  }
-
-  get chosenTickets(): any {
-    return {
-      Outbound: this._chosenOutboundTicket,
-      Inbound: this._chosenInboundTicket
-    };
-  }
-
-  get chosenOutboundJourney(): RecursivePartial<RailJourneyOption> {
-    return this._chosenOutboundJourney;
-  }
-
-  get chosenInboundJourney(): RecursivePartial<RailJourneyOption> {
-    return this._chosenInboundJourney;
-  }
-
-  get openReturn(): boolean {
-    return this.tempParams.openReturn;
-  }
-
-  set openReturn(newVal: boolean) {
-    this.tempParams.openReturn = newVal;
-
-    if (newVal) {
-      this.tempParams.chosenSearchType = RailJourneyType.OpenReturnJourney;
-    }
-    this._isValid();
-  }
-
-  get chosenSearchType(): RailJourneyType {
-    return this.tempParams.chosenSearchType;
-  }
-
-  set chosenSearchType(newType: RailJourneyType) {
-    this.tempParams.chosenSearchType = newType;
-    if (newType === RailJourneyType.SingleJourney) {
-      this.openReturn = false;
-    }
-    this._isValid();
-  }
-
-  get noOfAdults(): number {
-    return this.tempParams.noOfAdults;
-  }
-
-  set noOfAdults(adults: number) {
-    this.tempParams.noOfAdults = adults;
-    this._isValid();
-  }
-
-  get noOfChildren(): number {
-    return this.tempParams.noOfChildren;
-  }
-
-  set noOfChildren(children: number) {
-    this.tempParams.noOfChildren = children;
-    this._isValid();
-  }
-
-  get travellingTo(): any {
-    return this.tempParams.travellingTo;
-  }
-
-  set travellingTo(tt: any) {
-    this.tempParams.travellingTo = tt;
-
-    this._travellingTo = '';
-    if (tt?.railstation?.id) {
-      this._travellingTo = tt.railstation.id;
-    }
-
-    this._isValid();
-  }
-
-  get travellingFrom(): any {
-    return this.tempParams.travellingFrom;
-  }
-
-  set travellingFrom(tt: any) {
-    this.tempParams.travellingFrom = tt;
-    this._travellingFrom = '';
-    if (tt?.railstation?.id) {
-      this._travellingFrom = tt.railstation.id;
-    }
-
-    this._isValid();
-  }
-
-  get chosenRailClass(): RailClass {
-    return this.tempParams.chosenSearchClass;
-  }
-
-  set chosenRailClass(newClass: RailClass) {
-    this.tempParams.chosenSearchClass = newClass;
-  }
-
-  get chosenSearchClass(): RailClass {
-    return this.tempParams.chosenSearchClass;
-  }
-
-  set chosenSearchClass(classR: RailClass) {
-    this.tempParams.chosenSearchClass = classR;
-    this._isValid();
-  }
-
-  get extraTime(): boolean {
-    return this.tempParams.extraTime;
-  }
-
-  set extraTime(extra: boolean) {
-    this.tempParams.extraTime = extra;
-    this._isValid();
-  }
-
-  get via(): boolean {
-    return this.tempParams.via;
-  }
-
-  set via(via: boolean) {
-    this.tempParams.via = via;
-    this._isValid();
-  }
-
-  get viaLocation(): any {
-    return this.tempParams.viaLocation;
-  }
-
-  set viaLocation(viaLocation: any) {
-    this.tempParams.viaLocation = viaLocation;
-
-    this._viaLocation = '';
-    if (viaLocation?.railstation?.id) {
-      this._viaLocation = viaLocation.railstation.id;
-    }
-
-    this._isValid();
-  }
-
-  get outBoundDateTime(): moment.Moment {
-    return this.tempParams.outBoundDateTime;
-  }
-
-  set outBoundDateTime(newDateTime: moment.Moment) {
-    this.tempParams.outBoundDateTime = newDateTime;
-    if (newDateTime && newDateTime.isValid()) {
-      this._outbound_date = this.helpers.momentToNgDate(newDateTime);
-      this._outbound_time = moment(newDateTime).format('HHmm')
-        ? moment(newDateTime).format('HHmm')
-        : '0700';
-    }
-
-    this.minInboundDate = {
-      year: newDateTime.year(),
-      month: newDateTime.month() + 1,
-      day: newDateTime.date()
-    };
-
-    if (
-      this.outBoundDateTime &&
-      this.inBoundDateTime &&
-      this.outBoundDateTime.isAfter(this.inBoundDateTime)
-    ) {
-      this.inBoundDateTime = this.inBoundDateTime
-        .set('date', newDateTime.date())
-        .set('month', newDateTime.month())
-        .set('year', newDateTime.year());
-    }
-
-    this._isValid();
-  }
-
-  get outboundCriteria(): RailSearchCriteria {
-    return this.tempParams.outboundCriteria;
-  }
-
-  set outboundCriteria(newCrit: RailSearchCriteria) {
-    // console.warn(`+++ Setting New Criteria: ${newCrit} +++`);
-    this.tempParams.outboundCriteria = newCrit;
-
-    this._isValid();
-  }
-
-  get inBoundDateTime(): moment.Moment {
-    return this.tempParams.inBoundDateTime;
-  }
-
-  set inBoundDateTime(newDateTime: moment.Moment) {
-    this.tempParams.inBoundDateTime = newDateTime;
-    if (newDateTime && newDateTime.isValid()) {
-      this._return_date = this.helpers.momentToNgDate(newDateTime);
-      this._return_time = moment(newDateTime).format('HHmm')
-        ? moment(newDateTime).format('HHmm')
-        : '1600';
-    }
-    this._isValid();
-  }
-
-  // !date and time is handled differently for LU
-  private _outbound_date: NgbDateStruct = null;
-
-  get outbound_date(): NgbDateStruct {
-    return this._outbound_date;
-  }
-
-  set outbound_date(value: NgbDateStruct) {
-    this._outbound_date = value;
-    this._updateOutboundDateTime();
-  }
-
-  private _outbound_time: string = null;
-  get outbound_time(): string {
-    return this._outbound_time;
-  }
-
-  set outbound_time(value: string) {
-    this._outbound_time = value;
-    this._updateOutboundDateTime();
-  }
-
-  private _return_date: NgbDateStruct = null;
-
-  get return_date(): NgbDateStruct {
-    return this._return_date;
-  }
-
-  set return_date(value: NgbDateStruct) {
-    this._return_date = value;
-    this._updateReturnDateTime();
-  }
-
-  private _return_time: string = null;
-  get return_time(): string {
-    return this._return_time;
-  }
-
-  set return_time(value: string) {
-    this._return_time = value;
-    this._updateReturnDateTime();
-  }
-
-  get returnCriteria(): RailSearchCriteria {
-    return this.tempParams.returnCriteria;
-  }
-
-  set returnCriteria(newCrit: RailSearchCriteria) {
-    this.tempParams.returnCriteria = newCrit;
-    this._isValid();
-  }
-
-  get carnetTicket(): boolean {
-    return this.tempParams.carnetTicket;
-  }
-
-  set carnetTicket(newCarnet: boolean) {
-    this.tempParams.carnetTicket = newCarnet;
-    this._isValid();
-  }
-
-  get disableAutoDiscounts(): boolean {
-    return this.tempParams.disableAutoDiscounts;
-  }
-
-  set disableAutoDiscounts(newDis: boolean) {
-    this.tempParams.disableAutoDiscounts = newDis;
-    this._isValid();
-  }
-
-  get prioritiseByPrice(): boolean {
-    return this.tempParams.prioritiseByPrice;
-  }
-
-  set prioritiseByPrice(newPriority: boolean) {
-    this.tempParams.prioritiseByPrice = newPriority;
-    this._isValid();
-  }
-
-  get applyRailcards(): boolean {
-    return this.tempParams.applyRailcards;
-  }
-
-  set applyRailcards(apCards: boolean) {
-    this.tempParams.applyRailcards = apCards;
-  }
-
-  get railCards(): ReferenceRailCardQualifier[] {
-    return this.tempParams.railCards;
-  }
-
-  set railCards(value: ReferenceRailCardQualifier[]) {
-    this.tempParams.railCards = value;
-  }
-
-  public get timeArray(): ValueDisplay[] {
-    this._timeArray =
-      this._timeArray ||
-      Array(48)
-        .fill(0)
-        .map((_, index: number) => {
-          return {
-            value:
-              Math.floor(index / 2)
-                .toString()
-                .padStart(2, '0') +
-              ((index % 2) * 30).toString().padStart(2, '0'),
-            display:
-              Math.floor(index / 2)
-                .toString()
-                .padStart(2, '0') +
-              ':' +
-              ((index % 2) * 30).toString().padStart(2, '0')
-          };
-        });
-    return this._timeArray;
-  }
-
-  getAirportExpressStations(): { code: string; name: string }[] {
-    return this.airportExpressStations;
-  }
-
-  get airportExpressStation(): string {
-    return this.tempParams.airportExpressStation;
-  }
-
-  set airportExpressStation(station: string) {
-    this.tempParams.airportExpressStation = station;
-    this._setAirportExpressStations();
-    this._isValid();
-  }
-
-  get isAirportExpress(): boolean {
-    return this.tempParams.isAirportExpress;
-  }
-
-  set isAirportExpress(value: boolean) {
-    this.tempParams.isAirportExpress = value;
-    this.tempParams.openReturn = value;
-    this.tempParams.chosenSearchType = value
-      ? RailJourneyType.OpenReturnJourney
-      : RailJourneyType.ReturnJourney;
-    this._isValid();
-  }
-
-  setAirportExpressStationIds(stationIds: {
-    departureLocationId: string;
-    arrivalLocationId: string;
-  }): void {
-    const { departureLocationId, arrivalLocationId } = stationIds;
-    if (departureLocationId && arrivalLocationId) {
-      this._travellingFrom = departureLocationId;
-      this._travellingTo = arrivalLocationId;
-      this._isValid();
-    }
-  }
-
-  private _cheapestStandard: RailTicketOption = null;
-  get cheapestStandard(): RailTicketOption {
-    return this._cheapestStandard;
-  }
-  private _cheapestFirst: RailTicketOption = null;
-  get cheapestFirst(): RailTicketOption {
-    return this._cheapestFirst;
-  }
-
-  constructor(
-    private Railfetcher: BaseRailQuoteFetcher<Q>,
-    private getRailStationFetcher: BaseGetRailStationFetcher<GRS_Q>,
-    private helpers: BaseHelperRoutines,
-    private basketService: EnterpriseBasketServiceInterface,
-    storageService: BaseStorageService,
-    private searchService: EnterpriseSearchServiceInterface
-  ) {
-    super(storageService);
-
-    const data: {
-      query: {};
-      tempParams: RailTempParams;
-      originalUserSearch: RailTempParams;
-    } = storageService.getSessionItem(
-      RailEnterpriseSearch.STORAGE_SESSION_PARAMS
-    ) || {
-      query: {},
-      tempParams: {} as RailTempParams,
-      originalUserSearch: {} as RailTempParams
-    };
-
-    this.updateTempParams(this.searchService.makeRailQuery(data.tempParams));
-    this._originalUserSearch = data.originalUserSearch;
-
-    if (this._originalUserSearch && this._originalUserSearch.chosenSearchType) {
-      this.chosenSearchType = this._originalUserSearch.chosenSearchType;
-    }
-
-    if (searchService.shouldAddTravellerSubscription()) {
-      searchService.travellerInformation.subscribe(
-        (travellers: Traveller[]) => {
-          this.travellers = travellers;
-          const splitTravellers = this.helpers.selectedTravellers(
-            travellers,
-            ServiceType.Rail
-          );
-          this.tempParams.noOfAdults = splitTravellers.adults.length;
-          this.tempParams.noOfChildren = splitTravellers.children.length;
-          this.travellers = travellers;
-          this._isValid();
-        }
-      );
-    }
-    this._isValid();
-    const results =
-      storageService.getSessionItemAsList<RailQuoteResultArray>(
-        this.resultsSessionName
-      ) || [];
-    // if (results == null && this.isValid) {
-    //   searchService.startSearches();
-    // }
-    this._cheapestResultPrice = this.updateLowestPrice(results);
-    this.results.next(results || []);
-  }
-
-  protected resetQuery(): void {
-    this.updateTempParams(this.searchService.makeRailQuery());
-    this._isValid();
-  }
-
-  private _setAirportExpressStations() {
-    const parsedStation =
-      this.airportExpressStationsCodes[this.airportExpressStation];
-    console.log('--- Parsed Station is :', parsedStation);
-    if (parsedStation) {
-      this._travellingFrom = parsedStation.dep;
-      this._travellingTo = parsedStation.arr;
-    }
-  }
-
-  private _isValid() {
-    this.storageService.setSessionItem(
-      RailEnterpriseSearch.STORAGE_SESSION_PARAMS,
-      {
-        tempParams: this.tempParams,
-        originalUserSearch: this.originalUserSearch
-      }
-    );
-
-    this.validationMessages = [];
-
-    const now = moment();
-
-    if (!this._travellingFrom) {
-      this.validationMessages.push('Please Enter a From Location.');
-    }
-
-    if (!this._travellingTo) {
-      this.validationMessages.push('Please Enter a To Location.');
-    }
-
-    if (this.outBoundDateTime?.isBefore(now)) {
-      this.validationMessages.push(
-        'Departure Date/Time cannot be in the past.'
-      );
-    }
-
-    if (
-      this.chosenSearchType === RailJourneyType.ReturnJourney ||
-      this.chosenSearchType === RailJourneyType.DualSingleJourney
-    ) {
-      // check for return specific validations in here
-
-      if (this.inBoundDateTime?.isSameOrBefore(this.outBoundDateTime)) {
-        this.validationMessages.push(
-          'Return Date/Time must be after Departure Date/Time'
-        );
-      }
-    }
-
-    if (this.via) {
-      if (!this.tempParams.viaLocation) {
-        this.validationMessages.push('Please enter a via location.');
-      }
-    }
-
-    if (this.tempParams.noOfAdults + this.tempParams.noOfChildren < 1) {
-      this.validationMessages.push('There must be at least 1 traveller');
-    }
-
-    this.isValid.next(this.validationMessages.length === 0);
-    this.messages.next(this.validationMessages);
-  }
-
-  startSearch(): Promise<boolean> {
-    this.results.next([]);
-
-    if (this.isValid.value) {
-      this._originalUserSearch = Object.freeze({ ...this.tempParams });
-      this.storageService.setSessionItem(
-        RailEnterpriseSearch.STORAGE_SESSION_PARAMS,
-        {
-          tempParams: this.tempParams,
-          originalUserSearch: this.originalUserSearch
-        }
-      );
-      const query = this.getSearchQuery();
-      this.searchService.saveRecentSearch(this.getRecentSearchQuery(query));
-      return this._startSearch(
-        this.Railfetcher.fetchList(query).pipe(
-          map((result) => {
-            if (this.removePassingPointsFromResults) {
-              result = this._removeCallingPoints(result);
-            }
-
-            return result;
-          })
-        )
-      );
-    } else {
-      return Promise.resolve(false);
-    }
-  }
-
-  getRecentSearchQuery(
-    query: SearchRailQueryVariables
-  ): SaveRecentSearchMutationVariables {
-    const recentSearchQuery: RailRecentSearchArgs = query;
-    
-    if (this.isAirportExpress) {
-      recentSearchQuery.isAirportExpress = this.isAirportExpress;
-    }
-
-    if (this.airportExpressStation) {
-      recentSearchQuery.airportExpressStation = this.airportExpressStation;
-    }
-
-    return {
-      serviceType: ServiceType.Rail,
-      searchArgs: recentSearchQuery,
-      travelDate: this.outBoundDateTime.format(),
-      travellers: this.helpers.getTravellersId(this.travellers)
-    };
-  }
-
-  public startRecentSearch(recentSearch: RecentSearch): void {
-    this.chosenSearchType = recentSearch.searchArgs.journeyType;
-    this.chosenSearchClass = recentSearch.searchArgs.class;
-    this.extraTime = recentSearch.searchArgs.extraTimeToChange;
-    this.isAirportExpress = recentSearch.searchArgs.isAirportExpress;
-    this.airportExpressStation = recentSearch.searchArgs.airportExpressStation;
-
-    // get outBoundDateTime, inBoundDateTime and outboundCriteria ,returnCriteria
-    this.outBoundDateTime = recentSearch.searchArgs.outboundDepartureDateTime
-      ? moment(recentSearch.searchArgs.outboundDepartureDateTime)
-      : moment(recentSearch.searchArgs.outboundArrivalDateTime);
-    this.outboundCriteria = this.getCriteria(
-      recentSearch.searchArgs.outboundDepartureDateTime,
-      recentSearch.searchArgs.outboundArrivalDateTime
-    );
-
-    if (recentSearch.searchArgs.journeyType === RailJourneyType.ReturnJourney) {
-      this.inBoundDateTime = recentSearch.searchArgs.returnDepartureDateTime
-        ? moment(recentSearch.searchArgs.returnDepartureDateTime)
-        : moment(recentSearch.searchArgs.returnArrivalDateTime);
-
-      this.returnCriteria = this.getCriteria(
-        recentSearch.searchArgs.returnDepartureDateTime,
-        recentSearch.searchArgs.returnArrivalDateTime
-      );
-    }
-
-    if (
-      recentSearch.searchArgs.journeyType === RailJourneyType.OpenReturnJourney
-    ) {
-      this.openReturn = true;
-    }
-
-    this.applyRailcards = recentSearch.searchArgs?.railCardQualifiers?.length
-      ? true
-      : false;
-    if (this.applyRailcards) {
-      this.railCards = recentSearch.searchArgs.railCardQualifiers;
-    }
-
-    // get from, to, via
-    combineLatest([
-      this.getRailStationById(recentSearch.searchArgs.departureLocationId),
-      this.getRailStationById(recentSearch.searchArgs.arrivalLocationId)
-    ]).subscribe(([departureStation, arrivalStation]) => {
-      if (departureStation && arrivalStation) {
-        this.travellingTo = {
-          name: arrivalStation.name,
-          railstation: {
-            id: arrivalStation.id,
-            name: arrivalStation.name,
-            nlcCode: arrivalStation.nlcCode,
-            stationCode: arrivalStation.stationCode,
-            trainlineCode: arrivalStation.trainlineCode,
-            trainlineUniqueCode: arrivalStation.trainlineUniqueCode
-          }
-        };
-
-        this.travellingFrom = {
-          name: departureStation.name,
-          railstation: {
-            id: departureStation.id,
-            name: departureStation.name,
-            nlcCode: departureStation.nlcCode,
-            stationCode: departureStation.stationCode,
-            trainlineCode: departureStation.trainlineCode,
-            trainlineUniqueCode: departureStation.trainlineUniqueCode
-          }
-        };
-
-        if (recentSearch.searchArgs.viaLocationId) {
-          this.via = true;
-          this.getRailStationById(
-            recentSearch.searchArgs.viaLocationId
-          ).subscribe((viaLocation) => {
-            this.viaLocation = {
-              name: viaLocation.name,
-              railstation: {
-                id: viaLocation.id,
-                name: viaLocation.name,
-                nlcCode: viaLocation.nlcCode,
-                stationCode: viaLocation.stationCode,
-                trainlineCode: viaLocation.trainlineCode,
-                trainlineUniqueCode: viaLocation.trainlineUniqueCode
-              }
-            };
-            this.searchService.startSearches();
-          });
-        }
-
-        this.searchService.startSearches();
-      }
-    });
-  }
-
-  private _removeCallingPoints(
-    journeys: RailJourneyOptions[]
-  ): RailJourneyOptions[] {
-    journeys[0].outbound = journeys[0].outbound.map((outbound) => {
-      outbound.segments.map((segment) => {
-        segment.callingPoints = segment.callingPoints.filter(
-          (callingPoint) =>
-            callingPoint.stoppingPattern !== RailEnterpriseSearch.PASSING_POINT
-        );
-        return segment;
-      });
-      return outbound;
-    });
-
-    return journeys;
-  }
-
-  private _updateOutboundDateTime(): void {
-    if (this._outbound_date && this._outbound_time) {
-      const time = this.helpers.ngDateToMoment(
-        this._outbound_date,
-        this._outbound_time
-      );
-      this.outBoundDateTime = time.isValid() ? time : null;
-      this._isValid();
-    }
-  }
-
-  private _updateReturnDateTime(): void {
-    if (this._return_date && this._return_time) {
-      const time = this.helpers.ngDateToMoment(
-        this._return_date,
-        this._return_time
-      );
-      this.inBoundDateTime = time.isValid() ? time : null;
-      this._isValid();
-    }
-  }
-
-  getSearchQuery(): SearchRailQueryVariables {
-    const query: SearchRailQueryVariables = {
-      countryCode: 'GB',
-      journeyType: this.tempParams.chosenSearchType,
-      adults: this.tempParams.noOfAdults,
-      arrivalLocationId: this._travellingTo,
-      departureLocationId: this._travellingFrom,
-      children: this.tempParams.noOfChildren,
-      class: this.tempParams.chosenSearchClass,
-      extraTimeToChange: this.tempParams.extraTime,
-      outboundArrivalDateTime: this.tempParams.outBoundDateTime,
-      outboundDepartureDateTime: this.tempParams.outBoundDateTime,
-      returnArrivalDateTime: this.tempParams.inBoundDateTime,
-      returnDepartureDateTime: this.tempParams.inBoundDateTime,
-      viaLocationId: this._viaLocation,
-      railCardQualifiers: this.tempParams.railCards?.map(
-        (railCard: ReferenceRailCardQualifier) => {
-          return railCard.code;
-        }
-      )
-    };
-
-    if (this.tempParams.noOfChildren === 0) {
-      query.children = null;
-    }
-
-    if (this._viaLocation === '') {
-      query.viaLocationId = null;
-    }
-
-    switch (this.tempParams.outboundCriteria) {
-      case RailSearchCriteria.Depart:
-        query.outboundArrivalDateTime = null;
-        break;
-      case RailSearchCriteria.Arrive:
-        query.outboundDepartureDateTime = null;
-        break;
-      default:
-        console.warn(
-          `+++ Unknown Criteria: ${this.tempParams.outboundCriteria} +++`
-        );
-    }
-
-    switch (this.tempParams.returnCriteria) {
-      case RailSearchCriteria.Depart:
-        query.returnArrivalDateTime = null;
-        break;
-      case RailSearchCriteria.Arrive:
-        query.returnDepartureDateTime = null;
-        break;
-      default:
-        console.warn(
-          `+++ Unknown Criteria: ${this.tempParams.returnCriteria} +++`
-        );
-    }
-
-    switch (this.tempParams.chosenSearchType) {
-      case RailJourneyType.SingleJourney:
-      case RailJourneyType.OpenReturnJourney:
-        query.returnDepartureDateTime = null;
-        query.returnArrivalDateTime = null;
-        break;
-    }
-
-    return this.helpers.removeNulls<SearchRailQueryVariables>(query);
-  }
-
-  private getRailStationById(id: string): Observable<RailStation> {
-    if (id) {
-      return this.getRailStationFetcher.fetchList({ id }).pipe(take(1));
-    } else {
-      return of();
-    }
-  }
-
-  private getCriteria(
-    departureDateTime: string,
-    arrivalDateTime: string
-  ): RailSearchCriteria {
-    if (departureDateTime) {
-      return RailSearchCriteria.Depart;
-    } else if (arrivalDateTime) {
-      return RailSearchCriteria.Arrive;
-    }
-    {
-      return null;
-    }
-  }
-
-  createTicketGroups(results: RailJourneyOptions[]): RailTicketGroups {
-    let tickets: RailTicketGroups = {};
-    let ticketId = '';
-    this._canCombine = {};
-
-    let ticketGroupsOutbound = this.setTicketsGroups(results[0].outbound);
-    let ticketGroupsReturn = this.setTicketsGroups(results[0].return);
-    ticketGroupsOutbound = this.sortTicketPrices(ticketGroupsOutbound);
-    ticketGroupsReturn = this.sortTicketPrices(ticketGroupsReturn);
-
-    Object.keys(ticketGroupsOutbound).map((key) => {
-      ticketGroupsOutbound[key].map((tkt: RailTicketOption) => {
-        ticketId = `${tkt.type}${tkt.singleOrReturn}`;
-        const identifier = tkt.identifiers.journeyIdentifier;
-        const identifierObj: RailResultIndifiers = {};
-        identifierObj[identifier] = {
-          price: tkt.price,
-          isChild: false,
-          fareIdentifier: tkt.identifiers.fareIdentifier,
-          availableSeats: tkt.availableSeats
-        };
-        if (tickets[key]) {
-          this.updateCanCombine(tkt);
-          identifierObj[tkt.identifiers.journeyIdentifier].isChild = false;
-          if (tickets[tkt.type].header.price === tkt.price) {
-            tickets[tkt.type].resultIndifiers.push(identifier);
-            tickets[tkt.type].resultIndifiersPrices = {
-              ...tickets[tkt.type].resultIndifiersPrices,
-              ...identifierObj
-            };
-          } else if (tkt.price) {
-            // add identifier and price even if it is a child
-            if (!tickets[tkt.type].resultIndifiers.includes(identifier)) {
-              tickets[tkt.type].resultIndifiers.push(identifier);
-              tickets[tkt.type].resultIndifiersPrices = {
-                ...tickets[tkt.type].resultIndifiersPrices,
-                ...identifierObj
-              };
-            }
-            identifierObj[identifier].isChild = true;
-            const childTicket = {
-              header: tkt,
-              children: [],
-              open: false,
-              direction: RailDirection.Outbound,
-              resultIndifiers: [identifier],
-              resultIndifiersPrices: identifierObj,
-              child: true,
-              ticketId,
-              selectedIndicies: [],
-              disabledIndicies: [],
-              showLimitedSeats: false
-            } as RailTicketGroup;
-            tickets[tkt.type].children.push(childTicket);
-          }
-        } else {
-          this._canCombine[tkt.type] = {};
-          this.updateCanCombine(tkt);
-          tickets[tkt.type] = {
-            header: tkt,
-            children: [],
-            open: false,
-            direction: RailDirection.Outbound,
-            resultIndifiers: [identifier],
-            resultIndifiersPrices: identifierObj,
-            child: false,
-            ticketId,
-            selectedIndicies: [],
-            disabledIndicies: [],
-            showLimitedSeats: false
-          } as RailTicketGroup;
-        }
-      });
-    });
-
-    Object.keys(ticketGroupsReturn).map((key) => {
-      ticketGroupsReturn[key].map((tkt: RailTicketOption) => {
-        ticketId = `${tkt.type}${tkt.singleOrReturn}`;
-        const identifier = tkt.identifiers.journeyIdentifier;
-        const identifierObj: RailResultIndifiers = {};
-        identifierObj[identifier] = {
-          price: tkt.price,
-          isChild: true,
-          fareIdentifier: tkt.identifiers.fareIdentifier,
-          availableSeats: tkt.availableSeats
-        };
-        if (
-          tickets[tkt.type] &&
-          tkt.price &&
-          tkt.price !== tickets[tkt.type].header.price
-        ) {
-          this.updateCanCombine(tkt);
-          identifierObj[identifier].isChild = true;
-          const childTicket = {
-            header: tkt,
-            children: [],
-            open: false,
-            direction: RailDirection.Inbound,
-            resultIndifiers: [identifier],
-            resultIndifiersPrices: identifierObj,
-            child: true,
-            ticketId,
-            selectedIndicies: [],
-            disabledIndicies: [],
-            showLimitedSeats: false
-          } as any;
-          tickets[tkt.type].children.push(childTicket);
-        } else if (!tickets[tkt.type]) {
-          this.updateCanCombine(tkt);
-          tickets[tkt.type] = {
-            header: tkt,
-            children: [],
-            open: false,
-            direction: RailDirection.Inbound,
-            resultIndifiers: [identifier],
-            resultIndifiersPrices: identifierObj,
-            child: false,
-            ticketId,
-            selectedIndicies: [],
-            disabledIndicies: [],
-            showLimitedSeats: false
-          } as any;
-        } else if (!tkt.price || tkt.price === tickets[tkt.type].header.price) {
-          this.updateCanCombine(tkt);
-          tickets[tkt.type].resultIndifiers.push(identifier);
-          identifierObj[identifier].isChild = false;
-          tickets[tkt.type].resultIndifiersPrices = {
-            ...tickets[tkt.type].resultIndifiersPrices,
-            ...identifierObj
-          };
-        }
-      });
-    });
-
-    let combineTickets = { ...tickets };
-    tickets = this.combineChildTickets(combineTickets);
-
-    // console.log('groups: ', tickets);
-    // console.log('Can Combine: ', this._canCombine);
-    return tickets;
-  }
-
-  combineChildTickets(tickets: RailTicketGroups): RailTicketGroups {
-    const values = Object.values(tickets);
-    for (let i = 0; i < values.length; i++) {
-      const childObject: { [key: string]: RailTicketGroup } = {};
-
-      for (let j = 0; j < values[i].children.length; j++) {
-        const child = values[i].children[j];
-        const fareIdentifier = child.header.identifiers.fareIdentifier;
-        if (childObject[fareIdentifier]) {
-          childObject[fareIdentifier].resultIndifiers.push(
-            child.resultIndifiers[0]
-          );
-          childObject[fareIdentifier].resultIndifiersPrices = {
-            ...childObject[fareIdentifier].resultIndifiersPrices,
-            ...child.resultIndifiersPrices
-          };
-        } else {
-          childObject[fareIdentifier] = child;
-        }
-      }
-      // console.log(childObject);
-      // console.log(values[i]['header']['type']);
-      tickets[values[i].header.type].children = Object.values(childObject);
-    }
-    tickets = this.sortTicketChildrenPrices(tickets);
-    return tickets;
-  }
-  setTicketsGroups(results: RailJourneyOption[]): TicketGroups {
-    let ticketGroups: TicketGroups = {};
-    results.forEach((out: RailJourneyOption) => {
-      out.providers.forEach((prov: RailProvider) => {
-        prov.ticketOptions.forEach((tkt: RailTicketOption) => {
-          ticketGroups[tkt.type]
-            ? ticketGroups[tkt.type].push(tkt)
-            : (ticketGroups[tkt.type] = [tkt]);
-        });
-      });
-    });
-    return ticketGroups;
-  }
-
-  updateFromPreviousSearches(
-    previousItems: Record<ServiceType, BasketItem>
-  ): void {}
-
-  updateCanCombine(tkt: RailTicketOption): void {
-    (tkt.identifiers.allowedWith || []).forEach((allowed) => {
-      if (!this._canCombine[tkt.type][allowed.journeyIdentifier]) {
-        this._canCombine[tkt.type][allowed.journeyIdentifier] = [
-          allowed.fareIdentifier
-        ];
-      } else {
-        this._canCombine[tkt.type][allowed.journeyIdentifier].push(
-          allowed.fareIdentifier
-        );
-      }
-    });
-  }
-
-  toggleTicketSelect(
-    ticket: RailTicketGroup,
-    way: 'departs' | 'returns',
-    timeSlotId: string,
-    ticketId: string,
-    fareIdentifier: string,
-    ticketsGroups: RailTicketGroups
-  ): RailTicketGroups {
-    console.log(ticket);
-
-    if (!ticket) {
-      return;
-    }
-
-    this._chosenTicketGroup = ticket;
-    const keys = Object.keys(ticketsGroups);
-    let selectedTicket = null;
-    let departsTicket: RailTicketOption[] = [];
-    let returnTicket: RailTicketOption[] = [];
-    let isUnselected = false;
-    keys.forEach((key) => {
-      let group = ticketsGroups[key] as RailTicketGroup;
-
-      if (
-        group.ticketId === ticketId &&
-        group.selectedIndicies.includes(timeSlotId)
-      ) {
-        if (way === 'departs') {
-          group.selectedIndicies = [];
-          departsTicket = [];
-          returnTicket = [];
-          this._chosenInboundTicket = null;
-          this._chosenInboundJourney = null;
-          this._chosenTicketGroup = null;
-          group.children.forEach((child) => {
-            child.selectedIndicies = [];
-          });
-        } else {
-          group.selectedIndicies = group.selectedIndicies.filter(
-            (Indicies) => Indicies !== timeSlotId
-          );
-          returnTicket = returnTicket.filter(
-            (Indicies) => Indicies !== group.header
-          );
-        }
-      } else {
-        if (
-          group.ticketId === ticketId &&
-          group.header.identifiers.fareIdentifier === fareIdentifier &&
-          way === 'departs'
-        ) {
-          group = this.clearUnneededTickets(way, group, timeSlotId);
-          group.selectedIndicies.push(timeSlotId);
-          way === 'departs'
-            ? departsTicket.push(group.header)
-            : returnTicket.push(group.header);
-          selectedTicket = group.header;
-        } else {
-          // may have to modify this for dual singles
-          if (way === 'departs') {
-            group.selectedIndicies = [];
-          } else if (ticketId.includes(group.header.type)) {
-            selectedTicket = group.header;
-          }
-        }
-
-        group.children.forEach((child) => {
-          if (child.selectedIndicies.includes(timeSlotId)) {
-            if (way === 'departs') {
-              child.selectedIndicies = [];
-              departsTicket = [];
-              returnTicket = [];
-              this._chosenInboundTicket = null;
-              this._chosenInboundJourney = null;
-              isUnselected = true;
-            } else {
-              child.selectedIndicies = child.selectedIndicies.filter(
-                (Indicies) => Indicies !== timeSlotId
-              );
-              returnTicket = returnTicket.filter(
-                (Indicies) => Indicies !== group.header
-              );
-            }
-          } else {
-            if (
-              child.ticketId === ticketId &&
-              child.header.identifiers.fareIdentifier === fareIdentifier
-            ) {
-              if (
-                (way === 'departs' &&
-                  child.direction !== RailDirection.Inbound) ||
-                (way !== 'departs' && child.direction === RailDirection.Inbound)
-              ) {
-                child = this.clearUnneededTickets(way, child, timeSlotId);
-                child.selectedIndicies.push(timeSlotId);
-                way === 'departs'
-                  ? departsTicket.push(child.header)
-                  : returnTicket.push(child.header);
-                selectedTicket = child.header;
-              } else if (isUnselected) {
-                child.selectedIndicies = [];
-              }
-            } else {
-              child.selectedIndicies = [];
-            }
-          }
-        });
-      }
-    });
-
-    // now we need to mark tickets as disabled if they are returns that do not match the selected return
-    // or on overlapping times
-    if (way === 'departs') {
-      this._chosenOutboundTicket = this.helpers.clone(selectedTicket);
-
-      // now go over the full results and find the matching timeslot
-      departsTicket.length
-        ? (this._chosenOutboundJourney = this.results.value[0].outbound.find(
-            (out: RailJourneyOption) => {
-              return out.identifiers.journeyIdentifier === timeSlotId;
-            }
-          ))
-        : (this._chosenOutboundJourney = null);
-
-      if (
-        this._chosenInboundTicket &&
-        this._chosenOutboundTicket.singleOrReturn ===
-          RailTicketOptionType.Return &&
-        this._chosenOutboundTicket.identifiers.fareIdentifier !==
-          this._chosenInboundTicket.identifiers.fareIdentifier
-      ) {
-        console.warn('+++ Cannot combine fares, clearing inbound... +++');
-        this._chosenInboundTicket = null;
-        this._chosenInboundJourney = null;
-      }
-    } else if (way === 'returns') {
-      this._chosenInboundTicket = this.helpers.clone(selectedTicket);
-
-      this._chosenInboundTicket
-        ? (this._chosenInboundJourney = this.results.value[0].return.find(
-            (inT: RailJourneyOption) => {
-              return inT.identifiers.journeyIdentifier === timeSlotId;
-            }
-          ))
-        : (this._chosenInboundJourney = null);
-    }
-
-    return ticketsGroups;
-  }
-
-  /**
-   * @description - determine if a fare can be combined with what we currently have selected
-   */
-  canCombine(journeyIdentifier: string, fareIdentifier: string): boolean {
-    // may have to modify this for dual singles later on
-    try {
-      if (
-        this._chosenOutboundTicket &&
-        this._chosenOutboundTicket.singleOrReturn ===
-          RailTicketOptionType.Return &&
-        Number(journeyIdentifier) > 5
-      ) {
-        // greater than 5 only as we are not going to restrict outbounds
-        if (
-          this._canCombine[this._chosenOutboundTicket.type][
-            Number(journeyIdentifier)
-          ]?.includes(fareIdentifier) &&
-          this._chosenOutboundTicket.identifiers.fareIdentifier ===
-            fareIdentifier
-        ) {
-          return true;
-        }
-        return false;
-      }
-    } catch (error) {
-      console.error('+++ Error combining rail fares: ', error, ' +++');
-    }
-
-    return false;
-  }
-
-  clearUnneededTickets(
-    way: string,
-    group: RailTicketGroup,
-    timeSlotId: string
-  ): RailTicketGroup {
-    if (way === 'returns') {
-      group.selectedIndicies = group.selectedIndicies.filter(
-        (indicie: string) => {
-          return Number(indicie) <= 5 || indicie === timeSlotId;
-        }
-      );
-    } else {
-      group.selectedIndicies = group.selectedIndicies.filter(
-        (indicie: string) => {
-          return Number(indicie) > 5 || indicie === timeSlotId;
-        }
-      );
-    }
-
-    return group;
-  }
-
-  getRailStation(
-    code: string,
-    isLoading?: BehaviorSubject<boolean>
-  ): Observable<RailStation> {
-    if (code.length === 3) {
-      isLoading?.next(true);
-      return this.getRailStationFetcher.fetchList({ code }).pipe(
-        tap(() => isLoading?.next(false)),
-        take(1)
-      );
-    } else {
-      return of();
-    }
-  }
-
-  getSelectedRailTicketOption(
-    railJourneyOption: RailJourneyOption,
-    railTicketGroup: RailTicketGroup,
-    providerIndex: number
-  ): RailTicketOption {
-    return railJourneyOption.providers[providerIndex].ticketOptions.find(
-      (ticketOption) =>
-        ticketOption.type === railTicketGroup.header.type &&
-        (ticketOption.price === railTicketGroup.header.price ||
-          ticketOption.identifiers.fareIdentifier ===
-            railTicketGroup.header.identifiers.fareIdentifier)
-    );
-  }
-
-  getLegsFromRailJourneyOption(railJourneyOption: RailJourneyOption): any[] {
-    let legs: any[] = [];
-    if (railJourneyOption?.segments.length) {
-      legs = railJourneyOption.segments.map((segment) => {
-        return {
-          operator: segment.operator,
-          departureDateTime: segment.departDateTime,
-          departureStationName: segment.depart,
-          arrivalDateTime: segment.arriveDateTime,
-          arrivalStationName: segment.arrive
-        };
-      });
-    }
-    return legs;
-  }
-
-  async addSingleJourneyToBasket(
-    serviceId: string,
-    railQuery: SearchRailQueryVariables,
-    railJourneyOption: RailJourneyOption,
-    railTicketGroup: RailTicketGroup
-  ): Promise<boolean> {
-
-    let outTicketExtras: TicketExtras[];
-    // if ticketExtras exists create TicketExtrasObject and added it to the basket
-    if (railJourneyOption.ticketExtras) {
-      outTicketExtras = this.createTicketExtrasObject(railJourneyOption.ticketExtras[0]);
-    }
-    
-    if (railJourneyOption.unsellable) {
-      return Promise.resolve(false);
-    }
-    const intBasket: InternalBasketInterface =
-      await this.basketService.getDefaultBasket();
-    const basket = intBasket?.subject.value;
-    if (basket) {
-      const selectedRailTicketOption = this.getSelectedRailTicketOption(
-        railJourneyOption,
-        railTicketGroup,
-        0
-      );
-      const legs = this.getLegsFromRailJourneyOption(railJourneyOption);
-      const ticketQueueList = selectedRailTicketOption.ticketQueueList.map(
-        (ticketQueueList1) => {
-          return {
-            id: ticketQueueList1.id,
-            name: ticketQueueList1.name,
-            type: ticketQueueList1.type
-          };
-        }
-      );
-
-      const basketItem: RailBasketItem = {
-        basket: basket.id,
-        service: serviceId,
-        detail: {
-          accountsList: selectedRailTicketOption.accountsList.map(
-            (account: RailAccount) => {
-              return { id: account.id, description: account.description };
-            }
-          ),
-          outwardDetail: {
-            arrivalDateTime: railJourneyOption.arriveDateTime,
-            arrivalStationName: railJourneyOption.to,
-            departureDateTime: railJourneyOption.departDateTime,
-            departureStationName: railJourneyOption.from,
-            supplierTickets: [
-              {
-                supplierName: railJourneyOption.providers[0].name,
-                ticketDescription: selectedRailTicketOption.type,
-                price: selectedRailTicketOption.price,
-                legs
-              }
-            ]
-          },
-          transactionIdentifier:
-            railJourneyOption.identifiers.transactionIdentifier,
-          outbound: {
-            fareIdentifiers: [
-              selectedRailTicketOption.identifiers.fareIdentifier
-            ],
-            journeyIdentifier: selectedRailTicketOption.identifiers.journeyIdentifier
-          },
-          ticketQueueList
-        },
-        adults: railQuery.adults,
-        price: selectedRailTicketOption.price,
-        currency: selectedRailTicketOption.currency as CurrencyCode,
-        searchQuery: railQuery,
-        co2PerItem: railJourneyOption.co2PerItem,
-        co2PerPassenger: railJourneyOption.co2PerPassenger,
-        outboundDate: railJourneyOption.departDateTime
-      }
-
-      // if outTicketExtras exists add the object to basketItem
-      if (outTicketExtras) {
-        basketItem.detail.outbound.ticketExtras = outTicketExtras;
-      }
-
-      return this.basketService.addToBasket(
-        basketItem,
-        intBasket,
-        this.searchService,
-        this.travellers
-      );
-    }
-    return Promise.resolve(false);
-  }
-
-  async addReturnJourneyToBasket(
-    serviceId: string,
-    railQuery: SearchRailQueryVariables,
-    outbound: RailJourneyOption,
-    inbound: RailJourneyOption,
-    railTicketGroup: RailTicketGroup
-  ): Promise<boolean> {
-    if (outbound.unsellable) {
-      return Promise.resolve(false);
-    }
-
-    let inTicketExtras: TicketExtras[];
-    let outTicketExtras: TicketExtras[];
-
-    // if ticketExtras exists create TicketExtrasObject and added it to the basket
-    if (inbound.ticketExtras) {
-      inTicketExtras = this.createTicketExtrasObject(inbound.ticketExtras[0]);
-    }
-
-    if (outbound.ticketExtras) {
-      outTicketExtras = this.createTicketExtrasObject(outbound.ticketExtras[0]);
-    }
-
-    const intBasket: InternalBasketInterface =
-      await this.basketService.getDefaultBasket();
-    const basket = intBasket?.subject.value;
-    if (basket) {
-      const selectedRailTicketOption = this.getSelectedRailTicketOption(
-        outbound,
-        railTicketGroup,
-        0
-      );
-      const selectedInboundRailTicketOption = this.getSelectedRailTicketOption(
-        inbound,
-        railTicketGroup,
-        0
-      );
-      const outboundLegs = this.getLegsFromRailJourneyOption(outbound);
-      const inboundLegs = this.getLegsFromRailJourneyOption(inbound);
-      const ticketQueueList = selectedRailTicketOption.ticketQueueList.map(
-        (ticketQueueList1: RailTicketQueue) => {
-          return {
-            id: ticketQueueList1.id,
-            name: ticketQueueList1.name,
-            type: ticketQueueList1.type
-          };
-        }
-      );
-
-      const basketItem: RailBasketItem = {
-        basket: basket.id,
-        service: serviceId,
-        detail: {
-          accountsList: selectedRailTicketOption.accountsList.map(
-            (account: RailAccount) => {
-              return { id: account.id, description: account.description };
-            }
-          ),
-          outwardDetail: {
-            arrivalDateTime: outbound.arriveDateTime,
-            arrivalStationName: outbound.to,
-            departureDateTime: outbound.departDateTime,
-            departureStationName: outbound.from,
-            supplierTickets: [
-              {
-                supplierName: outbound.providers[0].name,
-                ticketDescription: selectedRailTicketOption.type,
-                price: selectedRailTicketOption.price,
-                legs: outboundLegs
-              }
-            ]
-          },
-          inwardDetail: {
-            arrivalDateTime: inbound.arriveDateTime,
-            arrivalStationName: inbound.to,
-            departureDateTime: inbound.departDateTime,
-            departureStationName: inbound.from,
-            supplierTickets: [
-              {
-                supplierName: inbound.providers[0].name,
-                ticketDescription: selectedRailTicketOption.type,
-                legs: inboundLegs
-              }
-            ]
-          },
-          transactionIdentifier: outbound.identifiers.transactionIdentifier,
-          outbound: {
-            fareIdentifiers: [
-              selectedRailTicketOption.identifiers.fareIdentifier
-            ],
-            journeyIdentifier: selectedRailTicketOption.identifiers.journeyIdentifier
-          },
-          ticketQueueList,
-          return: {
-            fareIdentifiers: [
-              selectedInboundRailTicketOption.identifiers.fareIdentifier
-            ],
-            journeyIdentifier: selectedInboundRailTicketOption.identifiers.journeyIdentifier
-          }
-        },
-        adults: railQuery.adults,
-        price: railTicketGroup.header.price,
-        currency: selectedRailTicketOption.currency as CurrencyCode,
-        searchQuery: railQuery,
-        co2PerItem: outbound.co2PerItem,
-        co2PerPassenger: outbound.co2PerPassenger,
-        outboundDate: outbound.arriveDateTime,
-        inboundDate: inbound.arriveDateTime
-      }
-
-      // if inTicketExtras or outTicketExtras exists add the object to basketItem
-      if (inTicketExtras) {
-        basketItem.detail.return.ticketExtras = inTicketExtras;
-      }
-      if (outTicketExtras) {
-        basketItem.detail.outbound.ticketExtras = outTicketExtras;
-      }
-
-      return this.basketService.addToBasket(
-        basketItem,
-        intBasket,
-        this.searchService,
-        this.travellers
-      );
-    }
-    return Promise.resolve(false);
-  }
-
-  createTicketExtrasObject(railTicketExtra: RailTicketExtra): TicketExtras[] {
-    return [{
-      type: railTicketExtra.description,
-      location: railTicketExtra.location,
-      date: railTicketExtra.date
-    }];
-  }
-
-  sortTicketPrices(tickets: TicketGroups): TicketGroups {
-    const sortTicketPrices = { ...tickets };
-    Object.keys(sortTicketPrices).map((key) => {
-      sortTicketPrices[key].sort((a: RailTicketOption, b: RailTicketOption) => {
-        const priceA = a.price;
-        const priceB = b.price;
-        return priceA < priceB ? -1 : priceA > priceB ? 1 : 0;
-      });
-    });
-    return sortTicketPrices;
-  }
-  sortTicketChildrenPrices(tickets: RailTicketGroups): RailTicketGroups {
-    const sortTicketPrices = { ...tickets };
-    Object.keys(sortTicketPrices).map((key) => {
-      sortTicketPrices[key].children.sort(
-        (a: RailTicketGroup, b: RailTicketGroup) => {
-          const priceA = a.header.price;
-          const priceB = b.header.price;
-          return priceA < priceB ? -1 : priceA > priceB ? 1 : 0;
-        }
-      );
-    });
-    return sortTicketPrices;
-  }
-  updateLowestPrice(results: RailJourneyOptions[]): ICheapestPrice {
-    if (!results.length) return null;
-    let currency;
-    try {
-      currency = results[0].outbound[0].providers[0].ticketOptions[0].currency;
-    } catch (error) {
-      currency = 'GBP';
-    }
-
-    const price = this.findCheapestTicket(results);
-    return {
-      amount: price,
-      currencyCode: currency
-    };
-  }
-  findCheapestTicket(results: RailJourneyOptions[]): number {
-    this._cheapestFirst = null;
-    this._cheapestStandard = null;
-    if (!results.length) return null;
-    let cheapestArr: number[] = [];
-
-    results.map((result) => {
-      result.outbound.map((out) => {
-        out.providers.map((tkt) => {
-          let cheapestTicket: number = tkt.ticketOptions[0].price;
-          tkt.ticketOptions.map((tktOption) => {
-            let tktPrice = tktOption.price;
-            let tktClass = tktOption.class;
-            if (
-              tktClass === 'First' &&
-              (this._cheapestFirst?.price > tktPrice || !this._cheapestFirst)
-            ) {
-              this._cheapestFirst = tktOption;
-            } else if (
-              tktClass === 'Standard' &&
-              (this._cheapestStandard?.price > tktPrice ||
-                !this._cheapestStandard)
-            ) {
-              this._cheapestStandard = tktOption;
-            }
-            if (tktPrice === cheapestTicket) {
-              cheapestArr.push(cheapestTicket);
-            }
-          });
-        });
-      });
-    });
-    return Math.min(...cheapestArr);
-  }
-
-  calculateTimeDifferenceInMins(
-    railJourney: RailJourneyOption | RailSegment
-  ): string {
-    return this.helpers
-      .getTimeDifference(railJourney.arriveDateTime, railJourney.departDateTime)
-      .toString();
-  }
-
-  /**
-   * @description - determine if a ticket is an eTicket
-   * @param ticket - the ticket we want to to check
-   * @returns - boolean
-   */
-  ticketIsAnETicket(ticket: RailTicketOption): boolean {
-    let foundETicket = null;
-
-    foundETicket = ticket.ticketQueueList.find((queueListItem) => {
-      return queueListItem.type === 'eTicket';
-    });
-
-    return foundETicket ? true : null;
-  }
-
-  /**
-   * @description - clear all of our chosen tickets/other rail stuff, call this when kicking off a new search
-   */
-  clearChosenTickets(): void {
-    this._chosenInboundTicket = null;
-    this._chosenOutboundTicket = null;
-    this._chosenInboundJourney = null;
-    this._chosenOutboundJourney = null;
-    this._chosenTicketGroup = null;
-  }
-}