@sabstravtech/obtservices 0.0.0 → 0.0.2

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

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