@sabstravtech/obtservices 0.0.0 → 0.0.2

package/dist/obtservices/esm2015/angular/lib/vendor/fetchers/user-ui-configs-fetcher.js

@@ -0,0 +1,25 @@
+import { Inject, Injectable } from '@angular/core';
+import { BaseUserUiConfigsFetcher } from 'obtservices/base';
+import { ModalOpenerService } from '../services/modal-opener.service';
+import { HelperRoutines } from '../classes/helpers';
+import { GetUserUiConfigsGQL } from '../types/graphql.angular.types';
+import * as i0 from "@angular/core";
+import * as i1 from "../types/graphql.angular.types";
+import * as i2 from "../classes/helpers";
+import * as i3 from "../services/modal-opener.service";
+export class UserUiConfigsFetcher extends BaseUserUiConfigsFetcher {
+    constructor(getUserUiConfigsGQL, helpers, modalService) {
+        super(getUserUiConfigsGQL, helpers, modalService);
+    }
+}
+/** @nocollapse */ UserUiConfigsFetcher.ɵprov = i0.ɵɵdefineInjectable({ factory: function UserUiConfigsFetcher_Factory() { return new UserUiConfigsFetcher(i0.ɵɵinject(i1.GetUserUiConfigsGQL), i0.ɵɵinject(i2.HelperRoutines), i0.ɵɵinject(i3.ModalOpenerService)); }, token: UserUiConfigsFetcher, providedIn: "root" });
+UserUiConfigsFetcher.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+UserUiConfigsFetcher.ctorParameters = () => [
+    { type: GetUserUiConfigsGQL, decorators: [{ type: Inject, args: [GetUserUiConfigsGQL,] }] },
+    { type: HelperRoutines, decorators: [{ type: Inject, args: [HelperRoutines,] }] },
+    { type: ModalOpenerService }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXNlci11aS1jb25maWdzLWZldGNoZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9vYnRzZXJ2aWNlcy9hbmd1bGFyL3NyYy9saWIvdmVuZG9yL2ZldGNoZXJzL3VzZXItdWktY29uZmlncy1mZXRjaGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxNQUFNLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQ25ELE9BQU8sRUFBRSx3QkFBd0IsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQzVELE9BQU8sRUFBRSxrQkFBa0IsRUFBRSxNQUFNLGtDQUFrQyxDQUFDO0FBQ3RFLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNwRCxPQUFPLEVBQUUsbUJBQW1CLEVBQUUsTUFBTSxnQ0FBZ0MsQ0FBQzs7Ozs7QUFHckUsTUFBTSxPQUFPLG9CQUFxQixTQUFRLHdCQUE2QztJQUNyRixZQUMrQixtQkFBd0MsRUFDN0MsT0FBdUIsRUFDL0MsWUFBZ0M7UUFFaEMsS0FBSyxDQUFDLG1CQUFtQixFQUFFLE9BQU8sRUFBRSxZQUFZLENBQUMsQ0FBQztJQUNwRCxDQUFDOzs7O1lBUkYsVUFBVSxTQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRTs7OztZQUZ6QixtQkFBbUIsdUJBS3ZCLE1BQU0sU0FBQyxtQkFBbUI7WUFOdEIsY0FBYyx1QkFPbEIsTUFBTSxTQUFDLGNBQWM7WUFSakIsa0JBQWtCIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0LCBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEJhc2VVc2VyVWlDb25maWdzRmV0Y2hlciB9IGZyb20gJ29idHNlcnZpY2VzL2Jhc2UnO1xyXG5pbXBvcnQgeyBNb2RhbE9wZW5lclNlcnZpY2UgfSBmcm9tICcuLi9zZXJ2aWNlcy9tb2RhbC1vcGVuZXIuc2VydmljZSc7XHJcbmltcG9ydCB7IEhlbHBlclJvdXRpbmVzIH0gZnJvbSAnLi4vY2xhc3Nlcy9oZWxwZXJzJztcclxuaW1wb3J0IHsgR2V0VXNlclVpQ29uZmlnc0dRTCB9IGZyb20gJy4uL3R5cGVzL2dyYXBocWwuYW5ndWxhci50eXBlcyc7XHJcblxyXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxyXG5leHBvcnQgY2xhc3MgVXNlclVpQ29uZmlnc0ZldGNoZXIgZXh0ZW5kcyBCYXNlVXNlclVpQ29uZmlnc0ZldGNoZXI8R2V0VXNlclVpQ29uZmlnc0dRTD4ge1xyXG4gIGNvbnN0cnVjdG9yKFxyXG4gICAgQEluamVjdChHZXRVc2VyVWlDb25maWdzR1FMKSBnZXRVc2VyVWlDb25maWdzR1FMOiBHZXRVc2VyVWlDb25maWdzR1FMLFxyXG4gICAgQEluamVjdChIZWxwZXJSb3V0aW5lcykgaGVscGVyczogSGVscGVyUm91dGluZXMsXHJcbiAgICBtb2RhbFNlcnZpY2U6IE1vZGFsT3BlbmVyU2VydmljZVxyXG4gICkge1xyXG4gICAgc3VwZXIoZ2V0VXNlclVpQ29uZmlnc0dRTCwgaGVscGVycywgbW9kYWxTZXJ2aWNlKTtcclxuICB9XHJcbn1cclxuIl19

package/dist/obtservices/esm2015/angular/lib/vendor/services/enterprise-basket.service.js

@@ -0,0 +1,91 @@
+import { Injectable } from '@angular/core';
+import * as moment_ from 'moment';
+import { GetUserBasketsFetcher } from '../fetchers/get-users-baskets-fetcher';
+import { AddItemToBasketUpdater } from '../updaters/add-item-to-basket.updater';
+import { RemoveItemFromBasketUpdater } from '../updaters/remove-item-from-basket.updater';
+import { UserService } from './user.service';
+import { CreateBasketUpdater } from '../updaters/create-basket-updater';
+import { SetBasketItemMiGroupUpdater } from '../updaters/set-basket-item-mi-group';
+import { AddUserToBasketItemUpdater } from '../updaters/addUserToBasketItem';
+import { DeleteBasketUpdater } from '../updaters/remove-basket-updater';
+import { AcceptNewPriceUpdater } from '../updaters/accept-new-price.updater';
+import { ValidateMiFreeValueTester } from '../testers/validate-mi-free-value.tester';
+import { GetBasketFetcher } from '../fetchers/basket-fetcher';
+import { RevalidateBasketUpdater } from '../updaters/revalidate-basket-updater';
+import { SetBasketItemMiValueUpdater } from '../updaters/set-basket-item-mi-value-updater';
+import { SendBasketForApprovalUpdater } from '../updaters/send-basket-for-approval.updater';
+import { GetMiAutoSugestionFetcher } from '../fetchers/getMiAutoSugestions.fetcher';
+import { GetUserFetcher } from '../fetchers/user-fetcher';
+import { BookBasketUpdater } from '../updaters/book-basket-updater';
+import { SetBasketItemLeadPassengerUpdater } from '../updaters/set-basket-item-lead-passenger.updater';
+import { BaseEnterpriseBasketService } from 'obtservices/base';
+import { HelperRoutines } from '../classes/helpers';
+import { ModalOpenerService } from './modal-opener.service';
+import { MoveBasketItemToBasketUpdater } from '../updaters/move-basket-item-to-basket';
+import { UpdateBasketTitleUpdater } from '../updaters/update-basket-title-updater';
+import { UpdateBasketNotesUpdater } from '../updaters/update-basket-notes-updater';
+import { SetPaymentOptionUpdater } from '../updaters/set-payment-option.updater';
+import * as i0 from "@angular/core";
+import * as i1 from "../updaters/accept-new-price.updater";
+import * as i2 from "../updaters/add-item-to-basket.updater";
+import * as i3 from "../updaters/addUserToBasketItem";
+import * as i4 from "../updaters/create-basket-updater";
+import * as i5 from "../fetchers/basket-fetcher";
+import * as i6 from "../updaters/book-basket-updater";
+import * as i7 from "../updaters/remove-basket-updater";
+import * as i8 from "../fetchers/getMiAutoSugestions.fetcher";
+import * as i9 from "../classes/helpers";
+import * as i10 from "../updaters/remove-item-from-basket.updater";
+import * as i11 from "../updaters/revalidate-basket-updater";
+import * as i12 from "../updaters/set-basket-item-mi-group";
+import * as i13 from "../updaters/set-basket-item-mi-value-updater";
+import * as i14 from "../testers/validate-mi-free-value.tester";
+import * as i15 from "../updaters/send-basket-for-approval.updater";
+import * as i16 from "../fetchers/user-fetcher";
+import * as i17 from "../fetchers/get-users-baskets-fetcher";
+import * as i18 from "../updaters/set-basket-item-lead-passenger.updater";
+import * as i19 from "../updaters/move-basket-item-to-basket";
+import * as i20 from "../updaters/update-basket-notes-updater";
+import * as i21 from "../updaters/update-basket-title-updater";
+import * as i22 from "./user.service";
+import * as i23 from "./modal-opener.service";
+import * as i24 from "../updaters/set-payment-option.updater";
+const moment = moment_;
+const TEMPID = 'TEMPID_';
+export class EnterpriseBasketService extends BaseEnterpriseBasketService {
+    constructor(acceptNewPriceUpdater, addItemToBasketUpdater, addUserToBasketItem, basketCreator, basketFetcher, bookBasketUpdater, deleteBasketUpdater, getMiAutoSugestionFetcher, helpers, removeItemFromBasketUpdater, revalidateBasketUpdater, setBasketItemMiGroupUpdater, setBasketItemMiValueUpdater, validateMiFreeValue, sendBasketForApprovalUpdater, getUserFetcher, getUserBasketsFetcher, setBasketItemLeadPassengerUpdater, moveItemToADifferentBasket, updateBasketNotes, updateBasketTitle, userService, modalService, setBasketItemPaymentOption) {
+        super(acceptNewPriceUpdater, addItemToBasketUpdater, addUserToBasketItem, basketCreator, basketFetcher, bookBasketUpdater, deleteBasketUpdater, getMiAutoSugestionFetcher, helpers, removeItemFromBasketUpdater, revalidateBasketUpdater, setBasketItemMiGroupUpdater, setBasketItemMiValueUpdater, validateMiFreeValue, sendBasketForApprovalUpdater, getUserFetcher, getUserBasketsFetcher, setBasketItemLeadPassengerUpdater, moveItemToADifferentBasket, updateBasketNotes, updateBasketTitle, setBasketItemPaymentOption, userService, modalService);
+    }
+}
+/** @nocollapse */ EnterpriseBasketService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EnterpriseBasketService_Factory() { return new EnterpriseBasketService(i0.ɵɵinject(i1.AcceptNewPriceUpdater), i0.ɵɵinject(i2.AddItemToBasketUpdater), i0.ɵɵinject(i3.AddUserToBasketItemUpdater), i0.ɵɵinject(i4.CreateBasketUpdater), i0.ɵɵinject(i5.GetBasketFetcher), i0.ɵɵinject(i6.BookBasketUpdater), i0.ɵɵinject(i7.DeleteBasketUpdater), i0.ɵɵinject(i8.GetMiAutoSugestionFetcher), i0.ɵɵinject(i9.HelperRoutines), i0.ɵɵinject(i10.RemoveItemFromBasketUpdater), i0.ɵɵinject(i11.RevalidateBasketUpdater), i0.ɵɵinject(i12.SetBasketItemMiGroupUpdater), i0.ɵɵinject(i13.SetBasketItemMiValueUpdater), i0.ɵɵinject(i14.ValidateMiFreeValueTester), i0.ɵɵinject(i15.SendBasketForApprovalUpdater), i0.ɵɵinject(i16.GetUserFetcher), i0.ɵɵinject(i17.GetUserBasketsFetcher), i0.ɵɵinject(i18.SetBasketItemLeadPassengerUpdater), i0.ɵɵinject(i19.MoveBasketItemToBasketUpdater), i0.ɵɵinject(i20.UpdateBasketNotesUpdater), i0.ɵɵinject(i21.UpdateBasketTitleUpdater), i0.ɵɵinject(i22.UserService), i0.ɵɵinject(i23.ModalOpenerService), i0.ɵɵinject(i24.SetPaymentOptionUpdater)); }, token: EnterpriseBasketService, providedIn: "root" });
+EnterpriseBasketService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+EnterpriseBasketService.ctorParameters = () => [
+    { type: AcceptNewPriceUpdater },
+    { type: AddItemToBasketUpdater },
+    { type: AddUserToBasketItemUpdater },
+    { type: CreateBasketUpdater },
+    { type: GetBasketFetcher },
+    { type: BookBasketUpdater },
+    { type: DeleteBasketUpdater },
+    { type: GetMiAutoSugestionFetcher },
+    { type: HelperRoutines },
+    { type: RemoveItemFromBasketUpdater },
+    { type: RevalidateBasketUpdater },
+    { type: SetBasketItemMiGroupUpdater },
+    { type: SetBasketItemMiValueUpdater },
+    { type: ValidateMiFreeValueTester },
+    { type: SendBasketForApprovalUpdater },
+    { type: GetUserFetcher },
+    { type: GetUserBasketsFetcher },
+    { type: SetBasketItemLeadPassengerUpdater },
+    { type: MoveBasketItemToBasketUpdater },
+    { type: UpdateBasketNotesUpdater },
+    { type: UpdateBasketTitleUpdater },
+    { type: UserService },
+    { type: ModalOpenerService },
+    { type: SetPaymentOptionUpdater }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"enterprise-basket.service.js","sourceRoot":"","sources":["../../../../../../../projects/obtservices/angular/src/lib/vendor/services/enterprise-basket.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport * as moment_ from 'moment';\r\nimport { GetUserBasketsFetcher } from '../fetchers/get-users-baskets-fetcher';\r\nimport { AddItemToBasketUpdater } from '../updaters/add-item-to-basket.updater';\r\nimport { RemoveItemFromBasketUpdater } from '../updaters/remove-item-from-basket.updater';\r\nimport { UserService } from './user.service';\r\nimport { CreateBasketUpdater } from '../updaters/create-basket-updater';\r\nimport { SetBasketItemMiGroupUpdater } from '../updaters/set-basket-item-mi-group';\r\nimport { AddUserToBasketItemUpdater } from '../updaters/addUserToBasketItem';\r\nimport { DeleteBasketUpdater } from '../updaters/remove-basket-updater';\r\nimport { AcceptNewPriceUpdater } from '../updaters/accept-new-price.updater';\r\nimport { ValidateMiFreeValueTester } from '../testers/validate-mi-free-value.tester';\r\nimport { GetBasketFetcher } from '../fetchers/basket-fetcher';\r\nimport { RevalidateBasketUpdater } from '../updaters/revalidate-basket-updater';\r\nimport { SetBasketItemMiValueUpdater } from '../updaters/set-basket-item-mi-value-updater';\r\nimport { SendBasketForApprovalUpdater } from '../updaters/send-basket-for-approval.updater';\r\nimport { GetMiAutoSugestionFetcher } from '../fetchers/getMiAutoSugestions.fetcher';\r\nimport { GetUserFetcher } from '../fetchers/user-fetcher';\r\nimport { BookBasketUpdater } from '../updaters/book-basket-updater';\r\nimport { SetBasketItemLeadPassengerUpdater } from '../updaters/set-basket-item-lead-passenger.updater';\r\n\r\nimport { BaseEnterpriseBasketService } from 'obtservices/base';\r\nimport { HelperRoutines } from '../classes/helpers';\r\nimport {\r\n  AcceptNewPriceGQL,\r\n  AddItemToBasketGQL,\r\n  AddUsersToBasketItemGQL,\r\n  BookBasketGQL,\r\n  CreateBasketGQL,\r\n  DeleteBasketGQL,\r\n  GetUserBasketGQL,\r\n  GetUserBasketsGQL,\r\n  GetUserGQL,\r\n  GetUserMiAutoSuggestValuesGQL,\r\n  MoveItemToADifferentBasketGQL,\r\n  RemoveItemFromBasketGQL,\r\n  RevalidateBasketGQL,\r\n  SendBasketForApprovalGQL,\r\n  SetBasketItemLeadPassengerGQL,\r\n  SetBasketItemMiGroupGQL,\r\n  SetBasketItemMiValueGQL,\r\n  SetBasketItemPaymentMethodGQL,\r\n  UpdateBasketNotesGQL,\r\n  UpdateBasketTitleGQL,\r\n  ValidateUserMiFreeValueGQL\r\n} from '../types/graphql.angular.types';\r\nimport { ModalOpenerService } from './modal-opener.service';\r\nimport { MoveBasketItemToBasketUpdater } from '../updaters/move-basket-item-to-basket';\r\nimport { UpdateBasketTitleUpdater } from '../updaters/update-basket-title-updater';\r\nimport { UpdateBasketNotesUpdater } from '../updaters/update-basket-notes-updater';\r\nimport { SetPaymentOptionUpdater } from '../updaters/set-payment-option.updater';\r\n\r\nconst moment = moment_;\r\nconst TEMPID = 'TEMPID_';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class EnterpriseBasketService extends BaseEnterpriseBasketService<\r\n  AcceptNewPriceGQL,\r\n  AddItemToBasketGQL,\r\n  AddUsersToBasketItemGQL,\r\n  CreateBasketGQL,\r\n  GetUserBasketGQL,\r\n  BookBasketGQL,\r\n  DeleteBasketGQL,\r\n  GetUserMiAutoSuggestValuesGQL,\r\n  RemoveItemFromBasketGQL,\r\n  RevalidateBasketGQL,\r\n  SetBasketItemMiGroupGQL,\r\n  SetBasketItemMiValueGQL,\r\n  ValidateUserMiFreeValueGQL,\r\n  SendBasketForApprovalGQL,\r\n  GetUserGQL,\r\n  GetUserBasketsGQL,\r\n  SetBasketItemLeadPassengerGQL,\r\n  MoveItemToADifferentBasketGQL,\r\n  UpdateBasketNotesGQL,\r\n  UpdateBasketTitleGQL,\r\n  SetBasketItemPaymentMethodGQL\r\n> {\r\n  constructor(\r\n    acceptNewPriceUpdater: AcceptNewPriceUpdater,\r\n    addItemToBasketUpdater: AddItemToBasketUpdater,\r\n    addUserToBasketItem: AddUserToBasketItemUpdater,\r\n    basketCreator: CreateBasketUpdater,\r\n    basketFetcher: GetBasketFetcher,\r\n    bookBasketUpdater: BookBasketUpdater,\r\n    deleteBasketUpdater: DeleteBasketUpdater,\r\n    getMiAutoSugestionFetcher: GetMiAutoSugestionFetcher,\r\n    helpers: HelperRoutines,\r\n    removeItemFromBasketUpdater: RemoveItemFromBasketUpdater,\r\n    revalidateBasketUpdater: RevalidateBasketUpdater,\r\n    setBasketItemMiGroupUpdater: SetBasketItemMiGroupUpdater,\r\n    setBasketItemMiValueUpdater: SetBasketItemMiValueUpdater,\r\n    validateMiFreeValue: ValidateMiFreeValueTester,\r\n    sendBasketForApprovalUpdater: SendBasketForApprovalUpdater,\r\n    getUserFetcher: GetUserFetcher,\r\n    getUserBasketsFetcher: GetUserBasketsFetcher,\r\n    setBasketItemLeadPassengerUpdater: SetBasketItemLeadPassengerUpdater,\r\n    moveItemToADifferentBasket: MoveBasketItemToBasketUpdater,\r\n    updateBasketNotes: UpdateBasketNotesUpdater,\r\n    updateBasketTitle: UpdateBasketTitleUpdater,\r\n    userService: UserService,\r\n    modalService: ModalOpenerService,\r\n    setBasketItemPaymentOption: SetPaymentOptionUpdater\r\n  ) {\r\n    super(\r\n      acceptNewPriceUpdater,\r\n      addItemToBasketUpdater,\r\n      addUserToBasketItem,\r\n      basketCreator,\r\n      basketFetcher,\r\n      bookBasketUpdater,\r\n      deleteBasketUpdater,\r\n      getMiAutoSugestionFetcher,\r\n      helpers,\r\n      removeItemFromBasketUpdater,\r\n      revalidateBasketUpdater,\r\n      setBasketItemMiGroupUpdater,\r\n      setBasketItemMiValueUpdater,\r\n      validateMiFreeValue,\r\n      sendBasketForApprovalUpdater,\r\n      getUserFetcher,\r\n      getUserBasketsFetcher,\r\n      setBasketItemLeadPassengerUpdater,\r\n      moveItemToADifferentBasket,\r\n      updateBasketNotes,\r\n      updateBasketTitle,\r\n      setBasketItemPaymentOption,\r\n      userService,\r\n      modalService\r\n    );\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,28 @@
+import { Injectable } from '@angular/core';
+import { Environment } from '../classes/environment';
+import { HelperRoutines } from '../classes/helpers';
+import { HotelAvalibilityQuoteFetcher } from '../fetchers/hotel-avaliability-fetcher';
+import { StorageService } from './storage.service';
+import { BaseHotelAvalibilityService } from 'obtservices/base';
+import * as i0 from "@angular/core";
+import * as i1 from "../fetchers/hotel-avaliability-fetcher";
+import * as i2 from "./storage.service";
+import * as i3 from "../classes/helpers";
+import * as i4 from "../classes/environment";
+export class HotelAvalibilityService extends BaseHotelAvalibilityService {
+    constructor(avalibilityFethcer, sessionStorage, helpers, environment) {
+        super(avalibilityFethcer, sessionStorage, helpers, environment);
+    }
+}
+/** @nocollapse */ HotelAvalibilityService.ɵprov = i0.ɵɵdefineInjectable({ factory: function HotelAvalibilityService_Factory() { return new HotelAvalibilityService(i0.ɵɵinject(i1.HotelAvalibilityQuoteFetcher), i0.ɵɵinject(i2.StorageService), i0.ɵɵinject(i3.HelperRoutines), i0.ɵɵinject(i4.Environment)); }, token: HotelAvalibilityService, providedIn: "root" });
+HotelAvalibilityService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+HotelAvalibilityService.ctorParameters = () => [
+    { type: HotelAvalibilityQuoteFetcher },
+    { type: StorageService },
+    { type: HelperRoutines },
+    { type: Environment }
+];
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,220 @@
+import { Inject, Injectable } from '@angular/core';
+import { map, timeout, catchError } from 'rxjs/operators';
+import jwt_decode from 'jwt-decode';
+import { WebTokenService } from './webtoken.service';
+import { StorageService } from './storage.service';
+import { AbstractHttpCallService } from 'obtservices/base';
+import { of, throwError } from 'rxjs';
+import { Environment } from '../classes/environment';
+import { HttpClient, HttpHeaders } from '@angular/common/http';
+import { Router } from '@angular/router';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/router";
+import * as i3 from "./storage.service";
+import * as i4 from "../classes/environment";
+import * as i5 from "./webtoken.service";
+class BaseHttpCallService extends AbstractHttpCallService {
+    constructor(http, router, storageSession, environment) {
+        super();
+        this.http = http;
+        this.router = router;
+        this.storageSession = storageSession;
+        this.environment = environment;
+    }
+    formEncodedPost(url, body = null, responseType = 'json') {
+        // console.log('--- Form Encoded Posting: ', body);
+        return this.http
+            .post(this.makeUrl(url), body, {
+            headers: this.getHeaders(),
+            withCredentials: true,
+            responseType: responseType
+        })
+            .pipe(timeout(this.environment.httpCallTimeout), map((data) => {
+            return this.handleResponse(data);
+        }), catchError((error) => {
+            return this.handleError(error);
+        }));
+    }
+    /*
+     *	@desc - form encoded post, but with a timeout - default 30 seconds
+     * if timeout occurs it is handled like a normal error (caught in the catch block)
+     **/
+    timeoutFormEncodedPost(url, body = null, reTimeout = 300) {
+        return this.http
+            .post(this.makeUrl(url), body, {
+            headers: this.getHeaders(),
+            withCredentials: true
+        })
+            .pipe(timeout(reTimeout * 1000), map((data) => {
+            return this.handleResponse(data);
+        }
+        /*(error) => {console.log(error);return false;}*/
+        ), catchError((error) => {
+            console.log(error);
+            return this.handleError(error, true);
+        }));
+    }
+    formEncodedPostNoErrorHandling(url, body = null) {
+        return this.http
+            .post(this.makeUrl(url), body, {
+            headers: this.getHeaders(),
+            withCredentials: true
+        })
+            .pipe(timeout(this.environment.httpCallTimeout), map((data) => {
+            return this.handleResponse(data);
+        }
+        /*(error) => {console.log(error);return false;}*/
+        ), catchError((error) => {
+            console.log(error);
+            return throwError(error);
+        }));
+    }
+    /*
+          @desc - call a url through post, with a Json Object as data (angular default)
+      **/
+    post(url, data = null) {
+        return this.http
+            .post(this.makeUrl(url), data, {
+            headers: this.getHeaders(),
+            withCredentials: true
+        })
+            .pipe(timeout(this.environment.httpCallTimeout), map((response) => {
+            return this.handleResponse(response);
+        }
+        /*(error) => {console.log(error);return false;}*/
+        ), catchError((error) => {
+            return this.handleError(error);
+        }));
+    }
+    /*
+          @desc - call a Angular standard get request (application/json headers)
+      **/
+    get(url, params = {}) {
+        console.log('+++ Get Called With Params +++', params);
+        return this.http.get(this.makeUrl(url), params).pipe(timeout(this.environment.httpCallTimeout), map((response) => {
+            return this.handleResponse(response);
+        }), catchError((error) => {
+            return throwError(error);
+        }));
+    }
+    /*
+          @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) {
+        // console.log('Handle Response Called');
+        /*console.log('received %O', data);*/
+        return data;
+    }
+    resetLogout() {
+        this.storageSession.clearSessionData();
+        this.router.navigate(['logon']);
+    }
+    /*
+          @desc - handle any fatal errors 404's 500's other generic http errors
+      **/
+    handleError(errorVal, skipTimeoutMessage = false) {
+        console.log('Handle Error Called');
+        return throwError(errorVal);
+    }
+    /*
+     * 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]));
+        }, '');
+    }
+}
+BaseHttpCallService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+BaseHttpCallService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: Router },
+    { type: StorageService },
+    { type: Environment }
+];
+/*
+  TODO REMOVE HttpCallService, as it's only used to let the system compile during transition.
+*/
+export class HttpCallService extends BaseHttpCallService {
+    getHeaders() {
+        return new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
+    }
+    makeUrl(url) {
+        return url.toString();
+    }
+    get(url, params = {}) {
+        return of({});
+    }
+    post(url, data = null) {
+        return of({});
+    }
+    formEncodedPostNoErrorHandling(url, body = null) {
+        return of({});
+    }
+    timeoutFormEncodedPost(url, body = null, reTimeout = 300) {
+        return of({});
+    }
+    formEncodedPost(url, body = null) {
+        return of({});
+    }
+}
+/** @nocollapse */ HttpCallService.ɵprov = i0.ɵɵdefineInjectable({ factory: function HttpCallService_Factory() { return new HttpCallService(); }, token: HttpCallService, providedIn: "root" });
+HttpCallService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+export class ExternalHttpService extends BaseHttpCallService {
+    getHeaders() {
+        return new HttpHeaders().set('Content-Type', 'application/x-www-form-urlencoded');
+    }
+    makeUrl(url) {
+        return url.toString();
+    }
+}
+/** @nocollapse */ ExternalHttpService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ExternalHttpService_Factory() { return new ExternalHttpService(); }, token: ExternalHttpService, providedIn: "root" });
+ExternalHttpService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+export class AuthHttpService extends BaseHttpCallService {
+    constructor(http, router, storageSession, environment, webTokenService) {
+        super(http, router, storageSession, environment);
+        this.webTokenService = webTokenService;
+    }
+    getHeaders() {
+        return new HttpHeaders().set('Content-Type', 'application/json');
+    }
+    makeUrl(url) {
+        return this.environment.authURL + url.toString();
+    }
+    /*
+          @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.webTokenService.jwtToken = data.jwt;
+            data.jwtObject = jwt_decode(data.jwt);
+        }
+        return data;
+    }
+}
+/** @nocollapse */ AuthHttpService.ɵprov = i0.ɵɵdefineInjectable({ factory: function AuthHttpService_Factory() { return new AuthHttpService(i0.ɵɵinject(i1.HttpClient), i0.ɵɵinject(i2.Router), i0.ɵɵinject(i3.StorageService), i0.ɵɵinject(i4.Environment), i0.ɵɵinject(i5.WebTokenService)); }, token: AuthHttpService, providedIn: "root" });
+AuthHttpService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+AuthHttpService.ctorParameters = () => [
+    { type: HttpClient },
+    { type: Router },
+    { type: StorageService },
+    { type: Environment, decorators: [{ type: Inject, args: [Environment,] }] },
+    { type: WebTokenService }
+];
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http-call.service.js","sourceRoot":"","sources":["../../../../../../../projects/obtservices/angular/src/lib/vendor/services/http-call.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Inject, Injectable } from '@angular/core';\r\nimport { map, timeout, catchError } from 'rxjs/operators';\r\nimport jwt_decode from 'jwt-decode';\r\nimport { WebTokenService } from './webtoken.service';\r\nimport { StorageService } from './storage.service';\r\nimport { AbstractHttpCallService, URLS } from 'obtservices/base';\r\nimport { Observable, of, throwError } from 'rxjs';\r\nimport { Environment } from '../classes/environment';\r\nimport { HttpClient, HttpHeaders } from '@angular/common/http';\r\nimport { Router } from '@angular/router';\r\n\r\n@Injectable({ providedIn: 'root' })\r\nabstract class BaseHttpCallService extends AbstractHttpCallService {\r\n  constructor(\r\n    private http: HttpClient,\r\n    private router: Router,\r\n    private storageSession: StorageService,\r\n    protected environment: Environment\r\n  ) {\r\n    super();\r\n  }\r\n\r\n  formEncodedPost(url: URLS, body: any = null, responseType = 'json'): Observable<any> {\r\n    // console.log('--- Form Encoded Posting: ', body);\r\n\r\n    return this.http\r\n      .post(this.makeUrl(url), body, {\r\n        headers: this.getHeaders(),\r\n        withCredentials: true,\r\n        responseType: responseType as 'json'\r\n      })\r\n      .pipe(\r\n        timeout(this.environment.httpCallTimeout),\r\n        map((data) => {\r\n          return this.handleResponse(data);\r\n        }),\r\n        catchError((error: any) => {\r\n          return this.handleError(error);\r\n        })\r\n      );\r\n  }\r\n\r\n  /*\r\n   *\t@desc - form encoded post, but with a timeout - default 30 seconds\r\n   * if timeout occurs it is handled like a normal error (caught in the catch block)\r\n   **/\r\n  timeoutFormEncodedPost(\r\n    url: URLS,\r\n    body: any = null,\r\n    reTimeout = 300\r\n  ): Observable<any> {\r\n    return this.http\r\n      .post(this.makeUrl(url), body, {\r\n        headers: this.getHeaders(),\r\n        withCredentials: true\r\n      })\r\n      .pipe(\r\n        timeout(reTimeout * 1000),\r\n        map(\r\n          (data) => {\r\n            return this.handleResponse(data);\r\n          }\r\n          /*(error) => {console.log(error);return false;}*/\r\n        ),\r\n        catchError((error: any) => {\r\n          console.log(error);\r\n          return this.handleError(error, true);\r\n        })\r\n      );\r\n  }\r\n\r\n  formEncodedPostNoErrorHandling(url: URLS, body: any = null): Observable<any> {\r\n    return this.http\r\n      .post(this.makeUrl(url), body, {\r\n        headers: this.getHeaders(),\r\n        withCredentials: true\r\n      })\r\n      .pipe(\r\n        timeout(this.environment.httpCallTimeout),\r\n        map(\r\n          (data) => {\r\n            return this.handleResponse(data);\r\n          }\r\n          /*(error) => {console.log(error);return false;}*/\r\n        ),\r\n        catchError((error: any) => {\r\n          console.log(error);\r\n          return throwError(error);\r\n        })\r\n      );\r\n  }\r\n\r\n  /*\r\n\t\t@desc - call a url through post, with a Json Object as data (angular default)\r\n\t**/\r\n  post(url: URLS, data: any = null): Observable<any> {\r\n    return this.http\r\n      .post(this.makeUrl(url), data, {\r\n        headers: this.getHeaders(),\r\n        withCredentials: true\r\n      })\r\n      .pipe(\r\n        timeout(this.environment.httpCallTimeout),\r\n        map(\r\n          (response) => {\r\n            return this.handleResponse(response);\r\n          }\r\n          /*(error) => {console.log(error);return false;}*/\r\n        ),\r\n        catchError((error: any) => {\r\n          return this.handleError(error);\r\n        })\r\n      );\r\n  }\r\n\r\n  /*\r\n\t\t@desc - call a Angular standard get request (application/json headers)\r\n\t**/\r\n  get(url: URLS, params = {}): Observable<any> {\r\n    console.log('+++ Get Called With Params +++', params);\r\n    return this.http.get(this.makeUrl(url), params).pipe(\r\n      timeout(this.environment.httpCallTimeout),\r\n      map((response) => {\r\n        return this.handleResponse(response);\r\n      }),\r\n      catchError((error: any) => {\r\n        return throwError(error);\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    // console.log('Handle Response Called');\r\n    /*console.log('received %O', data);*/\r\n    return data;\r\n  }\r\n\r\n  resetLogout() {\r\n    this.storageSession.clearSessionData();\r\n    this.router.navigate(['logon']);\r\n  }\r\n  /*\r\n\t\t@desc - handle any fatal errors 404's 500's other generic http errors\r\n\t**/\r\n  handleError(errorVal: any, skipTimeoutMessage: boolean = false): any {\r\n    console.log('Handle Error Called');\r\n    return throwError(errorVal);\r\n  }\r\n\r\n  /*\r\n   * Using the keys of the given object as parameter names create a parameter string url encoding the values.\r\n   * The function expects the values to be strings.\r\n   * @param obj\r\n   */\r\n  public serialize(obj: { [key: string]: string }): string {\r\n    return Object.keys(obj).reduce((toReturn: string, key: string) => {\r\n      return (\r\n        (toReturn.length ? toReturn + '&' : '') +\r\n        key +\r\n        '=' +\r\n        encodeURIComponent(\r\n          typeof obj[key] === 'object' ? JSON.stringify(obj[key]) : obj[key]\r\n        )\r\n      );\r\n    }, '');\r\n  }\r\n\r\n  abstract getHeaders(): HttpHeaders;\r\n  abstract makeUrl(url: URLS): string;\r\n}\r\n\r\n/*\r\n  TODO REMOVE HttpCallService, as it's only used to let the system compile during transition.\r\n*/\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class HttpCallService extends BaseHttpCallService {\r\n  getHeaders(): HttpHeaders {\r\n    return new HttpHeaders().set(\r\n      'Content-Type',\r\n      'application/x-www-form-urlencoded'\r\n    );\r\n  }\r\n  makeUrl(url: URLS): string {\r\n    return url.toString();\r\n  }\r\n  get(url: string, params = {}): Observable<any> {\r\n    return of({});\r\n  }\r\n  post(url: string, data: any = null): Observable<any> {\r\n    return of({});\r\n  }\r\n  formEncodedPostNoErrorHandling(url: URLS, body: any = null): Observable<any> {\r\n    return of({});\r\n  }\r\n  timeoutFormEncodedPost(\r\n    url: URLS,\r\n    body: any = null,\r\n    reTimeout = 300\r\n  ): Observable<any> {\r\n    return of({});\r\n  }\r\n  formEncodedPost(url: URLS, body: any = null): Observable<any> {\r\n    return of({});\r\n  }\r\n}\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class ExternalHttpService extends BaseHttpCallService {\r\n  getHeaders() {\r\n    return new HttpHeaders().set(\r\n      'Content-Type',\r\n      'application/x-www-form-urlencoded'\r\n    );\r\n  }\r\n  makeUrl(url: URLS): string {\r\n    return url.toString();\r\n  }\r\n}\r\n\r\n@Injectable({ providedIn: 'root' })\r\nexport class AuthHttpService extends BaseHttpCallService {\r\n  constructor(\r\n    http: HttpClient,\r\n    router: Router,\r\n    storageSession: StorageService,\r\n    @Inject(Environment) environment: Environment,\r\n    private webTokenService: WebTokenService\r\n  ) {\r\n    super(http, router, storageSession, environment);\r\n  }\r\n  getHeaders() {\r\n    return new HttpHeaders().set('Content-Type', 'application/json');\r\n  }\r\n  makeUrl(url: URLS): string {\r\n    return this.environment.authURL + url.toString();\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.webTokenService.jwtToken = data.jwt;\r\n      data.jwtObject = jwt_decode(data.jwt);\r\n    }\r\n    return data;\r\n  }\r\n}\r\n"]}

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

@@ -0,0 +1,41 @@
+import { Router } from '@angular/router';
+import { AuthHttpService } from './http-call.service';
+import { Injectable } from '@angular/core';
+import { UserService } from './user.service';
+import { ModalOpenerService } from './modal-opener.service';
+import { StorageService } from './storage.service';
+import { BaseLogonService } from 'obtservices/base';
+import { Environment } from '../classes/environment';
+import { EventMessenager } from '../classes/event-messenager';
+import * as i0 from "@angular/core";
+import * as i1 from "./user.service";
+import * as i2 from "./modal-opener.service";
+import * as i3 from "./http-call.service";
+import * as i4 from "@angular/router";
+import * as i5 from "../classes/event-messenager";
+import * as i6 from "./storage.service";
+import * as i7 from "../classes/environment";
+export class LogonService extends BaseLogonService {
+    constructor(userService, modalService, http, router, eventMessenager, storageService, environment) {
+        super(userService, modalService, http, router, eventMessenager, storageService, environment);
+        this.loading = false;
+        this.isLoggedIn = false;
+        this.redirectUrl = '';
+        this.refreshPromise = null;
+    }
+}
+/** @nocollapse */ LogonService.ɵprov = i0.ɵɵdefineInjectable({ factory: function LogonService_Factory() { return new LogonService(i0.ɵɵinject(i1.UserService), i0.ɵɵinject(i2.ModalOpenerService), i0.ɵɵinject(i3.AuthHttpService), i0.ɵɵinject(i4.Router), i0.ɵɵinject(i5.EventMessenager), i0.ɵɵinject(i6.StorageService), i0.ɵɵinject(i7.Environment)); }, token: LogonService, providedIn: "root" });
+LogonService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+LogonService.ctorParameters = () => [
+    { type: UserService },
+    { type: ModalOpenerService },
+    { type: AuthHttpService },
+    { type: Router },
+    { type: EventMessenager },
+    { type: StorageService },
+    { type: Environment }
+];
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,15 @@
+import { Injectable } from '@angular/core';
+import { BaseModalOpenerService } from 'obtservices/base';
+import * as i0 from "@angular/core";
+export class ModalOpenerService extends BaseModalOpenerService {
+    constructor() {
+        super();
+    }
+}
+/** @nocollapse */ ModalOpenerService.ɵprov = i0.ɵɵdefineInjectable({ factory: function ModalOpenerService_Factory() { return new ModalOpenerService(); }, token: ModalOpenerService, providedIn: "root" });
+ModalOpenerService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+ModalOpenerService.ctorParameters = () => [];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kYWwtb3BlbmVyLnNlcnZpY2UuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9vYnRzZXJ2aWNlcy9hbmd1bGFyL3NyYy9saWIvdmVuZG9yL3NlcnZpY2VzL21vZGFsLW9wZW5lci5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxVQUFVLEVBQUUsTUFBTSxlQUFlLENBQUM7QUFDM0MsT0FBTyxFQUFFLHNCQUFzQixFQUFFLE1BQU0sa0JBQWtCLENBQUM7O0FBRzFELE1BQU0sT0FBTyxrQkFBbUIsU0FBUSxzQkFBc0I7SUFDNUQ7UUFDRSxLQUFLLEVBQUUsQ0FBQztJQUNWLENBQUM7Ozs7WUFKRixVQUFVLFNBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSW5qZWN0YWJsZSB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBCYXNlTW9kYWxPcGVuZXJTZXJ2aWNlIH0gZnJvbSAnb2J0c2VydmljZXMvYmFzZSc7XHJcblxyXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxyXG5leHBvcnQgY2xhc3MgTW9kYWxPcGVuZXJTZXJ2aWNlIGV4dGVuZHMgQmFzZU1vZGFsT3BlbmVyU2VydmljZSB7XHJcbiAgY29uc3RydWN0b3IoKSB7XHJcbiAgICBzdXBlcigpO1xyXG4gIH1cclxufVxyXG4iXX0=

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

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { GetUserBasketsFetcher } from '../fetchers/get-users-baskets-fetcher';
+import { SearchUsersCanBookForFetcher } from '../fetchers/search-users-can-book-for-fetcher';
+import { BaseEnterpriseMyBookingsService } from 'obtservices/base';
+import * as i0 from "@angular/core";
+import * as i1 from "../fetchers/get-users-baskets-fetcher";
+import * as i2 from "../fetchers/search-users-can-book-for-fetcher";
+export class EnterpriseMyBookingsService extends BaseEnterpriseMyBookingsService {
+    constructor(getUserBasketsFetcher, searchUsersCanBookForFetcher) {
+        super(getUserBasketsFetcher, searchUsersCanBookForFetcher);
+    }
+}
+/** @nocollapse */ EnterpriseMyBookingsService.ɵprov = i0.ɵɵdefineInjectable({ factory: function EnterpriseMyBookingsService_Factory() { return new EnterpriseMyBookingsService(i0.ɵɵinject(i1.GetUserBasketsFetcher), i0.ɵɵinject(i2.SearchUsersCanBookForFetcher)); }, token: EnterpriseMyBookingsService, providedIn: "root" });
+EnterpriseMyBookingsService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+EnterpriseMyBookingsService.ctorParameters = () => [
+    { type: GetUserBasketsFetcher },
+    { type: SearchUsersCanBookForFetcher }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibXktYm9va2luZ3Muc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL29idHNlcnZpY2VzL2FuZ3VsYXIvc3JjL2xpYi92ZW5kb3Ivc2VydmljZXMvbXktYm9va2luZ3Muc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRTNDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLHVDQUF1QyxDQUFDO0FBQzlFLE9BQU8sRUFBRSw0QkFBNEIsRUFBRSxNQUFNLCtDQUErQyxDQUFDO0FBQzdGLE9BQU8sRUFBRSwrQkFBK0IsRUFBRSxNQUFNLGtCQUFrQixDQUFDOzs7O0FBR25FLE1BQU0sT0FBTywyQkFBNEIsU0FBUSwrQkFHaEQ7SUFDQyxZQUNFLHFCQUE0QyxFQUM1Qyw0QkFBMEQ7UUFFMUQsS0FBSyxDQUNILHFCQUFxQixFQUNyQiw0QkFBNEIsQ0FDN0IsQ0FBQztJQUNKLENBQUM7Ozs7WUFiRixVQUFVLFNBQUMsRUFBRSxVQUFVLEVBQUUsTUFBTSxFQUFFOzs7O1lBSnpCLHFCQUFxQjtZQUNyQiw0QkFBNEIiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RhYmxlIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IEdldFVzZXJCYXNrZXRzR1FMLCBTZWFyY2hVc2VyQ2FuQm9va0ZvckdRTCB9IGZyb20gJy4uL3R5cGVzL2dyYXBocWwuYW5ndWxhci50eXBlcyc7XHJcbmltcG9ydCB7IEdldFVzZXJCYXNrZXRzRmV0Y2hlciB9IGZyb20gJy4uL2ZldGNoZXJzL2dldC11c2Vycy1iYXNrZXRzLWZldGNoZXInO1xyXG5pbXBvcnQgeyBTZWFyY2hVc2Vyc0NhbkJvb2tGb3JGZXRjaGVyIH0gZnJvbSAnLi4vZmV0Y2hlcnMvc2VhcmNoLXVzZXJzLWNhbi1ib29rLWZvci1mZXRjaGVyJztcclxuaW1wb3J0IHsgQmFzZUVudGVycHJpc2VNeUJvb2tpbmdzU2VydmljZSB9IGZyb20gJ29idHNlcnZpY2VzL2Jhc2UnO1xyXG5cclxuQEluamVjdGFibGUoeyBwcm92aWRlZEluOiAncm9vdCcgfSlcclxuZXhwb3J0IGNsYXNzIEVudGVycHJpc2VNeUJvb2tpbmdzU2VydmljZSBleHRlbmRzIEJhc2VFbnRlcnByaXNlTXlCb29raW5nc1NlcnZpY2U8XHJcbiAgR2V0VXNlckJhc2tldHNHUUwsXHJcbiAgU2VhcmNoVXNlckNhbkJvb2tGb3JHUUxcclxuPiB7XHJcbiAgY29uc3RydWN0b3IoXHJcbiAgICBnZXRVc2VyQmFza2V0c0ZldGNoZXI6IEdldFVzZXJCYXNrZXRzRmV0Y2hlcixcclxuICAgIHNlYXJjaFVzZXJzQ2FuQm9va0ZvckZldGNoZXI6IFNlYXJjaFVzZXJzQ2FuQm9va0ZvckZldGNoZXJcclxuICApIHtcclxuICAgIHN1cGVyKFxyXG4gICAgICBnZXRVc2VyQmFza2V0c0ZldGNoZXIsXHJcbiAgICAgIHNlYXJjaFVzZXJzQ2FuQm9va0ZvckZldGNoZXJcclxuICAgICk7XHJcbiAgfVxyXG59XHJcbiJdfQ==

package/dist/obtservices/esm2015/angular/lib/vendor/services/route-happy.service.js

@@ -0,0 +1,22 @@
+import { Injectable } from '@angular/core';
+import { BaseRouteHappyService } from 'obtservices/base';
+import { HelperRoutines } from '../classes/helpers';
+import { HttpCallService } from './http-call.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./http-call.service";
+import * as i2 from "../classes/helpers";
+export class RouteHappyService extends BaseRouteHappyService {
+    constructor(httpService, helpers) {
+        super(httpService, helpers);
+    }
+}
+/** @nocollapse */ RouteHappyService.ɵprov = i0.ɵɵdefineInjectable({ factory: function RouteHappyService_Factory() { return new RouteHappyService(i0.ɵɵinject(i1.HttpCallService), i0.ɵɵinject(i2.HelperRoutines)); }, token: RouteHappyService, providedIn: "root" });
+RouteHappyService.decorators = [
+    { type: Injectable, args: [{ providedIn: 'root' },] }
+];
+/** @nocollapse */
+RouteHappyService.ctorParameters = () => [
+    { type: HttpCallService },
+    { type: HelperRoutines }
+];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm91dGUtaGFwcHkuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL29idHNlcnZpY2VzL2FuZ3VsYXIvc3JjL2xpYi92ZW5kb3Ivc2VydmljZXMvcm91dGUtaGFwcHkuc2VydmljZS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsVUFBVSxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBQzNDLE9BQU8sRUFBRSxxQkFBcUIsRUFBRSxNQUFNLGtCQUFrQixDQUFDO0FBQ3pELE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxvQkFBb0IsQ0FBQztBQUNwRCxPQUFPLEVBQUUsZUFBZSxFQUFFLE1BQU0scUJBQXFCLENBQUM7Ozs7QUFHdEQsTUFBTSxPQUFPLGlCQUFrQixTQUFRLHFCQUFxQjtJQUMxRCxZQUFZLFdBQTRCLEVBQUUsT0FBdUI7UUFDL0QsS0FBSyxDQUFDLFdBQVcsRUFBRSxPQUFPLENBQUMsQ0FBQztJQUM5QixDQUFDOzs7O1lBSkYsVUFBVSxTQUFDLEVBQUUsVUFBVSxFQUFFLE1BQU0sRUFBRTs7OztZQUZ6QixlQUFlO1lBRGYsY0FBYyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGFibGUgfSBmcm9tICdAYW5ndWxhci9jb3JlJztcclxuaW1wb3J0IHsgQmFzZVJvdXRlSGFwcHlTZXJ2aWNlIH0gZnJvbSAnb2J0c2VydmljZXMvYmFzZSc7XHJcbmltcG9ydCB7IEhlbHBlclJvdXRpbmVzIH0gZnJvbSAnLi4vY2xhc3Nlcy9oZWxwZXJzJztcclxuaW1wb3J0IHsgSHR0cENhbGxTZXJ2aWNlIH0gZnJvbSAnLi9odHRwLWNhbGwuc2VydmljZSc7XHJcblxyXG5ASW5qZWN0YWJsZSh7IHByb3ZpZGVkSW46ICdyb290JyB9KVxyXG5leHBvcnQgY2xhc3MgUm91dGVIYXBweVNlcnZpY2UgZXh0ZW5kcyBCYXNlUm91dGVIYXBweVNlcnZpY2Uge1xyXG4gIGNvbnN0cnVjdG9yKGh0dHBTZXJ2aWNlOiBIdHRwQ2FsbFNlcnZpY2UsIGhlbHBlcnM6IEhlbHBlclJvdXRpbmVzKSB7XHJcbiAgICBzdXBlcihodHRwU2VydmljZSwgaGVscGVycyk7XHJcbiAgfVxyXG59XHJcbiJdfQ==