@sabstravtech/obtservices 0.0.0 → 0.0.1

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

@@ -1,2026 +0,0 @@
-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 [];
-        })
-      );
-    }
-  }
-}