@sabstravtech/obtservices 0.0.0 → 0.0.1

package/dist/obtservices/esm2015/base/lib/vendor/services/hotel-avallibility.service.js

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

package/dist/obtservices/esm2015/base/lib/vendor/services/http-call.service.js

@@ -0,0 +1,16 @@
+export class AbstractHttpCallService {
+    /*
+     * 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
+     */
+    serialize(obj) {
+        return Object.keys(obj).reduce((toReturn, key) => {
+            return ((toReturn.length ? toReturn + '&' : '') +
+                key +
+                '=' +
+                encodeURIComponent(typeof obj[key] === 'object' ? JSON.stringify(obj[key]) : obj[key]));
+        }, '');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/obtservices/esm2015/base/lib/vendor/services/logon.service.js

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

package/dist/obtservices/esm2015/base/lib/vendor/services/modal-opener.service.js

@@ -0,0 +1,20 @@
+import { Subject } from 'rxjs';
+export class BaseModalOpenerService {
+    constructor() {
+        this.openModalEvent = new Subject();
+    }
+    open(type, options = null, data = null) {
+        return new Promise((resolve, reject) => {
+            this.openModalEvent.next({
+                type,
+                data: data || {},
+                options: options || {},
+                results: resolve
+            });
+        });
+    }
+    subscribe(next) {
+        return this.openModalEvent.subscribe(next);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/obtservices/esm2015/base/lib/vendor/services/my-bookings.service.js

@@ -0,0 +1,124 @@
+import { BehaviorSubject, of } from 'rxjs';
+import { map, take } from 'rxjs/operators';
+import { BasketStatus, ServiceType } from '../types/graphql.types';
+export class BaseEnterpriseMyBookingsService {
+    constructor(getUserBasketsFetcher, searchUserCanBookFor) {
+        this.getUserBasketsFetcher = getUserBasketsFetcher;
+        this.searchUserCanBookFor = searchUserCanBookFor;
+        this.baskets = new BehaviorSubject([]);
+        this._basketStatusIconClasses = {
+            [BasketStatus.Approved]: 'ico-tick',
+            [BasketStatus.AwaitingApproval]: 'ico-clock',
+            [BasketStatus.BookingFailed]: 'ico-deny',
+            [BasketStatus.Disapproved]: 'ico-deny',
+            [BasketStatus.Open]: 'ico-calendar',
+            [BasketStatus.PartiallyBooked]: 'ico-deny',
+            [BasketStatus.Booked]: 'ico-deny'
+        };
+        this._serviceTypeIconClasses = {
+            [ServiceType.Cab]: 'ico-m-taxi',
+            [ServiceType.Car]: 'ico-car',
+            [ServiceType.Coach]: 'ico-bus',
+            [ServiceType.Flight]: 'ico-flight',
+            [ServiceType.Hotel]: 'ico-bed',
+            [ServiceType.FastTrack]: '',
+            [ServiceType.InternationalRail]: 'ico-rail',
+            [ServiceType.Lounge]: 'ico-material ico-lounge',
+            [ServiceType.Parking]: 'ico-material ico-parking',
+            [ServiceType.Rail]: 'ico-rail',
+            [ServiceType.Eurostar]: 'ico-rail'
+        };
+    }
+    getUserBaskets(query, isLoading) {
+        isLoading.next(true);
+        this.getUserBasketsFetcher
+            .fetchList(query)
+            .pipe(take(1))
+            .subscribe((baskets) => {
+            this.baskets.next(baskets);
+            isLoading.next(false);
+        }, (error) => {
+            console.error(error);
+            isLoading.next(false);
+        });
+    }
+    getSearchUserCanBookFor(search, isLoading) {
+        if (search.length > 2) {
+            isLoading.next(true);
+            return this.searchUserCanBookFor
+                .fetchList({
+                email: search
+            })
+                .pipe(take(1), map((results) => {
+                isLoading.next(false);
+                return results;
+            }));
+        }
+        return of([]);
+    }
+    getServiceTypeFilters(searchService) {
+        const serviceTypeFilters = [];
+        for (const [key] of Object.entries(searchService.search_objects)) {
+            serviceTypeFilters.push(key);
+        }
+        return serviceTypeFilters;
+    }
+    getBasketStatusFilters() {
+        const basketStatusFilters = [];
+        Object.values(BasketStatus).forEach((basketStatus) => basketStatusFilters.push(basketStatus));
+        return basketStatusFilters;
+    }
+    getServiceTypeFilterVanityName(serviceType) {
+        switch (serviceType) {
+            case ServiceType.Cab:
+                return 'Taxi';
+            case ServiceType.InternationalRail:
+                return 'European Rail';
+            default:
+                return serviceType;
+        }
+    }
+    getBasketStatusIconClass(status) {
+        return this._basketStatusIconClasses[status] || 'ico-exclamation';
+    }
+    getServiceTypeIconClass(basketItem) {
+        return (this._serviceTypeIconClasses[basketItem.service.type] || 'ico-exclamation');
+    }
+    getTotalPriceForBasketItems(basketItems) {
+        return basketItems.reduce((total, basketItem) => {
+            return total + basketItem.price;
+        }, 0);
+    }
+    getTravellerNamesFromBasketItems(basketItems) {
+        let travellerNames = [];
+        basketItems.map((basketItem) => basketItem.users.map((user) => travellerNames.push(`${user.forename} ${user.surname}`)));
+        travellerNames = [...new Set(travellerNames)]; // remove any duplicate traveller names
+        return travellerNames;
+    }
+    allBasketItemsMatchStatus(basketItems, basketItemStatus) {
+        return basketItems.every((basketItem) => basketItem.status === basketItemStatus);
+    }
+    getHotelAddress(hotelAddress) {
+        const { county, postcode, streetName, town } = hotelAddress;
+        const hotelAddressArr = [];
+        if (streetName)
+            hotelAddressArr.push(streetName);
+        if (town)
+            hotelAddressArr.push(town);
+        if (county)
+            hotelAddressArr.push(county);
+        if (postcode)
+            hotelAddressArr.push(postcode);
+        return hotelAddressArr.join(', ');
+    }
+    getHotelLocation(hotelAddress) {
+        const { county, town } = hotelAddress;
+        const hotelAddressArr = [];
+        if (town)
+            hotelAddressArr.push(town);
+        if (county)
+            hotelAddressArr.push(county);
+        return hotelAddressArr.join(', ');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"my-bookings.service.js","sourceRoot":"","sources":["../../../../../../../projects/obtservices/base/src/lib/vendor/services/my-bookings.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { BehaviorSubject, Observable, of } from 'rxjs';\r\nimport { map, take } from 'rxjs/operators';\r\nimport { EnterpriseMyBookingsServiceInterface } from '../interfaces/Imybookings.service';\r\nimport {\r\n  BaseSearchUsersCanBookForFetcher,\r\n  SearchUserCanBookForFetcherType\r\n} from '../fetchers/search-users-can-book-for-fetcher';\r\nimport {\r\n  BaseGetUserBasketsFetcher,\r\n  GetUserBasketsFetcherType\r\n} from '../fetchers/get-users-baskets-fetcher';\r\nimport { UserBasketResult } from '../types/types';\r\nimport {\r\n  BasketItem,\r\n  BasketItemStatus,\r\n  BasketStatus,\r\n  QueryGetUserBasketsArgs,\r\n  ServiceType,\r\n  User\r\n} from '../types/graphql.types';\r\nimport { EnterpriseSearchServiceInterface } from '../interfaces/Isearch.service';\r\n\r\nexport class BaseEnterpriseMyBookingsService<\r\n  GUB_Q extends GetUserBasketsFetcherType,\r\n  SUCBF_Q extends SearchUserCanBookForFetcherType\r\n> implements EnterpriseMyBookingsServiceInterface\r\n{\r\n  public baskets: BehaviorSubject<UserBasketResult[]> = new BehaviorSubject<\r\n    UserBasketResult[]\r\n  >([]);\r\n\r\n  private _basketStatusIconClasses: Record<BasketStatus, string> = {\r\n    [BasketStatus.Approved]: 'ico-tick',\r\n    [BasketStatus.AwaitingApproval]: 'ico-clock',\r\n    [BasketStatus.BookingFailed]: 'ico-deny',\r\n    [BasketStatus.Disapproved]: 'ico-deny',\r\n    [BasketStatus.Open]: 'ico-calendar',\r\n    [BasketStatus.PartiallyBooked]: 'ico-deny',\r\n    [BasketStatus.Booked]: 'ico-deny'\r\n  };\r\n\r\n  private _serviceTypeIconClasses: Record<ServiceType, string> = {\r\n    [ServiceType.Cab]: 'ico-m-taxi',\r\n    [ServiceType.Car]: 'ico-car',\r\n    [ServiceType.Coach]: 'ico-bus',\r\n    [ServiceType.Flight]: 'ico-flight',\r\n    [ServiceType.Hotel]: 'ico-bed',\r\n    [ServiceType.FastTrack]: '',\r\n    [ServiceType.InternationalRail]: 'ico-rail',\r\n    [ServiceType.Lounge]: 'ico-material ico-lounge',\r\n    [ServiceType.Parking]: 'ico-material ico-parking',\r\n    [ServiceType.Rail]: 'ico-rail',\r\n    [ServiceType.Eurostar]: 'ico-rail'\r\n  };\r\n\r\n  constructor(\r\n    private getUserBasketsFetcher: BaseGetUserBasketsFetcher<GUB_Q>,\r\n    private searchUserCanBookFor: BaseSearchUsersCanBookForFetcher<SUCBF_Q>\r\n  ) {}\r\n\r\n  getUserBaskets(\r\n    query: QueryGetUserBasketsArgs,\r\n    isLoading: BehaviorSubject<boolean>\r\n  ): void {\r\n    isLoading.next(true);\r\n    this.getUserBasketsFetcher\r\n      .fetchList(query)\r\n      .pipe(take(1))\r\n      .subscribe(\r\n        (baskets: UserBasketResult[]) => {\r\n          this.baskets.next(baskets);\r\n          isLoading.next(false);\r\n        },\r\n        (error: any) => {\r\n          console.error(error);\r\n          isLoading.next(false);\r\n        }\r\n      );\r\n  }\r\n\r\n  getSearchUserCanBookFor(\r\n    search: string,\r\n    isLoading: BehaviorSubject<boolean>\r\n  ): Observable<User[]> {\r\n    if (search.length > 2) {\r\n      isLoading.next(true);\r\n      return this.searchUserCanBookFor\r\n        .fetchList({\r\n          email: search\r\n        })\r\n        .pipe(\r\n          take(1),\r\n          map((results: User[]) => {\r\n            isLoading.next(false);\r\n            return results;\r\n          })\r\n        );\r\n    }\r\n    return of([]);\r\n  }\r\n\r\n  getServiceTypeFilters(\r\n    searchService: EnterpriseSearchServiceInterface\r\n  ): string[] {\r\n    const serviceTypeFilters: string[] = [];\r\n    for (const [key] of Object.entries(searchService.search_objects)) {\r\n      serviceTypeFilters.push(key);\r\n    }\r\n    return serviceTypeFilters;\r\n  }\r\n\r\n  getBasketStatusFilters(): string[] {\r\n    const basketStatusFilters: string[] = [];\r\n    Object.values(BasketStatus).forEach((basketStatus) =>\r\n      basketStatusFilters.push(basketStatus)\r\n    );\r\n    return basketStatusFilters;\r\n  }\r\n\r\n  getServiceTypeFilterVanityName(serviceType: ServiceType): string {\r\n    switch (serviceType) {\r\n      case ServiceType.Cab:\r\n        return 'Taxi';\r\n      case ServiceType.InternationalRail:\r\n        return 'European Rail';\r\n      default:\r\n        return serviceType;\r\n    }\r\n  }\r\n\r\n  getBasketStatusIconClass(status: BasketStatus): string {\r\n    return this._basketStatusIconClasses[status] || 'ico-exclamation';\r\n  }\r\n\r\n  getServiceTypeIconClass(basketItem: BasketItem): string {\r\n    return (\r\n      this._serviceTypeIconClasses[basketItem.service.type] || 'ico-exclamation'\r\n    );\r\n  }\r\n\r\n  getTotalPriceForBasketItems(basketItems: BasketItem[]): number {\r\n    return basketItems.reduce((total, basketItem) => {\r\n      return total + basketItem.price;\r\n    }, 0);\r\n  }\r\n\r\n  getTravellerNamesFromBasketItems(basketItems: BasketItem[]): string[] {\r\n    let travellerNames: string[] = [];\r\n    basketItems.map((basketItem) =>\r\n      basketItem.users.map((user) =>\r\n        travellerNames.push(`${user.forename} ${user.surname}`)\r\n      )\r\n    );\r\n    travellerNames = [...new Set(travellerNames)]; // remove any duplicate traveller names\r\n    return travellerNames;\r\n  }\r\n\r\n  allBasketItemsMatchStatus(\r\n    basketItems: BasketItem[],\r\n    basketItemStatus: BasketItemStatus\r\n  ): boolean {\r\n    return basketItems.every(\r\n      (basketItem) => basketItem.status === basketItemStatus\r\n    );\r\n  }\r\n\r\n  getHotelAddress(hotelAddress: { [key: string]: string }): string {\r\n    const { county, postcode, streetName, town } = hotelAddress;\r\n    const hotelAddressArr = [];\r\n    if (streetName) hotelAddressArr.push(streetName);\r\n    if (town) hotelAddressArr.push(town);\r\n    if (county) hotelAddressArr.push(county);\r\n    if (postcode) hotelAddressArr.push(postcode);\r\n    return hotelAddressArr.join(', ');\r\n  }\r\n\r\n  getHotelLocation(hotelAddress: { [key: string]: string }): string {\r\n    const { county, town } = hotelAddress;\r\n    const hotelAddressArr = [];\r\n    if (town) hotelAddressArr.push(town);\r\n    if (county) hotelAddressArr.push(county);\r\n    return hotelAddressArr.join(', ');\r\n  }\r\n}\r\n"]}