@sabstravtech/obtservices 0.0.0

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

@@ -0,0 +1,907 @@
+import moment from 'moment';
+import { BaseEnterpriseSearch } from './base-enterprise';
+import { BaseStorageService } from '../services/storage.service';
+import { BaseHelperRoutines } from './helpers';
+import { BehaviorSubject, combineLatest, Observable, Subject } from 'rxjs';
+import { Traveller } from '../models/traveller.object';
+import {
+  AddressForm,
+  CabhireQuoteResultArray,
+  NgbDateStruct,
+  RailAirport,
+  RecentSearch,
+  LocationDetails,
+  LocationTypes
+} from '../types/types';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+import {
+  BaseCabhireQuoteFetcher,
+  CabhireQuoteFetcherType
+} from '../fetchers/cabhire-quote-fetcher';
+import {
+  BasketItem,
+  CabHireLocation,
+  CabHireQuote,
+  CabHireVehicleType,
+  LocationDetail,
+  QuerySearchCabHireArgs,
+  SaveRecentSearchMutationVariables,
+  SearchCabHireQueryVariables,
+  SearchFlightsV2QueryVariables,
+  ServiceType
+} from '../types/graphql.types';
+import {
+  AirportSearchMode,
+  CabHireEnterpriseSearchInterface,
+  CabHireTempParams,
+  TaxiAirport,
+  TaxiAttribute,
+  TaxiFormMode,
+  TransType
+} from '../interfaces/Icabhire-enterprise-search';
+import {
+  EnterpriseBasketServiceInterface,
+  InternalBasketInterface
+} from '../interfaces/Ienterprise-basket.service';
+import { ICheapestPrice } from '../interfaces/cheapest-price';
+import { map, take } from 'rxjs/operators';
+
+export class CabHireEnterpriseSearch<CH_Q extends CabhireQuoteFetcherType>
+  extends BaseEnterpriseSearch<
+    CabHireTempParams,
+    CabhireQuoteResultArray,
+    CabhireQuoteResultArray
+  >
+  implements CabHireEnterpriseSearchInterface
+{
+  static readonly STORAGE_SESSION_PARAMS = 'search_cab';
+  static readonly STORAGE_SESSION_RESULTS = 'results_cab';
+  private outboundVisibility: BehaviorSubject<boolean>;
+  private inboundVisibility: BehaviorSubject<boolean>;
+  public type: ServiceType = ServiceType.Cab;
+  private travellers: Traveller[];
+
+  airportChange: Subject<TaxiAirport> = new Subject();
+
+  readonly transTypes: TransType[] = [
+    { key: CabHireVehicleType.Any, value: 'Any (1-8 Passengers)', id: 8 },
+    {
+      key: CabHireVehicleType.StandardCar,
+      value: 'Saloon Car (1-4 Passengers)',
+      id: 4
+    },
+    {
+      key: CabHireVehicleType.BlackCab,
+      value: 'Hackney Carriage (1-4 Passengers)',
+      id: 4
+    },
+    {
+      key: CabHireVehicleType.DdaCar,
+      value: 'Dda - wheelchair accessible (1-4 Passengers)',
+      id: 4
+    },
+    {
+      key: CabHireVehicleType.MediumMpv,
+      value: 'People Carrier (1-7 Passengers)',
+      id: 7
+    },
+    {
+      key: CabHireVehicleType.ExecutiveCar,
+      value: 'Executive (1-4 Passengers)',
+      id: 4
+    }
+  ];
+  readonly attributes: TaxiAttribute[] = [
+    { enabled: false, key: 'wheelchair', value: 'Wheelchair (On Request)' },
+    { enabled: false, key: 'call_on_arrival', value: 'Call On Arrival' },
+    {
+      enabled: false,
+      key: 'meet_and_greet',
+      value: 'Meet And Greet (Charge Applies)'
+    },
+    { enabled: false, key: 'wait_and_return', value: 'Wait And Return' }
+  ];
+  readonly searchTypes = [
+    'One-way'
+    // , 'Return'
+  ];
+
+  readonly airportSearchTypes = ['Airport drop off', 'Airport Pick Up'];
+  readonly criteria = ['Pick Up Time'];
+
+  mode: TaxiFormMode = TaxiFormMode.ADDRESS;
+  minSelectDate: moment.Moment = moment();
+
+  // getters and setters
+  private _date: NgbDateStruct = null;
+  selectedPlaces: any = [];
+  private _fromLocation: CabHireLocation;
+  private _toLocation: CabHireLocation;
+  private _vias: CabHireLocation[] = [null, null, null, null];
+
+  get fromLocation(): CabHireLocation {
+    return this._fromLocation;
+  }
+
+  get toLocation(): CabHireLocation {
+    return this._toLocation;
+  }
+
+  get date(): NgbDateStruct {
+    return this._date;
+  }
+
+  set date(value: NgbDateStruct) {
+    this._date = value;
+    this._updateDateTime();
+  }
+
+  /*
+   * searchType
+   */
+  private _searchType = this.searchTypes[0];
+  get searchType() {
+    return this._searchType;
+  }
+
+  set searchType(value: string) {
+    this._searchType = value;
+  }
+
+  /*
+   * airpoirt searchType
+   */
+
+  _airportSearchType: AirportSearchMode = AirportSearchMode.DROPOFF;
+  get airportSearchType(): AirportSearchMode {
+    return this._airportSearchType;
+  }
+  set airportSearchType(mode: AirportSearchMode) {
+    this._airportSearchType = mode;
+    if (this.fromAddress || this.toAddress) {
+      this.switchFromAndToLocation();
+    }
+  }
+  /*
+   * airpoirt and train station searchType
+   */
+
+  get fromLocationType(): TaxiFormMode {
+    return this.tempParams.fromLocationType;
+  }
+  set fromLocationType(mode: TaxiFormMode) {
+    this.tempParams.fromLocationType = mode;
+  }
+  get toLocationType(): TaxiFormMode {
+    return this.tempParams.toLocationType;
+  }
+  set toLocationType(mode: TaxiFormMode) {
+    this.tempParams.toLocationType = mode;
+  }
+  /*
+   * searchCriteria
+   */
+  private _searchCriteria = this.criteria[0];
+  get searchCriteria() {
+    return this._searchCriteria;
+  }
+
+  set searchCriteria(value: string) {
+    this._searchCriteria = value;
+  }
+
+  /*
+   * outboundDateTime
+   */
+  private _outboundDateTime: moment.Moment = this.helpers.round(
+    moment(),
+    moment.duration(15, 'minutes')
+  );
+  get outboundDateTime() {
+    return this._outboundDateTime;
+  }
+
+  set outboundDateTime(value: moment.Moment) {
+    this._outboundDateTime = value;
+  }
+
+  /*
+   * returnDateTime
+   */
+  private _returnDateTime: moment.Moment = this.helpers.round(
+    moment(),
+    moment.duration(15, 'minutes')
+  );
+  get returnDateTime() {
+    return this._returnDateTime;
+  }
+
+  set returnDateTime(value: moment.Moment) {
+    this._returnDateTime = value;
+  }
+
+  /*
+   * flightNumber
+   */
+  private _flightNumber: string = '';
+  get flightNumber() {
+    return this._flightNumber;
+  }
+  set flightNumber(value: string) {
+    this._flightNumber = value;
+  }
+
+  /*
+   * airport
+   */
+
+  get airport() {
+    return this.tempParams.airport;
+  }
+  set airport(value: TaxiAirport) {
+    this.tempParams.airport = value;
+  }
+
+  /*
+   * terminal
+   */
+  private _terminal: string = null;
+  get terminal() {
+    return this._terminal;
+  }
+  set terminal(value: string) {
+    this._terminal = value;
+  }
+
+  private _time: string = null;
+  get time(): string {
+    return this._time;
+  }
+
+  set time(value: string) {
+    this._time = value;
+    this._updateDateTime();
+  }
+
+  get departs(): moment.Moment {
+    return this.tempParams.departs;
+  }
+
+  set departs(value: moment.Moment) {
+    this.tempParams.departs = value.isValid ? value : null;
+    if (value && value.isValid()) {
+      this._date = this.helpers.momentToNgDate(value);
+      this._time = this.helpers.formatTimeColon(value);
+    }
+    this._isValid();
+  }
+
+  // get fromLocation(): CabHireLocation {
+  //   return this._fromLocation;
+  // }
+
+  // set fromLocation(value: CabHireLocation) {
+  //   this._fromLocation = value;
+  //   this._isValid();
+  // }
+
+  // get toLocation(): CabHireLocation {
+  //   return this._toLocation;
+  // }
+
+  // set toLocation(value: CabHireLocation) {
+  //   this._toLocation = value;
+  //   this._isValid();
+  // }
+
+  get adults(): number {
+    return this.tempParams.adults;
+  }
+
+  set adults(value: number) {
+    this.tempParams.adults = value;
+    this._isValid();
+  }
+
+  get children(): number {
+    return this.tempParams.children;
+  }
+
+  set children(value: number) {
+    this.tempParams.children = value;
+    this._isValid();
+  }
+
+  get infants(): number {
+    return this.tempParams.infants;
+  }
+
+  set infants(value: number) {
+    this.tempParams.infants = value;
+    this._isValid();
+  }
+
+  get countryCode(): string {
+    return this.tempParams.countryCode;
+  }
+
+  set countryCode(value: string) {
+    this.tempParams.countryCode = value;
+    this._isValid();
+  }
+
+  get vias(): CabHireLocation[] {
+    return this._vias;
+  }
+
+  set vias(value: CabHireLocation[]) {
+    this._vias = value;
+    this._isValid();
+  }
+
+  get viasFrom(): AddressForm {
+    return this.tempParams.viasFrom;
+  }
+
+  set viasFrom(value: AddressForm) {
+    this.tempParams.viasFrom = value;
+    this._vias[0] = value ? this.createCabHireLocation(value) : null;
+    this._isValid();
+  }
+
+  get viasTo(): AddressForm {
+    return this.tempParams.viasTo;
+  }
+
+  set viasTo(value: AddressForm) {
+    this.tempParams.viasTo = value;
+    this._vias[1] = value ? this.createCabHireLocation(value) : null;
+    this._isValid();
+  }
+
+  get vehicleType(): CabHireVehicleType {
+    return this.tempParams.vehicleType;
+  }
+
+  set vehicleType(value: CabHireVehicleType) {
+    this.tempParams.vehicleType = value;
+    this._isValid();
+  }
+
+  get fromAddress(): AddressForm {
+    return this.tempParams.fromAddress;
+  }
+
+  set fromAddress(value: AddressForm) {
+    this.tempParams.fromAddress = value;
+    this._fromLocation = value ? this.createCabHireLocation(value) : null;
+    this._isValid();
+  }
+
+  get fromStation(): RailAirport {
+    return this.tempParams.fromStation;
+  }
+
+  set fromStation(value: RailAirport) {
+    this.tempParams.fromStation = value;
+
+    this._fromLocation = value
+      ? {
+          address: value.destination,
+          postcode: value.postcode
+        }
+      : null;
+    this._isValid();
+  }
+
+  get toAddress(): AddressForm {
+    return this.tempParams.toAddress;
+  }
+
+  set toAddress(value: AddressForm) {
+    this.tempParams.toAddress = value;
+    this._toLocation = value ? this.createCabHireLocation(value) : null;
+    this._isValid();
+  }
+
+  get toStation(): RailAirport {
+    return this.tempParams.toStation;
+  }
+
+  set toStation(value: RailAirport) {
+    this.tempParams.toStation = value;
+    this._toLocation = value
+      ? {
+          address: value.destination,
+          postcode: value.postcode
+        }
+      : null;
+    this._isValid();
+  }
+
+  constructor(
+    private cabfetcher: BaseCabhireQuoteFetcher<CH_Q>,
+    private helpers: BaseHelperRoutines,
+    storageService: BaseStorageService,
+    private searchService: EnterpriseSearchServiceInterface,
+    private basketService: EnterpriseBasketServiceInterface
+  ) {
+    super(storageService);
+    const data: {
+      tempParams: CabHireTempParams;
+    } = storageService.getSessionItem(
+      CabHireEnterpriseSearch.STORAGE_SESSION_PARAMS
+    ) || {
+      tempParams: {} as CabHireTempParams
+    };
+
+    // const momentDateTime = data.query.departs
+    //   ? moment(data.query.departs)
+    //   : moment();
+
+    this.updateTempParams(searchService.makeCabHireQuery(data.tempParams));
+
+    if (data.tempParams.fromAddress) {
+      this.fromAddress = data.tempParams.fromAddress;
+    }
+
+    if (data.tempParams.toAddress) {
+      this.toAddress = data.tempParams.toAddress;
+    }
+
+    if (searchService.shouldAddTravellerSubscription()) {
+      searchService.travellerInformation.subscribe(
+        (travellers: Traveller[]) => {
+          this.travellers = travellers;
+          const splitTravellers = this.helpers.selectedTravellers(
+            travellers,
+            ServiceType.Cab
+          );
+          this.tempParams.adults = splitTravellers.adults.length;
+          this.tempParams.children = splitTravellers.children.length;
+          this._isValid();
+        }
+      );
+    }
+
+    const results =
+      storageService.getSessionItemAsList<CabhireQuoteResultArray>(
+        this.resultsSessionName
+      ) || [];
+    this.fullResults = results;
+    this._cheapestResultPrice = this.updateLowestPrice(results);
+    this.results.next(results || []);
+    this._isValid();
+    this.outboundVisibility = new BehaviorSubject<boolean>(false);
+    this.inboundVisibility = new BehaviorSubject<boolean>(false);
+  }
+
+  protected resultsSessionName =
+    CabHireEnterpriseSearch.STORAGE_SESSION_RESULTS;
+
+  protected resetQuery(): void {
+    this.updateTempParams(this.searchService.makeCabHireQuery());
+    this._isValid();
+  }
+
+  public resetParams(): void {
+    this.reset();
+    this.resetQuery();
+    this.results.next([]);
+  }
+
+  private _isValid() {
+    if (!this.doChecks) {
+      return;
+    }
+    this.storageService.setSessionItem(
+      CabHireEnterpriseSearch.STORAGE_SESSION_PARAMS,
+      {
+        tempParams: this.tempParams
+      }
+    );
+
+    this.validationMessages = [];
+    if (!this.tempParams.fromAddress) {
+      this.validationMessages.push('From - Enter a location or postcode.');
+    }
+
+    if (!this.tempParams.toAddress) {
+      this.validationMessages.push('To - Enter a location or postcode.');
+    }
+
+    if (this.tempParams.departs.unix() < moment().unix()) {
+      this.validationMessages.push('Taxi journey cannot be in the past.');
+    }
+
+    if (this.tempParams.adults + this.tempParams.children < 1) {
+      this.validationMessages.push('There must be at least 1 traveller');
+    }
+
+    this.isValid.next(this.validationMessages.length === 0);
+    this.messages.next(this.validationMessages);
+  }
+
+  private _updateDateTime() {
+    if (this._date && this._time) {
+      this.departs = this.helpers.ngDateToMoment(this._date, this._time);
+    }
+  }
+
+  startSearch(): Promise<boolean> {
+    this.results.next([]);
+    if (this.isValid.value) {
+      const query = this.getSearchQuery();
+      this.searchService.saveRecentSearch(this.getRecentSearchQuery(query));
+
+      return this._startSearch(
+        this.cabfetcher.fetchList(
+          this.helpers.removeNulls<QuerySearchCabHireArgs>(query)
+        )
+      );
+    } else {
+      return Promise.resolve(false);
+    }
+  }
+
+  getRecentSearchQuery(query: QuerySearchCabHireArgs): SaveRecentSearchMutationVariables {
+    return {
+      serviceType: ServiceType.Cab,
+      searchArgs: query,
+      travelDate: this.departs.format(),
+      travellers: this.helpers.getTravellersId(this.travellers)
+    };
+  }
+
+  startRecentSearch(recentSearch: RecentSearch): void{
+    this.departs = moment(recentSearch.searchArgs.departs);
+    this.vehicleType = recentSearch.searchArgs.vehicleType;
+
+    combineLatest([
+      this.getStationOrAirport(recentSearch.searchArgs.fromLocation.address),
+      this.getStationOrAirport(recentSearch.searchArgs.toLocation.address)
+    ]).subscribe(([fromStationOrAirport, toStationOrAirport]) => {
+      if (fromStationOrAirport.length) {
+        this.fromStation = this.getStationOrAirportAdress(fromStationOrAirport[0]);
+        this.fromAddress = this.convertStationOrAirportLocation(recentSearch.searchArgs.fromLocation.address, recentSearch.searchArgs.fromLocation.postcode);
+      } else {
+        this.fromAddress = this.convertAddressLocation(recentSearch.searchArgs.fromLocation.address, recentSearch.searchArgs.fromLocation.postcode);
+      }
+      if (toStationOrAirport.length) {
+        this.toStation = this.getStationOrAirportAdress(toStationOrAirport[0]);
+        this.toAddress = this.convertStationOrAirportLocation(recentSearch.searchArgs.toLocation.address, recentSearch.searchArgs.toLocation.postcode);
+      } else {
+        this.toAddress = this.convertAddressLocation(recentSearch.searchArgs.toLocation.address, recentSearch.searchArgs.toLocation.postcode);
+      }
+      if(recentSearch.searchArgs.vias[0]) {
+        this.getStationOrAirport(recentSearch.searchArgs.vias[0].address).subscribe((viaFromStationOrAirport) => {
+        if (viaFromStationOrAirport.length) {
+          this.viasFrom = this.convertStationOrAirportLocation(recentSearch.searchArgs.vias[0].address, recentSearch.searchArgs.vias[0].postcode);
+        } else {
+          this.viasFrom = this.convertAddressLocation(recentSearch.searchArgs.vias[0].address, recentSearch.searchArgs.vias[0].postcode);
+        }
+        this.searchService.startSearches();
+      });
+    }
+    if(recentSearch.searchArgs.vias[1]) {
+      this.getStationOrAirport(recentSearch.searchArgs.vias[1].address).subscribe((viaToStationOrAirport) => {
+        if (viaToStationOrAirport.length) {
+          this.viasTo = this.convertStationOrAirportLocation(recentSearch.searchArgs.vias[1].address, recentSearch.searchArgs.vias[1].postcode);
+        } else {
+          this.viasTo = this.convertAddressLocation(recentSearch.searchArgs.vias[1].address, recentSearch.searchArgs.vias[1].postcode);
+        }
+        
+        this.searchService.startSearches();
+      });
+    }
+  
+    this.searchService.startSearches();
+    });
+
+  }
+
+  getSearchQuery(): QuerySearchCabHireArgs {
+    const query: QuerySearchCabHireArgs = {
+      adults: this.tempParams.adults,
+      children: this.tempParams.children,
+      departs: this.tempParams.departs,
+      fromLocation: this.createCabHireLocation(this.tempParams.fromAddress),
+      toLocation: this.createCabHireLocation(this.tempParams.toAddress),
+      infants: 0,
+      vehicleType: this.vehicleType,
+      vias: this._vias,
+    };
+    return this.helpers.removeNulls<QuerySearchCabHireArgs>(query);
+  }
+
+  updateOutboundAddress(location: any, placeDescription?: string): void {
+    this.tempParams.fromAddress = this.getAddressFormat(
+      location,
+      placeDescription
+    );
+  }
+
+  updateInboundAddress(location: any, placeDescription?: string): void {
+    this.tempParams.toAddress = this.getAddressFormat(
+      location,
+      placeDescription
+    );
+  }
+
+  private createCabHireLocation(location: AddressForm): CabHireLocation {
+    return {
+      address: [
+        location?.Terminal,
+        location?.House,
+        location?.Street,
+        location?.Town,
+        location?.Country
+      ]
+        .filter((item: string): boolean => !!item)
+        .join(','),
+      postcode: location?.PostCode
+    };
+  }
+
+  matchAddresses() {
+    this._toLocation = this.createCabHireLocation(this.tempParams.toAddress);
+    this._fromLocation = this.createCabHireLocation(
+      this.tempParams.fromAddress
+    );
+    this._isValid();
+  }
+
+  sortBy(asc?: boolean) {
+    let results = this.helpers.clone(this.fullResults);
+    if (asc) {
+      results = results.sort(
+        (a: CabHireQuote, b: CabHireQuote) => b.price - a.price
+      );
+    } else {
+      results = results.sort(
+        (a: CabHireQuote, b: CabHireQuote) => a.price - b.price
+      );
+    }
+    this.results.next(results);
+  }
+
+  // ! stuff to go in a postcode servie
+
+  getAddressFormat(location: any, placeDescription?: string) {
+    return {
+      House: this.getAddressFromPlaceDetails(location, [
+        'floor',
+        'street_number',
+        'premise'
+      ]),
+      Street: this.getAddressFromPlaceDetails(location, [
+        'route',
+        'street_name',
+        'establishment'
+      ]),
+      Town: this.getAddressFromPlaceDetails(location, [
+        'postal_town',
+        'administrative_area_level_2',
+        'locality'
+      ]),
+      PostCode: this.getAddressFromPlaceDetails(location, ['postal_code']),
+      Country: this.getAddressFromPlaceDetails(location, ['country']),
+      placeDescription
+    };
+  }
+
+  getAddressFromPlaceDetails(placeDetails: any, types: string[]): string {
+    let addressProp = null;
+    if (placeDetails && Array.isArray(placeDetails)) {
+      for (const type of types) {
+        const prop = placeDetails.filter((pd) => {
+          return Array.isArray(pd.types) && pd.types.includes(type);
+        })[0];
+
+        if (prop) {
+          addressProp = prop.long_name;
+          break;
+        }
+      }
+    }
+    return addressProp;
+  }
+
+  getAddressFromAirportDetails(
+    airportDetails: LocationDetail,
+    airportName: string
+  ) {
+    console.log(airportDetails);
+    let address: AddressForm = null;
+    if (airportDetails) {
+      address = {
+        Country: airportDetails.country,
+        Street: airportDetails.road,
+        PostCode: airportDetails.postcode,
+        Town: airportDetails.city,
+        placeDescription: airportName,
+        House: airportName
+      };
+    }
+    return address;
+  }
+
+  setLocationFromAirport(airportDetails: LocationDetail, airportName: string) {
+    const address = this.getAddressFromAirportDetails(
+      airportDetails,
+      airportName
+    );
+    if (this.mode === TaxiFormMode.STATION) {
+      if (this.airportSearchType === AirportSearchMode.PICKUP) {
+        this.fromAddress = address;
+      } else {
+        this.toAddress = address;
+      }
+    }
+  }
+
+  addToSelectedPlaces(address: any) {
+    this.selectedPlaces.push(address);
+  }
+
+  setOutboundFormVisibility(showForm: boolean): void {
+    this.outboundVisibility.next(showForm);
+  }
+
+  setInboundFormVisibility(showForm: boolean): void {
+    this.inboundVisibility.next(showForm);
+  }
+
+  getOutboundFormVisibility(): BehaviorSubject<boolean> {
+    return this.outboundVisibility;
+  }
+
+  getInboundFormVisibility(): BehaviorSubject<boolean> {
+    return this.inboundVisibility;
+  }
+
+  updateFromPreviousSearches(
+    previousItems: Record<ServiceType, BasketItem>
+  ): void {
+    const flightItem: SearchFlightsV2QueryVariables =
+      previousItems[ServiceType.Flight]?.searchQuery;
+    if (flightItem) {
+      // TODO flights haven't been done yet.
+    }
+  }
+
+  getTransType(): string {
+    const transTypeIndex = this.tempParams.vehicleType;
+    return this.transTypes.find((x) => x.key === transTypeIndex)?.value || '';
+  }
+
+  getPassengers = (): string => {
+    const adults = this.adults;
+    const children = this.children;
+    let passengers = `${adults} Adult`;
+
+    if (Number(adults) !== 1) {
+      passengers += 's';
+    }
+    if (Number(children) === 1) {
+      passengers += `, ${children} Child`;
+    }
+
+    if (Number(children) > 1) {
+      passengers += `, ${children} Children`;
+    }
+    return passengers;
+    return '';
+  };
+
+  private getStationOrAirport(text: string): Observable<LocationDetails[]>{
+    return this.searchService.getStationsAndAirportsList(text, null, this.isLoading).pipe(
+      take(1),
+      map((res: LocationDetails[]) => {
+        return res;
+      })
+    );
+  };
+
+  private getStationOrAirportAdress(stationOrAirport: LocationDetails): any {
+    if (stationOrAirport.type === LocationTypes.Airport) {
+      return {
+        name: stationOrAirport.name
+      };
+    } else if (stationOrAirport.type === LocationTypes.TrainStation) {
+      return {
+        name: stationOrAirport.name
+      }
+    }
+  }
+
+  private convertStationOrAirportLocation(address: string, postcode: string) {
+    return {
+      House: address,
+      PostCode: postcode,
+    }
+  }
+
+  private convertAddressLocation(address: string, postcode: string) {
+    let locationArray = address.split(',');
+    let street = '';
+    let town = locationArray[locationArray.length-2];
+    
+    for (let index = 1; index < locationArray.length-2; index++) {
+      street += locationArray[index] + ' ';
+    }
+    return {
+      Country: address.slice(-2),
+      House: locationArray[0],
+      PostCode: postcode,
+      Street: street,
+      Town: town
+    }
+  }
+
+  async addCabHireToBasket(
+    cabHireQuote: CabHireQuote,
+    cabHireQuery: SearchCabHireQueryVariables
+  ): Promise<boolean> {
+    if (cabHireQuote.unavailable) {
+      return Promise.resolve(false);
+    }
+    const intBasket: InternalBasketInterface =
+      await this.basketService.getDefaultBasket();
+    const basket = intBasket?.subject.value;
+    if (basket) {
+      return this.basketService.addToBasket(
+        {
+          adults: cabHireQuery.adults,
+          basket: basket.id,
+          service: cabHireQuote.sourceId.toString(),
+          detail: {
+            id: cabHireQuote.id,
+            departs: cabHireQuery.departs.format(),
+            supplierName: cabHireQuote.supplierName,
+            estimatedCO2: cabHireQuote.estimatedCO2,
+            fromLocation: {
+              address: cabHireQuery.fromLocation.address,
+              postcode: cabHireQuery.fromLocation.postcode
+            },
+            toLocation: {
+              address: cabHireQuery.toLocation.address,
+              postcode: cabHireQuery.toLocation.postcode
+            },
+            vehicleType: cabHireQuery.vehicleType
+          },
+          price: cabHireQuote.price,
+          currency: cabHireQuote.currency,
+          searchQuery: cabHireQuery,
+          co2PerItem: cabHireQuote.co2PerItem,
+          co2PerPassenger: cabHireQuote.co2PerPassenger,
+          outboundDate: cabHireQuery.departs.format()
+        },
+        intBasket,
+        this.searchService,
+        this.travellers
+      );
+    }
+    return Promise.resolve(false); // TODO should this throw an error?
+  }
+
+  switchFromAndToLocation() {
+    const newFromAddress = { ...this.toAddress };
+    const newToAddress = { ...this.fromAddress };
+    this.fromAddress = newFromAddress;
+    this.toAddress = newToAddress;
+  }
+
+  updateLowestPrice(results: CabHireQuote[]): ICheapestPrice {
+    if (!results.length) return null;
+    const currency = results[0].currency;
+    return results.reduce(
+      (cheapestPrice: ICheapestPrice, result: CabHireQuote) => {
+        const price = result.price;
+        if (cheapestPrice.amount > price) cheapestPrice.amount = price;
+        return cheapestPrice;
+      },
+      { amount: Number.MAX_SAFE_INTEGER, currencyCode: currency }
+    );
+  }
+}