@sabstravtech/obtservices 0.0.0

package/projects/obtservices/base/src/lib/vendor/services/search.service.ts

@@ -0,0 +1,2026 @@
+import { map, take } from 'rxjs/operators';
+import moment from 'moment';
+import Countries from '../data/countries.json';
+import { BehaviorSubject, forkJoin, of } from 'rxjs';
+import { BaseEnterpriseSearch } from '../classes/base-enterprise';
+import { Observable } from 'rxjs';
+import { ParkingEnterpriseSearch } from '../classes/parking-enterprise-search';
+import {
+  SearchObject,
+  SearchObjects
+} from '../interfaces/search-objects.interface';
+import {
+  Address,
+  Airport,
+  BasketItem,
+  BookerType,
+  FareType,
+  RailClass,
+  RailJourneyType,
+  SearchAirports,
+  ServiceType,
+  SaveUserAddressMutationVariables,
+  CarHireDepot,
+  CabHireVehicleType,
+  ConfermaOfficeNames,
+  CarbonAllowance,
+  RiskAlert,
+  RiskLevel,
+  RailStation,
+  GetRiskAlertsQueryVariables,
+  SearchAirlines,
+  AirlineResult,
+  HotelItinerary,
+  FlightCabinClass,
+  ReferenceRailCardQualifier,
+  SearchUserCanBookForQueryVariables,
+  Search,
+  SaveRecentSearchMutationVariables
+} from '../types/graphql.types';
+import { LoungesEnterpriseSearch } from '../classes/lounges-enterprise-search';
+import { HotelEnterpriseSearch } from '../classes/hotel-enterprise-search';
+import { CarhireEnterpriseSearch } from '../classes/carhire-enterprise-search';
+import {
+  FlightEnterpriseSearch,
+  TimeWindow
+} from '../classes/flight-enterprise-search';
+import { CabHireEnterpriseSearch } from '../classes/cabhire-enterprise-search';
+import {
+  RailEnterpriseSearch,
+  RailSearchCriteria
+} from '../classes/rail-enterprise-search';
+import { Traveller, TravellerObject } from '../models/traveller.object';
+import { BaseStorageService } from './storage.service';
+import { BaseHelperRoutines } from '../classes/helpers';
+import { BaseHotelAvalibilityService } from './hotel-avallibility.service';
+import { BaseEnvironment } from '../classes/enviroment';
+import {
+  BaseSearchPostcodeFetcher,
+  SearchPostcodesQuoteFetcherType
+} from '../fetchers/search-postcodes.fetcher';
+import {
+  AddressForm,
+  AirportSearchResults,
+  CarHireDepotResultArray,
+  CountryCode,
+  LocationDetails,
+  LocationTypes,
+  OBTAirportDetails,
+  RailAirport,
+  Router,
+  SearchCitiesResult,
+  SearchCitiesResultArray,
+  SearchPostcodesResult,
+  SearchPostcodesResultArray,
+  SearchRailStationsResult,
+  SearchRailStationsResultArray,
+  TerminalsType,
+  GetUserCompanyOfficesResultArray,
+  GetUserCompanyOfficesResult,
+  SearchHotelChainsResultArray,
+  SearchHotelChainsResult,
+  SearchRiskAlertsResult,
+  AirlinesSearchResult,
+  OBTAirlinesDetails,
+  GetUserRecentSearchesResultArray,
+  GetUserRecentSearchesResult,
+  RecentSearch,
+  HotelQuoteResultArray,
+  SearchConfermaCitiesResult
+} from '../types/types';
+import {
+  BaseSearchRailStationsFetcher,
+  SearchRailStationsFetcherType
+} from '../fetchers/search-rail-stations.fetcher';
+import {
+  BaseLoungeQuoteFetcher,
+  LoungeQuoteFetcherType
+} from '../fetchers/lounge-quote.fetcher';
+import {
+  BaseParkingQuoteFetcher,
+  ParkingQuoteFetcherType
+} from '../fetchers/parking-quote-fetcher';
+import {
+  BaseFlightQuoteFetcher,
+  FlightQuoteFetcherType
+} from '../fetchers/flight-quote.fetcher';
+import {
+  BaseHotelQuoteFetcher,
+  HotelQuoteFetcherType
+} from '../fetchers/hotel-quote-fetcher';
+import {
+  BaseCarhireQuoteFetcher,
+  CarHireFetcherType
+} from '../fetchers/carhire-quote-fetcher';
+import {
+  BaseCarHireAvailabilityDetailFetcher,
+  CarHireAvailabilityDetailFetcherType
+} from '../fetchers/carhire-availability-detail.fetcher';
+import {
+  BaseCabhireQuoteFetcher,
+  CabhireQuoteFetcherType
+} from '../fetchers/cabhire-quote-fetcher';
+import {
+  BaseRailQuoteFetcher,
+  RailQuoteFetcherType
+} from '../fetchers/rail-quote-fetcher';
+import {
+  BaseIrlQuoteFetcher,
+  IrlQuoteFetcherType
+} from '../fetchers/irl-quote-fetcher';
+import { RegExps } from '../models/regexp.model';
+import {
+  EnterpriseSearchServiceInterface,
+  SearchParams
+} from '../interfaces/Isearch.service';
+import {
+  BaseSearchAirportsFetcher,
+  SearchAirportsQuoteFetcherType
+} from '../fetchers/search-airports-fetcher';
+import {
+  BaseSearchAirlinesFetcher,
+  SearchAirlinesQuoteFetcherType
+} from '../fetchers/search-airlines.fetcher';
+import {
+  UserServiceInterface,
+  UserServices
+} from '../interfaces/Iuser.service';
+import {
+  BaseSearchCityFetcher,
+  SearchCitiesQuoteFetcherType
+} from '../fetchers/search-cities.fetcher';
+import {
+  BaseSearchConfermaCityFetcher,
+  SearchConfermaCitiesQuoteFetcherType
+} from '../fetchers/search-conferma-cities.fetcher';
+import { AbstractHttpCallService } from './http-call.service';
+import { EnterpriseBasketServiceInterface } from '../interfaces/Ienterprise-basket.service';
+import { HotelAvalinilityFetcherType } from '../fetchers/hotel-avaliability-fetcher';
+import {
+  BaseSaveUserAddressUpdater,
+  SaveUserAddressUpdaterType
+} from '../updaters/save-user-address.updater';
+import {
+  BaseUserAddressesFetcher,
+  UserAddressFetcherType
+} from '../fetchers/user-addresses.fetcher';
+
+import {
+  BaseConfermaOfficeNamesFetcher,
+  ConfermaOfficeNameFetcherType
+} from '../fetchers/conferma-office-names.fetcher';
+
+import {
+  BaseGetUserCompanyOfficesFetcher,
+  GetUserCompanyOfficesQuoteFetcherType
+} from '../fetchers/get-user-company-offices.fetcher';
+import {
+  BaseSearchHotelChainsFetcher,
+  SearchHotelChainsQuoteFetcherType
+} from '../fetchers/search-hotel-chains.fetcher';
+import {
+  BaseValidateIsPostcodeValidTester,
+  ValidateIsPostcodeValidType
+} from '../testers/postcode-validate.tester';
+
+import {
+  BaseSearchDepotFetcher,
+  SearchDepotQuoteFetcherType
+} from '../fetchers/search-depots.fetcher';
+
+import {
+  BaseGetRailStationFetcher,
+  GetRailStationFetcherType
+} from '../fetchers/get-rail-station.fetcher';
+
+import {
+  BaseSearchConfermaQuicklistFetcher,
+  ConfermaQuicklistFetcherType
+} from '../fetchers/conferma-quicklist.fetcher';
+
+import {
+  BaseDeleteUserAddressUpdater,
+  DeleteUserAddressFetcherType
+} from '../updaters/remove-user-address-updater';
+
+import {
+  BaseDeleteRecentSearchUpdater,
+  DeleteRecentSearchFetcherType
+} from '../updaters/remove-recent-search-updater';
+
+import {
+  BaseSaveRecentSearchUpdater,
+  SaveRecentSearchFetcherType
+} from '../updaters/save-recent-search-updater';
+
+import { HotelTempParams } from '../interfaces/Ihotel-enterprise-search';
+import { RailTempParams } from '../interfaces/Irail-enterprise-search';
+import { FlightTempParams } from '../interfaces/Iflight-enterprise-search';
+import { LoungesTempParams } from '../interfaces/Ilounges-enterprise-search';
+import { ParkingTempParams } from '../interfaces/Iparking-enterprise-search';
+import { CabHireTempParams, TaxiFormMode } from '../interfaces/Icabhire-enterprise-search';
+import { CarHireTempParams } from '../interfaces/Icarhire-enterprise-search';
+import {
+  BaseGetUserCurrentCarbonAllowanceFetcher,
+  GetUserCurrentCarbonAllowanceType
+} from '../fetchers/get-user-current-carbon-allowance.fetcher';
+import { BaseWebTokenService } from './webtoken.service';
+import {
+  BaseGetRiskAlertsFetcher,
+  GetRiskAlertsFetcherType
+} from '../fetchers/get-risk-alerts.fetcher';
+import { IrlTempParams } from '../interfaces/Iirl-enterprise-search';
+import { IRLEnterpriseSearch } from '../classes/irl-enterprise-search';
+import { FlightSearchType } from '../classes/flight-search-type.enum';
+
+import {
+  BaseGetUserRecentSearchesFetcher,
+  GetUserRecentSearchesFetcherType
+} from '../fetchers/get-user-recent-searches.fetcher';
+
+import {
+  BaseGetRailcardsFetcher,
+  GetRailCardsFetcherType
+} from '../fetchers/get-rail-cards.fetcher';
+
+import {
+  BaseEurostarQuoteFetcher,
+  EurostarQuoteFetcherType
+} from '../fetchers/eurostar-quote.fetcher';
+import { EurostarEnterpriseSearch } from '../classes/eurostar-enterprise-search';
+import { EurostarTempParams } from '../interfaces/Ieurostar-enterprise-search';
+import EuroStations from '../data/euro-stations.json';
+import _ from 'lodash';
+import {
+  BaseSearchUsersCanBookForFetcher,
+  SearchUserCanBookForFetcherType
+} from '../fetchers/search-users-can-book-for-fetcher';
+import { EurostarSearchType } from '../classes/eurostar-search-type.enum';
+
+export const MAX_TRAVELLERS = 8;
+
+export enum TravellerSearchTypes {
+  email = 'email',
+  name = 'name',
+  employeeNumber = 'employeeNumber'
+}
+
+interface HighestSearchPriorityObjectInterface {
+  highest: number;
+  currentItem: SearchObject;
+}
+
+export class BaseEnterpriseSearchService<
+  SP_Q extends SearchPostcodesQuoteFetcherType,
+  SR_Q extends SearchRailStationsFetcherType,
+  SL_Q extends LoungeQuoteFetcherType,
+  SPA_Q extends ParkingQuoteFetcherType,
+  SFL_Q extends FlightQuoteFetcherType,
+  SHO_Q extends HotelQuoteFetcherType,
+  SCH_Q extends CarHireFetcherType,
+  CHAD_Q extends CarHireAvailabilityDetailFetcherType,
+  STH_Q extends CabhireQuoteFetcherType,
+  SA_Q extends SearchAirportsQuoteFetcherType,
+  SAL_Q extends SearchAirlinesQuoteFetcherType,
+  HA_Q extends HotelAvalinilityFetcherType,
+  SC_Q extends SearchCitiesQuoteFetcherType,
+  SCC_Q extends SearchConfermaCitiesQuoteFetcherType,
+  SRA_Q extends RailQuoteFetcherType,
+  SI_Q extends IrlQuoteFetcherType,
+  SUA_Q extends SaveUserAddressUpdaterType,
+  SU_Q extends UserAddressFetcherType,
+  GUCO_Q extends GetUserCompanyOfficesQuoteFetcherType,
+  SHC_Q extends SearchHotelChainsQuoteFetcherType,
+  IPV_Q extends ValidateIsPostcodeValidType,
+  SD_Q extends SearchDepotQuoteFetcherType,
+  GRS_Q extends GetRailStationFetcherType,
+  GON_Q extends ConfermaOfficeNameFetcherType,
+  DUA_Q extends DeleteUserAddressFetcherType,
+  DRS_Q extends DeleteRecentSearchFetcherType,
+  SRS_Q extends SaveRecentSearchFetcherType,
+  UCA_Q extends GetUserCurrentCarbonAllowanceType,
+  GRA_Q extends GetRiskAlertsFetcherType,
+  QL_Q extends ConfermaQuicklistFetcherType,
+  GURSF_Q extends GetUserRecentSearchesFetcherType,
+  GRCF_Q extends GetRailCardsFetcherType,
+  SE_Q extends EurostarQuoteFetcherType,
+  SUCBF extends SearchUserCanBookForFetcherType
+  > implements EnterpriseSearchServiceInterface {
+  static SESSION_TRAVELLER: string = 'search_travellers';
+
+  searches: SearchParams;
+  traveller_error = false;
+  travellerInformation: BehaviorSubject<Traveller[]> = new BehaviorSubject<
+    Traveller[]
+  >([]);
+  errors: BehaviorSubject<string[]> = new BehaviorSubject<string[]>([]);
+  searchLoadingDone: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(
+    false
+  );
+  searchTimedOut: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(
+    false
+  );
+  newSearchStarted: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(
+    false
+  );
+
+  firstLoad = true;
+
+  search_objects: SearchObjects;
+  highest_search_priority = 8;
+  show_errors = false;
+  travellerValidationMessages: string[] = [];
+  search_loading = false;
+  search_airport_loading = false;
+
+  private selectedTravellers: Traveller[] = [];
+  selectedPlaces: any = [];
+  countries = Countries;
+  eurostations: { gateway: string; destination: string }[] =
+    _.toArray(EuroStations);
+
+  constructor(
+    protected searchAirportsFetcher: BaseSearchAirportsFetcher<SA_Q>,
+    protected searchAirlinesFetcher: BaseSearchAirlinesFetcher<SAL_Q>,
+    protected storageService: BaseStorageService,
+    protected userService: UserServiceInterface,
+    protected router: Router,
+    protected helpers: BaseHelperRoutines,
+    protected hotelAvalibilityService: BaseHotelAvalibilityService<HA_Q>,
+    private citiesFetcher: BaseSearchCityFetcher<SC_Q>,
+    private confermaCitiesFetcher: BaseSearchConfermaCityFetcher<SCC_Q>,
+    private postcodeFetcher: BaseSearchPostcodeFetcher<SP_Q>,
+    private railStationFetcher: BaseSearchRailStationsFetcher<SR_Q>,
+    private saveUserAddressUpdater: BaseSaveUserAddressUpdater<SUA_Q>,
+    private userAddressesFetcher: BaseUserAddressesFetcher<SU_Q>,
+    private basketService: EnterpriseBasketServiceInterface,
+    private getUserCompanyOfficesFetcher: BaseGetUserCompanyOfficesFetcher<GUCO_Q>,
+    private searchHotelChainsFetcher: BaseSearchHotelChainsFetcher<SHC_Q>,
+    private baseValidateIsPostcodeValidTester: BaseValidateIsPostcodeValidTester<IPV_Q>,
+    private depotFetcher: BaseSearchDepotFetcher<SD_Q>,
+    private confermaOfficeNamesFetcher: BaseConfermaOfficeNamesFetcher<GON_Q>,
+    private baseDeleteUserAddressUpdater: BaseDeleteUserAddressUpdater<DUA_Q>,
+    private baseDeleteRecentSearchUpdater: BaseDeleteRecentSearchUpdater<DRS_Q>,
+    private baseSaveRecentSearchUpdater: BaseSaveRecentSearchUpdater<SRS_Q>,
+    private getUserCurrentCarbonAllowanceFetcher: BaseGetUserCurrentCarbonAllowanceFetcher<UCA_Q>,
+    environment: BaseEnvironment,
+    loungeFetcher: BaseLoungeQuoteFetcher<SL_Q>,
+    parkingFetcher: BaseParkingQuoteFetcher<SPA_Q>,
+    httpCallService: AbstractHttpCallService,
+    flightFetcher: BaseFlightQuoteFetcher<SFL_Q>,
+    hotelFetcher: BaseHotelQuoteFetcher<SHO_Q>,
+    carhireFetcher: BaseCarhireQuoteFetcher<SCH_Q>,
+    carHireAvailabilityDetailFetcher: BaseCarHireAvailabilityDetailFetcher<CHAD_Q>,
+    cabhireFetcher: BaseCabhireQuoteFetcher<STH_Q>,
+    railFetcher: BaseRailQuoteFetcher<SRA_Q>,
+    irlFetcher: BaseIrlQuoteFetcher<SI_Q>,
+    protected getRailStationFetcher: BaseGetRailStationFetcher<GRS_Q>,
+    baseWebTokenService: BaseWebTokenService,
+    private riskAlertsFetcher: BaseGetRiskAlertsFetcher<GRA_Q>,
+    private quicklistFetcher: BaseSearchConfermaQuicklistFetcher<QL_Q>,
+    private getUserRecentSearchesFetcher: BaseGetUserRecentSearchesFetcher<GURSF_Q>,
+    protected getRailCardsFetcher: BaseGetRailcardsFetcher<GRCF_Q>,
+    eurostarFetcher: BaseEurostarQuoteFetcher<SE_Q>,
+    public searchUsersCanBookForFetcher: BaseSearchUsersCanBookForFetcher<SUCBF>
+  ) {
+    console.log('Enterpise search service being inited');
+    this.searches = {
+      [ServiceType.Lounge]: new LoungesEnterpriseSearch(
+        loungeFetcher,
+        helpers,
+        basketService,
+        storageService,
+        this
+      ),
+      [ServiceType.Parking]: new ParkingEnterpriseSearch(
+        parkingFetcher,
+        helpers,
+        basketService,
+        storageService,
+        this
+      ),
+      [ServiceType.Flight]: new FlightEnterpriseSearch(
+        flightFetcher,
+        helpers,
+        userService,
+        basketService,
+        storageService,
+        this
+      ),
+      [ServiceType.Hotel]: new HotelEnterpriseSearch(
+        hotelFetcher,
+        helpers,
+        userService,
+        environment,
+        hotelAvalibilityService,
+        basketService,
+        storageService,
+        this,
+        httpCallService,
+        quicklistFetcher,
+        getRailStationFetcher
+      ),
+      [ServiceType.Car]: new CarhireEnterpriseSearch(
+        carhireFetcher,
+        carHireAvailabilityDetailFetcher,
+        helpers,
+        basketService,
+        storageService,
+        this
+      ),
+      [ServiceType.Cab]: new CabHireEnterpriseSearch(
+        cabhireFetcher,
+        helpers,
+        storageService,
+        this,
+        basketService
+      ),
+      [ServiceType.InternationalRail]: new IRLEnterpriseSearch(
+        irlFetcher,
+        // getRailStationFetcher,
+        helpers,
+        basketService,
+        storageService,
+        this
+      ),
+      [ServiceType.FastTrack]: null,
+      [ServiceType.Coach]: null,
+      [ServiceType.Rail]: new RailEnterpriseSearch(
+        railFetcher,
+        getRailStationFetcher,
+        helpers,
+        basketService,
+        storageService,
+        this
+      ),
+      [ServiceType.Eurostar]: new EurostarEnterpriseSearch(
+        eurostarFetcher,
+        helpers,
+        userService,
+        basketService,
+        storageService,
+        this
+      )
+    };
+    console.log('Newly created search objects: ', this.searches);
+    this.search_objects = this.helpers.clone(this.init_search_objects());
+    this.selectedTravellers = this.storageService.getSessionItemAsList<
+      Traveller[]
+    >(BaseEnterpriseSearchService.SESSION_TRAVELLER);
+    this.travellerInformation.next(this.selectedTravellers);
+    userService.fullUserDetails.userServices.subscribe(
+      (services: UserServices) => {
+        if (services) {
+          this.search_objects = Object.keys(this.search_objects).reduce(
+            (objects: SearchObjects, key: string) => {
+              (objects as Record<string, any>)[key].enabled =
+                !!services && !!services[key];
+              return objects;
+            },
+            this.search_objects
+          );
+        }
+      }
+    );
+
+    if (Array.isArray(this.countries)) {
+      this.countries = this.countries.sort((a, b) => {
+        if (a.cName < b.cName) {
+          return -1;
+        }
+        if (a.cName > b.cName) {
+          return 1;
+        }
+        return 0;
+      });
+    }
+
+    baseWebTokenService.autoLogoutConfig = this.getAutoLogoutConfig();
+  }
+
+  reset() {
+    Object.values(this.searches).forEach(
+      (item: BaseEnterpriseSearch<any, any, any[]>) => {
+        item?.reset();
+      }
+    );
+    this.removeAllTravellers();
+    this.basketService.reset();
+  }
+
+  getUserCurrentCarbonAllowance(
+    user?: string,
+    isLoading?: BehaviorSubject<boolean>
+  ): Observable<CarbonAllowance> {
+    if (isLoading) {
+      isLoading.next(true);
+    }
+
+    const query = { user };
+    return this.getUserCurrentCarbonAllowanceFetcher.fetchList(query).pipe(
+      take(1),
+      map((results: CarbonAllowance) => {
+        return results;
+      })
+    );
+  }
+
+  getRiskAlerts(
+    minLevel: RiskLevel,
+    maxLevel: RiskLevel,
+    countryIsoCode: string,
+    isLoading?: BehaviorSubject<boolean>,
+    airport?: Airport,
+    railStation?: RailStation,
+    airportIata?: string
+  ): Observable<RiskAlert[]> {
+    if (isLoading) {
+      isLoading.next(true);
+    }
+
+    const query: GetRiskAlertsQueryVariables = {
+      minLevel,
+      maxLevel,
+      countryIsoCode
+    };
+
+    return this.riskAlertsFetcher.fetchList(query).pipe(
+      take(1),
+      map((result: RiskAlert[]) => {
+        if (isLoading) {
+          isLoading.next(false);
+        }
+
+        return result;
+      })
+    );
+  }
+
+  getAirportsList(
+    term: string,
+    countryCode?: CountryCode,
+    isLoading?: BehaviorSubject<boolean>,
+    hasLounge?: boolean,
+    hasParking?: boolean,
+    hasFastTrack?: boolean
+  ): Observable<OBTAirportDetails[]> {
+    if (term.length > 2) {
+      if (isLoading) {
+        isLoading.next(true);
+      }
+
+      const query: SearchAirports.Variables = { query: term };
+      if (!!countryCode) {
+        query.countryCode = countryCode;
+      }
+      if (typeof hasLounge === 'boolean') {
+        query.hasLounge = hasLounge;
+      }
+      if (typeof hasParking === 'boolean') {
+        query.hasParking = hasParking;
+      }
+      if (typeof hasFastTrack === 'boolean') {
+        query.hasFastTrack = hasFastTrack;
+      }
+      return this.searchAirportsFetcher.fetchOne(query).pipe(
+        take(1),
+        map((results: AirportSearchResults) => {
+          if (isLoading) {
+            isLoading.next(false);
+          }
+
+          if (results && results.generalMatches) {
+            const generalMatches = this.helpers.clone(results.generalMatches);
+
+            // Removing this as this creates duplicate airports in the list
+            // if (results.iataMatch) {
+            //   generalMatches.push(results.iataMatch);
+            // }
+            return (
+              generalMatches
+                // .filter((airport: AirportResult) => {
+                //   return !!countryCode
+                //     ? countryCode === airport.details.countryCode
+                //     : airport;
+                // })
+                .map((airport: Airport): OBTAirportDetails => {
+                  return {
+                    destination: airport.name,
+                    gateway: airport.iata,
+                    terminals: this.processTerminals(airport.terminals),
+                    country: airport?.locationDetails?.country,
+                    postcode: airport?.locationDetails?.postcode,
+                    countryCode: airport?.locationDetails?.countryCode
+                  };
+                })
+            );
+          }
+        })
+      );
+    } else {
+      return of([]);
+    }
+  }
+  getAirlinesList(
+    term: string,
+    isLoading?: BehaviorSubject<boolean>
+  ): Observable<OBTAirlinesDetails[]> {
+    if (term.length >= 2) {
+      if (isLoading) {
+        isLoading.next(true);
+      }
+      const query: SearchAirlines.Variables = { query: term };
+      return this.searchAirlinesFetcher.fetchOne(query).pipe(
+        take(1),
+        map((results: AirlinesSearchResult) => {
+          if (isLoading) {
+            isLoading.next(false);
+          }
+
+          if (results && results.generalMatches) {
+            const generalMatches = this.helpers.clone(results.generalMatches);
+            return generalMatches.map(
+              (airlines: AirlineResult): OBTAirlinesDetails => {
+                return {
+                  code: airlines.iata,
+                  name: airlines.name
+                };
+              }
+            );
+          }
+        })
+      );
+    } else {
+      return of([]);
+    }
+  }
+  getAirportLocations(
+    term: string,
+    countryCode: CountryCode,
+    isLoading?: BehaviorSubject<boolean>,
+    hasLounge?: boolean,
+    hasParking?: boolean,
+    hasFastTrack?: boolean
+  ): Observable<LocationDetails[]> {
+    const convert = (results: OBTAirportDetails[]): LocationDetails[] => {
+      return results.map((result: OBTAirportDetails) => {
+        return {
+          name: result.destination,
+          type: LocationTypes.Airport,
+          airport: result
+        };
+      });
+    };
+    return this.getAirportsList(
+      term,
+      countryCode,
+      isLoading,
+      hasLounge,
+      hasParking,
+      hasFastTrack
+    ).pipe(map(convert));
+  }
+
+  getCityLocations(
+    term: string,
+    countryCode?: CountryCode,
+    isLoading?: BehaviorSubject<boolean>,
+    isConfirma?: boolean
+  ): Observable<LocationDetails[]> {
+    if (term.length <= 2) {
+      return;
+    }
+    if (isConfirma) {
+      return this.getConfermaCityLocations(term, countryCode, isLoading);
+    } else {
+      return this._getCityLocations(term, countryCode, isLoading);
+    }
+  }
+
+  _getCityLocations(
+    term: string,
+    countryCode?: CountryCode,
+    isLoading?: BehaviorSubject<boolean>
+  ): Observable<LocationDetails[]> {
+    isLoading?.next(true);
+    const query: any = { query: term };
+    if (countryCode) {
+      query.countryCode = countryCode;
+    }
+    const obs: Observable<SearchCitiesResultArray> =
+      this.citiesFetcher.fetchList(query);
+    const func = (results: SearchCitiesResultArray): LocationDetails[] => {
+      const data: LocationDetails[] = results.map(
+        (result: SearchCitiesResult): LocationDetails => {
+          return {
+            name: result.name,
+            longitude: result.coordinates.longitude,
+            latitude: result.coordinates.latitude,
+            type: LocationTypes.City,
+            countryCode: result.countryCode,
+            id: result.id
+          };
+        }
+      );
+      isLoading?.next(false);
+      return data;
+    };
+    return obs.pipe(take(1), map(func));
+  }
+
+  private getConfermaCityLocations(
+    term: string,
+    countryCode?: CountryCode,
+    isLoading?: BehaviorSubject<boolean>
+  ): Observable<LocationDetails[]> {
+    isLoading?.next(true);
+    const query: any = { cityName: term };
+    if (countryCode) {
+      query.countryCode = countryCode;
+    }
+    const obs: Observable<SearchConfermaCitiesResult> =
+      this.confermaCitiesFetcher.fetchOne(query);
+    const func = (results: SearchConfermaCitiesResult): LocationDetails[] => {
+      const data: LocationDetails[] = results.suggestions.map(
+        (result): LocationDetails => {
+          return {
+            name: result.name,
+            longitude: result.longitude,
+            latitude: result.latitude,
+            type: LocationTypes.City,
+            countryCode: result.countryCode
+          };
+        }
+      );
+      isLoading?.next(false);
+      return data;
+    };
+    return obs.pipe(take(1), map(func));
+  }
+
+  /**
+   * @description - get car hire depots based on city cords
+   */
+  getCarHireDepots(
+    latitude: number,
+    longitude: number,
+    isLoading?: BehaviorSubject<boolean>
+  ): Observable<CarHireDepotResultArray> {
+    isLoading?.next(true);
+
+    const obs: Observable<CarHireDepotResultArray> =
+      this.depotFetcher.fetchList({ latitude, longitude });
+
+    const func = (
+      results: CarHireDepotResultArray
+    ): CarHireDepotResultArray => {
+      const data: CarHireDepotResultArray = results.map(
+        (result: CarHireDepot): CarHireDepot => {
+          console.log(result);
+          return result;
+        }
+      );
+      isLoading?.next(false);
+      return data;
+    };
+    return obs; // .pipe(take(1), map(func));
+
+    // return of([]);
+  }
+
+  /**
+   * @description - get postcode locations, these will use partial postcode,
+   *  full and then grabbing them will let us fill in the address form
+   * @todo - fill this out for the other location types, may need to mergeMap them or some other rxjs magic
+   * @param term - the term to search by e.g. 'wa14' should bring back, our office, 'm33' shoiuld bring back my addrs
+   */
+  getPostcodeList(term: string): Observable<LocationDetails[]> {
+    if (RegExps.UK_POSTCODE.test(term)) {
+      const subs = this.postcodeFetcher.fetchList({ postcode: term }).pipe(
+        map((results: SearchPostcodesResultArray) => {
+          return results.map(
+            (result: SearchPostcodesResult): LocationDetails => {
+              return {
+                name: result.postcode,
+                type: LocationTypes.Postcode,
+                latitude: result.latitude,
+                longitude: result.longitude
+              };
+            }
+          );
+        })
+      ); // expand this with the other searches when they are done
+
+      return subs;
+    } else {
+      return of([]);
+    }
+  }
+
+  addToSelectedPlaces(address: Address): void {
+    this.selectedPlaces.push(address);
+  }
+
+  getSelectedPlaceById(placeId: string): Address {
+    return this.selectedPlaces.find(
+      (place: { place_id: string }) => place.place_id === placeId
+    );
+  }
+
+  /*
+   * @description - get the list of Office locations based on search term given
+   * @todo - fill this out so that it actually performs a http call
+   * @param term - the term we want to search by
+   * @returns
+   */
+  getOfficeLocations(term: string): Observable<LocationDetails[]> {
+    if (term.length > 2) {
+      const obs: Observable<GetUserCompanyOfficesResultArray> =
+        this.getUserCompanyOfficesFetcher.fetchList();
+      const func = (
+        results: GetUserCompanyOfficesResultArray
+      ): LocationDetails[] => {
+        const data: LocationDetails[] = results.map(
+          (result: GetUserCompanyOfficesResult): LocationDetails => {
+            return {
+              name: result.name,
+              office: result.addresses[0],
+              type: LocationTypes.Office
+            };
+          }
+        );
+        return data;
+      };
+      return obs.pipe(take(1), map(func));
+    }
+
+    return of([]);
+  }
+
+  getStationLocations(
+    term: string,
+    isLoading?: BehaviorSubject<boolean>
+  ): Observable<LocationDetails[]> {
+    if (term.length > 2) {
+      isLoading?.next(true);
+      return this.railStationFetcher
+        .fetchList({
+          query: term
+        })
+        .pipe(
+          take(1),
+          map((results: SearchRailStationsResultArray): LocationDetails[] => {
+            if (isLoading) {
+              isLoading.next(false);
+            }
+            return results.map((result: SearchRailStationsResult) => {
+              return {
+                type: LocationTypes.TrainStation,
+                name: result.name,
+                railstation: result
+              };
+            });
+          })
+        );
+    } else {
+      return of([]);
+    }
+  }
+  /**
+   * @description - get hotel locations, these should be city, office, airport, railstation
+   * @todo - fill this out for the other location types, may need to mergeMap them or some other rxjs magic
+   * @param term - the term to search by e.g. 'Man' should bring back, manchester, manchester airport, manchester picadilly, etc
+   */
+  getHotelLocationsList(
+    term: string,
+    countryCode: CountryCode,
+    isLoading?: BehaviorSubject<boolean>
+  ): Observable<LocationDetails[]> {
+    if (term.length > 2) {
+      if (RegExps.UK_POSTCODE.test(term)) {
+        return this.getPostcodeList(term);
+      } else {
+        if (!isLoading?.value) {
+          isLoading.next(true);
+        }
+        const subs = forkJoin([
+          this.getAirportLocations(term, countryCode, isLoading),
+          this.getCityLocations(term, countryCode, isLoading),
+          this.getStationLocations(term, isLoading),
+          this.getOfficeLocations(term)
+        ]).pipe(
+          map((results: any[]) => {
+            if (isLoading?.value) {
+              isLoading.next(false);
+            }
+            return results.reduce((accum: LocationDetails[], result: any) => {
+              accum.push(...result);
+              return accum;
+            }, []);
+          })
+        ); // expand this with the other searches when they are done
+        return subs;
+      }
+    } else {
+      return of([]);
+    }
+  }
+
+  getStationsAndAirportsList(
+    term: string,
+    countryCode: CountryCode,
+    isLoading?: BehaviorSubject<boolean>
+  ): Observable<LocationDetails[]> {
+    if (term.length > 2) {
+      if (!isLoading?.value) {
+        isLoading.next(true);
+      }
+      const subs = forkJoin([
+        this.getAirportLocations(term, countryCode, isLoading),
+        this.getStationLocations(term, isLoading)
+      ]).pipe(
+        map((results: any[]) => {
+          if (isLoading?.value) {
+            isLoading.next(false);
+          }
+          return results.reduce((accum: any[], result: any[]) => {
+            accum.push(...result);
+            return accum;
+          }, []);
+        })
+      ); // expand this with the other searches when they are done
+      return subs;
+    } else {
+      return of([]);
+    }
+  }
+
+  /*
+  @desc - remove a specified traveller from the selected array
+  **/
+  removeTraveller(traveller: Traveller): void {
+    this._removeTraveller(traveller);
+
+    this.storageService.setSessionItem(
+      BaseEnterpriseSearchService.SESSION_TRAVELLER,
+      this.selectedTravellers
+    );
+    this.updateTravellerInformation();
+  }
+
+  _removeTraveller(traveller: Traveller) {
+    this.selectedTravellers = this.selectedTravellers.filter(
+      (travellerToTest: Traveller) => {
+        return !TravellerObject.equals(travellerToTest, traveller);
+      }
+    );
+  }
+
+  removeAllTravellers(): void {
+    console.log('remove all travellers called!');
+    console.log(this.selectedTravellers);
+    if (!this.selectedTravellers) {
+      this.selectedTravellers = [];
+    }
+    this.selectedTravellers.forEach((traveller: Traveller) => {
+      this._removeTraveller(traveller);
+    });
+
+    this.storageService.setSessionItem(
+      BaseEnterpriseSearchService.SESSION_TRAVELLER,
+      this.selectedTravellers
+    );
+    this.updateTravellerInformation();
+  }
+
+  addTraveller(traveller: Traveller) {
+    if (
+      !this.travellerAlreadyAdded(traveller) &&
+      !this.currentNoOfTravellersGreaterOrEqualToMax()
+    ) {
+      this.selectedTravellers.push(traveller);
+      this.storageService.setSessionItem(
+        BaseEnterpriseSearchService.SESSION_TRAVELLER,
+        this.selectedTravellers
+      );
+      this.updateTravellerInformation();
+    }
+  }
+  currentNoOfTravellersGreaterOrEqualToMax(): boolean {
+    return this.selectedTravellers.length >= this.maxTravellers();
+  }
+
+  maxTravellers(): number {
+    return /*this.userService.useTravellerProfile &&*/ this.canUseTravellerProfile()
+      ? 1
+      : MAX_TRAVELLERS;
+  }
+  /*
+    @desc - helper function - determines if a selected traveller is already added -
+    used to prevent same traveller being added more than once
+  **/
+  travellerAlreadyAdded(traveller: Traveller): boolean {
+    // iterate through the selected travellers and return true if found, false other wise
+    return !!this.selectedTravellers.find((travellers: Traveller) =>
+      TravellerObject.equals(travellers, traveller)
+    );
+  }
+
+  canUseTravellerProfile(): boolean {
+    /*
+    if (this.userService.isUserFavoriteSet(UserFavorurite.DontUseTravellerPolicy)) {
+      return false;
+    }
+    const user = this.userService.getUserDetails();
+    return (
+      this.selectedTravellers.length === 1 &&
+      !this.selectedTravellers[0]
+        .guest /*&&
+      this.selectedTravellers[0].pax_id &&
+      this.selectedTravellers[0].pax_id !== user.PaxId
+    );*/
+    return false;
+  }
+
+  getCurrentNoOfTravellers(): number {
+    return this.selectedTravellers.length;
+  }
+
+  updateTravellerInformation() {
+    this.storageService.setSessionItem(
+      BaseEnterpriseSearchService.SESSION_TRAVELLER,
+      this.selectedTravellers
+    );
+    this.travellerInformation.next([...this.selectedTravellers]);
+  }
+
+  /*
+   *  @desc - determine and return the highest priority value,
+   *   the highest is based on the priority value of the search type,
+   *    if it is chosen and if the booking has not been chosen
+   **/
+  determineHighestSearchPriority(): number {
+    return (this.highest_search_priority =
+      this._getHighestSearchPriorityObject().highest);
+  }
+
+  getHighestSearchPriorityObject(
+    basketItems: Record<ServiceType, BasketItem>
+  ): SearchObject {
+    return this._getHighestSearchPriorityObject(basketItems).currentItem;
+  }
+
+  private _getHighestSearchPriorityObject(
+    basketItems: Record<ServiceType, BasketItem> = {} as Record<
+      ServiceType,
+      BasketItem
+    >
+  ): HighestSearchPriorityObjectInterface {
+    return Object.values(this.search_objects).reduce(
+      ({ highest, currentItem }, item: SearchObject) => {
+        if (item.chosen && item.priority < highest) {
+          if (!basketItems[item.type as ServiceType]) {
+            return { highest: item.priority, currentItem: item };
+          } else {
+            item.chosen = false;
+          }
+        }
+        return { highest, currentItem };
+      },
+      { highest: Number.MAX_SAFE_INTEGER, currentItem: null }
+    );
+  }
+
+  getSelectedOptions(): ServiceType[] {
+    return Object.keys(this.search_objects).reduce((cv, itemIndex) => {
+      if ((this.search_objects as Record<string, any>)[itemIndex].chosen) {
+        cv.push(itemIndex as ServiceType);
+      }
+      return cv;
+    }, []);
+  }
+
+  /**
+   * Checks if selected travellers contains any guests without all of details
+   */
+  hasSimpleGuests(): boolean {
+    /*return !!this.selectedTravellers.find(({ guest, phone, nationality, email }) => {
+      return guest && !(!!email && !!phone && !!nationality);
+    });*/
+    return false;
+  }
+
+  /**
+   * @description - set the search objects to the get me there objects - called before starting the get me there searches
+   */
+  setGetMeThereSearchObjects(): void {
+    console.log('+++ Setting GetMeThere Search Objects +++');
+    this.search_objects = this.helpers.clone(this.getMeThereSearchObjects());
+  }
+
+  resetSearchParams(): void {
+    console.log('Reseting Search Params!');
+    this.search_objects = this.helpers.clone(this.init_search_objects());
+    this.storageService.setSessionItem(
+      BaseEnterpriseSearchService.SESSION_TRAVELLER,
+      this.search_objects
+    );
+    Object.values(this.searches).forEach(
+      (productSearchService: BaseEnterpriseSearch<any, any, any[]>) => {
+        productSearchService.reset();
+      }
+    );
+  }
+
+  canSearch(type: ServiceType | string): boolean {
+    // check that the selected type is chosen, has highest priority and has not already had a booking chosen
+
+    this.determineHighestSearchPriority();
+    // firstly check that the type of search exists
+    if ((this.search_objects as Record<string, any>)[type]) {
+      console.log('can search here');
+      // now check that the type is chosen has highest priority
+      if (
+        (this.search_objects as Record<string, any>)[type].chosen &&
+        this.hasHighestSearchPriority(
+          (this.search_objects as Record<string, any>)[type].priority
+        )
+      ) {
+        console.log(type + ' can be searched');
+        return true;
+      }
+    }
+    return false;
+  }
+
+  hasHighestSearchPriority(priorityVal: number): boolean {
+    this.determineHighestSearchPriority();
+    return priorityVal <= this.highest_search_priority;
+  }
+
+  /*
+   *  @desc - concatinats all the validation messages across all selected types +
+   *   travellers (or will do when it's complete) TODO - add Flight, Rail Car
+   **/
+  getAllErrorMessages(): string[] {
+    const concattedErrors: string[] = this.travellerValidationMessages;
+    if (
+      this.search_objects[ServiceType.Lounge].chosen &&
+      this.canSearch(ServiceType.Lounge)
+    ) {
+      concattedErrors.push(
+        ...this.searches[ServiceType.Lounge].validationMessages
+      );
+    }
+
+    if (
+      this.search_objects[ServiceType.Car].chosen &&
+      this.canSearch(ServiceType.Car)
+    ) {
+      concattedErrors.push(
+        ...this.searches[ServiceType.Car].validationMessages
+      );
+    }
+
+    if (
+      this.search_objects[ServiceType.Rail].chosen &&
+      this.canSearch(ServiceType.Rail)
+    ) {
+      concattedErrors.push(
+        ...this.searches[ServiceType.Rail].validationMessages
+      );
+    }
+
+    if (
+      this.search_objects[ServiceType.Parking].chosen &&
+      this.canSearch(ServiceType.Parking)
+    ) {
+      concattedErrors.push(
+        ...this.searches[ServiceType.Parking].validationMessages
+      );
+    }
+
+    if (
+      this.search_objects[ServiceType.Cab].chosen &&
+      this.canSearch(ServiceType.Cab)
+    ) {
+      concattedErrors.push(
+        ...this.searches[ServiceType.Cab].validationMessages
+      );
+    }
+
+    if (
+      this.search_objects[ServiceType.Hotel].chosen &&
+      this.canSearch(ServiceType.Hotel)
+    ) {
+      concattedErrors.push(
+        ...this.searches[ServiceType.Hotel].validationMessages
+      );
+    }
+
+    /*
+    if (this.search_objects.hotel.chosen && this.canSearch(TravelTypeEnum.HOTEL)) {
+      concattedErrors = concattedErrors.concat(this.hotel.validationMessages);
+    }
+
+
+
+    if (this.search_objects.flight.chosen && this.canSearch(TravelTypeEnum.FLIGHT)) {
+      concattedErrors = concattedErrors.concat(this.flight.validationMessages);
+    }
+
+    if (this.search_objects.parking.chosen && this.canSearch(TravelTypeEnum.AIR_PARKING)) {
+      concattedErrors.push(...this.parking.validationMessages);
+    }
+
+    if (this.search_objects.taxi.chosen && this.canSearch(TravelTypeEnum.TAXI)) {
+      concattedErrors.push(...this.taxi.validationMessages);
+    }
+
+    if (this.search_objects.eurostar.chosen && this.canSearch(TravelTypeEnum.EUROSTAR)) {
+      concattedErrors.push(...this.eurostar.validationMessages);
+    }
+
+    if (this.search_objects.coach.chosen && this.canSearch(TravelTypeEnum.COACH)) {
+      concattedErrors.push(...this.coach.validationMessages);
+    }*/
+    this.errors.next(concattedErrors);
+    return concattedErrors;
+  }
+
+  protected travellersContainUser(): boolean {
+    return !!this.selectedTravellers.find((traveller: Traveller) => {
+      return traveller.id === this.userService.getUserId().toString();
+    });
+  }
+
+  public validateTravellers(): boolean {
+    this.travellerValidationMessages = [];
+
+    switch (this.userService.fullUserDetails.userData.value.booker_type) {
+      case BookerType.SelfBook:
+        if (
+          !(
+            this.selectedTravellers.length === 1 && this.travellersContainUser()
+          )
+        ) {
+          // this should never trigger under normal conditions as the user should be loaded in as a traveller on login
+          this.travellerValidationMessages.push(
+            'Current user must be a traveller'
+          );
+        }
+        break;
+
+      case BookerType.BookerWithSelf:
+        if (
+          !(this.selectedTravellers.length < 1) ||
+          !this.travellersContainUser()
+        ) {
+          this.travellerValidationMessages.push('Please add your self.');
+          this.traveller_error = true;
+        }
+        break;
+      case BookerType.Booker:
+      case BookerType.Company:
+      case BookerType.CompanyGroup:
+      case BookerType.Office:
+      case BookerType.Tmc:
+      case BookerType.Root:
+        if (!(this.selectedTravellers.length >= 1)) {
+          this.travellerValidationMessages.push(
+            'Please select at least one traveller'
+          );
+          this.traveller_error = true;
+        }
+        break;
+      default:
+        this.travellerValidationMessages.push(
+          'Unrecognised user type! - Please contact support.'
+        );
+        return false;
+    }
+    // console.log(this.travellerValidationMessages);
+    return this.travellerValidationMessages.length === 0;
+  }
+
+  findPaxInTravellers(username: string) {
+    return this.selectedTravellers.find((traveller: Traveller) => {
+      return username === traveller.email;
+    });
+  }
+
+  validateForms(): boolean {
+    const searchObject: SearchObject = this._findSearchObtect();
+    this.getAllErrorMessages();
+    if (searchObject) {
+      this.errors.next(
+        this.searches[searchObject.type as keyof SearchParams].messages.value
+      );
+      return (
+        this.validateTravellers() &&
+        this.searches[searchObject.type as keyof SearchParams].isValid.value
+      );
+    } else {
+      return false;
+    }
+  }
+
+  private _findSearchObtect(): SearchObject | null {
+    return Object.values(this.search_objects).find((obj: SearchObject) => {
+      return !!obj && obj.priority === this.highest_search_priority;
+    });
+  }
+
+  startSearches(): void {
+    this.newSearchStarted.next(true);
+    this.search_loading = true;
+    let searchObject: SearchObject;
+    searchObject = this._findSearchObtect();
+    if (searchObject) {
+      searchObject.chosen = true;
+    }
+
+    if (searchObject && !this.router.url.includes(searchObject.resultUrl)) {
+      this.router.navigate([searchObject.resultUrl]);
+    }
+
+    /*If the search exceeds the timeout time, cancel search and tell OBT that it's timed out*/
+    const context = this;
+    setTimeout(function () {
+      if (context.search_loading) {
+        context.search_loading = false;
+        context.searchTimedOut.next(true);
+        context.searchLoadingDone.next(true);
+      }
+    }, 12000);
+
+    try {
+      Promise.all(
+        Object.values(this.searches).map(
+          (search: BaseEnterpriseSearch<any, any, any[]>) => {
+            return !!search &&
+              this.search_objects[search.type] &&
+              this.search_objects[search.type].chosen
+              ? search.startSearch()
+              : Promise.resolve(false);
+          }
+        )
+      ).finally(() => {
+        this.search_loading = false;
+        this.searchLoadingDone.next(true);
+      });
+    } catch (error) {
+      console.error(error);
+      this.search_loading = false;
+      this.searchLoadingDone.next(true);
+    }
+  }
+
+  getTaxiStationLocations(
+    term: string,
+    isLoading?: BehaviorSubject<boolean>
+  ): Observable<RailAirport[]> {
+    return term.length < 3
+      ? of([])
+      : of([
+        {
+          destination: 'Manchester Airpot',
+          isairport: true,
+          supplier_code: 'MAN',
+          address: 'Manchester Airport',
+          postcode: 'M90 1QX'
+        },
+        {
+          destination: 'Manchester Piccadilly',
+          isairport: false,
+          supplier_code: 'MMAN',
+          address: 'Manchester Piccadilly',
+          postcode: 'M1 2PZ'
+        },
+        {
+          destination: 'London Heathrow',
+          isairport: true,
+          supplier_code: 'LHR',
+          address: 'London Heathrow Airport',
+          postcode: 'TW6 1EW'
+        }
+      ]);
+  }
+
+  getAddresses(isLoading: BehaviorSubject<boolean>): Observable<AddressForm[]> {
+    return of([
+      {
+        House: 'Cecil Court',
+        Street: '28-36 Cecil Road',
+        Town: 'Hale',
+        PostCode: 'WA15 9PB',
+        Country: 'UK'
+      }
+    ]);
+  }
+
+  getUserAddresses(
+    isLoading?: BehaviorSubject<boolean>
+  ): Observable<AddressForm[]> {
+    return this.userAddressesFetcher.fetchList().pipe(
+      take(1),
+      map((results: any): any => {
+        return results.map((result: any) => {
+          return {
+            ID: result.id,
+            House: result.numberOrName,
+            Street: result.street,
+            Town: result.town,
+            PostCode: result.postcode,
+            Country: result.countryCode
+          };
+        });
+      })
+    );
+  }
+
+  deleteUserAddressByID(id: string): Observable<any> {
+    return this.baseDeleteUserAddressUpdater.updateOne({ id: id });
+  }
+
+  getHotelChain(
+    term: string,
+    isLoading?: BehaviorSubject<boolean>
+  ): Observable<any[]> {
+    if (term.length > 2) {
+      isLoading?.next(true);
+      const obs: Observable<SearchHotelChainsResultArray> =
+        this.searchHotelChainsFetcher.fetchList({ query: term });
+      const func = (results: SearchHotelChainsResultArray): any[] => {
+        const data: any[] = results.map(
+          (result: SearchHotelChainsResult): any => {
+            return {
+              name: result
+            };
+          }
+        );
+        isLoading?.next(false);
+        return data;
+      };
+      return obs.pipe(take(1), map(func));
+    }
+
+    return of([]);
+  }
+
+  getOfficeNames(
+    isLoading?: BehaviorSubject<boolean>
+  ): Observable<ConfermaOfficeNames[]> {
+    return this.confermaOfficeNamesFetcher.fetchList().pipe(
+      take(1),
+      map((results): any => {
+        if (results) {
+          return results?.results?.map((result: ConfermaOfficeNames) => {
+            return {
+              id: result.id,
+              name: result.name
+            };
+          });
+        }
+      })
+    );
+    isLoading?.next(false);
+  }
+
+  getRailCards(): Observable<ReferenceRailCardQualifier[]> {
+    return this.getRailCardsFetcher.fetchList().pipe(
+      take(1),
+      map((results): any => {
+        if (results) {
+          return results?.map((result: ReferenceRailCardQualifier) => {
+            return {
+              name: result.name,
+              code: result.code
+            };
+          });
+        }
+      })
+    );
+  }
+
+  public getAirportByCode(code: string): Observable<AirportSearchResults> {
+    if (code) {
+      return this.searchAirportsFetcher.fetchOne({ query: code }).pipe(
+        take(1),
+        map((result: AirportSearchResults) => {
+          return result
+        })
+      );
+    } else {
+      return of();
+    }
+  }
+
+  // TO BE OVER RIDDEN BY OBT SUBCLASSES
+  protected init_search_objects(): SearchObjects {
+    return {};
+  }
+
+  /********************************************************
+   * SEARCH OBJECTS FOR GET ME THERE DOOR 2 DOOR          *
+   * Difference(s):                                       *
+   * All objects have a priority of 1 so that they are    *
+   * searched at the same time                            *
+   * Urls changed to getmethere                           *
+   *******************************************************/
+  protected getMeThereSearchObjects(): SearchObjects {
+    return {};
+  }
+  /*
+   *  @desc - gets all selected travellers
+   *   Implemented for rail card reasons in LU
+   **/
+  getSelectedtravellers(): Traveller[] {
+    return this.selectedTravellers;
+  }
+
+  resetSearchObjects(): void {
+    this.search_objects = this.helpers.clone(this.init_search_objects());
+  }
+
+  /*
+   These are the possible array of values from API are exptected and function manipulate to create the list
+    ["Main"]
+    ["1"]
+    ["1", "2"]
+    ["1", "2", "3"]
+    ["1", "2", "3", "4"]
+    ["1", "2", "3", "4", "5"]
+    ["South", "North"]
+  */
+  public processTerminals(terminals: string[]): TerminalsType[] {
+    const tempTerminal: TerminalsType[] = [];
+    if (
+      terminals.includes('1') ||
+      terminals.includes('2') ||
+      terminals.includes('3') ||
+      terminals.includes('4') ||
+      terminals.includes('5')
+    ) {
+      tempTerminal.push({ key: 'Any Terminal', value: 'Any' });
+      terminals.forEach((item) => {
+        tempTerminal.push({ key: `Terminal ${item}`, value: `${item}` });
+      });
+    } else {
+      if (terminals.length === 1) {
+        tempTerminal.push({ key: `${terminals[0]} Terminal`, value: 'Any' });
+      } else {
+        tempTerminal.push({ key: 'Any Terminal', value: 'Any' });
+        terminals.forEach((item) => {
+          tempTerminal.push({ key: `${item} Terminal`, value: `${item}` });
+        });
+      }
+    }
+    return tempTerminal;
+  }
+
+  async saveUserAddress(
+    address: SaveUserAddressMutationVariables
+  ): Promise<void> {
+    if (address) {
+      await this.saveUserAddressUpdater.updateOne(address).toPromise();
+    }
+  }
+
+  public canBook(service: ServiceType) {
+    return this.userService.canBook(service) ? true : false;
+  }
+
+  isPostcodeVaild(postcode: string): Observable<boolean> {
+    return this.baseValidateIsPostcodeValidTester.test({ postcode });
+  }
+
+  /* Create Query Defaults Start */
+  /*
+   * Create the Cab Hire search query with supplied param, auto fill with defaults if fields are empty.
+   * @param  {any}           ...args example - searchService.setCabHireQuery(data.query, { departs: momentDateTime })
+   * @return {QuerySearchCabHireArgs}         Returns QuerySearchCabHireArgs type
+   */
+  public makeCabHireQuery(...args: any): CabHireTempParams {
+    const defaultVal: CabHireTempParams = {
+      adults: 0,
+      airport: null,
+      children: 0,
+      countryCode: null,
+      departs: this.helpers.makeMomentDayTime(),
+      fromAddress: null,
+      fromStation: null,
+      fromLocationType: TaxiFormMode.ADDRESS,
+      infants: 0,
+      toAddress: null,
+      toStation: null,
+      toLocationType: TaxiFormMode.ADDRESS,
+      vehicleType: CabHireVehicleType.Any,
+      viasFrom: null,
+      viasTo: null
+    };
+
+    return this.helpers.sanatizeReturns<CabHireTempParams>(
+      defaultVal,
+      Object.assign({}, ...args),
+      ['departs']
+    );
+  }
+
+  /*
+   * Create the Car Hire search query with supplied param, auto fill with defaults if fields are empty.
+   * @param  {any}           ...args example - searchService.setCarHireQuery(data.query, { departs: momentDateTime })
+   * @return {QuerySearchCarHireArgs}         Returns QuerySearchCarHireArgs type
+   */
+  public makeCarHireQuery(...args: any): CarHireTempParams {
+    const defaultVal: CarHireTempParams = {
+      adults: 0,
+      airCon: null,
+      carClass: null,
+      carType: null,
+      children: 0,
+      chosenVendor: null,
+      cityDropoff: null,
+      cityDropoffDepot: null,
+      cityPickup: null,
+      cityPickupDepot: null,
+      dropoff_country: 'GB',
+      dropoff_datetime: null,
+      dropoff_location: null,
+      estimatedMileage: null,
+      locationType: null,
+      pickup_country: null,
+      pickup_datetime: null,
+      pickup_location: null,
+      postcodeDropoff: null,
+      postcodeDropoffRaw: null,
+      postcodePickup: null,
+      postcodePickupRaw: null,
+      return_to_pickup: true,
+      transmission: null
+    };
+
+    return this.helpers.sanatizeReturns<CarHireTempParams>(
+      defaultVal,
+      Object.assign({}, ...args),
+      ['pickup_datetime', 'dropoff_datetime']
+    );
+  }
+
+  /*
+   * Creates a Flight search query with supplied params, auto fills with defaults if fields are empty.
+   * @param  {any}                    ...args Example - searchService.makeFlightQuery(data.query, { override: "property" })
+   * @return {QuerySearchFlightsArgs}         Returns QuerySearchFlightsArgs type
+   */
+  public makeFlightQuery(...args: any): FlightTempParams {
+    const now = this.helpers.makeMomentDayTime();
+    const tomorrow = this.helpers.makeMomentDayTime(1);
+    const momentOutDateTime = this.helpers.momentRoundMinutes(now, 30);
+    const momentInDateTime = this.helpers.momentRoundMinutes(tomorrow, 30);
+
+    const defaultVal: FlightTempParams = {
+      adults: 0,
+      arriveLocation: null,
+      cabinClass: FlightCabinClass.Any,
+      children: 0,
+      chosenSearchType: null,
+      departLocation: null,
+      fareType: FareType.Flexible,
+      inboundDate: momentOutDateTime,
+      inTimeCriteria: TimeWindow.Depart,
+      maxConnections: null,
+      includeNearbyAirports: false,
+      multiDestination: [],
+      outBoundDate: momentInDateTime,
+      outTimeCriteria: TimeWindow.Depart,
+      preferredCarriers: [null, null, null, null],
+      returnCabinClass: FlightCabinClass.Any
+    };
+
+    return this.helpers.sanatizeReturns<FlightTempParams>(
+      defaultVal,
+      Object.assign({}, ...args),
+      ['outBoundDate', 'inboundDate']
+    );
+  }
+
+  /*
+   * Creates a Hotel search query with supplied params, auto fills with defaults if fields are empty.
+   * @param  {any}                    ...args Example - searchService.makeHotelQuery(data.query, { override: "property" })
+   * @return {QuerySearchHotelsArgs}         Returns QuerySearchHotelsArgs type
+   */
+  public makeHotelQuery(...args: any): HotelTempParams {
+    const defaultVal = {
+      checkin_date: moment().set('hour', 23).set('minute', 59),
+      checkout_date: moment().add(1, 'day').set('hour', 23).set('minute', 59),
+      country: { cCode: 'GB', cName: 'United Kingdom' },
+      currency: 'GBP',
+      distance: 5, // default 5 miles radius
+      hotel_availability: null,
+      hotel_chain: null,
+      hotel_name: null,
+      location_type_select: LocationTypes.Airport,
+      location: null, // might want to split this out to city, airport, office, railstation - this will do for now
+      no_of_occupants: 1, // similarly think this is a max of 3
+      no_of_rooms: 1, // max of 4 in old sabs, not sure here
+      office: null,
+      postcode: null,
+      prefered_hotels_only: false,
+      trainsStation: null
+    } as HotelTempParams;
+
+    return this.helpers.sanatizeReturns<HotelTempParams>(
+      defaultVal,
+      Object.assign({}, ...args),
+      ['checkin_date', 'checkout_date']
+    );
+  }
+
+  /*
+   * Creates a Lounges search query with supplied params, auto fills with defaults if fields are empty.
+   * @param  {any}                    ...args Example - searchService.makeLoungesQuery(data.query, { override: "property" })
+   * @return {QuerySearchLoungesArgs}         Returns QuerySearchLoungesArgs type
+   */
+  public makeLoungesQuery(...args: any): LoungesTempParams {
+    const defaultVal = {
+      adults: 0,
+      arrivalDatetime: moment(),
+      children: 0,
+      infants: 0,
+      locationCode: null,
+      terminal: null
+    } as LoungesTempParams;
+
+    return this.helpers.sanatizeReturns<LoungesTempParams>(
+      defaultVal,
+      Object.assign({}, ...args),
+      ['arrivalDatetime']
+    );
+  }
+
+  /*
+   * Creates a Parking search query with supplied params, auto fills with defaults if fields are empty.
+   * @param  {any}                    ...args Example - searchService.makeParkingQuery(data.query, { override: "property" })
+   * @return {QuerySearchParkingArgs}         Returns QuerySearchParkingArgs type
+   */
+  public makeParkingQuery(...args: any): ParkingTempParams {
+    const now = this.helpers.makeMomentDayTime();
+    const tomorrow = this.helpers.makeMomentDayTime(1);
+    const momentOutDateTime = this.helpers.momentRoundMinutes(now, 30);
+    const momentInDateTime = this.helpers.momentRoundMinutes(tomorrow, 30);
+
+    const defaultVal = {
+      arrivalDatetime: momentOutDateTime,
+      carParkedForYou: null,
+      departDatetime: momentInDateTime,
+      locationCode: null,
+      meetAndGreet: null,
+      onAirport: null,
+      outFlightNumber: null,
+      parkAndRide: null,
+      parkAndStroll: null,
+      recommended: null,
+      terminal: null
+    } as ParkingTempParams;
+
+    return this.helpers.sanatizeReturns<ParkingTempParams>(
+      defaultVal,
+      Object.assign({}, ...args),
+      ['arrivalDatetime', 'departDatetime']
+    );
+  }
+
+  /*
+   * Creates a Rail search query with supplied params, auto fills with defaults if fields are empty.
+   * @param  {any}                    ...args Example - searchService.makeRailQuery(data.query, { override: "property" })
+   * @return {QuerySearchRailArgs}         Returns QuerySearchRailArgs type
+   */
+  public makeRailQuery(...args: any): RailTempParams {
+    const time = this.helpers.momentRoundMinutes(moment(), 30);
+    const defaultVal: RailTempParams = {
+      airportExpressStation: null,
+      applyRailcards: false,
+      carnetTicket: false,
+      chosenSearchClass: RailClass.All,
+      chosenSearchType: RailJourneyType.ReturnJourney,
+      disableAutoDiscounts: false,
+      extraTime: false,
+      inBoundDateTime: time,
+      isAirportExpress: false,
+      noOfAdults: 0,
+      noOfChildren: 0,
+      openReturn: false,
+      outboundCriteria: RailSearchCriteria.Depart,
+      outBoundDateTime: time,
+      prioritiseByPrice: false,
+      returnCriteria: RailSearchCriteria.Depart,
+      travellingFrom: null,
+      travellingTo: null,
+      via: false,
+      viaLocation: null,
+      railCards: null
+    };
+
+    return this.helpers.sanatizeReturns<RailTempParams>(
+      defaultVal,
+      Object.assign({}, ...args),
+      ['inBoundDateTime', 'outBoundDateTime']
+    );
+  }
+
+  /*
+   * Creates a Rail search query with supplied params, auto fills with defaults if fields are empty.
+   * @param  {any}                    ...args Example - searchService.makeRailQuery(data.query, { override: "property" })
+   * @return {QuerySearchRailArgs}         Returns QuerySearchRailArgs type
+   */
+  public makeIrlQuery(...args: any): IrlTempParams {
+    const time = this.helpers.momentRoundMinutes(moment(), 30);
+    const defaultVal: IrlTempParams = {
+      supplier: null, // IRLSupplier!
+      countryCode: '',
+      // journeyType: this.journeyType, // IRLJourneyType!
+      class: null, // IRLClass
+      outboundDepartureDateTime: time,
+      departureLocationId: null,
+      arrivalLocationId: null,
+      adults: 0,
+      children: 0,
+      returnDepartureDateTime: time,
+      journeyType: null
+    };
+
+    return this.helpers.sanatizeReturns<IrlTempParams>(
+      defaultVal,
+      Object.assign({}, ...args),
+      ['returnDepartureDateTime', 'outboundDepartureDateTime']
+    );
+  }
+
+  /*
+   * Creates a Eurostar search query with supplied params, auto fills with defaults if fields are empty.
+   * @param  {any}                    ...args Example - searchService.makeEurostarQuery(data.query, { override: "property" })
+   * @return {EurostarTempParams}         Returns QuerySearchEurostarArgs type
+   */
+  public makeEurostarQuery(...args: any): EurostarTempParams {
+    const now = this.helpers.makeMomentDayTime();
+    const tomorrow = this.helpers.makeMomentDayTime(1);
+    const momentOutDateTime = this.helpers.momentRoundMinutes(now, 30);
+    const momentInDateTime = this.helpers.momentRoundMinutes(tomorrow, 30);
+
+    const defaultVal: EurostarTempParams = {
+      adults: 0,
+      arriveLocation: null,
+      cabinClass: FlightCabinClass.Any,
+      children: 0,
+      chosenSearchType: EurostarSearchType.return,
+      departLocation: null,
+      fareType: FareType.Flexible,
+      inboundDate: momentOutDateTime,
+      inTimeCriteria: TimeWindow.Depart,
+      maxConnections: null,
+      includeNearbyAirports: false,
+      multiDestination: [],
+      outBoundDate: momentInDateTime,
+      outTimeCriteria: TimeWindow.Depart,
+      preferredCarriers: [null, null, null, null],
+      returnCabinClass: FlightCabinClass.Any
+    };
+
+    return this.helpers.sanatizeReturns<EurostarTempParams>(
+      defaultVal,
+      Object.assign({}, ...args),
+      ['outBoundDate', 'inboundDate']
+    );
+  }
+  /* Create Query Defaults End */
+
+  shouldAddTravellerSubscription(): boolean {
+    return false;
+  }
+
+  getAutoLogoutConfig() {
+    return {};
+  }
+  /**
+   * Overwrite if the OBT displays a list of offices instead of searching on them
+   */
+  public shouldFetchAllOffices(): boolean {
+    return false;
+  }
+  isFlightsGrouped(): boolean {
+    return false;
+  }
+  getCountryFullNameFromCountryCode(code: string): string {
+    let fullName = 'Unknown';
+
+    for (let i = 0; i < this.countries.length; i++) {
+      const country = this.countries[i];
+
+      if (country.cCode === code) {
+        return country.cName;
+      }
+    }
+
+    return fullName;
+  }
+
+  getUserRecentSearches(
+    serviceType?: ServiceType,
+    isLoading?: BehaviorSubject<boolean>
+  ): Observable<RecentSearch[]> {
+    isLoading?.next(true);
+    const query = { serviceType };
+    const obs: Observable<GetUserRecentSearchesResultArray> =
+      this.getUserRecentSearchesFetcher.fetchList(query);
+
+    const func = (
+      results: GetUserRecentSearchesResultArray
+    ): RecentSearch[] => {
+      const data: RecentSearch[] = results.map(
+        (result: GetUserRecentSearchesResult): RecentSearch => {
+          return {
+            id: result.id,
+            name: result.name,
+            serviceType: result.serviceType,
+            searchArgs: result.searchArgs,
+            createdAt: result.createdAt,
+            updatedAt: result.updatedAt,
+            travelDate: result.travelDate,
+            travellers: result.travellers
+          };
+        }
+      );
+      isLoading?.next(false);
+      return data;
+    };
+    return obs.pipe(take(1), map(func));
+  }
+
+  deleteRecentSearchByID(id: string): Observable<any> {
+    return this.baseDeleteRecentSearchUpdater.updateOne({ id: id });
+  }
+
+  saveRecentSearch(query: SaveRecentSearchMutationVariables): void {
+    if (query) {
+      this.baseSaveRecentSearchUpdater.updateOne(query).pipe(take(1)).subscribe();
+    }
+  }
+
+  /**
+   * @description - get the list of eurostar station locations based on search term given
+   * @todo - fill this out so that it actually performs a http call
+   * @param term - the term we want to search by
+   * @returns
+   */
+  lookupEurostarStations(term: string): Observable<any[]> {
+    console.log('term| ', term);
+    if (term === '') {
+      return of(this.eurostations);
+    } else {
+      return of(this.eurostations.filter(v => v.destination.toLowerCase().indexOf(term.toLowerCase()) > -1));
+    }
+  }
+
+  searchTravellers(
+    input: string,
+    searchTravellersBy: TravellerSearchTypes
+  ): Observable<Traveller[]> {
+    const type: BookerType = this.userService.getUserBookingType();
+    this.traveller_error = false;
+    /* TODO
+    if (this.userService.useAgentCanBookFor()) {
+      type = this.userService.getUserFavoriteValue('AgentCanBookFor');
+    }*/
+    if (
+      type &&
+      type !== BookerType.SelfBook &&
+      type !== BookerType.Traveller &&
+      input.length >= 1
+    ) {
+      const inputWords = input.toLowerCase().match(/([\w])+/g);
+      const args: SearchUserCanBookForQueryVariables = {};
+      switch (searchTravellersBy) {
+        case TravellerSearchTypes.name:
+          args.userName = inputWords.length > 1 ? inputWords[0] : input;
+          break;
+        case TravellerSearchTypes.email:
+          args.email = input;
+          break;
+        case TravellerSearchTypes.employeeNumber:
+          args.employeeId = input;
+          break;
+      }
+
+      return this.searchUsersCanBookForFetcher.fetchList(args).pipe(
+        map((data: Traveller[]) => {
+          if (data) {
+            return data.sort((a, b) => {
+              return a.surname < b.surname ? -1 : a.surname > b.surname ? 1 : 0;
+            });
+          }
+          return [];
+        })
+      );
+    }
+  }
+}