@sabstravtech/obtservices 0.0.0

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

@@ -0,0 +1,1597 @@
+import moment from 'moment';
+import { BaseEnterpriseSearch } from './base-enterprise';
+import { BaseStorageService } from '../services/storage.service';
+import { BaseHelperRoutines } from './helpers';
+import { Observable, of, BehaviorSubject, combineLatest } from 'rxjs';
+import { CarHireSort } from '../interfaces/car-hire-sort.interface';
+import { CarHireFilters } from '../interfaces/car-hire-filters.interface';
+import { SelectFilter } from '../interfaces/select-filter.interface';
+import { ValueDisplay } from '../interfaces/value-display';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+import {
+  EnterpriseBasketServiceInterface,
+  InternalBasketInterface
+} from '../interfaces/Ienterprise-basket.service';
+import {
+  CarHireDetailRequestResponse,
+  CurrencyCode,
+  BasketItem,
+  CarHireInputIdentifiers,
+  CarHireVehicleAvailibility,
+  QuerySearchCarHireArgs,
+  SearchFlightsV2QueryVariables,
+  ServiceType,
+  CarHireTransmission,
+  CarHireClass,
+  CarHireType,
+  DistanceTypes,
+  SearchCarHireQueryVariables,
+  SaveRecentSearchMutationVariables
+} from '../types/graphql.types';
+import {
+  CarHireQuoteResult,
+  CarHireQuoteResultArray,
+  NgbDateStruct,
+  OBTAirportDetails,
+  Vendor,
+  LocationTypes,
+  LocationDetails,
+  CarHireDepot,
+  RecentSearch
+} from '../types/types';
+import {
+  BaseCarhireQuoteFetcher,
+  CarHireFetcherType
+} from '../fetchers/carhire-quote-fetcher';
+import {
+  CarhireEnterpriseSearchInterface,
+  CarHireTempParams
+} from '../interfaces/Icarhire-enterprise-search';
+import { ICheapestPrice } from '../interfaces/cheapest-price';
+import {
+  BaseCarHireAvailabilityDetailFetcher,
+  CarHireAvailabilityDetailFetcherType
+} from '../fetchers/carhire-availability-detail.fetcher';
+import { take, map } from 'rxjs/operators';
+import { ICarClasses } from '../interfaces/car-hire-classes.interface';
+import { Traveller } from '../models/traveller.object';
+
+export enum SortTypesCar {
+  price = 'price',
+  brand = 'brand',
+  size = 'size',
+  preferred = 'preferred',
+  expensive = 'expensive'
+}
+
+export class CarhireEnterpriseSearch<
+    CH_Q extends CarHireFetcherType,
+    CHAD_Q extends CarHireAvailabilityDetailFetcherType
+  >
+  extends BaseEnterpriseSearch<
+    CarHireTempParams,
+    CarHireQuoteResultArray,
+    CarHireQuoteResultArray
+  >
+  implements CarhireEnterpriseSearchInterface
+{
+  static readonly STORAGE_SESSION_PARAMS = 'carhire_params';
+  static readonly STORAGE_SESSION_RESULTS = 'carhire_results';
+
+  // ! - Hardcoded Data
+  private _carTypeCodes: [string, string, CarHireType][] = [
+    ['B', '2-3 Door', CarHireType.TwoToThreeDoor],
+    ['C', '2/4 Door', CarHireType.TwoOrFourDoor],
+    ['D', '4-5 Door', CarHireType.FourToFiveDoor],
+    ['W', 'Wagon / Estate', CarHireType.WagonOrEstate],
+    ['V', 'Passenger Van', CarHireType.PassengerVan],
+    ['L', 'Limousine', CarHireType.Limousine],
+    ['S', 'Sport', CarHireType.Sport],
+    ['T', 'Convertible', CarHireType.Convertible],
+    ['F', 'SUV', CarHireType.Suv],
+    ['J', 'Open Air All Terrain', CarHireType.OpenAirAllTerrain],
+    ['X', 'Special', CarHireType.Special],
+    ['P', 'Pickup Regular Cab', CarHireType.PickUpRegularCab],
+    ['Q', 'Pickup Extended Cab', CarHireType.PickUpExtendedCab],
+    ['Z', 'Special Offer Car', CarHireType.SpecialOfferCar],
+    ['E', 'Coupe', CarHireType.Coupe],
+    ['M', 'Monospace (Europe)', CarHireType.MonospaceEuropeanUse],
+    ['R', 'Recreational Vehicle', CarHireType.Suv],
+    ['H', 'Motor Home', CarHireType.MotorHome],
+    ['Y', '2-Wheel Vehicle', CarHireType.TwoWheelVehicle],
+    ['N', 'Roadster', CarHireType.Roadster],
+    ['G', 'Crossover', CarHireType.Suv],
+    ['K', 'Commercial Van / Truck', CarHireType.PassengerVan]
+  ];
+
+  private _carAirConditionTypes: [string, string, boolean][] = [
+    ['Any', 'Any', null],
+    ['Y', 'Yes', true],
+    ['N', 'No', false]
+  ];
+
+  private _carTransmissionCodes: [string, string, CarHireTransmission][] = [
+    ['M', 'Manual', CarHireTransmission.Manual],
+    ['N', 'Manual 4-Wheel Drive', CarHireTransmission.Manual],
+    ['C', 'Manual All-Wheel Drive', CarHireTransmission.Manual],
+    ['A', 'Automatic', CarHireTransmission.Auto],
+    ['B', 'Automatic 4-Wheel Drive', CarHireTransmission.Auto],
+    ['D', 'Automatic All- Wheel Drive', CarHireTransmission.Auto]
+  ];
+
+  carhireCodes: any;
+  private _vendors: Vendor[] = [
+    { code: '-', name: 'Any' },
+    { code: 'AC', name: 'Ace Rent A Car' },
+    { code: 'AD', name: 'Advantage Rent A Car' },
+    { code: 'AL', name: 'Alamo' },
+    { code: 'ZI', name: 'Avis' },
+    { code: 'AT', name: 'Atesa' },
+    { code: 'ZD', name: 'Budget Rent A Car' },
+    { code: 'CI', name: 'Citer Rent A Car' },
+    { code: 'ZR', name: 'Dollar Rent A Car' },
+    { code: 'DF', name: 'Driving Force' },
+    { code: 'EY', name: 'Economy Rent A Car' },
+    { code: 'ET', name: 'Enterprise' },
+    { code: 'EP', name: 'Europcar' },
+    { code: 'IM', name: 'Europcar Southafrica' },
+    { code: 'EZ', name: 'Ez Rent A Car' },
+    { code: 'FF', name: 'Firefly' },
+    { code: 'FX', name: 'Fox Rent A Car' },
+    { code: 'GN', name: 'Guerin Car Rental' },
+    { code: 'ZE', name: 'Hertz' },
+    { code: 'LM', name: 'L & M Car Rental' },
+    { code: 'LL', name: 'Localiza' },
+    { code: 'MW', name: 'Midway Car Rental' },
+    { code: 'ZL', name: 'National Car Rental System' },
+    { code: 'NC', name: 'Nextcar' },
+    { code: 'NU', name: 'Nu Car Rentals' },
+    { code: 'ZA', name: 'Payless Car Rental' },
+    { code: 'PR', name: 'Priceless' },
+    { code: 'RW', name: 'Rent A Wreck' },
+    { code: 'SX', name: 'Sixt' },
+    { code: 'TE', name: 'Tempest' },
+    { code: 'XF', name: 'Test-S Cross Galileo' },
+    { code: 'XG', name: 'Test-S Cross Trng' },
+    { code: 'ZT', name: 'Thrifty Car Rental' },
+    { code: 'PM', name: 'Travelport Test Code' },
+    { code: 'SV', name: 'U-Save Auto Rental' },
+    { code: 'WF', name: 'Woodford' }
+  ];
+
+  private _car_classes: ICarClasses[] = [
+    { code: 'M', name: 'Mini', key: CarHireClass.Mini, value: '10' },
+    { code: 'N', name: 'Mini Elite', key: CarHireClass.MiniElite, value: '20' },
+    { code: 'E', name: 'Economy', key: CarHireClass.Economy, value: '30' },
+    {
+      code: 'H',
+      name: 'Economy Elite',
+      key: CarHireClass.EconomyElite,
+      value: '40'
+    },
+    { code: 'C', name: 'Compact', key: CarHireClass.Compact, value: '50' },
+    {
+      code: 'D',
+      name: 'Compact Elite',
+      key: CarHireClass.CompactElite,
+      value: '60'
+    },
+    {
+      code: 'I',
+      name: 'Intermediate',
+      key: CarHireClass.Intermediate,
+      value: '70'
+    },
+    {
+      code: 'J',
+      name: 'Intermediate Elite',
+      key: CarHireClass.IntermediateElite,
+      value: '80'
+    },
+    { code: 'S', name: 'Standard', key: CarHireClass.Standard, value: '90' },
+    {
+      code: 'R',
+      name: 'Standard Elite',
+      key: CarHireClass.StandardElite,
+      value: '100'
+    },
+    { code: 'F', name: 'Full Size', key: CarHireClass.Fullsize, value: '110' },
+    {
+      code: 'G',
+      name: 'Full Size Elite',
+      key: CarHireClass.FullsizeElite,
+      value: '120'
+    },
+    { code: 'P', name: 'Premium', key: CarHireClass.Premium, value: '130' },
+    {
+      code: 'U',
+      name: 'Premium Elite',
+      key: CarHireClass.PremiumElite,
+      value: '140'
+    },
+    { code: 'L', name: 'Luxury', key: CarHireClass.Luxury, value: '150' },
+    {
+      code: 'W',
+      name: 'Luxury Elite',
+      key: CarHireClass.LuxuryElite,
+      value: '160'
+    },
+    { code: 'O', name: 'Oversize', key: CarHireClass.Oversize, value: '170' },
+    { code: 'X', name: 'Special', key: CarHireClass.Special, value: '180' }
+  ];
+
+  private _location_types = [
+    LocationTypes.City,
+    LocationTypes.Airport,
+    LocationTypes.Postcode
+  ];
+
+  private carClassMap: { [key: string]: number } = {
+    mini: 0,
+    'mini elite': 1,
+    economy: 2,
+    'economy elite': 3,
+    compact: 4,
+    'compact special': 5,
+    'compact elite': 6,
+    intermediate: 7,
+    'intermediate elite': 8,
+    standard: 9,
+    'standard elite': 10,
+    'full size': 11,
+    'full size elite': 12,
+    premium: 13,
+    'premium elite': 14,
+    luxury: 15,
+    'luxury elite': 16,
+    oversize: 17,
+    special: 18
+  };
+  // ! - End of hardcoded data
+
+  public type: ServiceType = ServiceType.Car;
+
+  private _ngbPickupDate: NgbDateStruct;
+  private _pickupTime: string;
+  private _ngbDropoffDate: NgbDateStruct;
+  private _dropoffTime: string;
+  private _sorting_options: CarHireSort[] = [
+    {
+      value: 0,
+      display: 'Cheapest First'
+    },
+    {
+      value: 1,
+      display: 'Most Expensive First'
+    },
+    {
+      value: 2,
+      display: 'Preferred First'
+    }
+  ];
+  private _minDate: NgbDateStruct = {
+    day: moment().date(),
+    month: moment().month() + 1,
+    year: moment().year()
+  };
+
+  private _minInDate: NgbDateStruct = {
+    day: moment().date(),
+    month: moment().month() + 1,
+    year: moment().year()
+  };
+  travellers: Traveller[];
+
+  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 estimatedMileage(): number {
+    return this.tempParams.estimatedMileage;
+  }
+
+  set estimatedMileage(milage: number) {
+    this.tempParams.estimatedMileage = milage;
+    this._isValid();
+  }
+
+  get pickupTime(): string {
+    return this._pickupTime;
+  }
+
+  set pickupTime(newtime: string) {
+    this._pickupTime = newtime;
+    this._updateNgbPickupDateTime();
+  }
+
+  get dropoffTime(): string {
+    return this._dropoffTime;
+  }
+
+  set dropoffTime(newtime: string) {
+    this._dropoffTime = newtime;
+    this._updateNgbDropoffDateTime();
+  }
+
+  get postcodePickupRaw(): LocationDetails {
+    return this.tempParams.postcodePickupRaw;
+  }
+
+  set postcodePickupRaw(newPickupCountry: LocationDetails) {
+    this.tempParams.postcodePickupRaw = newPickupCountry;
+    this._isValid();
+  }
+
+  get postcodeDropoffRaw(): LocationDetails {
+    return this.tempParams.postcodeDropoffRaw;
+  }
+
+  set postcodeDropoffRaw(newPickupCountry: LocationDetails) {
+    this.tempParams.postcodeDropoffRaw = newPickupCountry;
+    this._isValid();
+  }
+
+  get cityPickupDepot(): CarHireDepot {
+    return this.tempParams.cityPickupDepot;
+  }
+
+  set cityPickupDepot(newPickupCountry: CarHireDepot) {
+    this.tempParams.cityPickupDepot = newPickupCountry;
+    this._isValid();
+  }
+
+  get cityDropoffDepot(): CarHireDepot {
+    return this.tempParams.cityDropoffDepot;
+  }
+
+  set cityDropoffDepot(newPostCodeDropoff: CarHireDepot) {
+    this.tempParams.cityDropoffDepot = newPostCodeDropoff;
+    this._isValid();
+  }
+
+  get postcodePickup(): CarHireDepot {
+    return this.tempParams.postcodePickup;
+  }
+
+  set postcodePickup(newPickupCountry: CarHireDepot) {
+    this.tempParams.postcodePickup = newPickupCountry;
+    if (this.tempParams.postcodePickup) {
+      this.tempParams.locationType = LocationTypes.Postcode;
+    }
+    this._isValid();
+  }
+
+  get postcodeDropoff(): CarHireDepot {
+    return this.tempParams.postcodeDropoff;
+  }
+
+  set postcodeDropoff(newPostCodeDropoff: CarHireDepot) {
+    this.tempParams.postcodeDropoff = newPostCodeDropoff;
+    this._isValid();
+  }
+
+  get cityPickup(): LocationDetails {
+    return this.tempParams.cityPickup;
+  }
+
+  set cityPickup(newPickup: LocationDetails) {
+    this.tempParams.cityPickup = newPickup;
+    if (this.tempParams.cityPickup) {
+      this.tempParams.locationType = LocationTypes.City;
+      console.log(this.tempParams.locationType);
+    }
+
+    this._isValid();
+  }
+
+  get cityDropoff(): LocationDetails {
+    return this.tempParams.cityDropoff;
+  }
+
+  set cityDropoff(newDropoff: LocationDetails) {
+    this.tempParams.cityDropoff = newDropoff;
+    this._isValid();
+  }
+
+  get minDate(): NgbDateStruct {
+    return this._minDate;
+  }
+
+  get minInDate(): NgbDateStruct {
+    return this._minInDate;
+  }
+
+  private _timeArray: ValueDisplay[];
+  // - Getters And Setters For Various Variables
+  get pickup_country(): string {
+    return this.tempParams.pickup_country;
+  }
+
+  set pickup_country(newPickupCountry: string) {
+    this.tempParams.pickup_country = newPickupCountry;
+    this._isValid();
+  }
+
+  get dropoff_country(): string {
+    return this.tempParams.dropoff_country;
+  }
+
+  set dropoff_country(newDropoffCountry: string) {
+    this.tempParams.dropoff_country = newDropoffCountry;
+    this._isValid();
+  }
+
+  get pickup_location(): OBTAirportDetails {
+    return this.tempParams.pickup_location;
+  }
+
+  set pickup_location(pickupLocation: OBTAirportDetails) {
+    this.tempParams.pickup_location = pickupLocation;
+    if (this.tempParams.pickup_location) {
+      this.tempParams.locationType = LocationTypes.Airport;
+    }
+
+    if (this.return_to_pickup) {
+      this.dropoff_location = pickupLocation;
+    }
+
+    this._isValid();
+  }
+
+  get dropoff_location(): OBTAirportDetails {
+    return this.tempParams.dropoff_location;
+  }
+
+  set dropoff_location(dropOffLocation: OBTAirportDetails) {
+    this.tempParams.dropoff_location = dropOffLocation;
+    this._isValid();
+  }
+
+  set ngbPickupDate(value: NgbDateStruct) {
+    this._ngbPickupDate = value;
+    this._updateNgbPickupDateTime();
+  }
+
+  get ngbPickupDate(): NgbDateStruct {
+    return this._ngbPickupDate;
+  }
+
+  set ngbDropoffDate(value: NgbDateStruct) {
+    this._ngbDropoffDate = value;
+    this._updateNgbDropoffDateTime();
+  }
+
+  get ngbDropoffDate(): NgbDateStruct {
+    return this._ngbDropoffDate;
+  }
+
+  // Datetimes within the query itself
+  get pickup_datetime(): moment.Moment {
+    return this.tempParams.pickup_datetime;
+  }
+
+  set pickup_datetime(value: moment.Moment) {
+    this.tempParams.pickup_datetime = value;
+    try {
+      if (value && value.isValid()) {
+        this._ngbPickupDate = this.helpers.momentToNgDate(value);
+        this._pickupTime = moment(value).format('HH:mm')
+          ? moment(value).format('HH:mm')
+          : '07:30';
+      }
+      this._minInDate = {
+        day: value.date(),
+        month: value.month() + 1,
+        year: value.year()
+      };
+
+      if (value.isSameOrAfter(this.tempParams.dropoff_datetime)) {
+        this.dropoff_datetime = this.dropoff_datetime
+          .set('date', value.date())
+          .set('month', value.month())
+          .set('year', value.year());
+      }
+    } catch (error) {}
+
+    this._isValid();
+  }
+
+  get dropoff_datetime(): moment.Moment {
+    return this.tempParams.dropoff_datetime;
+  }
+
+  set dropoff_datetime(value: moment.Moment) {
+    this.tempParams.dropoff_datetime = value;
+    if (value && value.isValid()) {
+      this._ngbDropoffDate = this.helpers.momentToNgDate(value);
+      this._dropoffTime = moment(value).format('HH:mm')
+        ? moment(value).format('HH:mm')
+        : '08:30';
+    }
+    this._isValid();
+  }
+
+  // !date and time is handled differently for LU
+  private _pickup_date: NgbDateStruct = null;
+
+  get pickup_date(): NgbDateStruct {
+    return this._pickup_date;
+  }
+
+  set pickup_date(value: NgbDateStruct) {
+    this._pickup_date = value;
+    this._updatePickupDateTime();
+  }
+
+  private _pickup_time: string = null;
+  get pickup_time(): string {
+    return this._pickup_time;
+  }
+
+  set pickup_time(value: string) {
+    this._pickup_time = value;
+    this._updatePickupDateTime();
+  }
+
+  private _dropoff_date: NgbDateStruct = null;
+
+  get dropoff_date(): NgbDateStruct {
+    return this._dropoff_date;
+  }
+
+  set dropoff_date(value: NgbDateStruct) {
+    this._dropoff_date = value;
+    this._updateDropoffDateTime();
+  }
+
+  private _dropoff_time: string = null;
+  get dropoff_time(): string {
+    return this._dropoff_time;
+  }
+
+  set dropoff_time(value: string) {
+    this._dropoff_time = value;
+    this._updateDropoffDateTime();
+  }
+
+  get return_to_pickup(): boolean {
+    return this.tempParams.return_to_pickup;
+  }
+
+  set return_to_pickup(newVal: boolean) {
+    this.tempParams.return_to_pickup = newVal;
+    this._isValid();
+  }
+
+  get chosenVendor(): string {
+    return this.tempParams.chosenVendor;
+  }
+
+  set chosenVendor(newVendor: string) {
+    this.tempParams.chosenVendor = newVendor;
+    this._isValid();
+  }
+
+  get carClass(): CarHireClass {
+    return this.tempParams.carClass;
+  }
+
+  set carClass(carClass: CarHireClass) {
+    this.tempParams.carClass = carClass;
+    this._isValid();
+  }
+
+  get carType(): CarHireType {
+    return this.tempParams.carType;
+  }
+
+  set carType(type: CarHireType) {
+    this.tempParams.carType = type;
+    this._isValid();
+  }
+
+  get transmission(): CarHireTransmission {
+    return this.tempParams.transmission;
+  }
+
+  set transmission(trans: CarHireTransmission) {
+    this.tempParams.transmission = trans;
+    this._isValid();
+  }
+
+  get airCon(): boolean {
+    return this.tempParams.airCon;
+  }
+
+  set airCon(newCon: boolean) {
+    this.tempParams.airCon = newCon;
+    this._isValid();
+  }
+
+  get locationType(): LocationTypes {
+    return this.tempParams.locationType;
+  }
+  set locationType(value: LocationTypes) {
+    this.tempParams.locationType = value;
+    this._isValid();
+  }
+
+  public get timeArray() {
+    this._timeArray =
+      this._timeArray ||
+      Array(96)
+        .fill(0)
+        .map((_, index: number) => {
+          return {
+            value:
+              Math.floor(index / 4)
+                .toString()
+                .padStart(2, '0') +
+              ':' +
+              ((index % 4) * 15).toString().padStart(2, '0'),
+            display:
+              Math.floor(index / 4)
+                .toString()
+                .padStart(2, '0') +
+              ':' +
+              ((index % 4) * 15).toString().padStart(2, '0')
+          };
+        });
+    return this._timeArray;
+  }
+
+  // ! - The below values have getters only (I.E Cannot modify)
+
+  get carAirConditionTypes(): [string, string, boolean][] {
+    return this._carAirConditionTypes;
+  }
+
+  get carTransmissionCodes(): [string, string, CarHireTransmission][] {
+    return this._carTransmissionCodes;
+  }
+
+  get carTypeCodes(): [string, string, CarHireType][] {
+    return this._carTypeCodes;
+  }
+
+  get vendors(): Vendor[] {
+    return this._vendors;
+  }
+
+  get sortingOptions(): CarHireSort[] {
+    return this._sorting_options;
+  }
+
+  // ! - End of getters and setters
+
+  constructor(
+    private carhirefetcher: BaseCarhireQuoteFetcher<CH_Q>,
+    private carHireAvailabilityDetailFetcher: BaseCarHireAvailabilityDetailFetcher<CHAD_Q>,
+    private helpers: BaseHelperRoutines,
+    private basketService: EnterpriseBasketServiceInterface,
+    storageService: BaseStorageService,
+    private searchService: EnterpriseSearchServiceInterface
+  ) {
+    super(storageService);
+    const data: {
+      tempParams: CarHireTempParams;
+    } = storageService.getSessionItem(
+      CarhireEnterpriseSearch.STORAGE_SESSION_PARAMS
+    ) || {
+      tempParams: {} as CarHireTempParams
+    };
+
+    this.updateTempParams(searchService.makeCarHireQuery(data.tempParams));
+
+    if (searchService.shouldAddTravellerSubscription()) {
+      searchService.travellerInformation.subscribe(
+        (travellers: Traveller[]) => {
+          const splitTravellers = this.helpers.selectedTravellers(
+            travellers,
+            ServiceType.Car
+          );
+          this.adults = splitTravellers.adults.length;
+          this.children = splitTravellers.children.length;
+          this.travellers = travellers;
+          this._isValid();
+        }
+      );
+    }
+
+    const results =
+      storageService.getSessionItemAsList<CarHireQuoteResultArray>(
+        this.resultsSessionName
+      ) || [];
+
+    this.fullResults = helpers.clone(results || []);
+    this._cheapestResultPrice = this.updateLowestPrice(results);
+    this.results.next(results);
+  }
+
+  protected resultsSessionName =
+    CarhireEnterpriseSearch.STORAGE_SESSION_RESULTS;
+
+  protected resetQuery(): void {
+    this.updateTempParams(this.searchService.makeCarHireQuery());
+    this.estimatedMileage = null;
+    this._isValid();
+  }
+
+  private _isValid() {
+    if (!this.doChecks) {
+      return;
+    }
+    this.storageService.setSessionItem(
+      CarhireEnterpriseSearch.STORAGE_SESSION_PARAMS,
+      {
+        tempParams: this.tempParams
+      }
+    );
+
+    // go over and check that all of the various variables are correct
+
+    // first of all check that we have a valid location
+    this.validationMessages = [];
+
+    switch (this.locationType) {
+      case LocationTypes.Airport:
+        if (!this.pickup_location || !this.pickup_location.destination) {
+          this.validationMessages.push('Please supply a pickup location');
+        }
+
+        if (!this.dropoff_location || !this.dropoff_location.destination) {
+          this.validationMessages.push('Please supply a dropoff location');
+        }
+        break;
+      case LocationTypes.City:
+        if (!this.cityPickup) {
+          this.validationMessages.push('Please supply a pickup city');
+        }
+
+        if (!this.cityDropoff) {
+          this.validationMessages.push('Please supply a dropoff city');
+        }
+        break;
+      case LocationTypes.Postcode:
+        if (!this.postcodePickup) {
+          this.validationMessages.push('Please supply a pickup depot');
+        }
+
+        if (!this.postcodeDropoff) {
+          this.validationMessages.push('Please supply a dropoff depot');
+        }
+        break;
+    }
+
+    if (this.estimatedMileage && this.estimatedMileage <= 0) {
+      this.validationMessages.push(
+        'Estimated Milage must be a positive number.'
+      );
+    }
+
+    try {
+      if (!this.pickup_datetime) {
+        this.validationMessages.push('Please supply a pickup time and date');
+      }
+
+      if (!this.dropoff_datetime) {
+        this.validationMessages.push('Please supply a drop off time and date');
+      }
+
+      if (
+        this.dropoff_datetime?.isSameOrBefore(this.pickup_datetime, 'minute')
+      ) {
+        this.validationMessages.push(
+          'Dropoff date/time cannot be before or the same as pickup date/time'
+        );
+      }
+
+      if (this.pickup_datetime?.isBefore(moment())) {
+        this.validationMessages.push(
+          'Pickup date/time must be after present date/time'
+        );
+      }
+
+      if (this.dropoff_datetime?.isBefore(moment())) {
+        this.validationMessages.push(
+          'Dropoff date/time must be after present date/time'
+        );
+      }
+    } catch (error) {}
+
+    this.isValid.next(this.validationMessages.length === 0);
+    this.messages.next(this.validationMessages);
+  }
+
+  startSearch(): Promise<boolean> {
+    this.results.next([]);
+    if (this.isValid.value) {
+      const query = this.getSearchQuery();
+      this.searchService.saveRecentSearch(
+        this.getRecentSearchQuery(this.getSearchQuery())
+      );
+      return this._startSearch(
+        this.carhirefetcher.fetchList(
+          this.helpers.removeNulls<QuerySearchCarHireArgs>(query)
+        )
+      );
+    } else {
+      return Promise.resolve(false);
+    }
+  }
+
+  getRecentSearchQuery(
+    query: QuerySearchCarHireArgs
+  ): SaveRecentSearchMutationVariables {
+    const recentSearchQuery: any = query;
+    switch (this.locationType) {
+      case LocationTypes.City:
+        recentSearchQuery.city = {
+          pickupName: this.cityPickup.name,
+          pickupCountryCode: this.cityPickup.countryCode,
+          pickupCity: this.cityPickup.id.toString(),
+          pickupLatitude: this.cityPickup.latitude,
+          pickupLongitude: this.cityPickup.longitude,
+
+          dropOffName: this.cityDropoff.name,
+          dropoffCountryCode: this.cityDropoff.countryCode,
+          dropoffCity: this.cityDropoff.id.toString(),
+          dropOffLatitude: this.cityDropoff.latitude,
+          dropOffLongitude: this.cityDropoff.longitude,
+
+          pickupAddressLines: this.cityPickupDepot.addressLines[0],
+          pickupCityName: this.cityPickupDepot.cityName,
+          pickupExtendedLocationCode: this.cityPickupDepot.extendedLocationCode,
+          pickupLocationCode: this.cityPickupDepot.locationCode,
+          pickupVendor: this.cityPickupDepot.vendor,
+          pickupVendorCode: this.cityPickupDepot.vendorCode,
+
+          dropOffAddressLines: this.cityDropoffDepot.addressLines[0],
+          dropOffCityName: this.cityDropoffDepot.cityName,
+          dropOffExtendedLocationCode:
+            this.cityDropoffDepot.extendedLocationCode,
+          dropOffLocationCode: this.cityDropoffDepot.locationCode,
+          dropOffVendor: this.cityDropoffDepot.vendor,
+          dropOffVendorCode: this.cityDropoffDepot.vendorCode
+        };
+        break;
+      case LocationTypes.Postcode:
+        recentSearchQuery.depot = {
+          vendorCode: this.postcodePickup.vendorCode,
+          pickupLocationCode: this.postcodePickup.locationCode,
+          pickupExtendedLocationCode: this.postcodePickup.extendedLocationCode,
+          pickupAddressLines: this.postcodePickup.addressLines[0],
+          pickupCityName: this.postcodePickup.cityName,
+          pickupVendor: this.postcodePickup.vendor,
+
+          dropOffLocationCode: this.postcodeDropoff.locationCode,
+          dropOffExtendedLocationCode:
+            this.postcodeDropoff.extendedLocationCode,
+          dropoffAddressLines: this.postcodeDropoff.addressLines[0],
+          dropoffCityName: this.postcodeDropoff.cityName,
+          dropoffVendor: this.postcodeDropoff.vendor,
+
+          pickupPostCode: this.postcodePickupRaw.name,
+          pickupLatitude: this.postcodePickupRaw.latitude,
+          pickupLongitude: this.postcodePickupRaw.longitude,
+
+          dropoffPostCode: this.postcodeDropoffRaw.name,
+          dropoffLatitude: this.postcodeDropoffRaw.latitude,
+          dropoffLongitude: this.postcodeDropoffRaw.longitude
+        };
+        break;
+    }
+
+    return {
+      serviceType: ServiceType.Car,
+      searchArgs: recentSearchQuery,
+      travelDate: this.pickup_datetime.format(),
+      travellers: this.helpers.getTravellersId(this.travellers)
+    };
+  }
+
+  public startRecentSearch(recentSearch: RecentSearch): void {
+    this.chosenVendor = recentSearch.searchArgs.vendor;
+    this.carClass = recentSearch.searchArgs.class;
+    this.carType = recentSearch.searchArgs.type;
+    this.transmission = recentSearch.searchArgs.transmission;
+    this.airCon = recentSearch.searchArgs.aircon;
+    this.estimatedMileage = recentSearch.searchArgs.estimatedDailyDistance;
+    this.dropoff_datetime = moment(recentSearch.searchArgs.dropoffDateTime);
+    this.pickup_datetime = moment(recentSearch.searchArgs.pickupDateTime);
+
+    if (recentSearch.searchArgs.city) {
+      this.getParamsForCarbyCity(recentSearch);
+    } else if (recentSearch.searchArgs.airport) {
+      this.getParamsForCarbyAirport(recentSearch);
+    } else if (recentSearch.searchArgs.depot) {
+      this.getParamsForCarbyPostCode(recentSearch);
+    }
+  }
+
+  private getParamsForCarbyAirport(recentSearch: RecentSearch): void {
+    this.locationType = LocationTypes.Airport;
+    combineLatest([
+      this.searchService.getAirportByCode(
+        recentSearch.searchArgs.airport.pickupCode
+      ),
+      this.searchService.getAirportByCode(
+        recentSearch.searchArgs.airport.dropoffCode
+      )
+    ]).subscribe(([departLocation, arriveLocation]) => {
+      if (departLocation && arriveLocation) {
+        this.dropoff_location = {
+          destination: departLocation.iataMatch.name,
+          gateway: departLocation.iataMatch.iata,
+          terminals: this.searchService.processTerminals(
+            arriveLocation.iataMatch.terminals
+          ),
+          country: departLocation.iataMatch?.locationDetails?.country,
+          postcode: departLocation.iataMatch?.locationDetails?.postcode,
+          countryCode: departLocation.iataMatch?.locationDetails?.countryCode
+        };
+        this.pickup_location = {
+          destination: arriveLocation.iataMatch.name,
+          gateway: arriveLocation.iataMatch.iata,
+          terminals: this.searchService.processTerminals(
+            arriveLocation.iataMatch.terminals
+          ),
+          country: arriveLocation.iataMatch?.locationDetails?.country,
+          postcode: arriveLocation.iataMatch?.locationDetails?.postcode,
+          countryCode: arriveLocation.iataMatch?.locationDetails?.countryCode
+        };
+
+        this.dropoff_country = this.dropoff_location.countryCode;
+        this.pickup_country = this.pickup_location.countryCode;
+        this.searchService.startSearches();
+      }
+    });
+  }
+
+  private getParamsForCarbyCity(recentSearch: RecentSearch): void {
+    this.locationType = LocationTypes.City;
+
+    this.cityPickup = {
+      countryCode: recentSearch.searchArgs.city.pickupCountryCode,
+      id: recentSearch.searchArgs.city.pickupCity,
+      name: recentSearch.searchArgs.city.pickupName,
+      type: LocationTypes.City,
+      latitude: recentSearch.searchArgs.city.pickupLatitude,
+      longitude: recentSearch.searchArgs.city.pickupLongitude
+    };
+
+    this.cityDropoff = {
+      countryCode: recentSearch.searchArgs.city.dropoffCountryCode,
+      id: recentSearch.searchArgs.city.dropoffCity,
+      name: recentSearch.searchArgs.city.dropOffName,
+      type: LocationTypes.City,
+      latitude: recentSearch.searchArgs.city.dropOffLatitude,
+      longitude: recentSearch.searchArgs.city.dropOffLongitude
+    };
+
+    this.cityDropoffDepot = {
+      addressLines: [recentSearch.searchArgs.city.dropOffAddressLines],
+      cityName: recentSearch.searchArgs.city.dropOffCityName,
+      extendedLocationCode:
+        recentSearch.searchArgs.city.dropOffExtendedLocationCode,
+      locationCode: recentSearch.searchArgs.city.dropOffLocationCode,
+      vendor: recentSearch.searchArgs.city.dropOffVendor,
+      vendorCode: recentSearch.searchArgs.city.dropOffVendorCode
+    };
+
+    this.cityPickupDepot = {
+      addressLines: [recentSearch.searchArgs.city.pickupAddressLines],
+      cityName: recentSearch.searchArgs.city.pickupCityName,
+      extendedLocationCode:
+        recentSearch.searchArgs.city.pickupExtendedLocationCode,
+      locationCode: recentSearch.searchArgs.city.pickupLocationCode,
+      vendor: recentSearch.searchArgs.city.pickupVendor,
+      vendorCode: recentSearch.searchArgs.city.pickupVendorCode
+    };
+
+    this.searchService.startSearches();
+  }
+
+  private getParamsForCarbyPostCode(recentSearch: RecentSearch): void {
+    this.locationType = LocationTypes.Postcode;
+    this.postcodeDropoff = {
+      addressLines: [recentSearch.searchArgs.depot.dropoffAddressLines],
+      vendorCode: recentSearch.searchArgs.depot.vendorCode,
+      locationCode: recentSearch.searchArgs.depot.dropOffLocationCode,
+      extendedLocationCode:
+        recentSearch.searchArgs.depot.dropOffExtendedLocationCode,
+      cityName: recentSearch.searchArgs.depot.dropoffCityName,
+      vendor: recentSearch.searchArgs.depot.dropoffVendor
+    };
+
+    this.postcodeDropoffRaw = {
+      name: recentSearch.searchArgs.depot.dropoffPostCode,
+      type: LocationTypes.Postcode,
+      latitude: recentSearch.searchArgs.depot.dropoffLatitude,
+      longitude: recentSearch.searchArgs.depot.dropoffLongitude
+    };
+    this.postcodePickup = {
+      addressLines: [recentSearch.searchArgs.depot.pickupAddressLines],
+      vendorCode: recentSearch.searchArgs.depot.vendorCode,
+      locationCode: recentSearch.searchArgs.depot.pickupLocationCode,
+      extendedLocationCode:
+        recentSearch.searchArgs.depot.pickupExtendedLocationCode,
+      cityName: recentSearch.searchArgs.depot.pickupCityName,
+      vendor: recentSearch.searchArgs.depot.pickupVendor
+    };
+
+    this.postcodePickupRaw = {
+      name: recentSearch.searchArgs.depot.pickupPostCode,
+      type: LocationTypes.Postcode,
+      latitude: recentSearch.searchArgs.depot.pickupLatitude,
+      longitude: recentSearch.searchArgs.depot.pickupLongitude
+    };
+
+    this.searchService.startSearches();
+  }
+
+  getSearchQuery(): QuerySearchCarHireArgs {
+    const query: QuerySearchCarHireArgs = {} as QuerySearchCarHireArgs;
+    switch (this.locationType) {
+      case LocationTypes.Airport:
+        query.airport = {
+          pickupCode: '',
+          dropoffCode: ''
+        };
+
+        query.airport.pickupCode = this.pickup_location.gateway;
+        query.airport.dropoffCode = this.return_to_pickup
+          ? this.pickup_location.gateway
+          : this.dropoff_location.gateway;
+        break;
+      case LocationTypes.City:
+        query.city = {
+          pickupCountryCode: this.cityPickup.countryCode,
+          pickupCity: this.cityPickup.id.toString(),
+          dropoffCountryCode: this.cityDropoff.countryCode,
+          dropoffCity: this.cityDropoff.id.toString()
+        };
+        break;
+      case LocationTypes.Postcode:
+        query.depot = {
+          vendorCode: this.postcodePickup.vendorCode,
+          pickupLocationCode: this.postcodePickup.locationCode,
+          pickupExtendedLocationCode: this.postcodePickup.extendedLocationCode,
+          dropOffLocationCode: this.postcodeDropoff.locationCode,
+          dropOffExtendedLocationCode: this.postcodeDropoff.extendedLocationCode
+        };
+        break;
+    }
+    query.dropoffDateTime = this.dropoff_datetime;
+    query.pickupDateTime = this.pickup_datetime;
+
+    // now for the optional fields - nullify these if they are '-' (Any)
+    query.aircon = this.airCon || null;
+    query.vendor = this.chosenVendor === '-' ? null : this.chosenVendor;
+    query.transmission = this.transmission || null;
+    query.class = this.carClass || null;
+    query.type = this.carType || null;
+    query.estimatedDailyDistance = this.estimatedMileage || null;
+    query.estimatedDailyDistanceUnits = this.estimatedMileage
+      ? DistanceTypes.M
+      : null; // Setting as miles for now - may swap out for kilometers later
+
+    return this.helpers.removeNulls<QuerySearchCarHireArgs>(query);
+  }
+
+  /**
+   * @todo - turn this into a BE call to dynamically get the list of car classes
+   * @returns all car classes as an array
+   */
+  getCarClasses(): Observable<ICarClasses[]> {
+    return of(this._car_classes);
+  }
+
+  getLocationTypes() {
+    return of(this._location_types);
+  }
+
+  /**
+   * @description - filter down the car results based on user chosen filters
+   */
+  filterResults(appliedFilters: CarHireFilters, selectedSort: number): void {
+    let fullResults: CarHireQuoteResultArray = this.helpers.clone(
+      this.fullResults
+    );
+
+    // now apply filters
+    // price filters
+    fullResults = fullResults.filter((result: CarHireQuoteResult) => {
+      const price = this.getPrice(result);
+
+      return (
+        price >= appliedFilters.minPrice && price <= appliedFilters.maxPrice
+      );
+    });
+
+    // apply transmission filters
+    fullResults = this.filterByTransmissionType(
+      appliedFilters.transmissions,
+      fullResults
+    );
+
+    // aircon
+    fullResults = this.filterByAirconType(
+      appliedFilters.airConditioning,
+      fullResults
+    );
+
+    // car types (class)
+    fullResults = this.filterByCarType(appliedFilters.types, fullResults);
+
+    // company
+    fullResults = this.filterByCompany(appliedFilters.companies, fullResults);
+
+    // lastly apply any required sorting
+    fullResults = this.sortResults(selectedSort, fullResults);
+
+    this.results.next(fullResults);
+  }
+
+  filterByCompany(
+    companies: SelectFilter[],
+    cars: CarHireQuoteResultArray
+  ): CarHireQuoteResultArray {
+    const selected = companies.filter((company) => company.selected);
+
+    if (selected.length) {
+      cars = cars.filter((car: CarHireQuoteResult) => {
+        const haveSelected = selected.find(
+          (selc: any) =>
+            selc.value.toString().toLowerCase() ===
+            car.identifiers.vendor.toLowerCase()
+        );
+
+        return haveSelected;
+      });
+    }
+
+    return cars;
+  }
+
+  filterByCarType(
+    types: SelectFilter[],
+    cars: CarHireQuoteResultArray
+  ): CarHireQuoteResultArray {
+    // this is a filter type which allows more than one to be set
+    // if none are set allow all through
+
+    const selected = types.filter((type) => type.selected);
+
+    if (selected.length) {
+      cars = cars.filter((car: any) => {
+        const haveSelected = selected.find(
+          (selc) =>
+            selc.value.toString().toLowerCase() ===
+            car.displayRecord.vehicle.class.toLowerCase()
+        );
+
+        return haveSelected;
+      });
+    }
+
+    return cars;
+  }
+
+  filterByTransmissionType(
+    tranmissions: SelectFilter[],
+    cars: CarHireQuoteResultArray
+  ): CarHireQuoteResultArray {
+    const selectedTransmission = tranmissions.find((trans) => {
+      return trans.selected;
+    });
+
+    if (selectedTransmission && selectedTransmission.value !== 'Y') {
+      // not 'Any'
+      try {
+        cars = cars.filter((car: CarHireQuoteResult) => {
+          const trans = car.identifiers.vehType[2];
+
+          return (
+            trans.toLowerCase() ===
+            selectedTransmission.value.toString().toLowerCase()
+          );
+        });
+      } catch (error) {
+        console.error(`+++ Error filtering transmissions: ${error} +++`);
+      }
+    }
+
+    return cars;
+  }
+
+  filterByAirconType(
+    aircons: SelectFilter[],
+    cars: CarHireQuoteResultArray
+  ): CarHireQuoteResultArray {
+    const selectedAircon = aircons.find((ac) => {
+      return ac.selected;
+    });
+
+    if (selectedAircon && selectedAircon.value !== 'A') {
+      // not 'Any'
+      try {
+        cars = cars.filter((car: CarHireQuoteResult) => {
+          const ac = car.identifiers.vehType[3];
+
+          return (
+            ac.toLowerCase() === selectedAircon.value.toString().toLowerCase()
+          );
+        });
+      } catch (error) {
+        console.error(`+++ Error filtering aircons: ${error} +++`);
+      }
+    }
+
+    return cars;
+  }
+
+  /**
+   * @description - sort the results
+   * @param selectedSort - the sort we have chosen
+   * @param results - optionally pass in the results, if not provided - uses internal results (not full, would cause issues)
+   */
+  sortResults(
+    selectedSort: number,
+    results?: CarHireQuoteResultArray
+  ): CarHireQuoteResultArray {
+    let fullResults = this.helpers.clone(
+      results ? results : this.results.value
+    );
+    switch (selectedSort) {
+      case 0: // cheapest
+        fullResults = fullResults.sort(
+          (a: CarHireQuoteResult, b: CarHireQuoteResult) =>
+            this.getPrice(a) - this.getPrice(b)
+        );
+        break;
+      case 1: // expensive
+        fullResults = fullResults.sort(
+          (a: CarHireQuoteResult, b: CarHireQuoteResult) =>
+            this.getPrice(b) - this.getPrice(a)
+        );
+        break;
+      case 2: // preferred TODO
+        break;
+      case 3: // brand
+        fullResults = this.sortByBrand(fullResults);
+        break;
+      case 4: // size
+        fullResults = this.sortBySize(fullResults);
+        break;
+    }
+    // fallback to whatever was before
+    this.results.next(fullResults);
+    return fullResults;
+  }
+
+  /**
+   * @description - sort the results expensive
+   * @param results - full results from sort results function
+   */
+
+  sortExpensive(results?: CarHireQuoteResultArray): CarHireQuoteResultArray {
+    const fullResults = this.helpers.clone(
+      results ? results : this.results.value
+    );
+    const sortedResults = fullResults.sort(
+      (a: CarHireQuoteResult, b: CarHireQuoteResult) =>
+        this.getPrice(b) - this.getPrice(a)
+    );
+    this.results.next(sortedResults);
+    return sortedResults;
+  }
+
+  /**
+   * @description - sort the results cheapest
+   * @param results - full results from sort results function
+   */
+
+  sortCheapest(results?: CarHireQuoteResultArray): CarHireQuoteResultArray {
+    const fullResults = this.helpers.clone(
+      results ? results : this.results.value
+    );
+    const sortedResults = fullResults.sort(
+      (a: CarHireQuoteResult, b: CarHireQuoteResult) =>
+        this.getPrice(a) - this.getPrice(b)
+    );
+    this.results.next(sortedResults);
+    return sortedResults;
+  }
+
+  /**
+   * @description - sort the results
+   * @param results - full results from sort results function
+   */
+  sortBySize(results?: CarHireQuoteResultArray): CarHireQuoteResultArray {
+    const fullResults = this.helpers.clone(
+      results ? results : this.results.value
+    );
+    const sortedResults = fullResults.sort(
+      (a: CarHireQuoteResult, b: CarHireQuoteResult) => {
+        let aVal: number;
+        let bVal: number;
+        aVal = this.carClassMap[a.displayRecord.vehicle.class.toLowerCase()];
+        bVal = this.carClassMap[b.displayRecord.vehicle.class.toLowerCase()];
+        if (aVal >= 0 && bVal >= 0) {
+          return aVal - bVal;
+        }
+        return -1; // just place them at end  - unrecognised product description
+      }
+    );
+    this.results.next(sortedResults);
+    return sortedResults;
+  }
+
+  /**
+   * @description - sort the results
+   * @param results - full results from sort results function
+   */
+  sortByBrand(results?: CarHireQuoteResultArray): CarHireQuoteResultArray {
+    const fullResults = this.helpers.clone(
+      results ? results : this.results.value
+    );
+    const sortedResults = fullResults.sort(
+      (a: CarHireQuoteResult, b: CarHireQuoteResult) => {
+        let brandA = a.identifiers.vendor;
+        let brandB = b.identifiers.vendor;
+
+        // switching as these strings don't match the brand name
+        switch (brandA) {
+          case 'ZE':
+            brandA = 'HE';
+            break;
+          case 'ZI':
+            brandA = 'AV';
+            break;
+        }
+
+        switch (brandB) {
+          case 'ZE':
+            brandB = 'HE';
+            break;
+          case 'ZI':
+            brandB = 'AV';
+            break;
+        }
+
+        if (brandA < brandB) {
+          return -1;
+        } else if (brandA > brandB) {
+          return 1;
+        } else {
+          return 0;
+        }
+      }
+    );
+
+    this.results.next(sortedResults);
+    return sortedResults;
+  }
+
+  /**
+   * @description - get the price of a individual car
+   */
+  getPrice(car: CarHireQuoteResult): number {
+    try {
+      return Number(car.displayRecord.charges[0].amount);
+    } catch (error) {}
+
+    return 0;
+  }
+
+  getMinPrice(cars: CarHireQuoteResultArray): number {
+    return cars.reduce((min: number, car: CarHireQuoteResult) => {
+      const price = this.getPrice(car);
+      if (price < min) {
+        min = price;
+      }
+      return min;
+    }, Number.MAX_SAFE_INTEGER);
+  }
+
+  getMaxPrice(cars: CarHireQuoteResultArray): number {
+    return cars.reduce((max: number, car: CarHireQuoteResult) => {
+      const price = this.getPrice(car);
+      if (price > max) {
+        max = price;
+      }
+      return max;
+    }, Number.MIN_SAFE_INTEGER);
+  }
+
+  updateFromPreviousSearches(
+    previousItems: Record<ServiceType, BasketItem>
+  ): void {
+    const flightItem: SearchFlightsV2QueryVariables =
+      previousItems[ServiceType.Flight]?.searchQuery;
+    if (flightItem) {
+      // TODO flights haven't been done yet.
+    }
+  }
+
+  // !date and time is handled differently for LU
+  private _updatePickupDateTime() {
+    if (this._pickup_date && this._pickup_time) {
+      const time = this.helpers.ngDateToMoment(
+        this._pickup_date,
+        this._pickup_time
+      );
+      this.pickup_datetime = time.isValid() ? time : null;
+      this._isValid();
+    }
+  }
+
+  private _updateDropoffDateTime() {
+    if (this._dropoff_date && this._dropoff_time) {
+      const time = this.helpers.ngDateToMoment(
+        this._dropoff_date,
+        this._dropoff_time
+      );
+      this.dropoff_datetime = time.isValid() ? time : null;
+      this._isValid();
+    }
+  }
+
+  private _updateNgbPickupDateTime() {
+    if (this._ngbPickupDate && this._pickupTime) {
+      const time = this.helpers.ngDateToMoment(
+        this._ngbPickupDate,
+        this._pickupTime
+      );
+      this.pickup_datetime = time.isValid() ? time : null;
+      this._isValid();
+    }
+  }
+
+  private _updateNgbDropoffDateTime() {
+    if (this._ngbDropoffDate && this._dropoffTime) {
+      const time = this.helpers.ngDateToMoment(
+        this._ngbDropoffDate,
+        this._dropoffTime
+      );
+      this.dropoff_datetime = time.isValid() ? time : null;
+      this._isValid();
+    }
+  }
+
+  isOverNight(): boolean {
+    const outwardDay = this.pickup_datetime.date();
+    const returnDay = this.dropoff_datetime.date();
+    if (returnDay - outwardDay >= 1) {
+      return true;
+    }
+    return false;
+  }
+
+  updateLowestPrice(results: CarHireQuoteResultArray): ICheapestPrice {
+    if (!results.length) return null;
+    const minPrice = this.getMinPrice(results);
+    return {
+      amount: minPrice,
+      currencyCode: results[0].displayRecord.charges[0].currencyCode
+    };
+  }
+
+  /**
+   * @description - get the availability details for a particular car hire result using locationDetails param
+   * @param locationDetails - e.g. taken from response data in searchCarHire query
+   * @param isLoading behaviourSubject for handling loading spinner state of request
+   */
+  getCarHireAvailabilityDetail(
+    locationDetails: CarHireInputIdentifiers,
+    isLoading: BehaviorSubject<boolean>
+  ): Observable<CarHireDetailRequestResponse> {
+    if (!isLoading.value) {
+      isLoading.next(true);
+    }
+    return this.carHireAvailabilityDetailFetcher
+      .fetchList({ locationDetails })
+      .pipe(
+        take(1),
+        map((result: CarHireDetailRequestResponse) => {
+          if (isLoading.value) {
+            isLoading.next(false);
+          }
+          return result;
+        })
+      );
+  }
+
+  /**
+   * @description - add car hire to basket
+   */
+  async addCarHireToBasket(
+    carHireVehicleAvailibility: CarHireVehicleAvailibility,
+    carHireQuery: SearchCarHireQueryVariables
+  ): Promise<boolean> {
+    if (carHireVehicleAvailibility.unavailable) {
+      return Promise.resolve(false);
+    }
+    const intBasket: InternalBasketInterface =
+      await this.basketService.getDefaultBasket();
+    const basket = intBasket?.subject.value;
+    if (basket) {
+      const {
+        co2PerItem,
+        co2PerPassenger,
+        displayRecord,
+        identifiers,
+        sourceId
+      } = carHireVehicleAvailibility;
+      const price = parseFloat(displayRecord?.charges[0]?.amount ?? '0');
+      return this.basketService.addToBasket(
+        {
+          adults: this.adults,
+          basket: basket.id,
+          service: sourceId.toString(),
+          detail: {
+            pickUpDatetime: new Date(displayRecord.pickup).toISOString(),
+            dropOffDatetime: new Date(displayRecord.dropoff).toISOString(),
+            pickUpLocation: {
+              iata:
+                this.locationType === LocationTypes.Airport
+                  ? identifiers.locationCode
+                  : '',
+              name: displayRecord.pickupLocation.name,
+              address: `${displayRecord.pickupLocation.topLine}, ${displayRecord.pickupLocation.city}`,
+              postcode: displayRecord.pickupLocation.postCode
+            },
+            dropOffLocation: {
+              iata:
+                this.locationType === LocationTypes.Airport
+                  ? identifiers.dropOffLocation
+                  : '',
+              name: displayRecord.returnLocation.name,
+              address: `${displayRecord.returnLocation.topLine}, ${displayRecord.returnLocation.city}`,
+              postcode: displayRecord.returnLocation.postCode
+            },
+            car: {
+              type: displayRecord.vehicle.type,
+              manualTransmission: displayRecord.vehicle.transmission.includes(
+                CarHireTransmission.Manual
+              )
+            },
+            vendorName: displayRecord.vendor.name,
+            identifiers: {
+              dropOffLocation: identifiers.dropOffLocation,
+              locationCode: identifiers.locationCode,
+              locationName: identifiers.locationName,
+              vehType: identifiers.vehType,
+              vendor: identifiers.vendor
+            }
+          },
+          price,
+          currency: 'GBP' as CurrencyCode,
+          searchQuery: carHireQuery,
+          co2PerItem,
+          co2PerPassenger,
+          outboundDate: new Date(displayRecord.pickup).toISOString()
+        },
+        intBasket,
+        this.searchService,
+        this.travellers
+      );
+    }
+    return Promise.resolve(false);
+  }
+}