@sabstravtech/obtservices 0.0.0

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

@@ -0,0 +1,1370 @@
+import moment from 'moment';
+import { BaseEnterpriseSearch } from './base-enterprise';
+import { BaseStorageService } from '../services/storage.service';
+import { BaseHelperRoutines } from './helpers';
+import { BehaviorSubject, from, of, Observable, Subject } from 'rxjs';
+import { map, take } from 'rxjs/operators';
+import { BaseEnvironment } from './enviroment';
+import { BaseHotelAvalibilityService } from '../services/hotel-avallibility.service';
+import { URLS } from './../services/url.service';
+import {
+  Country,
+  HotelQuoteResult,
+  HotelQuoteResultArray,
+  LocationTypes,
+  NgbDateStruct,
+  LocationDetails,
+  HotelAvalibilityQuoteResult,
+  includedExpression,
+  excludedExpression,
+  SearchHandler,
+  RecentSearch,
+  AirportSearchResults
+} from '../types/types';
+import {
+  BasketItem,
+  ConfermaOfficeNames,
+  CurrencyCode,
+  DistanceTypes,
+  HotelLocation,
+  HotelRoom,
+  HotelTag,
+  RailStation,
+  SaveRecentSearchMutationVariables,
+  SearchFlightsV2QueryVariables,
+  SearchHotelsQueryVariables,
+  ServiceType
+} from '../types/graphql.types';
+import {
+  BaseHotelQuoteFetcher,
+  HotelQuoteFetcherType
+} from '../fetchers/hotel-quote-fetcher';
+import {
+  FullUserDetails,
+  UserServiceInterface
+} from '../interfaces/Iuser.service';
+import { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';
+import { AbstractHttpCallService } from '../services/http-call.service';
+
+import { HotelAvalinilityFetcherType } from '../fetchers/hotel-avaliability-fetcher';
+import {
+  EnterpriseBasketServiceInterface,
+  InternalBasketInterface
+} from '../interfaces/Ienterprise-basket.service';
+import {
+  AvailabilityObject,
+  DisplayFilterSettings,
+  HotelDetails,
+  HotelDetailsArray,
+  HotelEnterpriseSearchInterface,
+  HotelFilters,
+  HotelTempParams,
+  HotelView,
+  ResultDetails
+} from '../interfaces/Ihotel-enterprise-search';
+import { ICheapestPrice } from '../interfaces/cheapest-price';
+import { Traveller } from '../models/traveller.object';
+import { BaseSearchConfermaQuicklistFetcher, ConfermaQuicklistFetcherType } from '../fetchers/conferma-quicklist.fetcher';
+import { BaseGetRailStationFetcher, GetRailStationFetcherType } from '../fetchers/get-rail-station.fetcher';
+
+export enum SortTypesHotel {
+  distance = 'distance',
+  name = 'name',
+  price = 'price'
+}
+
+const CLIENT_PREFERRED_VALUE = 1;
+const AGENT_PREFERRED_VALUE = 2;
+
+export class HotelEnterpriseSearch<
+  HQ_Q extends HotelQuoteFetcherType,
+  HA_Q extends HotelAvalinilityFetcherType,
+  QL_Q extends ConfermaQuicklistFetcherType,
+  GRS_Q extends GetRailStationFetcherType
+  >
+  extends BaseEnterpriseSearch<
+  HotelTempParams,
+  HotelQuoteResultArray,
+  HotelDetailsArray
+  >
+  implements HotelEnterpriseSearchInterface {
+  static readonly MAX_HOTEL_ROOMS = 4;
+  static readonly STORAGE_SESSION_PARAMS = 'search_hotel';
+  static readonly STORAGE_SESSION_RESULTS = 'results_hotel';
+
+  public type: ServiceType = ServiceType.Hotel;
+  private travellers: Traveller[];
+  public location_types: BehaviorSubject<LocationTypes[]> = new BehaviorSubject<
+    LocationTypes[]
+  >([]);
+  public offices: BehaviorSubject<LocationTypes[]> = new BehaviorSubject<
+    LocationTypes[]
+  >([]);
+  public lastActivePage: BehaviorSubject<number> = new BehaviorSubject(null);
+
+  readonly galleries: { [key: string]: string[] } = {};
+  private occupied: number = 0;
+  private results_details: ResultDetails = {
+    chains: new Set<string>(),
+    amenities: [],
+    maxDistance: 0
+  };
+  private _checkin_date_ngb: NgbDateStruct;
+  private _checkout_date_ngb: NgbDateStruct;
+
+  get chains(): string[] {
+    return [...this.results_details.chains];
+  }
+
+  get amenities(): string[] {
+    return [...this.results_details.amenities];
+  }
+
+  get maxDistance(): number {
+    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(): number {
+    return Math.ceil(this.filters.priceRange.max);
+  }
+
+  get currency(): string {
+    return this.tempParams.currency;
+  }
+
+  set currency(value: string) {
+    this.tempParams.currency = value;
+  }
+  // Event Emitters
+  public filterChange: Subject<any> = new Subject();
+  public selectItemMapView: Subject<any> = new Subject();
+
+  public display: DisplayFilterSettings = {
+    minprice: Number.NEGATIVE_INFINITY,
+    maxprice: Number.POSITIVE_INFINITY,
+    filters: {
+      breakfastType: []
+    }
+  };
+
+  // public variables
+  public min_date = {
+    year: moment().year(),
+    month: moment().month() + 1, // ngbDate months are not 0 indexed
+    day: moment().date()
+  };
+
+  public min_return_date = {
+    year: moment().year(),
+    month: moment().month() + 1, // ngbDate months are not 0 indexed
+    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?
+
+  private localFilters = new HotelFilters();
+
+  public currentView: HotelView = HotelView.LIST;
+
+  // For NgForing over in the templates
+  private _max_no_of_rooms = 4;
+  private _max_rooms_array = new Array(this._max_no_of_rooms).fill(0);
+  private _max_no_of_occupants = 2;
+  private _max_occupant_array = new Array(this._max_no_of_occupants).fill(0);
+  private _distance_list = [1, 2, 5, 10, 20, 25]; // copied from old frontend for now
+  private _default_currency: any = null;
+
+  // getters and setters
+
+  get checkin_date_ngb(): NgbDateStruct {
+    return this._checkin_date_ngb;
+  }
+
+  set checkin_date_ngb(value: NgbDateStruct) {
+    this._checkin_date_ngb = value;
+
+    this.tempParams.checkin_date = this.helpers.ngDateToMoment(value);
+    this.checkin_date = this.helpers.ngDateToMoment(value);
+  }
+
+  get checkout_date_ngb(): NgbDateStruct {
+    return this._checkout_date_ngb;
+  }
+
+  set checkout_date_ngb(value: NgbDateStruct) {
+    this._checkout_date_ngb = value;
+    this.tempParams.checkout_date = this.helpers.ngDateToMoment(value);
+    this._isValid();
+  }
+
+  get checkin_date(): moment.Moment {
+    return this.tempParams.checkin_date;
+  }
+
+  set checkin_date(newDate: moment.Moment) {
+    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(): moment.Moment {
+    return this.tempParams.checkout_date;
+  }
+
+  set checkout_date(newDate: moment.Moment) {
+    // 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(): number {
+    return this.tempParams.no_of_rooms;
+  }
+
+  set no_of_rooms(newRooms: number) {
+    if (newRooms > 4 || newRooms < 1) {
+      return;
+    }
+
+    this.tempParams.no_of_rooms = newRooms;
+    this._isValid();
+  }
+
+  get no_of_occupants(): number {
+    return this.tempParams.no_of_occupants;
+  }
+
+  set no_of_occupants(newOcc: number) {
+    if (newOcc < 1 || newOcc > 3) {
+      return;
+    }
+
+    this.tempParams.no_of_occupants = newOcc;
+    this._isValid();
+  }
+
+  get default_currency(): string {
+    return this.tempParams.currency;
+  }
+
+  set default_currency(currency: string) {
+    this.tempParams.currency = currency;
+  }
+
+  // may have to modify these
+  get location(): any {
+    return this.tempParams.location;
+  }
+
+  set location(newLoc: any) {
+    this.tempParams.location = newLoc;
+
+    this._isValid();
+  }
+
+  get formatted_location(): string {
+    return this.tempParams.location
+      ? this.tempParams.location.destination
+      : 'No Location Set'; // TODO -  expand this for different types
+  }
+
+  get distance(): number {
+    return this.tempParams.distance;
+  }
+
+  set distance(newDist: number) {
+    this.tempParams.distance = newDist;
+    this._isValid();
+  }
+
+  get prefered_hotels_only(): boolean {
+    return this.tempParams.prefered_hotels_only;
+  }
+
+  set prefered_hotels_only(newPref: boolean) {
+    this.tempParams.prefered_hotels_only = newPref;
+    this._isValid();
+  }
+
+  get country(): Country {
+    return this.tempParams.country;
+  }
+
+  set country(newCont: Country) {
+    this.tempParams.country = newCont;
+    this._isValid();
+  }
+
+  get postcode(): LocationDetails {
+    return this.tempParams.postcode;
+  }
+
+  set postcode(postcode: LocationDetails) {
+    this.tempParams.postcode = postcode;
+    this._isValid();
+  }
+
+  get trainsStation(): LocationDetails {
+    return this.tempParams.trainsStation;
+  }
+
+  set trainsStation(station: LocationDetails) {
+    this.tempParams.trainsStation = station;
+    this._isValid();
+  }
+
+  get office(): ConfermaOfficeNames {
+    return this.tempParams.office;
+  }
+
+  set office(office: ConfermaOfficeNames) {
+    this.tempParams.office = office;
+    this._isValid();
+  }
+
+  // Additional Variables
+  get hotel_name(): string {
+    return this.tempParams.hotel_name;
+  }
+
+  set hotel_name(newName: string) {
+    this.tempParams.hotel_name = newName;
+    this._isValid();
+  }
+
+  get hotel_chain(): any {
+    return this.tempParams.hotel_chain;
+  }
+
+  set hotel_chain(newChain: any) {
+    this.tempParams.hotel_chain = newChain;
+    this._isValid();
+  }
+
+  // Getters Only
+
+  get max_rooms_array(): number[] {
+    return this._max_rooms_array;
+  }
+
+  get max_occupant_array(): number[] {
+    return this._max_occupant_array;
+  }
+
+  get distance_list(): number[] {
+    return this._distance_list;
+  }
+
+  get location_type_select(): LocationTypes {
+    return this.tempParams.location_type_select;
+  }
+
+  set location_type_select(value: LocationTypes) {
+    this.tempParams.location_type_select = value;
+    this._isValid();
+  }
+
+  get filters(): HotelFilters {
+    return this.localFilters;
+  }
+
+  constructor(
+    private hotelFetcher: BaseHotelQuoteFetcher<HQ_Q>,
+    private helpers: BaseHelperRoutines,
+    private userService: UserServiceInterface,
+    private environment: BaseEnvironment,
+    private avaliabilityService: BaseHotelAvalibilityService<HA_Q>,
+    private basketService: EnterpriseBasketServiceInterface,
+    storageService: BaseStorageService,
+    private searchService: EnterpriseSearchServiceInterface,
+    private httpCallService: AbstractHttpCallService,
+    private quickListFetcher: BaseSearchConfermaQuicklistFetcher<QL_Q>,
+    private getRailStationFetcher: BaseGetRailStationFetcher<GRS_Q>
+  ) {
+    super(storageService, (resultsToMap: HotelQuoteResultArray) => {
+      this.results_details.maxDistance = 0;
+      this.results_details.chains = new Set<string>();
+      return resultsToMap.map(
+        (hotelResult: HotelQuoteResult, index: number): HotelDetails => {
+          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 {
+            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' }
+            },
+            // avilability: this.hotel_availability,
+            ...hotelResult
+          };
+        }
+      );
+    });
+    this.results_details.chains = new Set<string>();
+    const data: {
+      tempParams: HotelTempParams;
+    } = storageService.getSessionItem(
+      HotelEnterpriseSearch.STORAGE_SESSION_PARAMS
+    ) || {
+        tempParams: {} as HotelTempParams
+      };
+
+    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: Traveller[]) => {
+          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<HotelDetailsArray>(
+        this.resultsSessionName
+      ) || [];
+    results
+      .slice(0, this.environment.numberHotelToPreload)
+      .forEach((hotel: HotelDetails) => {
+        this.avaliabilityService.getAvailabilityForId(
+          this.makeHotelAvalilityObject(hotel)
+        );
+      });
+
+    results.forEach((hotelResult: HotelDetails) => {
+      this.results_details.chains.add(hotelResult.group);
+    });
+    this.fullResults = results;
+    this.results.next(results);
+    this._isValid();
+
+    this.userService.changeUser.subscribe((user: Partial<FullUserDetails>) => {
+      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: boolean) => {
+      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);
+      }
+    });
+  }
+
+  protected resultsSessionName = HotelEnterpriseSearch.STORAGE_SESSION_RESULTS;
+
+  private query: SearchHotelsQueryVariables = {} as SearchHotelsQueryVariables;
+
+  makeLocations(location: HotelLocation[]): { [key: string]: HotelLocation[] } {
+    return this.helpers.arrayToObjectArray<HotelLocation>(
+      location,
+      'distanceType'
+    );
+  }
+
+  sortTags(tags: HotelTag[]): any[] {
+    if (tags) {
+      return [...tags]
+        .sort((a: HotelTag, b: HotelTag) => {
+          if (a.name < b.name) {
+            return -1;
+          } else if (a.name > b.name) {
+            return 1;
+          } else {
+            return 0;
+          }
+        })
+        .map((tag: HotelTag) => {
+          return {
+            ...tag,
+            icon: this.environment.tagMap[tag.name] || tag.icon
+          };
+        });
+    }
+    return [];
+  }
+
+  protected resetQuery(): void {
+    this.updateTempParams(this.searchService.makeHotelQuery());
+    this.localFilters = new HotelFilters();
+    this.results_details = {
+      chains: new Set<string>(),
+      amenities: [],
+      maxDistance: 0
+    };
+    this._isValid();
+  }
+
+  private _isValid() {
+    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 (!this.tempParams.location?.office) {
+          this.validationMessages.push('Please select an office.');
+        }
+        break;
+
+      case LocationTypes.Airport:
+        if (this.tempParams?.location) {
+          if (!this.tempParams.location.airport?.gateway) {
+            this.validationMessages.push('Please select a airport.');
+          }
+          break;
+        } else {
+          this.validationMessages.push('Please select a airport.');
+        }
+
+        break;
+        
+      case LocationTypes.TrainStation:
+        if (this.tempParams?.location) {
+          if (!this.tempParams.location.railstation?.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(): Promise<boolean> {
+    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: SearchHotelsQueryVariables): SaveRecentSearchMutationVariables {
+    if (this.location?.name) {
+      query.cityName = this.location.name;
+    }
+    return {
+      serviceType: ServiceType.Hotel,
+      searchArgs: query,
+      travelDate: this.checkin_date.format(),
+      travellers: this.helpers.getTravellersId(this.travellers)
+    };
+  }
+
+  public startRecentSearch(recentSearch: RecentSearch): void {
+    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: AirportSearchResults) => {
+        let airport = {
+          airport: {
+            gateway: iata.iataMatch.iata
+          }
+        }
+        this.location = { ...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: ConfermaOfficeNames[]) => { 
+        if (offices) {
+          let office: ConfermaOfficeNames = offices.find((office: ConfermaOfficeNames) => 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: RailStation) => {
+        this.trainsStation = trainsStation as LocationDetails
+        this.searchService.startSearches();
+      });
+    } else {
+      this.location_type_select = LocationTypes.Shortlist;
+      this.country = {
+        cCode: recentSearch.searchArgs.countryCode,
+        cName: '' 
+      }
+      this.searchService.startSearches();
+    }
+  }
+
+  private getRailStationByCode(code: string): Observable<RailStation> {
+    if (code) {
+      return this.getRailStationFetcher.fetchList({ id: null, code: code }).pipe(
+        take(1)
+      );
+    } else {
+      return of();
+    }
+  }
+
+  getSearchQuery(): SearchHotelsQueryVariables {
+    this.buildQuery();
+    return this.helpers.removeNulls<SearchHotelsQueryVariables>(this.query);
+  }
+
+  buildQuery(): void {
+    const query: SearchHotelsQueryVariables = {
+      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 = +this.location.office?.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 = this.tempParams.hotel_chain?.name;
+    }
+
+    this.query = query;
+  }
+
+  makeHotelAvalilityObject(hotel: HotelQuoteResult): AvailabilityObject {
+    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'
+    };
+  }
+
+  public filterResults = () => {
+    this.results.next(
+      this.fullResults.filter((hotel: HotelDetails) => {
+        return (
+          this.inPriceRange(hotel) &&
+          this.inDistanceRange(hotel) &&
+          this.containsHotelname(hotel) &&
+          this.hasChain(hotel) &&
+          this.breakfastTypeFilter(hotel)
+        );
+      })
+    );
+  };
+
+  // Lightening Filters
+  public filterLighteningResults = () => {
+    this.results.next(
+      this.fullResults.filter((hotel: HotelDetails) => {
+        return (
+          this.inLighteningPriceRange(hotel) &&
+          this.containsHotelname(hotel) &&
+          this.hasChain(hotel) &&
+          this.hasPreferred(hotel) &&
+          this.breakfastTypeFilter(hotel) &&
+          this.getExtraFilter(hotel) &&
+          this.getAmenitiesFilter(hotel)
+        );
+      })
+    );
+  };
+
+  private inPriceRange(hotel: HotelDetails): boolean {
+    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;
+  }
+
+  private inDistanceRange(hotel: HotelDetails): boolean {
+    return (
+      this.filters.distanceRange.max === 0 ||
+      this.helpers.inRange(hotel.location.distance, this.filters.distanceRange)
+    );
+  }
+
+  private containsHotelname(hotel: HotelDetails): boolean {
+    const tocheck = this.filters.hotelName.toLowerCase();
+
+    return tocheck && tocheck.length > 0
+      ? hotel.name.toLowerCase().includes(tocheck)
+      : true;
+  }
+
+  private inLighteningPriceRange(hotel: HotelDetails): boolean {
+    const availability = this.avaliabilityService.getAvailabilityValue(hotel);
+    if (availability && Object.keys(availability).length !== 0) {
+      let maxRange: boolean = false;
+      let findMax: number = 0;
+      let minRange = this.helpers.inRange(
+        availability.prpn,
+        this.filters.priceRange
+      );
+      if (availability?.maxprice) {
+        findMax = availability.maxprice;
+      } else {
+        findMax = availability?.rooms.reduce(
+          (op, item) => (op = op > item.total ? op : item.total),
+          0
+        );
+      }
+      maxRange = this.helpers.inRange(findMax, this.filters.priceRange);
+      let result: boolean = minRange && maxRange;
+      return result;
+    }
+    return true;
+  }
+
+  private hasChain(hotel: HotelDetails): boolean {
+    const tocheck = (this.filters.chain || []).map((chain: string): string => {
+      return chain.toLowerCase();
+    });
+    return tocheck && tocheck.length
+      ? !!tocheck.find((chain: string) => {
+        return hotel.group.toLowerCase().includes(chain);
+      })
+      : true;
+  }
+
+  private breakfastTypeFilter(hotel: HotelDetails): boolean {
+    if(!this.filters.breakfastType.length) return true;
+    const hotelObject = this.avaliabilityService.getAvailabilityForId(this.makeHotelAvalilityObject(hotel));
+    if(!hotelObject && !hotelObject.value) return false;
+    const hotelObjectValue: HotelAvalibilityQuoteResult = 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: any) => {
+        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): void {
+    // store all results
+    const hotels: HotelDetailsArray = this.fullResults;
+
+    // get hotels with and without prices
+    const hotelsWithPrices: HotelDetailsArray = [];
+    const hotelsWithoutPrices: HotelDetailsArray = [];
+    hotels.map((hotelResult) => {
+      this.avaliabilityService.getAvailabilityValue(hotelResult)?.prpn
+        ? hotelsWithPrices.push(hotelResult)
+        : hotelsWithoutPrices.push(hotelResult);
+    });
+
+    // sort hotels with prices according to the 'min' parameter for the order
+    hotelsWithPrices.sort((first: HotelDetails, second: HotelDetails) => {
+      const firstPrice =
+        this.avaliabilityService.getAvailabilityValue(first)?.prpn;
+      const secondPrice =
+        this.avaliabilityService.getAvailabilityValue(second)?.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(): void {
+    this.results.next(
+      this.results.value.sort(
+        (fst: HotelDetails, snd: HotelDetails): number => {
+          return fst.name.toLowerCase().localeCompare(snd.name.toLowerCase());
+        }
+      )
+    );
+  }
+
+  sortByDistance(): void {
+    let results = this.results.value || [];
+    results = results.sort((a, b) => {
+      return Number(a.location.distance) - Number(b.location.distance);
+    });
+    this.results.next(results);
+  }
+
+  byPreferred(): void {
+    let results = this.results.value || [];
+    results = results.sort((a: HotelDetails, b: HotelDetails) => {
+      return this.preferredToInt(b) - this.preferredToInt(a);
+    });
+    this.results.next(results);
+  }
+
+  private preferredToInt(hotel: HotelDetails): number {
+    return (
+      (hotel.preferred.client ? CLIENT_PREFERRED_VALUE : 0) +
+      (hotel.preferred.consumer ? AGENT_PREFERRED_VALUE : 0)
+    );
+  }
+
+  private intToPreferred(preferred: 0 | 1 | 2 | 3) {
+    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: string, type: keyof HotelFilters): void {
+    const filt: any = this.localFilters;
+    filt[type].push(filter);
+  }
+
+  removeFilter(filter: string, type: keyof HotelFilters): void {
+    const filt = this.localFilters;
+    if (Array.isArray(filt[type])) {
+      (filt[type] as string[]) = (filt[type] as string[]).filter(
+        (chain: string) => {
+          return filter !== chain;
+        }
+      );
+    }
+  }
+
+  resetFilters(): void {
+    this.localFilters.chain = [];
+    this.localFilters.amenitytype = [];
+    this.localFilters.preferred = [];
+    this.localFilters.extra = [];
+    this.localFilters.hotelName = '';
+    this.localFilters.breakfastType = [];
+  }
+
+  updateFromPreviousSearches(
+    previousItems: Record<ServiceType, BasketItem>
+  ): void {
+    const flightItem: SearchFlightsV2QueryVariables =
+      previousItems[ServiceType.Flight]?.searchQuery;
+    if (flightItem) {
+      // TODO flights haven't been done yet.
+    }
+  }
+
+  private hasPreferred(hotel: HotelDetails): boolean {
+    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;
+    }
+  }
+
+  public getmaxPriceForCurrency(currency: string): any {
+    return this.avaliabilityService.maxPriceForCurrency(currency);
+  }
+
+  // Lightening Extra Filters
+  private getExtraFilter(hotel: HotelDetails): boolean {
+    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: string = this.convertToOneString(tag.name).toLowerCase();
+            return name.includes(
+              this.convertToOneString(
+                SearchHandler.FEMALE_FRIENDLY
+              ).toLowerCase()
+            );
+          } else {
+            return true;
+          }
+        }).length > 0
+      );
+    }
+    return true;
+  }
+
+  // Lightening Amernities Filters
+  private getAmenitiesFilter(hotel: HotelDetails): boolean {
+    let isTrue: boolean = true;
+    this.filters.amenitytype.forEach((search) => {
+      let filteredResults: any = hotel.tags.filter((tag) => {
+        if (tag.name) {
+          let name: string = 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;
+  }
+
+  private convertToOneString(item: string) {
+    return item.replace(/[^a-zA-Z]/g, '');
+  }
+
+  getImages(HolidayCode: string): Observable<string[]> {
+    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 as URLS, { 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: number): any {
+    const key = 'PaginationPageCount';
+    this.storageService.setSessionItem(key, currentPage);
+    return this.storageService.getSessionItem(key);
+  }
+
+  toggleView(): void {
+    if (this.currentView === HotelView.LIST) {
+      this.currentView = HotelView.MAP;
+    } else {
+      this.currentView = HotelView.LIST;
+    }
+  }
+
+  calcDayDiff(): number {
+    const checkout = moment(this.checkout_date);
+    const checkin = moment(this.checkin_date);
+    return checkout.startOf().diff(checkin.startOf(), 'days');
+  }
+  updateLowestPrice(results: HotelDetails[]): ICheapestPrice {
+    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: any[] = [];
+    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: number[] = [];
+    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: number, travellers: number): number{
+    console.log('No of Travellers: ' + travellers + '| No of rooms: ' + no_of_rooms + ' | Assigned: ' + this.occupied);
+    let roomOccupancy: number = 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;
+  }
+
+  async addHotelRoomToBasket(
+    hotel: HotelQuoteResult,
+    hotelRoom: HotelRoom,
+    hotelQuery: SearchHotelsQueryVariables,
+    travellers?: Traveller[]
+  ): Promise<boolean> {
+    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 = { ...hotelQuery };
+    delete searchQuery.adults;
+
+    const intBasket: InternalBasketInterface =
+      await this.basketService.getDefaultBasket();
+    const basket = 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 as CurrencyCode,
+          searchQuery,
+          outboundDate: hotelQuery.startDate
+        },
+        intBasket,
+        this.searchService,
+        this.travellers
+      );
+    }
+
+    return Promise.resolve(false);
+  }
+}