@sabstravtech/obtservices 0.0.0

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

@@ -0,0 +1,15 @@
+export abstract class BaseStorageService {
+  abstract getSessionItem<T>(key: string): T;
+
+  abstract getSessionItemAsList<T extends Array<any>>(key: string): T;
+
+  abstract getLocalItem<T>(key: string): T;
+
+  abstract setSessionItem(key: string, data: {}): void;
+
+  abstract setLocalItem(key: string, data: {}): void;
+
+  abstract removeSessionItem(key: string): void;
+
+  abstract clearSessionData(): void;
+}

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

@@ -0,0 +1,12 @@
+import { BaseEnvironment } from '../classes/enviroment';
+
+export enum URLS {
+  AccessToken = 'accessToken',
+  LOGOUT_URL = 'logout',
+  Refresh = 'refreshToken',
+  CONFERMA_THUMBNAIL_URL = 'https://ssl.conferma.com/Images/PropertyThumbnails/',
+  CONFIRMA_PHOTO_URL = '/confermainfo/Info.aspx?mode=media&key=MICROSSABS&id=',
+  CONFIRMA_INFO_URL = '/confermainfo/Info.aspx?mode=hotel&key=MICROSSABS&id=',
+  RECOVER_PASSWORD_URL = 'password/getResetToken',
+  RESET_PASSWORD = 'password/resetByToken'
+}

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

@@ -0,0 +1,354 @@
+import { BehaviorSubject, Observable } from 'rxjs';
+import { BaseHelperRoutines } from '../classes/helpers';
+
+import { Suppliers, UserFavorurite } from '../classes/user-favourite.enum';
+import {
+  BaseUserMessagesFetcher,
+  UserMessageFetcherType
+} from '../fetchers/user-message.fetcher';
+import {
+  BaseUserProductsFetcher,
+  UserProductsFetcherType
+} from '../fetchers/user-products-fetcher';
+import {
+  BaseUserUiConfigsFetcher,
+  UserUiConfigsFetcherType
+} from '../fetchers/user-ui-configs-fetcher';
+import {
+  FullUserDetails,
+  UserServiceInterface,
+  UserServices
+} from '../interfaces/Iuser.service';
+import { UserData } from '../interfaces/user.data';
+import { Traveller, TravellerObject } from '../models/traveller.object';
+import {
+  BookerType,
+  Message,
+  Service,
+  ServiceType
+} from '../types/graphql.types';
+import { ServiceProvider, Unpacked, UserUiConfigsResult } from '../types/types';
+import { BaseStorageService } from './storage.service';
+export const USER_SIGNEDOUT = 'USER_SIGNEDOUT';
+export const USER_SIGNEDIN = 'USER_SIGNEDIN';
+
+export class BaseUserService<
+  UC_Q extends UserUiConfigsFetcherType,
+  US_Q extends UserProductsFetcherType,
+  UM_Q extends UserMessageFetcherType
+> implements UserServiceInterface
+{
+  public fullUserDetails: FullUserDetails = {
+    bookingAllowedFor: '',
+    messages: new BehaviorSubject<Message[]>(null),
+    travllerObject: new BehaviorSubject<Traveller>(null),
+    userConfigs: new BehaviorSubject<{
+      [key: string]: Unpacked<UserUiConfigsResult>;
+    }>(null),
+    userData: new BehaviorSubject<UserData>(null),
+    userServices: new BehaviorSubject<UserServices>(null)
+  };
+  changeUser: BehaviorSubject<FullUserDetails> =
+    new BehaviorSubject<FullUserDetails>(null);
+
+  constructor(
+    private userUiConfigsFetcher: BaseUserUiConfigsFetcher<UC_Q>,
+    private userProductsFetcher: BaseUserProductsFetcher<US_Q>,
+    private userMessagesFetcher: BaseUserMessagesFetcher<UM_Q>,
+    private storageService: BaseStorageService,
+    private helpers: BaseHelperRoutines
+  ) {}
+
+  setUser(user_data: UserData): void {
+    const userdata = this.fullUserDetails.userData.value;
+    if (!userdata || userdata.username !== user_data.username) {
+      this.userUiConfigsFetcher.fetchKeyedObject('key').subscribe(
+        (result1: { [key: string]: Unpacked<UserUiConfigsResult> }) => {
+          this.fullUserDetails.userConfigs.next(result1);
+          this.checkEmitUser();
+        },
+        (error) => {
+          console.error(error);
+        }
+      );
+      this.userProductsFetcher
+        .fetchKeyedObjectArray('type')
+        .subscribe((result2: UserServices) => {
+          this.fullUserDetails.userServices.next(result2);
+
+          this.checkEmitUser();
+        });
+      this.userMessagesFetcher.fetchList().subscribe(
+        (result3: Message[]) => {
+          this.fullUserDetails.messages.next(result3);
+          this.checkEmitUser();
+        },
+        (error) => {
+          console.error(error);
+        }
+      );
+
+      this.fullUserDetails.travllerObject.next(
+        TravellerObject.makeTravellerObjectFromUser(user_data)
+      );
+    }
+
+    this.fullUserDetails.userData.next(user_data);
+
+    this.storageService.setSessionItem('lightning_user_data', user_data);
+  }
+
+  checkEmitUser() {
+    if (
+      !!this.fullUserDetails.userConfigs.value &&
+      !!this.fullUserDetails.userData.value &&
+      !!this.fullUserDetails.userServices.value &&
+      !!this.fullUserDetails.messages.value
+    ) {
+      this.changeUser.next(this.fullUserDetails);
+    }
+  }
+
+  getfullUserDetails(admin: boolean = false): FullUserDetails | null {
+    if (admin) {
+      return this._getFullUserDetails();
+    }
+
+    return this._getFullUserDetails();
+    // return this.onBehalfUser || this._getUserDetails();
+  }
+
+  _getFullUserDetails(): FullUserDetails {
+    return (
+      this.fullUserDetails ||
+      this.storageService.getSessionItem('lightning_user_data')
+    );
+  }
+
+  getUserDropdownInfo(): {
+    name: string;
+    email: string;
+    account_type: BookerType | string;
+    title: string;
+  } {
+    const dropdown_info = {
+      name: 'Unable to retrieve name.',
+      email: 'Unable to rerieve email',
+      account_type: 'Unknown',
+      title: ''
+    };
+    const name = this.getUsersFullname();
+    const email = this.getUserEmail();
+    const type = this.getUserBookingType();
+    const title = this.getUserTitle();
+
+    if (name) {
+      dropdown_info.name = name;
+    }
+
+    if (email) {
+      dropdown_info.email = email;
+    }
+
+    if (type) {
+      dropdown_info.account_type = type;
+    }
+
+    if (title) {
+      dropdown_info.title = title;
+    }
+
+    return dropdown_info;
+  }
+
+  getUserTitle(): string {
+    const user: FullUserDetails = this.getfullUserDetails();
+    return user && user.userData ? user.userData.value.title : '';
+  }
+
+  getUserEmail(): string {
+    const user: FullUserDetails = this.getfullUserDetails();
+    return user && user.userData ? user.userData.value.username : '';
+  }
+
+  getUserBookingType(): BookerType {
+    const user: FullUserDetails = this.getfullUserDetails();
+    return user && user.userData ? user.userData.value.booker_type : null;
+  }
+
+  getUsersFullname(): string | false {
+    const user: FullUserDetails = this.getfullUserDetails();
+    return user && user.userData
+      ? user.userData.value.forename + ' ' + user.userData.value.surname
+      : false;
+  }
+
+  getUsersTitleAndFullName(): string | false {
+    const user: FullUserDetails = this.getfullUserDetails();
+    return user && user.userData
+      ? user.userData.value.title +
+          ' ' +
+          user.userData.value.forename +
+          ' ' +
+          user.userData.value.surname
+      : false;
+  }
+
+  getUserFavoriteValue(
+    uf: UserFavorurite,
+    supplier: Suppliers = Suppliers.non
+  ): string {
+    const ufValue: Record<string, any> = this.fullUserDetails.userConfigs.value;
+
+    return this.helpers.fromObject(ufValue, uf.value, 'config', uf.value);
+  }
+
+  getUserFavoriteNumber(
+    uf: UserFavorurite,
+    supplier: Suppliers = Suppliers.non
+  ): string {
+    const ufValue: Record<string, any> = this.fullUserDetails.userConfigs.value;
+
+    return this.helpers.fromObject(ufValue, uf.value, 'config', 'value');
+  }
+
+  isUserFavoriteSet(
+    uf: UserFavorurite,
+    supplier: Suppliers = Suppliers.non
+  ): boolean {
+    const ufValue: Record<string, any> = this.fullUserDetails.userConfigs.value;
+
+    return this.helpers.fromObject(ufValue, uf.value, 'config', 'value');
+  }
+
+  /**
+   * @desc - create a dummy user for self bookers
+   */
+  createSelfTraveller(): Traveller {
+    return this.fullUserDetails.travllerObject.value;
+  }
+
+  travellerIsUser(traveller: Traveller): boolean {
+    // TODO check the traveller isn't the current user or agent book
+    return false;
+  }
+
+  emptyUserData(): void {
+    this.fullUserDetails.userData.next(null);
+    this.fullUserDetails.userConfigs.next(null);
+    this.fullUserDetails.userServices.next(null);
+    this.fullUserDetails.messages.next(null);
+    this.changeUser.next(this.fullUserDetails);
+  }
+
+  createGuestUser(
+    title: string,
+    forename: string,
+    surname: string,
+    email: string,
+    guestMobileCountryNo: string,
+    guestMobileNumber: string,
+    guest_nationality: string,
+    gender: string,
+    isChild: boolean,
+    isInfant: boolean,
+    childDOB: Date
+  ): Traveller {
+    return {
+      isChild,
+      isInfant,
+      childDOB,
+      guest: true,
+      id: '',
+      forename,
+      surname,
+      email,
+      title,
+      name: [title, forename, surname].join(' ')
+    };
+  }
+
+  userIsClient(): boolean {
+    /* TODO
+    const user = this.getUserDetails();
+    return user && !this.isAgencyUser() && ['Traveller', 'Me', 'Others', 'Booker'].includes(user.BookingAllowedFor);
+    */
+    return true;
+  }
+
+  hasIgnorePolicy(): boolean {
+    /* TODO
+    const user = this.getUserDetails();
+    return user && user.BookingPolicyOverride && user.BookingPolicyOverride === '9999-01-01 00:00:00';*/
+    return false;
+  }
+  useAgentCanBookFor(): boolean {
+    return true; // TODO
+  }
+
+  canBook(service: ServiceType): boolean {
+    const services: UserServices = this.fullUserDetails.userServices.value;
+    return services && !!services[service];
+  }
+
+  isTraveller(): boolean {
+    return (
+      this.fullUserDetails.userData.value.booker_type === BookerType.Traveller
+    );
+  }
+
+  userIsAgent(): boolean {
+    return (
+      this.fullUserDetails.userData.value.booker_type === BookerType.Company
+    );
+  }
+
+  userIsAdmin(): boolean {
+    return this.fullUserDetails.userData.value.admin;
+  }
+
+  userIsCompanyAdmin(): boolean {
+    return this.fullUserDetails.userData.value.company_admin;
+  }
+
+  isSelfBook(): boolean {
+    return (
+      this.fullUserDetails.userData.value.booker_type === BookerType.SelfBook
+    );
+  }
+
+  isBooker(): boolean {
+    return (
+      this.fullUserDetails.userData.value.booker_type === BookerType.Booker
+    );
+  }
+
+  getUserId(): number {
+    return this.fullUserDetails.userData.value.user_id;
+  }
+
+  userHasServiceProvider(
+    service: ServiceType,
+    provider: ServiceProvider
+  ): boolean {
+    if (this.fullUserDetails.userServices.value) {
+      return !!(this.fullUserDetails.userServices.value[service] || []).find(
+        (value: Service) => {
+          return value.name === (provider as string);
+        }
+      );
+    } else {
+      return false;
+    }
+  }
+
+  findService(id: string): Service {
+    if (this.fullUserDetails.userServices.value) {
+      return this.helpers.findService(
+        this.fullUserDetails.userServices.value,
+        id
+      );
+    }
+    return null;
+  }
+}

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

@@ -0,0 +1,66 @@
+import moment from 'moment';
+import { BaseEnvironment } from '../classes/enviroment';
+import { ModalTypes } from '../classes/modal-types.enum';
+import { LogoutEnum } from '../types/types';
+import { BaseModalOpenerService } from './modal-opener.service';
+
+export abstract class BaseWebTokenService {
+  // tslint:disable-next-line: variable-name
+  protected _jwtToken: string = null;
+  protected timer: number = null;
+  protected timeoutDuration: number = 60 * 60;
+  protected lastUpdated: moment.Moment;
+  autoLogoutConfig = {};
+
+  /**
+   * @param value:  number // The time in minutes before hte user is auto logged out.
+   */
+  set timeOutDuration(value: number) {
+    this.timeoutDuration = value * 60 - 60;
+  }
+
+  set jwtToken(value: string) {
+    if (value !== this.jwtToken) {
+      this._jwtToken = value;
+    }
+  }
+
+  constructor(
+    private modalOpenerService: BaseModalOpenerService,
+    environment: BaseEnvironment
+  ) {
+    this.timeOutDuration = environment.autoLogoutTime;
+  }
+
+  protected _updateTimer() {
+    window.clearTimeout(this.timer);
+    this.timer = null;
+    console.log('Resetting auto log out');
+    this.timer = window.setTimeout(() => {
+      this.checkToLogout();
+    }, 60000);
+  }
+
+  protected checkToLogout() {
+    const a = moment().unix();
+    const b = this.lastUpdated.unix();
+    const c = this.timeoutDuration;
+    if (moment().unix() - this.lastUpdated.unix() > this.timeoutDuration) {
+      this.timer = null;
+      this.lastUpdated = moment();
+      this.modalOpenerService
+        .open(ModalTypes.AutoLogout, this.autoLogoutConfig, {})
+        .then((logout: LogoutEnum) => {
+          if (logout !== LogoutEnum.LOGOUT) {
+            this._updateTimer();
+          } else {
+            this._jwtToken = null;
+          }
+        });
+    } else {
+      this._updateTimer();
+    }
+  }
+
+  public abstract getHeaders(): object;
+}

package/projects/obtservices/base/src/lib/vendor/testers/base.tester.ts

@@ -0,0 +1,18 @@
+import { Observable } from 'rxjs';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { BaseNetworkCall } from '../classes/base-network-call';
+import { ApolloQueryResult } from '@apollo/client/core';
+
+export abstract class BaseTester<
+  Q extends { fetch: (a: A) => Observable<ApolloQueryResult<R>> },
+  A,
+  R
+> extends BaseNetworkCall<Q, A, R, boolean> {
+  constructor(private query: Q, modalService: BaseModalOpenerService) {
+    super(modalService);
+  }
+
+  public test(queryArgs: A): Observable<boolean> {
+    return this.processCall(this.query.fetch(queryArgs));
+  }
+}

package/projects/obtservices/base/src/lib/vendor/testers/postcode-validate.tester.ts

@@ -0,0 +1,24 @@
+import { ApolloQueryResult } from '@apollo/client/core';
+import { BaseTester } from './base.tester';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { Observable } from 'rxjs';
+import { IsPostcodeValidQueryVariables } from '../types/graphql.types';
+
+type A = IsPostcodeValidQueryVariables;
+type R = { isPostcodeValid: boolean };
+
+export type ValidateIsPostcodeValidType = {
+  fetch: (a: A) => Observable<ApolloQueryResult<R>>;
+};
+
+export class BaseValidateIsPostcodeValidTester<
+  Q extends ValidateIsPostcodeValidType
+> extends BaseTester<Q, A, R> {
+  constructor(isPostcodeValidGQL: Q, modalService: BaseModalOpenerService) {
+    super(isPostcodeValidGQL, modalService);
+  }
+
+  getDataFromResult(results: ApolloQueryResult<R>): boolean {
+    return results.data.isPostcodeValid;
+  }
+}

package/projects/obtservices/base/src/lib/vendor/testers/validate-mi-free-value.tester.ts

@@ -0,0 +1,23 @@
+import { ApolloQueryResult } from '@apollo/client/core';
+import { BaseTester } from './base.tester';
+import { BaseModalOpenerService } from '../services/modal-opener.service';
+import { Observable } from 'rxjs';
+import { ValidateUserMiFreeValueQueryVariables } from '../types/graphql.types';
+
+type A = ValidateUserMiFreeValueQueryVariables;
+type R = { validateUserMIFreeValue: boolean };
+
+export type ValidateMiFetcherType = {
+  fetch: (a: A) => Observable<ApolloQueryResult<R>>;
+};
+export class BaseValidateMiFreeValueTester<
+  Q extends ValidateMiFetcherType
+> extends BaseTester<Q, A, R> {
+  constructor(validateMiFreeValueGQL: Q, modalService: BaseModalOpenerService) {
+    super(validateMiFreeValueGQL, modalService);
+  }
+
+  getDataFromResult(results: ApolloQueryResult<R>): boolean {
+    return results.data.validateUserMIFreeValue;
+  }
+}