@sabstravtech/obtservices 0.0.0 → 0.0.1

package/dist/obtservices/esm2015/base/lib/vendor/services/search.service.js

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