@valtimo/keycloak 10.4.0 → 10.5.1

package/esm2020/lib/services/keycloak-user.service.mjs

@@ -0,0 +1,180 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { combineLatest, map, ReplaySubject, Subject, switchMap, timer } from 'rxjs';
+import { KeycloakEventType } from 'keycloak-angular';
+import { ValtimoUserIdentity } from '@valtimo/config';
+import jwt_decode from 'jwt-decode';
+import { take } from 'rxjs/operators';
+import { STORAGE_KEYS } from '../constants';
+import * as i0 from "@angular/core";
+import * as i1 from "keycloak-angular";
+import * as i2 from "./keycloak-options.service";
+import * as i3 from "ngx-logger";
+import * as i4 from "@valtimo/user-interface";
+import * as i5 from "@ngx-translate/core";
+import * as i6 from "@angular/common";
+import * as i7 from "@valtimo/config";
+import * as i8 from "@angular/router";
+import * as i9 from "./keycloak-storage.service";
+export class KeycloakUserService {
+    constructor(keycloakService, keycloakOptionsService, logger, promptService, translateService, datePipe, configService, router, keycloakStorageService) {
+        this.keycloakService = keycloakService;
+        this.keycloakOptionsService = keycloakOptionsService;
+        this.logger = logger;
+        this.promptService = promptService;
+        this.translateService = translateService;
+        this.datePipe = datePipe;
+        this.configService = configService;
+        this.router = router;
+        this.keycloakStorageService = keycloakStorageService;
+        this._refreshToken$ = new Subject();
+        this.FIVE_MINUTES_MS = 300000;
+        this.EXPIRE_TOKEN_CONFIRMATION = 'EXPIRE_TOKEN_CONFIRMATION';
+        this.openTokenRefreshSubscription();
+        this.openRefreshTokenSubscription();
+    }
+    ngOnDestroy() {
+        this.tokenRefreshSubscription?.unsubscribe();
+        this.refreshTokenSubscription?.unsubscribe();
+        this.closeExpiryTimerSubscription();
+    }
+    init() {
+        this.userIdentity = new ReplaySubject();
+        this.keycloakService.loadUserProfile().then(user => {
+            this.logger.debug('KeycloakUserService: loadUserProfile = ', user);
+            const roles = [];
+            this.keycloakService.getUserRoles(true).forEach(role => roles.push(role));
+            const valtimoUserIdentity = new ValtimoUserIdentity(user.email, user.firstName, user.lastName, roles, user.username);
+            this.logger.debug('KeycloakUserService: loaded user identity', valtimoUserIdentity);
+            this.userIdentity.next(valtimoUserIdentity);
+        });
+        this.setRefreshToken();
+    }
+    getUserSubject() {
+        this.logger.debug('KeycloakUserService: getUserIdentity');
+        return this.userIdentity;
+    }
+    logout() {
+        this.logger.debug('KeycloakUserService: logout');
+        this.keycloakService.logout(this.keycloakOptionsService.logoutRedirectUri);
+    }
+    async getToken() {
+        this.logger.debug('KeycloakUserService: getToken');
+        return this.keycloakService.getToken();
+    }
+    async updateToken(minValidity) {
+        this.logger.debug('KeycloakUserService: updateToken');
+        return this.keycloakService.updateToken(minValidity);
+    }
+    openTokenRefreshSubscription() {
+        this.tokenRefreshSubscription = this.keycloakService.keycloakEvents$.subscribe(keycloakEvent => {
+            if (keycloakEvent.type === KeycloakEventType.OnAuthRefreshSuccess) {
+                this.setRefreshToken();
+            }
+        });
+    }
+    openRefreshTokenSubscription() {
+        this.refreshTokenSubscription = this._refreshToken$.subscribe(refreshToken => {
+            const decodedRefreshToken = jwt_decode(refreshToken);
+            const tokenExp = decodedRefreshToken.exp * 1000;
+            const expiryTimeMs = tokenExp - Date.now() - 1000;
+            this._expiryTimeMs = expiryTimeMs;
+            this.closeExpiryTimerSubscription();
+            this.openExpiryTimerSubscription();
+        });
+    }
+    setRefreshToken() {
+        const refreshToken = this.keycloakService.getKeycloakInstance()?.refreshToken;
+        if (refreshToken)
+            this._refreshToken$.next(refreshToken);
+    }
+    openExpiryTimerSubscription() {
+        this.expiryTimerSubscription = timer(0, 1000)
+            .pipe(map(() => {
+            this._expiryTimeMs = this._expiryTimeMs - 1000;
+            return this._expiryTimeMs;
+        }), switchMap(expiryTimeMs => {
+            if (expiryTimeMs <= this.FIVE_MINUTES_MS) {
+                this._counter = new Date(0, 0, 0, 0, 0, 0);
+                this._counter.setSeconds(expiryTimeMs / 1000);
+            }
+            return combineLatest([
+                this.promptService.promptVisible$,
+                this.translateService.stream('keycloak.expiryPromptTitle'),
+                this.translateService.stream('keycloak.expiryPromptDescription', {
+                    expiryTime: this.datePipe.transform(this._counter, 'mm:ss'),
+                }),
+                this.translateService.stream('keycloak.expiryPromptCancel'),
+                this.translateService.stream('keycloak.expiryPromptConfirm'),
+            ]);
+        }))
+            .subscribe(([promptVisible, headerText, bodyText, cancelButtonText, confirmButtonText]) => {
+            this.promptService.identifier$.pipe(take(1)).subscribe(identifier => {
+                if ((!promptVisible || identifier !== this.EXPIRE_TOKEN_CONFIRMATION) &&
+                    this._expiryTimeMs <= this.FIVE_MINUTES_MS) {
+                    this.openConfirmationPrompt(headerText, bodyText, cancelButtonText, confirmButtonText);
+                }
+                if (promptVisible && identifier === this.EXPIRE_TOKEN_CONFIRMATION) {
+                    this.promptService.setBodyText(bodyText);
+                }
+            });
+            if (this._expiryTimeMs < 2000) {
+                this.saveUrl();
+                this.logout();
+            }
+        });
+    }
+    closeExpiryTimerSubscription() {
+        this.expiryTimerSubscription?.unsubscribe();
+    }
+    openConfirmationPrompt(headerText, bodyText, cancelButtonText, confirmButtonText) {
+        this.promptService.openPrompt({
+            identifier: this.EXPIRE_TOKEN_CONFIRMATION,
+            headerText,
+            bodyText,
+            cancelButtonText,
+            confirmButtonText,
+            cancelMdiIcon: 'logout',
+            confirmMdiIcon: 'check',
+            closeOnConfirm: true,
+            closeOnCancel: false,
+            cancelCallbackFunction: () => {
+                this.keycloakService.logout();
+            },
+            confirmCallBackFunction: () => {
+                this.closeExpiryTimerSubscription();
+                this.updateToken(20);
+            },
+        });
+    }
+    saveUrl() {
+        const returnToLastUrlAfterTokenExpiration = this.configService?.config?.featureToggles?.returnToLastUrlAfterTokenExpiration;
+        if (returnToLastUrlAfterTokenExpiration) {
+            sessionStorage.setItem(STORAGE_KEYS.urlBeforeExpiration, this.keycloakStorageService.getCurrentUrl());
+            sessionStorage.setItem(STORAGE_KEYS.urlBeforeExpirationParams, this.keycloakStorageService.getCurrentUrlParams());
+        }
+    }
+}
+KeycloakUserService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: KeycloakUserService, deps: [{ token: i1.KeycloakService }, { token: i2.KeycloakOptionsService }, { token: i3.NGXLogger }, { token: i4.PromptService }, { token: i5.TranslateService }, { token: i6.DatePipe }, { token: i7.ConfigService }, { token: i8.Router }, { token: i9.KeycloakStorageService }], target: i0.ɵɵFactoryTarget.Injectable });
+KeycloakUserService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: KeycloakUserService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: KeycloakUserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.KeycloakService }, { type: i2.KeycloakOptionsService }, { type: i3.NGXLogger }, { type: i4.PromptService }, { type: i5.TranslateService }, { type: i6.DatePipe }, { type: i7.ConfigService }, { type: i8.Router }, { type: i9.KeycloakStorageService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keycloak-user.service.js","sourceRoot":"","sources":["../../../../../../projects/valtimo/keycloak/src/lib/services/keycloak-user.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Injectable, OnDestroy} from '@angular/core';\nimport {combineLatest, map, ReplaySubject, Subject, Subscription, switchMap, timer} from 'rxjs';\nimport {NGXLogger} from 'ngx-logger';\nimport {KeycloakEventType, KeycloakService} from 'keycloak-angular';\nimport {ConfigService, UserIdentity, UserService, ValtimoUserIdentity} from '@valtimo/config';\nimport {KeycloakOptionsService} from './keycloak-options.service';\nimport jwt_decode from 'jwt-decode';\nimport {PromptService} from '@valtimo/user-interface';\nimport {TranslateService} from '@ngx-translate/core';\nimport {DatePipe} from '@angular/common';\nimport {take} from 'rxjs/operators';\nimport {Router} from '@angular/router';\nimport {STORAGE_KEYS} from '../constants';\nimport {KeycloakStorageService} from './keycloak-storage.service';\n\n@Injectable({\n  providedIn: 'root',\n})\nexport class KeycloakUserService implements UserService, OnDestroy {\n  private userIdentity: ReplaySubject<UserIdentity>;\n\n  private tokenRefreshSubscription!: Subscription;\n  private refreshTokenSubscription!: Subscription;\n  private expiryTimerSubscription!: Subscription;\n\n  private readonly _refreshToken$ = new Subject<string>();\n\n  private _expiryTimeMs!: number;\n\n  private readonly FIVE_MINUTES_MS = 300000;\n  private readonly EXPIRE_TOKEN_CONFIRMATION = 'EXPIRE_TOKEN_CONFIRMATION';\n\n  private _counter!: Date;\n\n  constructor(\n    private readonly keycloakService: KeycloakService,\n    private readonly keycloakOptionsService: KeycloakOptionsService,\n    private readonly logger: NGXLogger,\n    private readonly promptService: PromptService,\n    private readonly translateService: TranslateService,\n    private readonly datePipe: DatePipe,\n    private readonly configService: ConfigService,\n    private readonly router: Router,\n    private readonly keycloakStorageService: KeycloakStorageService\n  ) {\n    this.openTokenRefreshSubscription();\n    this.openRefreshTokenSubscription();\n  }\n\n  ngOnDestroy(): void {\n    this.tokenRefreshSubscription?.unsubscribe();\n    this.refreshTokenSubscription?.unsubscribe();\n    this.closeExpiryTimerSubscription();\n  }\n\n  init(): void {\n    this.userIdentity = new ReplaySubject();\n    this.keycloakService.loadUserProfile().then(user => {\n      this.logger.debug('KeycloakUserService: loadUserProfile = ', user);\n      const roles: Array<string> = [];\n      this.keycloakService.getUserRoles(true).forEach(role => roles.push(role));\n      const valtimoUserIdentity = new ValtimoUserIdentity(\n        user.email,\n        user.firstName,\n        user.lastName,\n        roles,\n        user.username\n      );\n      this.logger.debug('KeycloakUserService: loaded user identity', valtimoUserIdentity);\n      this.userIdentity.next(valtimoUserIdentity);\n    });\n    this.setRefreshToken();\n  }\n\n  getUserSubject(): ReplaySubject<UserIdentity> {\n    this.logger.debug('KeycloakUserService: getUserIdentity');\n    return this.userIdentity;\n  }\n\n  logout(): void {\n    this.logger.debug('KeycloakUserService: logout');\n    this.keycloakService.logout(this.keycloakOptionsService.logoutRedirectUri);\n  }\n\n  async getToken(): Promise<string> {\n    this.logger.debug('KeycloakUserService: getToken');\n    return this.keycloakService.getToken();\n  }\n\n  async updateToken(minValidity: number): Promise<boolean> {\n    this.logger.debug('KeycloakUserService: updateToken');\n    return this.keycloakService.updateToken(minValidity);\n  }\n\n  private openTokenRefreshSubscription(): void {\n    this.tokenRefreshSubscription = this.keycloakService.keycloakEvents$.subscribe(\n      keycloakEvent => {\n        if (keycloakEvent.type === KeycloakEventType.OnAuthRefreshSuccess) {\n          this.setRefreshToken();\n        }\n      }\n    );\n  }\n\n  private openRefreshTokenSubscription(): void {\n    this.refreshTokenSubscription = this._refreshToken$.subscribe(refreshToken => {\n      const decodedRefreshToken: any = jwt_decode(refreshToken);\n      const tokenExp = decodedRefreshToken.exp * 1000;\n      const expiryTimeMs = tokenExp - Date.now() - 1000;\n\n      this._expiryTimeMs = expiryTimeMs;\n      this.closeExpiryTimerSubscription();\n      this.openExpiryTimerSubscription();\n    });\n  }\n\n  private setRefreshToken(): void {\n    const refreshToken = this.keycloakService.getKeycloakInstance()?.refreshToken;\n    if (refreshToken) this._refreshToken$.next(refreshToken);\n  }\n\n  private openExpiryTimerSubscription(): void {\n    this.expiryTimerSubscription = timer(0, 1000)\n      .pipe(\n        map(() => {\n          this._expiryTimeMs = this._expiryTimeMs - 1000;\n          return this._expiryTimeMs;\n        }),\n        switchMap(expiryTimeMs => {\n          if (expiryTimeMs <= this.FIVE_MINUTES_MS) {\n            this._counter = new Date(0, 0, 0, 0, 0, 0);\n            this._counter.setSeconds(expiryTimeMs / 1000);\n          }\n\n          return combineLatest([\n            this.promptService.promptVisible$,\n            this.translateService.stream('keycloak.expiryPromptTitle'),\n            this.translateService.stream('keycloak.expiryPromptDescription', {\n              expiryTime: this.datePipe.transform(this._counter, 'mm:ss'),\n            }),\n            this.translateService.stream('keycloak.expiryPromptCancel'),\n            this.translateService.stream('keycloak.expiryPromptConfirm'),\n          ]);\n        })\n      )\n      .subscribe(([promptVisible, headerText, bodyText, cancelButtonText, confirmButtonText]) => {\n        this.promptService.identifier$.pipe(take(1)).subscribe(identifier => {\n          if (\n            (!promptVisible || identifier !== this.EXPIRE_TOKEN_CONFIRMATION) &&\n            this._expiryTimeMs <= this.FIVE_MINUTES_MS\n          ) {\n            this.openConfirmationPrompt(headerText, bodyText, cancelButtonText, confirmButtonText);\n          }\n\n          if (promptVisible && identifier === this.EXPIRE_TOKEN_CONFIRMATION) {\n            this.promptService.setBodyText(bodyText);\n          }\n        });\n\n        if (this._expiryTimeMs < 2000) {\n          this.saveUrl();\n          this.logout();\n        }\n      });\n  }\n\n  private closeExpiryTimerSubscription(): void {\n    this.expiryTimerSubscription?.unsubscribe();\n  }\n\n  private openConfirmationPrompt(\n    headerText: string,\n    bodyText: string,\n    cancelButtonText: string,\n    confirmButtonText: string\n  ): void {\n    this.promptService.openPrompt({\n      identifier: this.EXPIRE_TOKEN_CONFIRMATION,\n      headerText,\n      bodyText,\n      cancelButtonText,\n      confirmButtonText,\n      cancelMdiIcon: 'logout',\n      confirmMdiIcon: 'check',\n      closeOnConfirm: true,\n      closeOnCancel: false,\n      cancelCallbackFunction: () => {\n        this.keycloakService.logout();\n      },\n      confirmCallBackFunction: () => {\n        this.closeExpiryTimerSubscription();\n        this.updateToken(20);\n      },\n    });\n  }\n\n  private saveUrl(): void {\n    const returnToLastUrlAfterTokenExpiration =\n      this.configService?.config?.featureToggles?.returnToLastUrlAfterTokenExpiration;\n\n    if (returnToLastUrlAfterTokenExpiration) {\n      sessionStorage.setItem(\n        STORAGE_KEYS.urlBeforeExpiration,\n        this.keycloakStorageService.getCurrentUrl()\n      );\n      sessionStorage.setItem(\n        STORAGE_KEYS.urlBeforeExpirationParams,\n        this.keycloakStorageService.getCurrentUrlParams()\n      );\n    }\n  }\n}\n"]}

package/esm2020/public_api.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -18,9 +18,10 @@
  */
 export * from './lib/models';
 export * from './lib/keycloak.module';
-export * from './lib/keycloak-auth-guard.service';
-export * from './lib/keycloak-user.service';
+export * from './lib/services/keycloak-auth-guard.service';
+export * from './lib/services/keycloak-user.service';
 export * from './lib/keycloak.init';
-export * from './lib/keycloak-options.service';
+export * from './lib/services/keycloak-options.service';
 export * from './lib/callback.component';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8va2V5Y2xvYWsvc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFFSDs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLDZCQUE2QixDQUFDO0FBQzVDLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxnQ0FBZ0MsQ0FBQztBQUMvQyxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAyMDE1LTIwMjAgUml0ZW5zZSBCViwgdGhlIE5ldGhlcmxhbmRzLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIEVVUEwsIFZlcnNpb24gMS4yICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogaHR0cHM6Ly9qb2ludXAuZWMuZXVyb3BhLmV1L2NvbGxlY3Rpb24vZXVwbC9ldXBsLXRleHQtZXVwbC0xMlxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBiYXNpcyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuLypcbiAqIFB1YmxpYyBBUEkgU3VyZmFjZSBvZiBrZXljbG9ha1xuICovXG5cbmV4cG9ydCAqIGZyb20gJy4vbGliL21vZGVscyc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9rZXljbG9hay5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIva2V5Y2xvYWstYXV0aC1ndWFyZC5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2tleWNsb2FrLXVzZXIuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9rZXljbG9hay5pbml0JztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2tleWNsb2FrLW9wdGlvbnMuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jYWxsYmFjay5jb21wb25lbnQnO1xuIl19
+export * from './lib/constants';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljX2FwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8va2V5Y2xvYWsvc3JjL3B1YmxpY19hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7Ozs7Ozs7O0dBY0c7QUFFSDs7R0FFRztBQUVILGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyw0Q0FBNEMsQ0FBQztBQUMzRCxjQUFjLHNDQUFzQyxDQUFDO0FBQ3JELGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyx5Q0FBeUMsQ0FBQztBQUN4RCxjQUFjLDBCQUEwQixDQUFDO0FBQ3pDLGNBQWMsaUJBQWlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMyBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG4vKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIGtleWNsb2FrXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9saWIvbW9kZWxzJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2tleWNsb2FrLm1vZHVsZSc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9zZXJ2aWNlcy9rZXljbG9hay1hdXRoLWd1YXJkLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMva2V5Y2xvYWstdXNlci5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2tleWNsb2FrLmluaXQnO1xuZXhwb3J0ICogZnJvbSAnLi9saWIvc2VydmljZXMva2V5Y2xvYWstb3B0aW9ucy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vbGliL2NhbGxiYWNrLmNvbXBvbmVudCc7XG5leHBvcnQgKiBmcm9tICcuL2xpYi9jb25zdGFudHMnO1xuIl19