@sabstravtech/obtservices 0.0.0

package/projects/obtservices/base/src/lib/vendor/services/hotel-avallibility.service.ts

@@ -0,0 +1,251 @@
+import { BehaviorSubject } from 'rxjs';
+import { take } from 'rxjs/operators';
+import { BaseEnvironment } from '../classes/enviroment';
+import { BaseHelperRoutines } from '../classes/helpers';
+import {
+  BaseHotelAvalibilityQuoteFetcher,
+  HotelAvalinilityFetcherType
+} from '../fetchers/hotel-avaliability-fetcher';
+import { HotelDetails } from '../interfaces/Ihotel-enterprise-search';
+import { QueryGetMultipleHotelsAvailabilityArgs } from '../types/graphql.types';
+import {
+  CurrencyDetails,
+  HotelAvalibilityQuery,
+  HotelAvalibilityQuoteResult,
+  HotelAvalibilityQuoteResultArray,
+  HotelRoomWithLocalPrice
+} from '../types/types';
+
+import { BaseStorageService } from './storage.service';
+
+type StoredData = { [key: string]: HotelAvalibilityQuoteResult };
+
+const SESSION_NAME = 'results_hotel_avallibility';
+
+export class BaseHotelAvalibilityService<
+  Q extends HotelAvalinilityFetcherType
+> {
+  private data: StoredData = null;
+  private behaviours: {
+    [key: string]: BehaviorSubject<HotelAvalibilityQuoteResult>;
+  } = {};
+  private timeout: number;
+  private toFetch: HotelAvalibilityQuery[] = [];
+  public fetching: BehaviorSubject<boolean> = new BehaviorSubject<boolean>(
+    false
+  );
+  currencies: CurrencyDetails = {};
+  constructor(
+    private avalibilityFethcer: BaseHotelAvalibilityQuoteFetcher<Q>,
+    private sessionStorage: BaseStorageService,
+    private helpers: BaseHelperRoutines,
+    private environment: BaseEnvironment
+  ) {}
+
+  private readFromSession() {
+    const data =
+      this.sessionStorage.getSessionItem<StoredData>(SESSION_NAME) || {};
+    Object.values(data).forEach((item: HotelAvalibilityQuoteResult) => {
+      this.behaviours[item.hotelId] =
+        new BehaviorSubject<HotelAvalibilityQuoteResult>(item);
+    });
+    return data;
+  }
+
+  reset() {
+    this.data = {};
+    this.currencies = {};
+    this.sessionStorage.removeSessionItem(SESSION_NAME);
+    Object.values(this.data).forEach((item: HotelAvalibilityQuoteResult) => {
+      this.behaviours[item.hotelId].complete();
+      delete this.behaviours[item.hotelId];
+    });
+    this.behaviours = {};
+  }
+
+  getAvailabilityForId(
+    hotel: HotelAvalibilityQuery
+  ): BehaviorSubject<HotelAvalibilityQuoteResult> {
+    this.data = this.data || this.readFromSession();
+    return (
+      this.behaviours[hotel.hotel as string] ||
+      this._getAvailabilityForId(hotel)
+    );
+  }
+
+  getAvailabilityValue(hotel: HotelDetails): HotelAvalibilityQuoteResult {
+    this.data = this.data || this.readFromSession();
+    return (
+      this.behaviours[hotel.id as string]?.value ||
+      ({} as HotelAvalibilityQuoteResult)
+    );
+  }
+
+  private _getAvailabilityForId(
+    hotel: HotelAvalibilityQuery
+  ): BehaviorSubject<HotelAvalibilityQuoteResult> {
+    if (this.timeout) {
+      window.clearTimeout(this.timeout);
+      this.timeout = 0;
+    }
+
+    if (!this.fetching.value) {
+      this.timeout = window.setTimeout(
+        this.fetchAvalilbility.bind(this),
+        this.environment.autoFetchHotelTimeout
+      );
+    }
+    this.toFetch.push(hotel);
+    if (
+      !this.fetching.value &&
+      this.toFetch.length >= this.environment.numberOfHotelsToFetch
+    ) {
+      this.fetchAvalilbility();
+    }
+    this.behaviours[hotel.hotel as string] =
+      new BehaviorSubject<HotelAvalibilityQuoteResult>(null);
+    return this.behaviours[hotel.hotel as string];
+  }
+
+  private fetchAvalilbility() {
+    this.fetching.next(true);
+    if (this.timeout) {
+      window.clearTimeout(this.timeout);
+      this.timeout = 0;
+    }
+    const toFetch = this.toFetch.slice(
+      0,
+      this.environment.numberOfHotelsToFetch
+    );
+    this.toFetch = this.toFetch.slice(this.environment.numberOfHotelsToFetch);
+
+    console.log('Hotels still to fetch', this.toFetch.length);
+
+    const query: QueryGetMultipleHotelsAvailabilityArgs = {
+      hotel: toFetch.map((hotel) => hotel.hotel) as string[],
+      currency: toFetch[0].currency,
+      endDate: toFetch[0].endDate,
+      startDate: toFetch[0].startDate,
+      occupants: toFetch[0].occupants,
+      rooms: toFetch[0].rooms
+    };
+
+    this.avalibilityFethcer
+      .fetchList(query)
+      .pipe(take(1))
+      .subscribe((hotels: HotelAvalibilityQuoteResultArray) => {
+        hotels.forEach((hotel: HotelAvalibilityQuoteResult) => {
+          hotel = this.helpers.clone(hotel);
+          hotel.rooms = (hotel.rooms || [])
+            .filter((room: HotelRoomWithLocalPrice) => {
+              return room.total > 0;
+            })
+            .map((room: HotelRoomWithLocalPrice) => {
+              room = this.helpers.clone<HotelRoomWithLocalPrice>(room);
+              room.LocalPrice = room.currencyConversion
+                ? room.currencyConversion.localTotal
+                : room.total;
+              room.LocalCurrency = room.currencyConversion
+                ? room.currencyConversion.localCode
+                : room.currencyCode;
+              return room;
+            });
+          hotel.currencies = hotel.rooms.reduce(
+            (details: CurrencyDetails, room: HotelRoomWithLocalPrice) => {
+              if (room.currencyConversion) {
+                details[room.currencyConversion.convertedCode] = details[
+                  room.currencyConversion.convertedCode
+                ] || {
+                  maxprice: Number.MIN_VALUE,
+                  minprice: Number.MAX_VALUE
+                };
+                details[room.currencyConversion.convertedCode].maxprice =
+                  Math.max(
+                    details[room.currencyConversion.convertedCode].maxprice,
+                    room.currencyConversion.convertedTotal
+                  );
+                details[room.currencyConversion.convertedCode].minprice =
+                  Math.min(
+                    details[room.currencyConversion.convertedCode].minprice,
+                    room.currencyConversion.convertedTotal
+                  );
+
+                this.currencies[room.currencyConversion.convertedCode] = this
+                  .currencies[room.currencyConversion.convertedCode] || {
+                  maxprice: Number.MIN_VALUE,
+                  minprice: Number.MAX_VALUE
+                };
+                this.currencies[
+                  room.currencyConversion.convertedCode
+                ].minprice = Math.ceil(
+                  Math.min(
+                    this.currencies[room.currencyConversion.convertedCode]
+                      .minprice,
+                    room.currencyConversion.convertedTotal
+                  )
+                );
+                this.currencies[
+                  room.currencyConversion.convertedCode
+                ].maxprice = Math.ceil(
+                  Math.max(
+                    this.currencies[room.currencyConversion.convertedCode]
+                      .maxprice,
+                    room.currencyConversion.convertedTotal
+                  )
+                );
+              }
+              return details;
+            },
+            {} as CurrencyDetails
+          );
+          const roomPrices = hotel.rooms.map(
+            this.helpers.mapFieldFromObject<string, number>('total')
+          );
+          if (!roomPrices.length) roomPrices.push(0);
+          hotel.minprice = Math.min(...roomPrices);
+          hotel.maxprice = Math.max(...roomPrices);
+
+          hotel.rooms = hotel.rooms;
+          if (hotel?.hotelId) {
+            this.data[hotel.hotelId] = hotel;
+            this.behaviours[hotel.hotelId].next(hotel);
+          }
+        });
+
+        // this.sessionStorage.setSessionItem(SESSION_NAME, this.data);
+        this.sessionStorage.setSessionItem(SESSION_NAME, hotels);
+        if (this.toFetch.length > 0) {
+          setTimeout(() => {
+            this.fetchAvalilbility();
+          }, this.environment.hotelAvalibilityTimeout);
+        } else {
+          this.fetching.next(false);
+        }
+      });
+  }
+
+  maxPriceForCurrency(currency: string) {
+    return (
+      this.currencies[currency] || {
+        maxprice: Number.MAX_VALUE,
+        minprice: Number.MIN_VALUE
+      }
+    ).maxprice;
+  }
+
+  /**
+   * @description - return the number of hotels that have a price (prpn value)
+   */
+  numberOfHotelsWithPrice(): number {
+    let count = 0;
+    if (this.data) {
+      for (const [key, value] of Object.entries(this.data)) {
+        if (value?.prpn) {
+          count++;
+        }
+      }
+    }
+    return count;
+  }
+
+}

package/projects/obtservices/base/src/lib/vendor/services/http-call.service.ts

@@ -0,0 +1,57 @@
+import { Observable } from 'rxjs';
+import { URLS } from './url.service';
+
+export abstract class AbstractHttpCallService {
+  abstract formEncodedPost(url: URLS, body?: any, responseType?: 'json' | 'text'): Observable<any>;
+
+  abstract timeoutFormEncodedPost(
+    url: URLS,
+    body?: any,
+    reTimeout?: number
+  ): Observable<any>;
+
+  abstract formEncodedPostNoErrorHandling(
+    url: URLS,
+    body?: any
+  ): Observable<any>;
+
+  /*
+		@desc - call a url through post, with a Json Object as data (angular default)
+	**/
+  abstract post(url: URLS, data?: any): Observable<any>;
+  /*
+		@desc - call a Angular standard get request (application/json headers)
+	**/
+  abstract get(url: URLS, params?: any): Observable<any>;
+
+  /*
+		@desc - this will determine if there is a login error for the request or not, since this is a potential error for every call
+	**/
+  abstract handleResponse(data: any): any;
+  abstract resetLogout(): void;
+  /*
+		@desc - handle any fatal errors 404's 500's other generic http errors
+	**/
+  abstract handleError(errorVal: any, skipTimeoutMessage?: boolean): any;
+
+  /*
+   * Using the keys of the given object as parameter names create a parameter string url encoding the values.
+   * The function expects the values to be strings.
+   * @param obj
+   */
+  public serialize(obj: { [key: string]: string }): string {
+    return Object.keys(obj).reduce((toReturn: string, key: string) => {
+      return (
+        (toReturn.length ? toReturn + '&' : '') +
+        key +
+        '=' +
+        encodeURIComponent(
+          typeof obj[key] === 'object' ? JSON.stringify(obj[key]) : obj[key]
+        )
+      );
+    }, '');
+  }
+
+  abstract getHeaders(): any;
+  abstract makeUrl(url: URLS): string;
+}

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

@@ -0,0 +1,245 @@
+import { USER_SIGNEDOUT } from './user.service';
+import { map, take } from 'rxjs/operators';
+import { BaseModalOpenerService } from './modal-opener.service';
+import { BaseStorageService } from './storage.service';
+
+import { URLS } from './url.service';
+import { UserFavorurite } from '../classes/user-favourite.enum';
+import { Observable, of } from 'rxjs';
+import { BaseEventMessenager } from '../classes/event-messenager';
+import { BaseEnvironment } from '../classes/enviroment';
+import { ModalTypes } from '../classes/modal-types.enum';
+import { UserData } from '../interfaces/user.data';
+import {
+  AuthInfo,
+  LoginResponse,
+  PasswordChangeResponse
+} from '../models/login.model';
+import { UserServiceInterface } from '../interfaces/Iuser.service';
+import { AbstractHttpCallService } from './http-call.service';
+import { Router } from '../types/types';
+
+export class BaseLogonService {
+  loading = false;
+  isLoggedIn = false;
+  redirectUrl = '';
+  authInfo: AuthInfo;
+  loginResponse: LoginResponse;
+  timeoutSubscription: number;
+  refreshPromise: Promise<boolean> = null;
+
+  constructor(
+    private userService: UserServiceInterface,
+    private modalService: BaseModalOpenerService,
+    private http: AbstractHttpCallService,
+    private router: Router,
+    private eventMessenager: BaseEventMessenager,
+    private storageService: BaseStorageService,
+    private environment: BaseEnvironment
+  ) {}
+
+  checkLogin(): Promise<boolean> {
+    return this.refreshToken();
+  }
+
+  refreshToken(): Promise<boolean> {
+    this.refreshPromise =
+      this.refreshPromise ||
+      new Promise(
+        (resolve: (value: boolean) => void, reject: (error: any) => void) => {
+          this.clearRefresh();
+          this.http
+            .formEncodedPostNoErrorHandling(URLS.Refresh, {})
+            .pipe(
+              take(1),
+              map((data) => {
+                return this.handleResponse(data);
+              })
+            )
+            .subscribe(
+              (data) => {
+                if (typeof data === 'string') {
+                  resolve(false);
+                  if (this.router.url !== 'login') {
+                    const logoutDialog = this.modalService
+                      .open(
+                        ModalTypes.BaseModalComponent,
+                        {},
+                        {
+                          title: 'Auto Logout',
+                          body: '',
+                          isLoading: false,
+                          options: {
+                            buttonCancel: false,
+                            buttonOk: true,
+                            buttonOkText: 'Continue'
+                          }
+                        }
+                      )
+                      .then(() => {
+                        this.logout();
+                        resolve(false);
+                      });
+                  }
+                } else {
+                  resolve(true);
+                  this.setRefresh();
+                }
+              },
+              (error) => {
+                resolve(false);
+              }
+            );
+        }
+      )
+        .then((data: any) => {
+          this.refreshPromise = null;
+          return data;
+        })
+        .catch((error: any) => {
+          this.refreshPromise = null;
+          throw error;
+        });
+
+    return this.refreshPromise;
+  }
+
+  private clearRefresh() {
+    if (this.timeoutSubscription) {
+      clearTimeout(this.timeoutSubscription);
+      this.timeoutSubscription = null;
+    }
+  }
+
+  private setRefresh() {
+    this.timeoutSubscription = window.setTimeout(
+      this.refreshToken.bind(this),
+      this.environment.authRefreshTimeout * 1000
+    );
+  }
+
+  login(
+    username: string,
+    password: string,
+    again?: boolean
+  ): Observable<UserData> {
+    this.userService.emptyUserData();
+
+    this.storageService.clearSessionData();
+    this.clearRefresh();
+    return this.http
+      .formEncodedPostNoErrorHandling(URLS.AccessToken, {
+        username,
+        password
+      })
+      .pipe(
+        take(1),
+        map((value: any, index: number) => {
+          this.setRefresh();
+          return this.handleResponse(value);
+        })
+      );
+  }
+
+  /*
+		@desc - this will determine if there is a login error for the request or not, since this is a potential error for every call
+	**/
+  handleResponse(data: any): any {
+    if (typeof data === 'object' && data.jwt) {
+      this.userService.setUser(data.jwtObject);
+      delete data.jwt;
+      delete data.jwtObject;
+    }
+    return data;
+  }
+
+  cookieLogin(username: string): Observable<UserData> {
+    // const sso = sessionStorage.getItem('sso_query');
+    /*
+    this.userService.emptyUserData();
+    this.userService.setUserAgent(username);
+    sessionStorage.setItem('sso_query', sso);
+    this.authInfo = new AuthInfo(username, '', false);*/
+    // return this.http.get(URLS.NUMBER_ONCE_TOKEN_URL);
+    return of(null);
+  }
+
+  logout() {
+    const isSSO = this.userService.isUserFavoriteSet(
+      UserFavorurite.SSO_no_password
+    );
+    this.clearRefresh();
+    this.isLoggedIn = false;
+    this.userService.emptyUserData();
+
+    this.storageService.clearSessionData();
+    this.http.post(URLS.LOGOUT_URL).subscribe(
+      (data) => {
+        if (!data.LogoutSuccess) {
+          // tslint:disable-next-line: quotemark
+          console.warn("You're not logged in, cannot log out.");
+        }
+      },
+      () => {
+        this.eventMessenager.emit(USER_SIGNEDOUT, {});
+
+        if (
+          this.userService.isUserFavoriteSet(UserFavorurite.SSO_no_password)
+        ) {
+          this.router.navigate(['logOutDigitsUser']);
+        } else {
+          this.router.navigate(['logon']);
+        }
+      }
+    );
+  }
+
+  changePassword(authInfo: AuthInfo): Observable<PasswordChangeResponse> {
+    // return this.http
+    //   .formEncodedPost(URLS.CHANGE_PASSWORD, authInfo.getChangePassTokenStr())
+    //   .pipe(
+    //     map((res: PasswordChangeResponse) => {
+    //       if (res.success) {
+    //         return res;
+    //       } else {
+    //         throw new LoginError(LoginErrorReason.PASSWORD_CHANGE, res);
+    //       }
+    //     })
+    //   );
+    return of(null);
+  }
+
+  resetPassword(passwordResetToken: string, newPassword: string): Observable<PasswordChangeResponse> {
+    return this.http.formEncodedPost(
+      URLS.RESET_PASSWORD,
+      {
+        passwordResetToken,
+        newPassword
+      }
+    );
+  }
+
+  /*
+		@desc - actaually call the backend perl for recover pass
+	**/
+  recoverPassword(username: string): Observable<any> {
+    return this.http.formEncodedPost(
+      URLS.RECOVER_PASSWORD_URL,
+      {
+        username:`${username}`,
+      },
+      'text'
+    )
+  }
+
+  /*
+   *	@desc - error handling, opens a modal with the passed in error message
+   **/
+  handleError(error: string) {
+    // this.userService.becomingUser = false;
+    const modalValues = {
+      error
+    };
+    this.modalService.open(ModalTypes.ModalErrorComponent, {}, modalValues);
+  }
+}

package/projects/obtservices/base/src/lib/vendor/services/modal-opener.service.ts

@@ -0,0 +1,30 @@
+import { Subject } from 'rxjs';
+import { ModalTypes } from '../classes/modal-types.enum';
+
+export interface ModalEvent {
+  type: ModalTypes;
+  data: any;
+  options: object;
+  results: (data: any) => void;
+}
+
+export class BaseModalOpenerService {
+  private openModalEvent = new Subject<ModalEvent>();
+
+  constructor() {}
+
+  open(type: ModalTypes, options: any = null, data: any = null): Promise<any> {
+    return new Promise((resolve, reject) => {
+      this.openModalEvent.next({
+        type,
+        data: data || {},
+        options: options || {},
+        results: resolve
+      });
+    });
+  }
+
+  subscribe(next: (data: any) => void) {
+    return this.openModalEvent.subscribe(next);
+  }
+}