@sabstravtech/obtservices 0.0.0 → 0.0.1

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

@@ -1,251 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,245 +0,0 @@
-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

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