@sabstravtech/obtservices 0.0.0

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

@@ -0,0 +1,1751 @@
+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;
+  }
+}