@sabstravtech/obtservices 0.0.0 → 0.0.1

package/dist/obtservices/esm2015/base/lib/vendor/classes/hotel-enterprise-search.js

@@ -0,0 +1,1022 @@
+import { __awaiter } from "tslib";
+import moment from 'moment';
+import { BaseEnterpriseSearch } from './base-enterprise';
+import { BehaviorSubject, of, Subject } from 'rxjs';
+import { map, take } from 'rxjs/operators';
+import { URLS } from './../services/url.service';
+import { LocationTypes, includedExpression, excludedExpression, SearchHandler } from '../types/types';
+import { DistanceTypes, ServiceType } from '../types/graphql.types';
+import { HotelFilters, HotelView } from '../interfaces/Ihotel-enterprise-search';
+export var SortTypesHotel;
+(function (SortTypesHotel) {
+    SortTypesHotel["distance"] = "distance";
+    SortTypesHotel["name"] = "name";
+    SortTypesHotel["price"] = "price";
+})(SortTypesHotel || (SortTypesHotel = {}));
+const CLIENT_PREFERRED_VALUE = 1;
+const AGENT_PREFERRED_VALUE = 2;
+export class HotelEnterpriseSearch extends BaseEnterpriseSearch {
+    constructor(hotelFetcher, helpers, userService, environment, avaliabilityService, basketService, storageService, searchService, httpCallService, quickListFetcher, getRailStationFetcher) {
+        super(storageService, (resultsToMap) => {
+            this.results_details.maxDistance = 0;
+            this.results_details.chains = new Set();
+            return resultsToMap.map((hotelResult, index) => {
+                this.results_details.maxDistance = Math.max(this.results_details.maxDistance, hotelResult.location.distance);
+                this.filters.distanceRange.max = this.results_details.maxDistance;
+                this.results_details.chains.add(hotelResult.group);
+                if (index < this.environment.numberHotelToPreload) {
+                    this.avaliabilityService.getAvailabilityForId(this.makeHotelAvalilityObject(hotelResult));
+                }
+                // this.getHotelAvailability(hotelResult);
+                return Object.assign({ sortedTags: this.sortTags(hotelResult.tags), Details: {
+                        distance_airport: 0,
+                        distance_metro: 0,
+                        distance_rail: 0,
+                        airport_details: { name: 'Not returned' },
+                        metro_details: { name: 'Not returned' },
+                        rail_details: { name: 'Not returned' }
+                    } }, hotelResult);
+            });
+        });
+        this.hotelFetcher = hotelFetcher;
+        this.helpers = helpers;
+        this.userService = userService;
+        this.environment = environment;
+        this.avaliabilityService = avaliabilityService;
+        this.basketService = basketService;
+        this.searchService = searchService;
+        this.httpCallService = httpCallService;
+        this.quickListFetcher = quickListFetcher;
+        this.getRailStationFetcher = getRailStationFetcher;
+        this.type = ServiceType.Hotel;
+        this.location_types = new BehaviorSubject([]);
+        this.offices = new BehaviorSubject([]);
+        this.lastActivePage = new BehaviorSubject(null);
+        this.galleries = {};
+        this.occupied = 0;
+        this.results_details = {
+            chains: new Set(),
+            amenities: [],
+            maxDistance: 0
+        };
+        // Event Emitters
+        this.filterChange = new Subject();
+        this.selectItemMapView = new Subject();
+        this.display = {
+            minprice: Number.NEGATIVE_INFINITY,
+            maxprice: Number.POSITIVE_INFINITY,
+            filters: {
+                breakfastType: []
+            }
+        };
+        // public variables
+        this.min_date = {
+            year: moment().year(),
+            month: moment().month() + 1,
+            day: moment().date()
+        };
+        this.min_return_date = {
+            year: moment().year(),
+            month: moment().month() + 1,
+            day: moment().date() + 1 // min 1 night stay
+        };
+        // private variables
+        // don't need to worry about times here - maybe normalise these in the request body?
+        this.localFilters = new HotelFilters();
+        this.currentView = HotelView.LIST;
+        // For NgForing over in the templates
+        this._max_no_of_rooms = 4;
+        this._max_rooms_array = new Array(this._max_no_of_rooms).fill(0);
+        this._max_no_of_occupants = 2;
+        this._max_occupant_array = new Array(this._max_no_of_occupants).fill(0);
+        this._distance_list = [1, 2, 5, 10, 20, 25]; // copied from old frontend for now
+        this._default_currency = null;
+        this.resultsSessionName = HotelEnterpriseSearch.STORAGE_SESSION_RESULTS;
+        this.query = {};
+        this.filterResults = () => {
+            this.results.next(this.fullResults.filter((hotel) => {
+                return (this.inPriceRange(hotel) &&
+                    this.inDistanceRange(hotel) &&
+                    this.containsHotelname(hotel) &&
+                    this.hasChain(hotel) &&
+                    this.breakfastTypeFilter(hotel));
+            }));
+        };
+        // Lightening Filters
+        this.filterLighteningResults = () => {
+            this.results.next(this.fullResults.filter((hotel) => {
+                return (this.inLighteningPriceRange(hotel) &&
+                    this.containsHotelname(hotel) &&
+                    this.hasChain(hotel) &&
+                    this.hasPreferred(hotel) &&
+                    this.breakfastTypeFilter(hotel) &&
+                    this.getExtraFilter(hotel) &&
+                    this.getAmenitiesFilter(hotel));
+            }));
+        };
+        this.results_details.chains = new Set();
+        const data = storageService.getSessionItem(HotelEnterpriseSearch.STORAGE_SESSION_PARAMS) || {
+            tempParams: {}
+        };
+        this.default_currency = this.tempParams.currency
+            ? this.tempParams.currency
+            : this._default_currency;
+        this.updateTempParams(searchService.makeHotelQuery(data.tempParams));
+        if (searchService.shouldAddTravellerSubscription()) {
+            searchService.travellerInformation.subscribe((travellers) => {
+                this.travellers = travellers;
+                const splitTravellers = this.helpers.selectedTravellers(travellers, ServiceType.Hotel);
+                this.tempParams.no_of_occupants = splitTravellers.adults.length;
+                this.travellers = travellers;
+                this._isValid();
+            });
+        }
+        const results = storageService.getSessionItemAsList(this.resultsSessionName) || [];
+        results
+            .slice(0, this.environment.numberHotelToPreload)
+            .forEach((hotel) => {
+            this.avaliabilityService.getAvailabilityForId(this.makeHotelAvalilityObject(hotel));
+        });
+        results.forEach((hotelResult) => {
+            this.results_details.chains.add(hotelResult.group);
+        });
+        this.fullResults = results;
+        this.results.next(results);
+        this._isValid();
+        this.userService.changeUser.subscribe((user) => {
+            this.location_types.next([
+                LocationTypes.Airport,
+                LocationTypes.City,
+                LocationTypes.Office,
+                LocationTypes.Shortlist,
+                LocationTypes.TrainStation
+            ]);
+            if (searchService.shouldFetchAllOffices()) {
+                this.offices.next([]); // TODO fetch offices
+            }
+        });
+        this.localFilters = new HotelFilters();
+        this.avaliabilityService.fetching.subscribe((isFetching) => {
+            if (!isFetching) {
+                // We've just finished fetching avalibility so update filters.
+                const maxNumber = this.avaliabilityService.maxPriceForCurrency('GBP');
+                if (maxNumber > 0) {
+                    this.filters.priceRange.max = maxNumber;
+                    this.localFilters.priceRange.max = maxNumber;
+                }
+                this._cheapestResultPrice = this.updateLowestPrice(results);
+            }
+        });
+    }
+    get chains() {
+        return [...this.results_details.chains];
+    }
+    get amenities() {
+        return [...this.results_details.amenities];
+    }
+    get maxDistance() {
+        this.filters.distanceRange.max = Math.ceil(Math.max.apply(Math, this.results.value.map((o) => o.location.distance)));
+        this.results_details.maxDistance = this.filters.distanceRange.max;
+        return this.results_details.maxDistance;
+    }
+    get maxPrice() {
+        return Math.ceil(this.filters.priceRange.max);
+    }
+    get currency() {
+        return this.tempParams.currency;
+    }
+    set currency(value) {
+        this.tempParams.currency = value;
+    }
+    // getters and setters
+    get checkin_date_ngb() {
+        return this._checkin_date_ngb;
+    }
+    set checkin_date_ngb(value) {
+        this._checkin_date_ngb = value;
+        this.tempParams.checkin_date = this.helpers.ngDateToMoment(value);
+        this.checkin_date = this.helpers.ngDateToMoment(value);
+    }
+    get checkout_date_ngb() {
+        return this._checkout_date_ngb;
+    }
+    set checkout_date_ngb(value) {
+        this._checkout_date_ngb = value;
+        this.tempParams.checkout_date = this.helpers.ngDateToMoment(value);
+        this._isValid();
+    }
+    get checkin_date() {
+        return this.tempParams.checkin_date;
+    }
+    set checkin_date(newDate) {
+        if (newDate && newDate.isValid()) {
+            this.tempParams.checkin_date = moment(newDate);
+            this._checkin_date_ngb = this.helpers.momentToNgDate(newDate);
+            if (newDate.isSameOrBefore(this.tempParams.checkout_date)) {
+                this.checkout_date = moment(newDate).add(1, 'day');
+            }
+            this._isValid();
+        }
+    }
+    get checkout_date() {
+        return this.tempParams.checkout_date;
+    }
+    set checkout_date(newDate) {
+        // if (newDate.isSameOrBefore(this.checkin_date)) {  // not allowed
+        //   return;
+        // }
+        if (newDate && newDate.isValid()) {
+            this.tempParams.checkout_date = newDate;
+            this.checkout_date_ngb = this.helpers.momentToNgDate(newDate);
+            this._isValid();
+        }
+    }
+    get no_of_rooms() {
+        return this.tempParams.no_of_rooms;
+    }
+    set no_of_rooms(newRooms) {
+        if (newRooms > 4 || newRooms < 1) {
+            return;
+        }
+        this.tempParams.no_of_rooms = newRooms;
+        this._isValid();
+    }
+    get no_of_occupants() {
+        return this.tempParams.no_of_occupants;
+    }
+    set no_of_occupants(newOcc) {
+        if (newOcc < 1 || newOcc > 3) {
+            return;
+        }
+        this.tempParams.no_of_occupants = newOcc;
+        this._isValid();
+    }
+    get default_currency() {
+        return this.tempParams.currency;
+    }
+    set default_currency(currency) {
+        this.tempParams.currency = currency;
+    }
+    // may have to modify these
+    get location() {
+        return this.tempParams.location;
+    }
+    set location(newLoc) {
+        this.tempParams.location = newLoc;
+        this._isValid();
+    }
+    get formatted_location() {
+        return this.tempParams.location
+            ? this.tempParams.location.destination
+            : 'No Location Set'; // TODO -  expand this for different types
+    }
+    get distance() {
+        return this.tempParams.distance;
+    }
+    set distance(newDist) {
+        this.tempParams.distance = newDist;
+        this._isValid();
+    }
+    get prefered_hotels_only() {
+        return this.tempParams.prefered_hotels_only;
+    }
+    set prefered_hotels_only(newPref) {
+        this.tempParams.prefered_hotels_only = newPref;
+        this._isValid();
+    }
+    get country() {
+        return this.tempParams.country;
+    }
+    set country(newCont) {
+        this.tempParams.country = newCont;
+        this._isValid();
+    }
+    get postcode() {
+        return this.tempParams.postcode;
+    }
+    set postcode(postcode) {
+        this.tempParams.postcode = postcode;
+        this._isValid();
+    }
+    get trainsStation() {
+        return this.tempParams.trainsStation;
+    }
+    set trainsStation(station) {
+        this.tempParams.trainsStation = station;
+        this._isValid();
+    }
+    get office() {
+        return this.tempParams.office;
+    }
+    set office(office) {
+        this.tempParams.office = office;
+        this._isValid();
+    }
+    // Additional Variables
+    get hotel_name() {
+        return this.tempParams.hotel_name;
+    }
+    set hotel_name(newName) {
+        this.tempParams.hotel_name = newName;
+        this._isValid();
+    }
+    get hotel_chain() {
+        return this.tempParams.hotel_chain;
+    }
+    set hotel_chain(newChain) {
+        this.tempParams.hotel_chain = newChain;
+        this._isValid();
+    }
+    // Getters Only
+    get max_rooms_array() {
+        return this._max_rooms_array;
+    }
+    get max_occupant_array() {
+        return this._max_occupant_array;
+    }
+    get distance_list() {
+        return this._distance_list;
+    }
+    get location_type_select() {
+        return this.tempParams.location_type_select;
+    }
+    set location_type_select(value) {
+        this.tempParams.location_type_select = value;
+        this._isValid();
+    }
+    get filters() {
+        return this.localFilters;
+    }
+    makeLocations(location) {
+        return this.helpers.arrayToObjectArray(location, 'distanceType');
+    }
+    sortTags(tags) {
+        if (tags) {
+            return [...tags]
+                .sort((a, b) => {
+                if (a.name < b.name) {
+                    return -1;
+                }
+                else if (a.name > b.name) {
+                    return 1;
+                }
+                else {
+                    return 0;
+                }
+            })
+                .map((tag) => {
+                return Object.assign(Object.assign({}, tag), { icon: this.environment.tagMap[tag.name] || tag.icon });
+            });
+        }
+        return [];
+    }
+    resetQuery() {
+        this.updateTempParams(this.searchService.makeHotelQuery());
+        this.localFilters = new HotelFilters();
+        this.results_details = {
+            chains: new Set(),
+            amenities: [],
+            maxDistance: 0
+        };
+        this._isValid();
+    }
+    _isValid() {
+        var _a, _b, _c, _d, _e;
+        if (!this.doChecks) {
+            return;
+        }
+        this.storageService.setSessionItem(HotelEnterpriseSearch.STORAGE_SESSION_PARAMS, {
+            tempParams: this.tempParams
+        });
+        this.min_return_date = this.helpers.momentToNgDate(this.tempParams.checkin_date);
+        if (this.tempParams.checkin_date.isSameOrAfter(this.tempParams.checkout_date)) {
+            this.checkout_date = moment(this.tempParams.checkin_date).add(1, 'day'); // ensure that checkout date is min 1 day after checkin date
+        }
+        this.validationMessages = [];
+        switch (this.tempParams.location_type_select) {
+            case LocationTypes.City:
+                if (!this.country) {
+                    this.validationMessages.push('Please select country');
+                }
+                if (!this.location && !this.postcode) {
+                    this.validationMessages.push('Please select a hotel location or enter a postcode.');
+                }
+                break;
+            case LocationTypes.Office:
+                if (!((_a = this.tempParams.location) === null || _a === void 0 ? void 0 : _a.office)) {
+                    this.validationMessages.push('Please select an office.');
+                }
+                break;
+            case LocationTypes.Airport:
+                if ((_b = this.tempParams) === null || _b === void 0 ? void 0 : _b.location) {
+                    if (!((_c = this.tempParams.location.airport) === null || _c === void 0 ? void 0 : _c.gateway)) {
+                        this.validationMessages.push('Please select a airport.');
+                    }
+                    break;
+                }
+                else {
+                    this.validationMessages.push('Please select a airport.');
+                }
+                break;
+            case LocationTypes.TrainStation:
+                if ((_d = this.tempParams) === null || _d === void 0 ? void 0 : _d.location) {
+                    if (!((_e = this.tempParams.location.railstation) === null || _e === void 0 ? void 0 : _e.stationCode)) {
+                        this.validationMessages.push('Please select a train station.');
+                    }
+                    break;
+                }
+                else {
+                    this.validationMessages.push('Please select a train station.');
+                }
+                break;
+            case LocationTypes.Shortlist:
+                if (!this.country) {
+                    this.validationMessages.push('Please select country');
+                }
+                break;
+        }
+        if (this.checkout_date &&
+            this.checkout_date.isSameOrBefore(this.checkin_date)) {
+            this.validationMessages.push('Checkout date must be after checkin date');
+        }
+        if (this.checkout_date && this.checkout_date.isBefore(moment())) {
+            this.validationMessages.push('Checkout date must not be in the past');
+        }
+        if (this.checkin_date && this.checkin_date.isBefore(moment())) {
+            this.validationMessages.push('Checkin date must not be in the past');
+        }
+        if (this.checkout_date &&
+            this.checkin_date &&
+            this.checkin_date.isAfter(this.checkout_date)) {
+            this.validationMessages.push('Checkout data must be after the checkin date');
+        }
+        // Calculating Occupancy
+        const occupancy = this.no_of_occupants / this.no_of_rooms;
+        if (!(occupancy === 1 || occupancy === 2)) {
+            this.validationMessages.push('Occupants per room must be 1 or 2, if you have an odd number of travellers (greater than one), the no of rooms must be equal');
+        }
+        console.log(this.validationMessages);
+        this.isValid.next(this.validationMessages.length === 0);
+        this.messages.next(this.validationMessages);
+    }
+    startSearch() {
+        this.results.next([]);
+        this.avaliabilityService.reset();
+        if (this.isValid.value) {
+            // build the query
+            this.buildQuery();
+            const query = this.getSearchQuery();
+            this.searchService.saveRecentSearch(this.getRecentSearchQuery(this.getSearchQuery()));
+            return this._startSearch(this.tempParams.location_type_select === LocationTypes.Shortlist ?
+                this.quickListFetcher.fetchList({ countryCode: this.country.cCode }) :
+                this.hotelFetcher.fetchList(query));
+        }
+        else {
+            return Promise.resolve(false);
+        }
+    }
+    getRecentSearchQuery(query) {
+        var _a;
+        if ((_a = this.location) === null || _a === void 0 ? void 0 : _a.name) {
+            query.cityName = this.location.name;
+        }
+        return {
+            serviceType: ServiceType.Hotel,
+            searchArgs: query,
+            travelDate: this.checkin_date.format(),
+            travellers: this.helpers.getTravellersId(this.travellers)
+        };
+    }
+    startRecentSearch(recentSearch) {
+        this.currency = recentSearch.searchArgs.currency;
+        this.distance = recentSearch.searchArgs.distance;
+        this.no_of_rooms = recentSearch.searchArgs.rooms;
+        this.checkin_date = moment(recentSearch.searchArgs.startDate);
+        this.checkout_date = moment(recentSearch.searchArgs.endDate);
+        this.hotel_name = recentSearch.searchArgs.hotelName;
+        if (recentSearch.searchArgs.groupName) {
+            this.hotel_chain = {
+                name: recentSearch.searchArgs.groupName
+            };
+        }
+        // get location_type_select
+        if (recentSearch.searchArgs.iata) {
+            this.location_type_select = LocationTypes.Airport;
+            this.searchService.getAirportByCode(recentSearch.searchArgs.iata).subscribe((iata) => {
+                let airport = {
+                    airport: {
+                        gateway: iata.iataMatch.iata
+                    }
+                };
+                this.location = Object.assign(Object.assign({}, airport), iata.iataMatch);
+                this.searchService.startSearches();
+            });
+        }
+        else if ((recentSearch.searchArgs.latitude && recentSearch.searchArgs.longitude) || recentSearch.searchArgs.postOrZipCode) {
+            this.location_type_select = LocationTypes.City;
+            this.country = {
+                cCode: recentSearch.searchArgs.countryCode,
+                cName: ''
+            };
+            // should be one search metod for the city search: location or postcode
+            if (recentSearch.searchArgs.latitude && recentSearch.searchArgs.longitude) {
+                this.location = {
+                    name: recentSearch.searchArgs.cityName,
+                    latitude: recentSearch.searchArgs.latitude,
+                    longitude: recentSearch.searchArgs.longitude
+                };
+            }
+            else if (recentSearch.searchArgs.postOrZipCode) {
+                this.postcode = {
+                    name: recentSearch.searchArgs.postOrZipCode,
+                    type: LocationTypes.Postcode
+                };
+            }
+            this.searchService.startSearches();
+        }
+        else if (recentSearch.searchArgs.officeId) {
+            this.location_type_select = LocationTypes.Office;
+            this.searchService.getOfficeNames(this.isLoading).pipe(take(1)).subscribe((offices) => {
+                if (offices) {
+                    let office = offices.find((office) => office.id === recentSearch.searchArgs.officeId);
+                    this.office = {
+                        id: recentSearch.searchArgs.officeId,
+                        name: office.name
+                    };
+                    this.searchService.startSearches();
+                }
+            });
+        }
+        else if (recentSearch.searchArgs.trainStationCode) {
+            this.location_type_select = LocationTypes.TrainStation;
+            this.getRailStationByCode(recentSearch.searchArgs.trainStationCode).subscribe((trainsStation) => {
+                this.trainsStation = trainsStation;
+                this.searchService.startSearches();
+            });
+        }
+        else {
+            this.location_type_select = LocationTypes.Shortlist;
+            this.country = {
+                cCode: recentSearch.searchArgs.countryCode,
+                cName: ''
+            };
+            this.searchService.startSearches();
+        }
+    }
+    getRailStationByCode(code) {
+        if (code) {
+            return this.getRailStationFetcher.fetchList({ id: null, code: code }).pipe(take(1));
+        }
+        else {
+            return of();
+        }
+    }
+    getSearchQuery() {
+        this.buildQuery();
+        return this.helpers.removeNulls(this.query);
+    }
+    buildQuery() {
+        var _a, _b;
+        const query = {
+            startDate: this.tempParams.checkin_date.format('YYYY-MM-DD'),
+            endDate: this.tempParams.checkout_date.format('YYYY-MM-DD'),
+            rooms: this.tempParams.no_of_rooms,
+            adults: this.tempParams.no_of_occupants,
+            currency: this.tempParams.currency ? this.tempParams.currency : null,
+            distance: this.tempParams.distance,
+            distanceType: DistanceTypes.M,
+            maxResults: 100
+        };
+        this.getRoomNumber();
+        console.log(this.location);
+        switch (this.tempParams.location_type_select) {
+            case LocationTypes.Airport:
+                query.iata = this.tempParams.location.airport.gateway;
+                break;
+            case LocationTypes.City:
+                query.countryCode = this.country.cCode;
+                // should be one search metod for the city search: location or postcode
+                if (this.location) {
+                    query.latitude = this.location.latitude;
+                    query.longitude = this.location.longitude;
+                }
+                else if (this.postcode) {
+                    query.postOrZipCode = this.postcode.name;
+                }
+                break;
+            case LocationTypes.TrainStation:
+                query.trainStationCode = this.location.railstation.stationCode;
+                break;
+            case LocationTypes.Office: // Needs to fix in next PR
+                query.officeId = +((_a = this.location.office) === null || _a === void 0 ? void 0 : _a.id);
+                break;
+            case LocationTypes.Shortlist:
+                query.countryCode = this.country.cCode;
+                break;
+        }
+        // Add hotel name in the query
+        if (this.hotel_name) {
+            query.hotelName = this.tempParams.hotel_name;
+        }
+        // add chain or group name int he query
+        if (this.hotel_chain) {
+            query.groupName = (_b = this.tempParams.hotel_chain) === null || _b === void 0 ? void 0 : _b.name;
+        }
+        this.query = query;
+    }
+    makeHotelAvalilityObject(hotel) {
+        return {
+            hotel: hotel.id,
+            startDate: this.helpers.formatIsoDate(this.checkin_date),
+            endDate: this.helpers.formatIsoDate(this.checkout_date),
+            rooms: this.no_of_rooms,
+            occupants: this.no_of_occupants,
+            currency: 'GBP'
+        };
+    }
+    inPriceRange(hotel) {
+        const availability = this.avaliabilityService.getAvailabilityValue(hotel);
+        if (availability) {
+            return (this.helpers.inRange(availability.maxprice, this.filters.priceRange) &&
+                this.helpers.inRange(availability.minprice, this.filters.priceRange));
+        }
+        return false;
+    }
+    inDistanceRange(hotel) {
+        return (this.filters.distanceRange.max === 0 ||
+            this.helpers.inRange(hotel.location.distance, this.filters.distanceRange));
+    }
+    containsHotelname(hotel) {
+        const tocheck = this.filters.hotelName.toLowerCase();
+        return tocheck && tocheck.length > 0
+            ? hotel.name.toLowerCase().includes(tocheck)
+            : true;
+    }
+    inLighteningPriceRange(hotel) {
+        const availability = this.avaliabilityService.getAvailabilityValue(hotel);
+        if (availability && Object.keys(availability).length !== 0) {
+            let maxRange = false;
+            let findMax = 0;
+            let minRange = this.helpers.inRange(availability.prpn, this.filters.priceRange);
+            if (availability === null || availability === void 0 ? void 0 : availability.maxprice) {
+                findMax = availability.maxprice;
+            }
+            else {
+                findMax = availability === null || availability === void 0 ? void 0 : availability.rooms.reduce((op, item) => (op = op > item.total ? op : item.total), 0);
+            }
+            maxRange = this.helpers.inRange(findMax, this.filters.priceRange);
+            let result = minRange && maxRange;
+            return result;
+        }
+        return true;
+    }
+    hasChain(hotel) {
+        const tocheck = (this.filters.chain || []).map((chain) => {
+            return chain.toLowerCase();
+        });
+        return tocheck && tocheck.length
+            ? !!tocheck.find((chain) => {
+                return hotel.group.toLowerCase().includes(chain);
+            })
+            : true;
+    }
+    breakfastTypeFilter(hotel) {
+        if (!this.filters.breakfastType.length)
+            return true;
+        const hotelObject = this.avaliabilityService.getAvailabilityForId(this.makeHotelAvalilityObject(hotel));
+        if (!hotelObject && !hotelObject.value)
+            return false;
+        const hotelObjectValue = hotelObject.value;
+        const isBreakfastIncluded = this.filters.breakfastType.includes(SearchHandler.BREAKFAST_INCLUDED);
+        const isBreakfastExcluded = this.filters.breakfastType.includes(SearchHandler.BREAKFAST_NOT_INCLUDED);
+        const breakfastMatches = hotelObjectValue.rooms.filter((rooms) => {
+            if (isBreakfastIncluded && isBreakfastExcluded) {
+                return rooms;
+            }
+            else if (isBreakfastIncluded) {
+                return rooms.rateDescription.match(includedExpression) && !rooms.rateDescription.match(excludedExpression);
+            }
+            else if (isBreakfastExcluded) {
+                return !rooms.rateDescription.match(includedExpression) || rooms.rateDescription.match(excludedExpression);
+            }
+        });
+        return !!breakfastMatches.length;
+    }
+    byMostExpensive() {
+        this.sortByPrice(false);
+    }
+    /**
+     * @param {boolean} min
+     * @param {boolean} debug set this to true to output console logs
+     * @description sorts results by price according to the 'min' paramater. min = true (lowest price first), min = false (highest price first)
+     * In summary, this method creates a sorted array of hotels with prices and an array of hotels WITHOUT prices,
+     * then finally joins these 2 temporary arrays together before triggering the next observable.
+     */
+    sortByPrice(min = true, debug = false) {
+        // store all results
+        const hotels = this.fullResults;
+        // get hotels with and without prices
+        const hotelsWithPrices = [];
+        const hotelsWithoutPrices = [];
+        hotels.map((hotelResult) => {
+            var _a;
+            ((_a = this.avaliabilityService.getAvailabilityValue(hotelResult)) === null || _a === void 0 ? void 0 : _a.prpn) ? hotelsWithPrices.push(hotelResult)
+                : hotelsWithoutPrices.push(hotelResult);
+        });
+        // sort hotels with prices according to the 'min' parameter for the order
+        hotelsWithPrices.sort((first, second) => {
+            var _a, _b;
+            const firstPrice = (_a = this.avaliabilityService.getAvailabilityValue(first)) === null || _a === void 0 ? void 0 : _a.prpn;
+            const secondPrice = (_b = this.avaliabilityService.getAvailabilityValue(second)) === null || _b === void 0 ? void 0 : _b.prpn;
+            return min
+                ? firstPrice > secondPrice
+                    ? 1
+                    : secondPrice > firstPrice
+                        ? -1
+                        : 0
+                : firstPrice < secondPrice
+                    ? 1
+                    : secondPrice < firstPrice
+                        ? -1
+                        : 0;
+        });
+        // join hotels with prices to hotels WITHOUT prices
+        const sortedHotels = [...hotelsWithPrices, ...hotelsWithoutPrices];
+        // trigger next observable
+        this.results.next(sortedHotels);
+        // display console logs if debug is true (could prove useful in future)
+        if (debug) {
+            console.log('++ sortByPrice() called ++');
+            console.log('++ hotel ++', hotels);
+            console.log('++ hotelsWithPrices ++', hotelsWithPrices);
+            console.log('++ hotelsWithoutPrices ++', hotelsWithoutPrices);
+            console.log('++ sortedHotels ++', sortedHotels);
+        }
+    }
+    sortByName() {
+        this.results.next(this.results.value.sort((fst, snd) => {
+            return fst.name.toLowerCase().localeCompare(snd.name.toLowerCase());
+        }));
+    }
+    sortByDistance() {
+        let results = this.results.value || [];
+        results = results.sort((a, b) => {
+            return Number(a.location.distance) - Number(b.location.distance);
+        });
+        this.results.next(results);
+    }
+    byPreferred() {
+        let results = this.results.value || [];
+        results = results.sort((a, b) => {
+            return this.preferredToInt(b) - this.preferredToInt(a);
+        });
+        this.results.next(results);
+    }
+    preferredToInt(hotel) {
+        return ((hotel.preferred.client ? CLIENT_PREFERRED_VALUE : 0) +
+            (hotel.preferred.consumer ? AGENT_PREFERRED_VALUE : 0));
+    }
+    intToPreferred(preferred) {
+        return {
+            // tslint:disable-next-line: no-bitwise
+            client: (preferred & CLIENT_PREFERRED_VALUE) === CLIENT_PREFERRED_VALUE,
+            // tslint:disable-next-line: no-bitwise
+            consumer: (preferred & AGENT_PREFERRED_VALUE) === AGENT_PREFERRED_VALUE
+        };
+    }
+    addFilter(filter, type) {
+        const filt = this.localFilters;
+        filt[type].push(filter);
+    }
+    removeFilter(filter, type) {
+        const filt = this.localFilters;
+        if (Array.isArray(filt[type])) {
+            filt[type] = filt[type].filter((chain) => {
+                return filter !== chain;
+            });
+        }
+    }
+    resetFilters() {
+        this.localFilters.chain = [];
+        this.localFilters.amenitytype = [];
+        this.localFilters.preferred = [];
+        this.localFilters.extra = [];
+        this.localFilters.hotelName = '';
+        this.localFilters.breakfastType = [];
+    }
+    updateFromPreviousSearches(previousItems) {
+        var _a;
+        const flightItem = (_a = previousItems[ServiceType.Flight]) === null || _a === void 0 ? void 0 : _a.searchQuery;
+        if (flightItem) {
+            // TODO flights haven't been done yet.
+        }
+    }
+    hasPreferred(hotel) {
+        const preferredFilters = this.filters.preferred;
+        // Empty preferred filters OR "Any"
+        if (!preferredFilters.length ||
+            preferredFilters.includes(SearchHandler.ANY)) {
+            return true;
+        }
+        // Agency (consumer) && Client
+        if (preferredFilters.includes(SearchHandler.AGENCY) &&
+            preferredFilters.includes(SearchHandler.CLIENT)) {
+            return (hotel.preferred.consumer === true && hotel.preferred.client === true);
+        }
+        // Agency
+        if (preferredFilters.includes(SearchHandler.AGENCY)) {
+            return hotel.preferred.consumer === true;
+        }
+        // Client
+        if (preferredFilters.includes(SearchHandler.CLIENT)) {
+            return hotel.preferred.client === true;
+        }
+    }
+    getmaxPriceForCurrency(currency) {
+        return this.avaliabilityService.maxPriceForCurrency(currency);
+    }
+    // Lightening Extra Filters
+    getExtraFilter(hotel) {
+        const checkAvailability = this.filters.extra.includes(SearchHandler.AVAILABILITY);
+        if (checkAvailability) {
+            return hotel.unavailable === true;
+        }
+        const checkFemaleFriendly = this.filters.extra.includes(SearchHandler.FEMALE_FRIENDLY);
+        if (checkFemaleFriendly) {
+            return (hotel.tags.filter((tag) => {
+                if (tag.name) {
+                    let name = this.convertToOneString(tag.name).toLowerCase();
+                    return name.includes(this.convertToOneString(SearchHandler.FEMALE_FRIENDLY).toLowerCase());
+                }
+                else {
+                    return true;
+                }
+            }).length > 0);
+        }
+        return true;
+    }
+    // Lightening Amernities Filters
+    getAmenitiesFilter(hotel) {
+        let isTrue = true;
+        this.filters.amenitytype.forEach((search) => {
+            let filteredResults = hotel.tags.filter((tag) => {
+                if (tag.name) {
+                    let name = this.convertToOneString(tag.name).toLowerCase();
+                    if (name.includes(this.convertToOneString(search).toLowerCase())) {
+                        return true;
+                    }
+                    return false;
+                }
+            });
+            isTrue = filteredResults && filteredResults.length > 0 ? true : false;
+            // console.log(`Hotel ${hotel.name} with filter applied`, hotel?.tags, isTrue);
+            return isTrue;
+        });
+        return isTrue;
+    }
+    convertToOneString(item) {
+        return item.replace(/[^a-zA-Z]/g, '');
+    }
+    getImages(HolidayCode) {
+        const url = this.environment.hostBaseUrl +
+            URLS.CONFIRMA_PHOTO_URL +
+            HolidayCode.split(',')[0];
+        const imgProvider = 'https://www.vfmii.com/'; // img provider thats holds images, used to match which images on page belongs to gallery.
+        if (this.galleries[HolidayCode]) {
+            return of(this.galleries[HolidayCode]);
+        }
+        return this.httpCallService.get(url, { responseType: 'text' }).pipe(map((imagesHTML) => {
+            if (!imagesHTML) {
+                throw Error(`Gallery for ${HolidayCode} can not be loaded.`);
+            }
+            const temp = document.createElement('div');
+            temp.innerHTML = imagesHTML;
+            const images = Array.from(temp.getElementsByTagName('img')).reduce((acc, img) => {
+                if (img.src.includes(imgProvider)) {
+                    acc.push(img.src);
+                }
+                return acc;
+            }, []);
+            if (!images.length) {
+                throw Error(`There is no media content provided for this hotel ${HolidayCode}`);
+            }
+            return (this.galleries[HolidayCode] = images);
+        }));
+    }
+    addPaginationPage(currentPage) {
+        const key = 'PaginationPageCount';
+        this.storageService.setSessionItem(key, currentPage);
+        return this.storageService.getSessionItem(key);
+    }
+    toggleView() {
+        if (this.currentView === HotelView.LIST) {
+            this.currentView = HotelView.MAP;
+        }
+        else {
+            this.currentView = HotelView.LIST;
+        }
+    }
+    calcDayDiff() {
+        const checkout = moment(this.checkout_date);
+        const checkin = moment(this.checkin_date);
+        return checkout.startOf().diff(checkin.startOf(), 'days');
+    }
+    updateLowestPrice(results) {
+        const currenciesKey = Object.keys(this.avaliabilityService.currencies);
+        if ((!results.length && !currenciesKey.length) || !currenciesKey.length)
+            return null;
+        const currencie = currenciesKey[0];
+        return {
+            amount: this.avaliabilityService.currencies[currencie].minprice,
+            currencyCode: currencie
+        };
+    }
+    getRoomNumber() {
+        let roomsOccupancy = [];
+        for (let i = 0; i < Number(this.tempParams.no_of_rooms); i++) {
+            const newRoomOccupancy = {
+                Adults: this.calcRoomOccupancy(this.tempParams.no_of_rooms, this.tempParams.no_of_occupants),
+                Children: 0,
+                Infants: 0
+            };
+            roomsOccupancy.push(newRoomOccupancy);
+        }
+        let rooms = [];
+        for (let index = 0; index < roomsOccupancy.length; index++) {
+            for (let j = 0; j < roomsOccupancy[index].Adults; j++) {
+                rooms.push(index + 1);
+            }
+        }
+        // --- should we add new property roomNumber for traveller? --
+        // for (let index = 0; index < this.travellers.length; index++) {
+        //   this.travellers[index].roomNumber = rooms[index];
+        // };
+    }
+    /**
+     *	@desc - return the occupancy for a room - need to calculate based on no of rooms, no of travellers and currently occupied rooms;
+     **/
+    calcRoomOccupancy(no_of_rooms, travellers) {
+        console.log('No of Travellers: ' + travellers + '| No of rooms: ' + no_of_rooms + ' | Assigned: ' + this.occupied);
+        let roomOccupancy = Math.ceil(travellers / no_of_rooms);
+        if (travellers - this.occupied < roomOccupancy) {
+            console.log('We have run out of occupiers!');
+            roomOccupancy = travellers - this.occupied;
+        }
+        if (roomOccupancy <= 0) {
+            roomOccupancy = 1;
+        }
+        this.occupied += roomOccupancy;
+        return roomOccupancy;
+    }
+    addHotelRoomToBasket(hotel, hotelRoom, hotelQuery, travellers) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (hotel.unavailable) {
+                return Promise.resolve(false);
+            }
+            // modify the 'startDate' and 'endDate' properties to have ISO format
+            hotelQuery.startDate = new Date(hotelQuery.startDate).toISOString();
+            hotelQuery.endDate = new Date(hotelQuery.endDate).toISOString();
+            // create copy of hotelQuery and delete 'adults' property as searchQuerySchema for hotel (conferma) does not seem to support it being added
+            const searchQuery = Object.assign({}, hotelQuery);
+            delete searchQuery.adults;
+            const intBasket = yield this.basketService.getDefaultBasket();
+            const basket = intBasket === null || intBasket === void 0 ? void 0 : intBasket.subject.value;
+            if (basket) {
+                const { address: hotelAaddress } = hotel;
+                const { rateDescription, roomDescription, roomId, roomType } = hotelRoom;
+                return this.basketService.addToBasket({
+                    adults: hotelQuery.adults,
+                    basket: basket.id,
+                    service: hotel.sourceId.toString(),
+                    detail: {
+                        checkIn: hotelQuery.startDate,
+                        checkOut: hotelQuery.endDate,
+                        hotelAddress: {
+                            streetName: hotelAaddress.addressLine1,
+                            town: hotelAaddress.addressLine2,
+                            county: hotelAaddress.addressLine3,
+                            postcode: hotelAaddress.postOrZipCode,
+                            countryCode: hotelAaddress.countryCode
+                        },
+                        hotelDescription: hotel.group,
+                        hotelName: hotel.name,
+                        numberOfRooms: hotelQuery.rooms,
+                        rateDescription,
+                        roomDescription,
+                        roomId,
+                        roomType
+                    },
+                    price: hotelRoom.total,
+                    currency: hotelRoom.currencyCode,
+                    searchQuery,
+                    outboundDate: hotelQuery.startDate
+                }, intBasket, this.searchService, this.travellers);
+            }
+            return Promise.resolve(false);
+        });
+    }
+}
+HotelEnterpriseSearch.MAX_HOTEL_ROOMS = 4;
+HotelEnterpriseSearch.STORAGE_SESSION_PARAMS = 'search_hotel';
+HotelEnterpriseSearch.STORAGE_SESSION_RESULTS = 'results_hotel';
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"hotel-enterprise-search.js","sourceRoot":"","sources":["../../../../../../../projects/obtservices/base/src/lib/vendor/classes/hotel-enterprise-search.ts"],"names":[],"mappings":"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","sourcesContent":["import moment from 'moment';\r\nimport { BaseEnterpriseSearch } from './base-enterprise';\r\nimport { BaseStorageService } from '../services/storage.service';\r\nimport { BaseHelperRoutines } from './helpers';\r\nimport { BehaviorSubject, from, of, Observable, Subject } from 'rxjs';\r\nimport { map, take } from 'rxjs/operators';\r\nimport { BaseEnvironment } from './enviroment';\r\nimport { BaseHotelAvalibilityService } from '../services/hotel-avallibility.service';\r\nimport { URLS } from './../services/url.service';\r\nimport {\r\n  Country,\r\n  HotelQuoteResult,\r\n  HotelQuoteResultArray,\r\n  LocationTypes,\r\n  NgbDateStruct,\r\n  LocationDetails,\r\n  HotelAvalibilityQuoteResult,\r\n  includedExpression,\r\n  excludedExpression,\r\n  SearchHandler,\r\n  RecentSearch,\r\n  AirportSearchResults\r\n} from '../types/types';\r\nimport {\r\n  BasketItem,\r\n  ConfermaOfficeNames,\r\n  CurrencyCode,\r\n  DistanceTypes,\r\n  HotelLocation,\r\n  HotelRoom,\r\n  HotelTag,\r\n  RailStation,\r\n  SaveRecentSearchMutationVariables,\r\n  SearchFlightsV2QueryVariables,\r\n  SearchHotelsQueryVariables,\r\n  ServiceType\r\n} from '../types/graphql.types';\r\nimport {\r\n  BaseHotelQuoteFetcher,\r\n  HotelQuoteFetcherType\r\n} from '../fetchers/hotel-quote-fetcher';\r\nimport {\r\n  FullUserDetails,\r\n  UserServiceInterface\r\n} from '../interfaces/Iuser.service';\r\nimport { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';\r\nimport { AbstractHttpCallService } from '../services/http-call.service';\r\n\r\nimport { HotelAvalinilityFetcherType } from '../fetchers/hotel-avaliability-fetcher';\r\nimport {\r\n  EnterpriseBasketServiceInterface,\r\n  InternalBasketInterface\r\n} from '../interfaces/Ienterprise-basket.service';\r\nimport {\r\n  AvailabilityObject,\r\n  DisplayFilterSettings,\r\n  HotelDetails,\r\n  HotelDetailsArray,\r\n  HotelEnterpriseSearchInterface,\r\n  HotelFilters,\r\n  HotelTempParams,\r\n  HotelView,\r\n  ResultDetails\r\n} from '../interfaces/Ihotel-enterprise-search';\r\nimport { ICheapestPrice } from '../interfaces/cheapest-price';\r\nimport { Traveller } from '../models/traveller.object';\r\nimport { BaseSearchConfermaQuicklistFetcher, ConfermaQuicklistFetcherType } from '../fetchers/conferma-quicklist.fetcher';\r\nimport { BaseGetRailStationFetcher, GetRailStationFetcherType } from '../fetchers/get-rail-station.fetcher';\r\n\r\nexport enum SortTypesHotel {\r\n  distance = 'distance',\r\n  name = 'name',\r\n  price = 'price'\r\n}\r\n\r\nconst CLIENT_PREFERRED_VALUE = 1;\r\nconst AGENT_PREFERRED_VALUE = 2;\r\n\r\nexport class HotelEnterpriseSearch<\r\n  HQ_Q extends HotelQuoteFetcherType,\r\n  HA_Q extends HotelAvalinilityFetcherType,\r\n  QL_Q extends ConfermaQuicklistFetcherType,\r\n  GRS_Q extends GetRailStationFetcherType\r\n  >\r\n  extends BaseEnterpriseSearch<\r\n  HotelTempParams,\r\n  HotelQuoteResultArray,\r\n  HotelDetailsArray\r\n  >\r\n  implements HotelEnterpriseSearchInterface {\r\n  static readonly MAX_HOTEL_ROOMS = 4;\r\n  static readonly STORAGE_SESSION_PARAMS = 'search_hotel';\r\n  static readonly STORAGE_SESSION_RESULTS = 'results_hotel';\r\n\r\n  public type: ServiceType = ServiceType.Hotel;\r\n  private travellers: Traveller[];\r\n  public location_types: BehaviorSubject<LocationTypes[]> = new BehaviorSubject<\r\n    LocationTypes[]\r\n  >([]);\r\n  public offices: BehaviorSubject<LocationTypes[]> = new BehaviorSubject<\r\n    LocationTypes[]\r\n  >([]);\r\n  public lastActivePage: BehaviorSubject<number> = new BehaviorSubject(null);\r\n\r\n  readonly galleries: { [key: string]: string[] } = {};\r\n  private occupied: number = 0;\r\n  private results_details: ResultDetails = {\r\n    chains: new Set<string>(),\r\n    amenities: [],\r\n    maxDistance: 0\r\n  };\r\n  private _checkin_date_ngb: NgbDateStruct;\r\n  private _checkout_date_ngb: NgbDateStruct;\r\n\r\n  get chains(): string[] {\r\n    return [...this.results_details.chains];\r\n  }\r\n\r\n  get amenities(): string[] {\r\n    return [...this.results_details.amenities];\r\n  }\r\n\r\n  get maxDistance(): number {\r\n    this.filters.distanceRange.max = Math.ceil(\r\n      Math.max.apply(\r\n        Math,\r\n        this.results.value.map((o) => o.location.distance)\r\n      )\r\n    );\r\n    this.results_details.maxDistance = this.filters.distanceRange.max;\r\n    return this.results_details.maxDistance;\r\n  }\r\n\r\n  get maxPrice(): number {\r\n    return Math.ceil(this.filters.priceRange.max);\r\n  }\r\n\r\n  get currency(): string {\r\n    return this.tempParams.currency;\r\n  }\r\n\r\n  set currency(value: string) {\r\n    this.tempParams.currency = value;\r\n  }\r\n  // Event Emitters\r\n  public filterChange: Subject<any> = new Subject();\r\n  public selectItemMapView: Subject<any> = new Subject();\r\n\r\n  public display: DisplayFilterSettings = {\r\n    minprice: Number.NEGATIVE_INFINITY,\r\n    maxprice: Number.POSITIVE_INFINITY,\r\n    filters: {\r\n      breakfastType: []\r\n    }\r\n  };\r\n\r\n  // public variables\r\n  public min_date = {\r\n    year: moment().year(),\r\n    month: moment().month() + 1, // ngbDate months are not 0 indexed\r\n    day: moment().date()\r\n  };\r\n\r\n  public min_return_date = {\r\n    year: moment().year(),\r\n    month: moment().month() + 1, // ngbDate months are not 0 indexed\r\n    day: moment().date() + 1 // min 1 night stay\r\n  };\r\n\r\n  // private variables\r\n  // don't need to worry about times here - maybe normalise these in the request body?\r\n\r\n  private localFilters = new HotelFilters();\r\n\r\n  public currentView: HotelView = HotelView.LIST;\r\n\r\n  // For NgForing over in the templates\r\n  private _max_no_of_rooms = 4;\r\n  private _max_rooms_array = new Array(this._max_no_of_rooms).fill(0);\r\n  private _max_no_of_occupants = 2;\r\n  private _max_occupant_array = new Array(this._max_no_of_occupants).fill(0);\r\n  private _distance_list = [1, 2, 5, 10, 20, 25]; // copied from old frontend for now\r\n  private _default_currency: any = null;\r\n\r\n  // getters and setters\r\n\r\n  get checkin_date_ngb(): NgbDateStruct {\r\n    return this._checkin_date_ngb;\r\n  }\r\n\r\n  set checkin_date_ngb(value: NgbDateStruct) {\r\n    this._checkin_date_ngb = value;\r\n\r\n    this.tempParams.checkin_date = this.helpers.ngDateToMoment(value);\r\n    this.checkin_date = this.helpers.ngDateToMoment(value);\r\n  }\r\n\r\n  get checkout_date_ngb(): NgbDateStruct {\r\n    return this._checkout_date_ngb;\r\n  }\r\n\r\n  set checkout_date_ngb(value: NgbDateStruct) {\r\n    this._checkout_date_ngb = value;\r\n    this.tempParams.checkout_date = this.helpers.ngDateToMoment(value);\r\n    this._isValid();\r\n  }\r\n\r\n  get checkin_date(): moment.Moment {\r\n    return this.tempParams.checkin_date;\r\n  }\r\n\r\n  set checkin_date(newDate: moment.Moment) {\r\n    if (newDate && newDate.isValid()) {\r\n      this.tempParams.checkin_date = moment(newDate);\r\n      this._checkin_date_ngb = this.helpers.momentToNgDate(newDate);\r\n      if (newDate.isSameOrBefore(this.tempParams.checkout_date)) {\r\n        this.checkout_date = moment(newDate).add(1, 'day');\r\n      }\r\n      this._isValid();\r\n    }\r\n  }\r\n\r\n  get checkout_date(): moment.Moment {\r\n    return this.tempParams.checkout_date;\r\n  }\r\n\r\n  set checkout_date(newDate: moment.Moment) {\r\n    // if (newDate.isSameOrBefore(this.checkin_date)) {  // not allowed\r\n    //   return;\r\n    // }\r\n    if (newDate && newDate.isValid()) {\r\n      this.tempParams.checkout_date = newDate;\r\n      this.checkout_date_ngb = this.helpers.momentToNgDate(newDate);\r\n      this._isValid();\r\n    }\r\n  }\r\n\r\n  get no_of_rooms(): number {\r\n    return this.tempParams.no_of_rooms;\r\n  }\r\n\r\n  set no_of_rooms(newRooms: number) {\r\n    if (newRooms > 4 || newRooms < 1) {\r\n      return;\r\n    }\r\n\r\n    this.tempParams.no_of_rooms = newRooms;\r\n    this._isValid();\r\n  }\r\n\r\n  get no_of_occupants(): number {\r\n    return this.tempParams.no_of_occupants;\r\n  }\r\n\r\n  set no_of_occupants(newOcc: number) {\r\n    if (newOcc < 1 || newOcc > 3) {\r\n      return;\r\n    }\r\n\r\n    this.tempParams.no_of_occupants = newOcc;\r\n    this._isValid();\r\n  }\r\n\r\n  get default_currency(): string {\r\n    return this.tempParams.currency;\r\n  }\r\n\r\n  set default_currency(currency: string) {\r\n    this.tempParams.currency = currency;\r\n  }\r\n\r\n  // may have to modify these\r\n  get location(): any {\r\n    return this.tempParams.location;\r\n  }\r\n\r\n  set location(newLoc: any) {\r\n    this.tempParams.location = newLoc;\r\n\r\n    this._isValid();\r\n  }\r\n\r\n  get formatted_location(): string {\r\n    return this.tempParams.location\r\n      ? this.tempParams.location.destination\r\n      : 'No Location Set'; // TODO -  expand this for different types\r\n  }\r\n\r\n  get distance(): number {\r\n    return this.tempParams.distance;\r\n  }\r\n\r\n  set distance(newDist: number) {\r\n    this.tempParams.distance = newDist;\r\n    this._isValid();\r\n  }\r\n\r\n  get prefered_hotels_only(): boolean {\r\n    return this.tempParams.prefered_hotels_only;\r\n  }\r\n\r\n  set prefered_hotels_only(newPref: boolean) {\r\n    this.tempParams.prefered_hotels_only = newPref;\r\n    this._isValid();\r\n  }\r\n\r\n  get country(): Country {\r\n    return this.tempParams.country;\r\n  }\r\n\r\n  set country(newCont: Country) {\r\n    this.tempParams.country = newCont;\r\n    this._isValid();\r\n  }\r\n\r\n  get postcode(): LocationDetails {\r\n    return this.tempParams.postcode;\r\n  }\r\n\r\n  set postcode(postcode: LocationDetails) {\r\n    this.tempParams.postcode = postcode;\r\n    this._isValid();\r\n  }\r\n\r\n  get trainsStation(): LocationDetails {\r\n    return this.tempParams.trainsStation;\r\n  }\r\n\r\n  set trainsStation(station: LocationDetails) {\r\n    this.tempParams.trainsStation = station;\r\n    this._isValid();\r\n  }\r\n\r\n  get office(): ConfermaOfficeNames {\r\n    return this.tempParams.office;\r\n  }\r\n\r\n  set office(office: ConfermaOfficeNames) {\r\n    this.tempParams.office = office;\r\n    this._isValid();\r\n  }\r\n\r\n  // Additional Variables\r\n  get hotel_name(): string {\r\n    return this.tempParams.hotel_name;\r\n  }\r\n\r\n  set hotel_name(newName: string) {\r\n    this.tempParams.hotel_name = newName;\r\n    this._isValid();\r\n  }\r\n\r\n  get hotel_chain(): any {\r\n    return this.tempParams.hotel_chain;\r\n  }\r\n\r\n  set hotel_chain(newChain: any) {\r\n    this.tempParams.hotel_chain = newChain;\r\n    this._isValid();\r\n  }\r\n\r\n  // Getters Only\r\n\r\n  get max_rooms_array(): number[] {\r\n    return this._max_rooms_array;\r\n  }\r\n\r\n  get max_occupant_array(): number[] {\r\n    return this._max_occupant_array;\r\n  }\r\n\r\n  get distance_list(): number[] {\r\n    return this._distance_list;\r\n  }\r\n\r\n  get location_type_select(): LocationTypes {\r\n    return this.tempParams.location_type_select;\r\n  }\r\n\r\n  set location_type_select(value: LocationTypes) {\r\n    this.tempParams.location_type_select = value;\r\n    this._isValid();\r\n  }\r\n\r\n  get filters(): HotelFilters {\r\n    return this.localFilters;\r\n  }\r\n\r\n  constructor(\r\n    private hotelFetcher: BaseHotelQuoteFetcher<HQ_Q>,\r\n    private helpers: BaseHelperRoutines,\r\n    private userService: UserServiceInterface,\r\n    private environment: BaseEnvironment,\r\n    private avaliabilityService: BaseHotelAvalibilityService<HA_Q>,\r\n    private basketService: EnterpriseBasketServiceInterface,\r\n    storageService: BaseStorageService,\r\n    private searchService: EnterpriseSearchServiceInterface,\r\n    private httpCallService: AbstractHttpCallService,\r\n    private quickListFetcher: BaseSearchConfermaQuicklistFetcher<QL_Q>,\r\n    private getRailStationFetcher: BaseGetRailStationFetcher<GRS_Q>\r\n  ) {\r\n    super(storageService, (resultsToMap: HotelQuoteResultArray) => {\r\n      this.results_details.maxDistance = 0;\r\n      this.results_details.chains = new Set<string>();\r\n      return resultsToMap.map(\r\n        (hotelResult: HotelQuoteResult, index: number): HotelDetails => {\r\n          this.results_details.maxDistance = Math.max(\r\n            this.results_details.maxDistance,\r\n            hotelResult.location.distance\r\n          );\r\n          this.filters.distanceRange.max = this.results_details.maxDistance;\r\n          this.results_details.chains.add(hotelResult.group);\r\n          if (index < this.environment.numberHotelToPreload) {\r\n            this.avaliabilityService.getAvailabilityForId(\r\n              this.makeHotelAvalilityObject(hotelResult)\r\n            );\r\n          }\r\n          // this.getHotelAvailability(hotelResult);\r\n          return {\r\n            sortedTags: this.sortTags(hotelResult.tags),\r\n            Details: {\r\n              distance_airport: 0,\r\n              distance_metro: 0,\r\n              distance_rail: 0,\r\n              airport_details: { name: 'Not returned' },\r\n              metro_details: { name: 'Not returned' },\r\n              rail_details: { name: 'Not returned' }\r\n            },\r\n            // avilability: this.hotel_availability,\r\n            ...hotelResult\r\n          };\r\n        }\r\n      );\r\n    });\r\n    this.results_details.chains = new Set<string>();\r\n    const data: {\r\n      tempParams: HotelTempParams;\r\n    } = storageService.getSessionItem(\r\n      HotelEnterpriseSearch.STORAGE_SESSION_PARAMS\r\n    ) || {\r\n        tempParams: {} as HotelTempParams\r\n      };\r\n\r\n    this.default_currency = this.tempParams.currency\r\n      ? this.tempParams.currency\r\n      : this._default_currency;\r\n    this.updateTempParams(searchService.makeHotelQuery(data.tempParams));\r\n\r\n    if (searchService.shouldAddTravellerSubscription()) {\r\n      searchService.travellerInformation.subscribe(\r\n        (travellers: Traveller[]) => {\r\n          this.travellers = travellers;\r\n          const splitTravellers = this.helpers.selectedTravellers(\r\n            travellers,\r\n            ServiceType.Hotel\r\n          );\r\n          this.tempParams.no_of_occupants = splitTravellers.adults.length;\r\n          this.travellers = travellers;\r\n          this._isValid();\r\n        }\r\n      );\r\n    }\r\n\r\n    const results =\r\n      storageService.getSessionItemAsList<HotelDetailsArray>(\r\n        this.resultsSessionName\r\n      ) || [];\r\n    results\r\n      .slice(0, this.environment.numberHotelToPreload)\r\n      .forEach((hotel: HotelDetails) => {\r\n        this.avaliabilityService.getAvailabilityForId(\r\n          this.makeHotelAvalilityObject(hotel)\r\n        );\r\n      });\r\n\r\n    results.forEach((hotelResult: HotelDetails) => {\r\n      this.results_details.chains.add(hotelResult.group);\r\n    });\r\n    this.fullResults = results;\r\n    this.results.next(results);\r\n    this._isValid();\r\n\r\n    this.userService.changeUser.subscribe((user: Partial<FullUserDetails>) => {\r\n      this.location_types.next([\r\n        LocationTypes.Airport,\r\n        LocationTypes.City,\r\n        LocationTypes.Office,\r\n        LocationTypes.Shortlist,\r\n        LocationTypes.TrainStation\r\n      ]);\r\n      if (searchService.shouldFetchAllOffices()) {\r\n        this.offices.next([]); // TODO fetch offices\r\n      }\r\n    });\r\n\r\n    this.localFilters = new HotelFilters();\r\n\r\n    this.avaliabilityService.fetching.subscribe((isFetching: boolean) => {\r\n      if (!isFetching) {\r\n        // We've just finished fetching avalibility so update filters.\r\n\r\n        const maxNumber = this.avaliabilityService.maxPriceForCurrency('GBP');\r\n        if (maxNumber > 0) {\r\n          this.filters.priceRange.max = maxNumber;\r\n          this.localFilters.priceRange.max = maxNumber;\r\n        }\r\n        this._cheapestResultPrice = this.updateLowestPrice(results);\r\n      }\r\n    });\r\n  }\r\n\r\n  protected resultsSessionName = HotelEnterpriseSearch.STORAGE_SESSION_RESULTS;\r\n\r\n  private query: SearchHotelsQueryVariables = {} as SearchHotelsQueryVariables;\r\n\r\n  makeLocations(location: HotelLocation[]): { [key: string]: HotelLocation[] } {\r\n    return this.helpers.arrayToObjectArray<HotelLocation>(\r\n      location,\r\n      'distanceType'\r\n    );\r\n  }\r\n\r\n  sortTags(tags: HotelTag[]): any[] {\r\n    if (tags) {\r\n      return [...tags]\r\n        .sort((a: HotelTag, b: HotelTag) => {\r\n          if (a.name < b.name) {\r\n            return -1;\r\n          } else if (a.name > b.name) {\r\n            return 1;\r\n          } else {\r\n            return 0;\r\n          }\r\n        })\r\n        .map((tag: HotelTag) => {\r\n          return {\r\n            ...tag,\r\n            icon: this.environment.tagMap[tag.name] || tag.icon\r\n          };\r\n        });\r\n    }\r\n    return [];\r\n  }\r\n\r\n  protected resetQuery(): void {\r\n    this.updateTempParams(this.searchService.makeHotelQuery());\r\n    this.localFilters = new HotelFilters();\r\n    this.results_details = {\r\n      chains: new Set<string>(),\r\n      amenities: [],\r\n      maxDistance: 0\r\n    };\r\n    this._isValid();\r\n  }\r\n\r\n  private _isValid() {\r\n    if (!this.doChecks) {\r\n      return;\r\n    }\r\n\r\n    this.storageService.setSessionItem(\r\n      HotelEnterpriseSearch.STORAGE_SESSION_PARAMS,\r\n      {\r\n        tempParams: this.tempParams\r\n      }\r\n    );\r\n\r\n    this.min_return_date = this.helpers.momentToNgDate(\r\n      this.tempParams.checkin_date\r\n    );\r\n    if (\r\n      this.tempParams.checkin_date.isSameOrAfter(this.tempParams.checkout_date)\r\n    ) {\r\n      this.checkout_date = moment(this.tempParams.checkin_date).add(1, 'day'); // ensure that checkout date is min 1 day after checkin date\r\n    }\r\n    this.validationMessages = [];\r\n\r\n    switch (this.tempParams.location_type_select) {\r\n      case LocationTypes.City:\r\n        if (!this.country) {\r\n          this.validationMessages.push('Please select country');\r\n        }\r\n        if (!this.location && !this.postcode) {\r\n          this.validationMessages.push(\r\n            'Please select a hotel location or enter a postcode.'\r\n          );\r\n        }\r\n        break;\r\n\r\n      case LocationTypes.Office:\r\n        if (!this.tempParams.location?.office) {\r\n          this.validationMessages.push('Please select an office.');\r\n        }\r\n        break;\r\n\r\n      case LocationTypes.Airport:\r\n        if (this.tempParams?.location) {\r\n          if (!this.tempParams.location.airport?.gateway) {\r\n            this.validationMessages.push('Please select a airport.');\r\n          }\r\n          break;\r\n        } else {\r\n          this.validationMessages.push('Please select a airport.');\r\n        }\r\n\r\n        break;\r\n        \r\n      case LocationTypes.TrainStation:\r\n        if (this.tempParams?.location) {\r\n          if (!this.tempParams.location.railstation?.stationCode) {\r\n            this.validationMessages.push('Please select a train station.');\r\n          }\r\n          break;\r\n        } else {\r\n          this.validationMessages.push('Please select a train station.');\r\n        }\r\n\r\n        break;\r\n\r\n      case LocationTypes.Shortlist:\r\n        if (!this.country) {\r\n          this.validationMessages.push('Please select country');\r\n        }\r\n        break;\r\n    }\r\n\r\n    if (\r\n      this.checkout_date &&\r\n      this.checkout_date.isSameOrBefore(this.checkin_date)\r\n    ) {\r\n      this.validationMessages.push('Checkout date must be after checkin date');\r\n    }\r\n\r\n    if (this.checkout_date && this.checkout_date.isBefore(moment())) {\r\n      this.validationMessages.push('Checkout date must not be in the past');\r\n    }\r\n\r\n    if (this.checkin_date && this.checkin_date.isBefore(moment())) {\r\n      this.validationMessages.push('Checkin date must not be in the past');\r\n    }\r\n\r\n    if (\r\n      this.checkout_date &&\r\n      this.checkin_date &&\r\n      this.checkin_date.isAfter(this.checkout_date)\r\n    ) {\r\n      this.validationMessages.push(\r\n        'Checkout data must be after the checkin date'\r\n      );\r\n    }\r\n\r\n    // Calculating Occupancy\r\n    const occupancy = this.no_of_occupants / this.no_of_rooms;\r\n\r\n    if (!(occupancy === 1 || occupancy === 2)) {\r\n      this.validationMessages.push(\r\n        'Occupants per room must be 1 or 2, if you have an odd number of travellers (greater than one), the no of rooms must be equal'\r\n      );\r\n    }\r\n\r\n    console.log(this.validationMessages);\r\n    this.isValid.next(this.validationMessages.length === 0);\r\n    this.messages.next(this.validationMessages);\r\n  }\r\n\r\n  startSearch(): Promise<boolean> {\r\n    this.results.next([]);\r\n    this.avaliabilityService.reset();\r\n    if (this.isValid.value) {\r\n      // build the query\r\n      this.buildQuery();\r\n      const query = this.getSearchQuery();\r\n      this.searchService.saveRecentSearch(this.getRecentSearchQuery(this.getSearchQuery()));\r\n      return this._startSearch(\r\n        this.tempParams.location_type_select === LocationTypes.Shortlist ?\r\n        this.quickListFetcher.fetchList({countryCode: this.country.cCode}) :\r\n        this.hotelFetcher.fetchList(\r\n          query\r\n        )\r\n      );\r\n    } else {\r\n      return Promise.resolve(false);\r\n    }\r\n  }\r\n\r\n  getRecentSearchQuery(query: SearchHotelsQueryVariables): SaveRecentSearchMutationVariables {\r\n    if (this.location?.name) {\r\n      query.cityName = this.location.name;\r\n    }\r\n    return {\r\n      serviceType: ServiceType.Hotel,\r\n      searchArgs: query,\r\n      travelDate: this.checkin_date.format(),\r\n      travellers: this.helpers.getTravellersId(this.travellers)\r\n    };\r\n  }\r\n\r\n  public startRecentSearch(recentSearch: RecentSearch): void {\r\n    this.currency = recentSearch.searchArgs.currency;\r\n    this.distance = recentSearch.searchArgs.distance;\r\n    this.no_of_rooms = recentSearch.searchArgs.rooms;\r\n    this.checkin_date = moment(recentSearch.searchArgs.startDate);\r\n    this.checkout_date = moment(recentSearch.searchArgs.endDate);\r\n    this.hotel_name = recentSearch.searchArgs.hotelName;\r\n\r\n    if (recentSearch.searchArgs.groupName) {\r\n      this.hotel_chain = {\r\n        name: recentSearch.searchArgs.groupName\r\n      }\r\n    }\r\n\r\n    // get location_type_select\r\n    if (recentSearch.searchArgs.iata) {\r\n      this.location_type_select = LocationTypes.Airport;\r\n      this.searchService.getAirportByCode(recentSearch.searchArgs.iata).subscribe((iata: AirportSearchResults) => {\r\n        let airport = {\r\n          airport: {\r\n            gateway: iata.iataMatch.iata\r\n          }\r\n        }\r\n        this.location = { ...airport, ...iata.iataMatch };\r\n        this.searchService.startSearches();\r\n      })\r\n    } else if ((recentSearch.searchArgs.latitude && recentSearch.searchArgs.longitude) || recentSearch.searchArgs.postOrZipCode) {\r\n      this.location_type_select = LocationTypes.City;\r\n      this.country = {\r\n        cCode: recentSearch.searchArgs.countryCode,\r\n        cName: '' \r\n      }\r\n      // should be one search metod for the city search: location or postcode\r\n      if (recentSearch.searchArgs.latitude && recentSearch.searchArgs.longitude) {\r\n        this.location = {\r\n          name: recentSearch.searchArgs.cityName,\r\n          latitude: recentSearch.searchArgs.latitude,\r\n          longitude: recentSearch.searchArgs.longitude\r\n        }\r\n      } else if (recentSearch.searchArgs.postOrZipCode) {\r\n        this.postcode = {\r\n          name: recentSearch.searchArgs.postOrZipCode,\r\n          type: LocationTypes.Postcode\r\n        }\r\n      }\r\n      this.searchService.startSearches();\r\n    } else if (recentSearch.searchArgs.officeId) { \r\n      this.location_type_select = LocationTypes.Office;\r\n      this.searchService.getOfficeNames(this.isLoading).pipe(take(1)).subscribe((offices: ConfermaOfficeNames[]) => { \r\n        if (offices) {\r\n          let office: ConfermaOfficeNames = offices.find((office: ConfermaOfficeNames) => office.id === recentSearch.searchArgs.officeId);\r\n          this.office = {\r\n            id: recentSearch.searchArgs.officeId,\r\n            name: office.name\r\n          }\r\n          this.searchService.startSearches();\r\n        }\r\n      });\r\n    } else if (recentSearch.searchArgs.trainStationCode) {\r\n      this.location_type_select = LocationTypes.TrainStation;\r\n      this.getRailStationByCode(recentSearch.searchArgs.trainStationCode).subscribe((trainsStation: RailStation) => {\r\n        this.trainsStation = trainsStation as LocationDetails\r\n        this.searchService.startSearches();\r\n      });\r\n    } else {\r\n      this.location_type_select = LocationTypes.Shortlist;\r\n      this.country = {\r\n        cCode: recentSearch.searchArgs.countryCode,\r\n        cName: '' \r\n      }\r\n      this.searchService.startSearches();\r\n    }\r\n  }\r\n\r\n  private getRailStationByCode(code: string): Observable<RailStation> {\r\n    if (code) {\r\n      return this.getRailStationFetcher.fetchList({ id: null, code: code }).pipe(\r\n        take(1)\r\n      );\r\n    } else {\r\n      return of();\r\n    }\r\n  }\r\n\r\n  getSearchQuery(): SearchHotelsQueryVariables {\r\n    this.buildQuery();\r\n    return this.helpers.removeNulls<SearchHotelsQueryVariables>(this.query);\r\n  }\r\n\r\n  buildQuery(): void {\r\n    const query: SearchHotelsQueryVariables = {\r\n      startDate: this.tempParams.checkin_date.format('YYYY-MM-DD'),\r\n      endDate: this.tempParams.checkout_date.format('YYYY-MM-DD'),\r\n      rooms: this.tempParams.no_of_rooms,\r\n      adults: this.tempParams.no_of_occupants,\r\n      currency: this.tempParams.currency ? this.tempParams.currency : null,\r\n      distance: this.tempParams.distance,\r\n      distanceType: DistanceTypes.M,\r\n      maxResults: 100\r\n    };\r\n\r\n    this.getRoomNumber();\r\n    console.log(this.location)\r\n    switch (this.tempParams.location_type_select) {\r\n      case LocationTypes.Airport:\r\n        query.iata = this.tempParams.location.airport.gateway;\r\n        break;\r\n\r\n      case LocationTypes.City:\r\n        query.countryCode = this.country.cCode;\r\n        // should be one search metod for the city search: location or postcode\r\n        if (this.location) {\r\n          query.latitude = this.location.latitude;\r\n          query.longitude = this.location.longitude;\r\n        } else if (this.postcode) {\r\n          query.postOrZipCode = this.postcode.name;\r\n        }\r\n        break;\r\n        \r\n      case LocationTypes.TrainStation:\r\n        query.trainStationCode = this.location.railstation.stationCode;\r\n        break;\r\n\r\n      case LocationTypes.Office: // Needs to fix in next PR\r\n        query.officeId = +this.location.office?.id;\r\n        break;\r\n\r\n      case LocationTypes.Shortlist: \r\n        query.countryCode = this.country.cCode;\r\n        break;\r\n\r\n    }\r\n\r\n    // Add hotel name in the query\r\n    if (this.hotel_name) {\r\n      query.hotelName = this.tempParams.hotel_name;\r\n    }\r\n\r\n    // add chain or group name int he query\r\n    if (this.hotel_chain) {\r\n      query.groupName = this.tempParams.hotel_chain?.name;\r\n    }\r\n\r\n    this.query = query;\r\n  }\r\n\r\n  makeHotelAvalilityObject(hotel: HotelQuoteResult): AvailabilityObject {\r\n    return {\r\n      hotel: hotel.id,\r\n      startDate: this.helpers.formatIsoDate(this.checkin_date),\r\n      endDate: this.helpers.formatIsoDate(this.checkout_date),\r\n      rooms: this.no_of_rooms,\r\n      occupants: this.no_of_occupants,\r\n      currency: 'GBP'\r\n    };\r\n  }\r\n\r\n  public filterResults = () => {\r\n    this.results.next(\r\n      this.fullResults.filter((hotel: HotelDetails) => {\r\n        return (\r\n          this.inPriceRange(hotel) &&\r\n          this.inDistanceRange(hotel) &&\r\n          this.containsHotelname(hotel) &&\r\n          this.hasChain(hotel) &&\r\n          this.breakfastTypeFilter(hotel)\r\n        );\r\n      })\r\n    );\r\n  };\r\n\r\n  // Lightening Filters\r\n  public filterLighteningResults = () => {\r\n    this.results.next(\r\n      this.fullResults.filter((hotel: HotelDetails) => {\r\n        return (\r\n          this.inLighteningPriceRange(hotel) &&\r\n          this.containsHotelname(hotel) &&\r\n          this.hasChain(hotel) &&\r\n          this.hasPreferred(hotel) &&\r\n          this.breakfastTypeFilter(hotel) &&\r\n          this.getExtraFilter(hotel) &&\r\n          this.getAmenitiesFilter(hotel)\r\n        );\r\n      })\r\n    );\r\n  };\r\n\r\n  private inPriceRange(hotel: HotelDetails): boolean {\r\n    const availability = this.avaliabilityService.getAvailabilityValue(hotel);\r\n    if (availability) {\r\n      return (\r\n        this.helpers.inRange(availability.maxprice, this.filters.priceRange) &&\r\n        this.helpers.inRange(availability.minprice, this.filters.priceRange)\r\n      );\r\n    }\r\n\r\n    return false;\r\n  }\r\n\r\n  private inDistanceRange(hotel: HotelDetails): boolean {\r\n    return (\r\n      this.filters.distanceRange.max === 0 ||\r\n      this.helpers.inRange(hotel.location.distance, this.filters.distanceRange)\r\n    );\r\n  }\r\n\r\n  private containsHotelname(hotel: HotelDetails): boolean {\r\n    const tocheck = this.filters.hotelName.toLowerCase();\r\n\r\n    return tocheck && tocheck.length > 0\r\n      ? hotel.name.toLowerCase().includes(tocheck)\r\n      : true;\r\n  }\r\n\r\n  private inLighteningPriceRange(hotel: HotelDetails): boolean {\r\n    const availability = this.avaliabilityService.getAvailabilityValue(hotel);\r\n    if (availability && Object.keys(availability).length !== 0) {\r\n      let maxRange: boolean = false;\r\n      let findMax: number = 0;\r\n      let minRange = this.helpers.inRange(\r\n        availability.prpn,\r\n        this.filters.priceRange\r\n      );\r\n      if (availability?.maxprice) {\r\n        findMax = availability.maxprice;\r\n      } else {\r\n        findMax = availability?.rooms.reduce(\r\n          (op, item) => (op = op > item.total ? op : item.total),\r\n          0\r\n        );\r\n      }\r\n      maxRange = this.helpers.inRange(findMax, this.filters.priceRange);\r\n      let result: boolean = minRange && maxRange;\r\n      return result;\r\n    }\r\n    return true;\r\n  }\r\n\r\n  private hasChain(hotel: HotelDetails): boolean {\r\n    const tocheck = (this.filters.chain || []).map((chain: string): string => {\r\n      return chain.toLowerCase();\r\n    });\r\n    return tocheck && tocheck.length\r\n      ? !!tocheck.find((chain: string) => {\r\n        return hotel.group.toLowerCase().includes(chain);\r\n      })\r\n      : true;\r\n  }\r\n\r\n  private breakfastTypeFilter(hotel: HotelDetails): boolean {\r\n    if(!this.filters.breakfastType.length) return true;\r\n    const hotelObject = this.avaliabilityService.getAvailabilityForId(this.makeHotelAvalilityObject(hotel));\r\n    if(!hotelObject && !hotelObject.value) return false;\r\n    const hotelObjectValue: HotelAvalibilityQuoteResult = hotelObject.value;\r\n    const isBreakfastIncluded = this.filters.breakfastType.includes(SearchHandler.BREAKFAST_INCLUDED);\r\n    const isBreakfastExcluded = this.filters.breakfastType.includes(SearchHandler.BREAKFAST_NOT_INCLUDED);\r\n\r\n    const breakfastMatches = hotelObjectValue.rooms.filter((rooms: any) => {\r\n        if(isBreakfastIncluded && isBreakfastExcluded){\r\n          return rooms;\r\n        } else if(isBreakfastIncluded) {\r\n          return rooms.rateDescription.match(includedExpression) && !rooms.rateDescription.match(excludedExpression);\r\n        } else if(isBreakfastExcluded){\r\n          return !rooms.rateDescription.match(includedExpression) || rooms.rateDescription.match(excludedExpression);\r\n        }\r\n      }\r\n    );\r\n    return !!breakfastMatches.length;\r\n  }\r\n\r\n  byMostExpensive() {\r\n    this.sortByPrice(false);\r\n  }\r\n\r\n  /**\r\n   * @param {boolean} min\r\n   * @param {boolean} debug set this to true to output console logs\r\n   * @description sorts results by price according to the 'min' paramater. min = true (lowest price first), min = false (highest price first)\r\n   * In summary, this method creates a sorted array of hotels with prices and an array of hotels WITHOUT prices,\r\n   * then finally joins these 2 temporary arrays together before triggering the next observable.\r\n   */\r\n\r\n  sortByPrice(min = true, debug = false): void {\r\n    // store all results\r\n    const hotels: HotelDetailsArray = this.fullResults;\r\n\r\n    // get hotels with and without prices\r\n    const hotelsWithPrices: HotelDetailsArray = [];\r\n    const hotelsWithoutPrices: HotelDetailsArray = [];\r\n    hotels.map((hotelResult) => {\r\n      this.avaliabilityService.getAvailabilityValue(hotelResult)?.prpn\r\n        ? hotelsWithPrices.push(hotelResult)\r\n        : hotelsWithoutPrices.push(hotelResult);\r\n    });\r\n\r\n    // sort hotels with prices according to the 'min' parameter for the order\r\n    hotelsWithPrices.sort((first: HotelDetails, second: HotelDetails) => {\r\n      const firstPrice =\r\n        this.avaliabilityService.getAvailabilityValue(first)?.prpn;\r\n      const secondPrice =\r\n        this.avaliabilityService.getAvailabilityValue(second)?.prpn;\r\n      return min\r\n        ? firstPrice > secondPrice\r\n          ? 1\r\n          : secondPrice > firstPrice\r\n            ? -1\r\n            : 0\r\n        : firstPrice < secondPrice\r\n          ? 1\r\n          : secondPrice < firstPrice\r\n            ? -1\r\n            : 0;\r\n    });\r\n\r\n    // join hotels with prices to hotels WITHOUT prices\r\n    const sortedHotels = [...hotelsWithPrices, ...hotelsWithoutPrices];\r\n\r\n    // trigger next observable\r\n    this.results.next(sortedHotels);\r\n\r\n    // display console logs if debug is true (could prove useful in future)\r\n    if (debug) {\r\n      console.log('++ sortByPrice() called ++');\r\n      console.log('++ hotel ++', hotels);\r\n      console.log('++ hotelsWithPrices ++', hotelsWithPrices);\r\n      console.log('++ hotelsWithoutPrices ++', hotelsWithoutPrices);\r\n      console.log('++ sortedHotels ++', sortedHotels);\r\n    }\r\n  }\r\n\r\n  sortByName(): void {\r\n    this.results.next(\r\n      this.results.value.sort(\r\n        (fst: HotelDetails, snd: HotelDetails): number => {\r\n          return fst.name.toLowerCase().localeCompare(snd.name.toLowerCase());\r\n        }\r\n      )\r\n    );\r\n  }\r\n\r\n  sortByDistance(): void {\r\n    let results = this.results.value || [];\r\n    results = results.sort((a, b) => {\r\n      return Number(a.location.distance) - Number(b.location.distance);\r\n    });\r\n    this.results.next(results);\r\n  }\r\n\r\n  byPreferred(): void {\r\n    let results = this.results.value || [];\r\n    results = results.sort((a: HotelDetails, b: HotelDetails) => {\r\n      return this.preferredToInt(b) - this.preferredToInt(a);\r\n    });\r\n    this.results.next(results);\r\n  }\r\n\r\n  private preferredToInt(hotel: HotelDetails): number {\r\n    return (\r\n      (hotel.preferred.client ? CLIENT_PREFERRED_VALUE : 0) +\r\n      (hotel.preferred.consumer ? AGENT_PREFERRED_VALUE : 0)\r\n    );\r\n  }\r\n\r\n  private intToPreferred(preferred: 0 | 1 | 2 | 3) {\r\n    return {\r\n      // tslint:disable-next-line: no-bitwise\r\n      client: (preferred & CLIENT_PREFERRED_VALUE) === CLIENT_PREFERRED_VALUE,\r\n      // tslint:disable-next-line: no-bitwise\r\n      consumer: (preferred & AGENT_PREFERRED_VALUE) === AGENT_PREFERRED_VALUE\r\n    };\r\n  }\r\n\r\n  addFilter(filter: string, type: keyof HotelFilters): void {\r\n    const filt: any = this.localFilters;\r\n    filt[type].push(filter);\r\n  }\r\n\r\n  removeFilter(filter: string, type: keyof HotelFilters): void {\r\n    const filt = this.localFilters;\r\n    if (Array.isArray(filt[type])) {\r\n      (filt[type] as string[]) = (filt[type] as string[]).filter(\r\n        (chain: string) => {\r\n          return filter !== chain;\r\n        }\r\n      );\r\n    }\r\n  }\r\n\r\n  resetFilters(): void {\r\n    this.localFilters.chain = [];\r\n    this.localFilters.amenitytype = [];\r\n    this.localFilters.preferred = [];\r\n    this.localFilters.extra = [];\r\n    this.localFilters.hotelName = '';\r\n    this.localFilters.breakfastType = [];\r\n  }\r\n\r\n  updateFromPreviousSearches(\r\n    previousItems: Record<ServiceType, BasketItem>\r\n  ): void {\r\n    const flightItem: SearchFlightsV2QueryVariables =\r\n      previousItems[ServiceType.Flight]?.searchQuery;\r\n    if (flightItem) {\r\n      // TODO flights haven't been done yet.\r\n    }\r\n  }\r\n\r\n  private hasPreferred(hotel: HotelDetails): boolean {\r\n    const preferredFilters = this.filters.preferred;\r\n\r\n    // Empty preferred filters OR \"Any\"\r\n    if (\r\n      !preferredFilters.length ||\r\n      preferredFilters.includes(SearchHandler.ANY)\r\n    ) {\r\n      return true;\r\n    }\r\n\r\n    // Agency (consumer) && Client\r\n    if (\r\n      preferredFilters.includes(SearchHandler.AGENCY) &&\r\n      preferredFilters.includes(SearchHandler.CLIENT)\r\n    ) {\r\n      return (\r\n        hotel.preferred.consumer === true && hotel.preferred.client === true\r\n      );\r\n    }\r\n\r\n    // Agency\r\n    if (preferredFilters.includes(SearchHandler.AGENCY)) {\r\n      return hotel.preferred.consumer === true;\r\n    }\r\n\r\n    // Client\r\n    if (preferredFilters.includes(SearchHandler.CLIENT)) {\r\n      return hotel.preferred.client === true;\r\n    }\r\n  }\r\n\r\n  public getmaxPriceForCurrency(currency: string): any {\r\n    return this.avaliabilityService.maxPriceForCurrency(currency);\r\n  }\r\n\r\n  // Lightening Extra Filters\r\n  private getExtraFilter(hotel: HotelDetails): boolean {\r\n    const checkAvailability = this.filters.extra.includes(\r\n      SearchHandler.AVAILABILITY\r\n    );\r\n    if (checkAvailability) {\r\n      return hotel.unavailable === true;\r\n    }\r\n\r\n    const checkFemaleFriendly = this.filters.extra.includes(\r\n      SearchHandler.FEMALE_FRIENDLY\r\n    );\r\n    if (checkFemaleFriendly) {\r\n      return (\r\n        hotel.tags.filter((tag) => {\r\n          if (tag.name) {\r\n            let name: string = this.convertToOneString(tag.name).toLowerCase();\r\n            return name.includes(\r\n              this.convertToOneString(\r\n                SearchHandler.FEMALE_FRIENDLY\r\n              ).toLowerCase()\r\n            );\r\n          } else {\r\n            return true;\r\n          }\r\n        }).length > 0\r\n      );\r\n    }\r\n    return true;\r\n  }\r\n\r\n  // Lightening Amernities Filters\r\n  private getAmenitiesFilter(hotel: HotelDetails): boolean {\r\n    let isTrue: boolean = true;\r\n    this.filters.amenitytype.forEach((search) => {\r\n      let filteredResults: any = hotel.tags.filter((tag) => {\r\n        if (tag.name) {\r\n          let name: string = this.convertToOneString(tag.name).toLowerCase();\r\n          if (name.includes(this.convertToOneString(search).toLowerCase())) {\r\n            return true;\r\n          }\r\n          return false;\r\n        }\r\n      });\r\n      isTrue = filteredResults && filteredResults.length > 0 ? true : false;\r\n      // console.log(`Hotel ${hotel.name} with filter applied`, hotel?.tags, isTrue);\r\n      return isTrue;\r\n    });\r\n    return isTrue;\r\n  }\r\n\r\n  private convertToOneString(item: string) {\r\n    return item.replace(/[^a-zA-Z]/g, '');\r\n  }\r\n\r\n  getImages(HolidayCode: string): Observable<string[]> {\r\n    const url =\r\n      this.environment.hostBaseUrl +\r\n      URLS.CONFIRMA_PHOTO_URL +\r\n      HolidayCode.split(',')[0];\r\n    const imgProvider = 'https://www.vfmii.com/'; // img provider thats holds images, used to match which images on page belongs to gallery.\r\n    if (this.galleries[HolidayCode]) {\r\n      return of(this.galleries[HolidayCode]);\r\n    }\r\n\r\n    return this.httpCallService.get(url as URLS, { responseType: 'text' }).pipe(\r\n      map((imagesHTML) => {\r\n        if (!imagesHTML) {\r\n          throw Error(`Gallery for ${HolidayCode} can not be loaded.`);\r\n        }\r\n        const temp = document.createElement('div');\r\n        temp.innerHTML = imagesHTML;\r\n        const images = Array.from(temp.getElementsByTagName('img')).reduce(\r\n          (acc, img) => {\r\n            if (img.src.includes(imgProvider)) {\r\n              acc.push(img.src);\r\n            }\r\n            return acc;\r\n          },\r\n          []\r\n        );\r\n        if (!images.length) {\r\n          throw Error(\r\n            `There is no media content provided for this hotel ${HolidayCode}`\r\n          );\r\n        }\r\n        return (this.galleries[HolidayCode] = images);\r\n      })\r\n    );\r\n  }\r\n\r\n  addPaginationPage(currentPage: number): any {\r\n    const key = 'PaginationPageCount';\r\n    this.storageService.setSessionItem(key, currentPage);\r\n    return this.storageService.getSessionItem(key);\r\n  }\r\n\r\n  toggleView(): void {\r\n    if (this.currentView === HotelView.LIST) {\r\n      this.currentView = HotelView.MAP;\r\n    } else {\r\n      this.currentView = HotelView.LIST;\r\n    }\r\n  }\r\n\r\n  calcDayDiff(): number {\r\n    const checkout = moment(this.checkout_date);\r\n    const checkin = moment(this.checkin_date);\r\n    return checkout.startOf().diff(checkin.startOf(), 'days');\r\n  }\r\n  updateLowestPrice(results: HotelDetails[]): ICheapestPrice {\r\n    const currenciesKey = Object.keys(this.avaliabilityService.currencies);\r\n    if ((!results.length && !currenciesKey.length) || !currenciesKey.length)\r\n      return null;\r\n\r\n    const currencie = currenciesKey[0];\r\n\r\n    return {\r\n      amount: this.avaliabilityService.currencies[currencie].minprice,\r\n      currencyCode: currencie\r\n    };\r\n  }\r\n\r\n  getRoomNumber() {\r\n    let roomsOccupancy: any[] = [];\r\n    for (let i = 0; i < Number(this.tempParams.no_of_rooms); i++) {\r\n      const newRoomOccupancy = {\r\n        Adults: this.calcRoomOccupancy(this.tempParams.no_of_rooms, this.tempParams.no_of_occupants),\r\n        Children: 0,\r\n        Infants: 0\r\n      };\r\n      roomsOccupancy.push(newRoomOccupancy);\r\n    }\r\n\r\n    let rooms: number[] = [];\r\n    for (let index = 0; index < roomsOccupancy.length; index++) {\r\n      for (let j = 0; j < roomsOccupancy[index].Adults; j++) {\r\n        rooms.push(index+1);\r\n      }\r\n    }\r\n\r\n    // --- should we add new property roomNumber for traveller? --\r\n    // for (let index = 0; index < this.travellers.length; index++) {\r\n    //   this.travellers[index].roomNumber = rooms[index];\r\n    // };\r\n  }\r\n\r\n\r\n  /**\r\n   *\t@desc - return the occupancy for a room - need to calculate based on no of rooms, no of travellers and currently occupied rooms;\r\n   **/\r\n\r\n   calcRoomOccupancy(no_of_rooms: number, travellers: number): number{\r\n    console.log('No of Travellers: ' + travellers + '| No of rooms: ' + no_of_rooms + ' | Assigned: ' + this.occupied);\r\n    let roomOccupancy: number = Math.ceil(travellers/no_of_rooms);\r\n\r\n    if (travellers - this.occupied < roomOccupancy) {\r\n      console.log('We have run out of occupiers!');\r\n      roomOccupancy = travellers - this.occupied;\r\n    }\r\n\r\n    if (roomOccupancy <= 0) {\r\n      roomOccupancy = 1;\r\n    }\r\n\r\n    this.occupied += roomOccupancy;\r\n    return roomOccupancy;\r\n  }\r\n\r\n  async addHotelRoomToBasket(\r\n    hotel: HotelQuoteResult,\r\n    hotelRoom: HotelRoom,\r\n    hotelQuery: SearchHotelsQueryVariables,\r\n    travellers?: Traveller[]\r\n  ): Promise<boolean> {\r\n    if (hotel.unavailable) {\r\n      return Promise.resolve(false);\r\n    }\r\n    // modify the 'startDate' and 'endDate' properties to have ISO format\r\n    hotelQuery.startDate = new Date(hotelQuery.startDate).toISOString();\r\n    hotelQuery.endDate = new Date(hotelQuery.endDate).toISOString();\r\n\r\n    // create copy of hotelQuery and delete 'adults' property as searchQuerySchema for hotel (conferma) does not seem to support it being added\r\n    const searchQuery = { ...hotelQuery };\r\n    delete searchQuery.adults;\r\n\r\n    const intBasket: InternalBasketInterface =\r\n      await this.basketService.getDefaultBasket();\r\n    const basket = intBasket?.subject.value;\r\n    if (basket) {\r\n      const { address: hotelAaddress } = hotel;\r\n      const { rateDescription, roomDescription, roomId, roomType } = hotelRoom;\r\n      return this.basketService.addToBasket(\r\n        {\r\n          adults: hotelQuery.adults,\r\n          basket: basket.id,\r\n          service: hotel.sourceId.toString(),\r\n          detail: {\r\n            checkIn: hotelQuery.startDate,\r\n            checkOut: hotelQuery.endDate,\r\n            hotelAddress: {\r\n              streetName: hotelAaddress.addressLine1,\r\n              town: hotelAaddress.addressLine2,\r\n              county: hotelAaddress.addressLine3,\r\n              postcode: hotelAaddress.postOrZipCode,\r\n              countryCode: hotelAaddress.countryCode\r\n            },\r\n            hotelDescription: hotel.group,\r\n            hotelName: hotel.name,\r\n            numberOfRooms: hotelQuery.rooms,\r\n            rateDescription,\r\n            roomDescription,\r\n            roomId,\r\n            roomType\r\n          },\r\n          price: hotelRoom.total,\r\n          currency: hotelRoom.currencyCode as CurrencyCode,\r\n          searchQuery,\r\n          outboundDate: hotelQuery.startDate\r\n        },\r\n        intBasket,\r\n        this.searchService,\r\n        this.travellers\r\n      );\r\n    }\r\n\r\n    return Promise.resolve(false);\r\n  }\r\n}\r\n"]}