@softheon/armature 10.45.4 → 15.0.0

package/esm2020/lib/rbac/directives/rbac-action.directive.mjs

@@ -0,0 +1,50 @@
+import { Directive, Input } from '@angular/core';
+import { Subscription } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "../services/oauth2-role.service";
+export class RbacActionDirective {
+    /**
+     * Constructs the component
+     * @param templateRef The template reference
+     * @param viewContainer The view container reference
+     * @param oAuth2RoleService The oauth 2 role service
+     */
+    constructor(templateRef, viewContainer, oAuth2RoleService) {
+        this.templateRef = templateRef;
+        this.viewContainer = viewContainer;
+        this.oAuth2RoleService = oAuth2RoleService;
+        /** The directive subscription */
+        this.directiveSub = new Subscription();
+    }
+    /** Life cycle hook for directive initialization */
+    ngOnInit() {
+        this.directiveSub.add(this.oAuth2RoleService.hasActionAccess(this.sofArRbacAction)
+            .subscribe(hasAccess => {
+            if (hasAccess) {
+                if (!this.isContentRendered) {
+                    this.viewContainer.createEmbeddedView(this.templateRef);
+                }
+                this.isContentRendered = true;
+            }
+            else {
+                this.viewContainer.clear();
+                this.isContentRendered = false;
+            }
+        }));
+    }
+    /** Life cycle hook for directive destruction */
+    ngOnDestroy() {
+        this.directiveSub.unsubscribe();
+    }
+}
+RbacActionDirective.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: RbacActionDirective, deps: [{ token: i0.TemplateRef }, { token: i0.ViewContainerRef }, { token: i1.Oauth2RoleService }], target: i0.ɵɵFactoryTarget.Directive });
+RbacActionDirective.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "15.1.5", type: RbacActionDirective, selector: "[sofArRbacAction]", inputs: { sofArRbacAction: "sofArRbacAction" }, ngImport: i0 });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: RbacActionDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    selector: '[sofArRbacAction]'
+                }]
+        }], ctorParameters: function () { return [{ type: i0.TemplateRef }, { type: i0.ViewContainerRef }, { type: i1.Oauth2RoleService }]; }, propDecorators: { sofArRbacAction: [{
+                type: Input
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/rbac/models/access-token-claims.mjs

@@ -0,0 +1,23 @@
+// tslint:disable: variable-name
+/** The access token claims */
+export class AccessTokenClaims {
+    /** The roles of the user */
+    get getRole() {
+        if (typeof this.role === 'string') {
+            this.role = [this.role];
+        }
+        return this.role;
+    }
+    /** constructs the claims from an existing claims object */
+    constructor(claims) {
+        if (claims) {
+            this.role = claims.role;
+            this.given_name = claims.given_name;
+            this.family_name = claims.family_name;
+            this.name = claims.name;
+            this.preferred_username = claims.preferred_username;
+            this.upn = claims.upn;
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/rbac/models/constants.mjs

@@ -0,0 +1,4 @@
+import { InjectionToken } from '@angular/core';
+/** The rbac config injection token */
+export const RBAC_CONFIG = new InjectionToken('RbacConfig');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY29uc3RhbnRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYXJtYXR1cmUvc3JjL2xpYi9yYmFjL21vZGVscy9jb25zdGFudHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUFFLGNBQWMsRUFBRSxNQUFNLGVBQWUsQ0FBQztBQUcvQyxzQ0FBc0M7QUFDdEMsTUFBTSxDQUFDLE1BQU0sV0FBVyxHQUErQixJQUFJLGNBQWMsQ0FBYSxZQUFZLENBQUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEluamVjdGlvblRva2VuIH0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XHJcbmltcG9ydCB7IFJiYWNDb25maWcgfSBmcm9tICcuL3JiYWMtY29uZmlnJztcclxuXHJcbi8qKiBUaGUgcmJhYyBjb25maWcgaW5qZWN0aW9uIHRva2VuICovXHJcbmV4cG9ydCBjb25zdCBSQkFDX0NPTkZJRzogSW5qZWN0aW9uVG9rZW48UmJhY0NvbmZpZz4gPSBuZXcgSW5qZWN0aW9uVG9rZW48UmJhY0NvbmZpZz4oJ1JiYWNDb25maWcnKTtcclxuIl19

package/esm2020/lib/rbac/models/decoded-access-token.mjs

@@ -0,0 +1,69 @@
+import { AccessTokenClaims } from './access-token-claims';
+// tslint:disable: variable-name no-unused-expression
+/** The access token claims class */
+export class DecodedAccessToken {
+    /** The scopes the token was requested with */
+    get getScope() {
+        if (typeof this.scope === 'string') {
+            this.scope = [this.scope];
+        }
+        return this.scope;
+    }
+    /** The audience, who or what the token is intended for  */
+    get getAud() {
+        if (typeof this.aud === 'string') {
+            this.aud = [this.aud];
+        }
+        return this.aud;
+    }
+    /** Gets claims for the user associated with the access token */
+    get claims() {
+        return this._claims;
+    }
+    /** Sets claims for the user associate with the access token */
+    set claims(value) {
+        this._claims = new AccessTokenClaims(value);
+    }
+    /**
+     * Constructs the access Token
+     * @param encodedToken The encoded Auth Token
+     */
+    constructor(encodedToken) {
+        const base64Url = encodedToken.split('.')[1];
+        const base64 = base64Url.replace(/-/g, '+')
+            .replace(/_/g, '/');
+        const jsonPayload = decodeURIComponent(atob(base64)
+            .split('')
+            .map(c => 
+        // tslint:disable-next-line: restrict-plus-operands prefer-template
+        '%' + ('00' + c.charCodeAt(0)
+            .toString(16))
+            .slice(-2))
+            .join(''));
+        const decodedToken = JSON.parse(jsonPayload);
+        this.setAllProps(decodedToken);
+        this.convertAllDualTypes();
+    }
+    /** Converts all the dual types to single types */
+    convertAllDualTypes() {
+        this.getAud;
+        this.getScope;
+    }
+    /**
+     * Sets all the properties from an existing object
+     * @param decodedToken The decoded token object
+     */
+    setAllProps(decodedToken) {
+        this.amr = decodedToken.amr;
+        this.aud = decodedToken.aud;
+        this.auth_time = decodedToken.auth_time;
+        this.client_id = decodedToken.client_id;
+        this.exp = decodedToken.exp;
+        this.idp = decodedToken.idp;
+        this.iss = decodedToken.iss;
+        this.nbf = decodedToken.nbf;
+        this.scope = decodedToken.scope;
+        this.sub = decodedToken.sub;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGVjb2RlZC1hY2Nlc3MtdG9rZW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hcm1hdHVyZS9zcmMvbGliL3JiYWMvbW9kZWxzL2RlY29kZWQtYWNjZXNzLXRva2VuLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSxpQkFBaUIsRUFBRSxNQUFNLHVCQUF1QixDQUFDO0FBRTFELHFEQUFxRDtBQUNyRCxvQ0FBb0M7QUFDcEMsTUFBTSxPQUFPLGtCQUFrQjtJQThCM0IsOENBQThDO0lBQzlDLElBQVcsUUFBUTtRQUNmLElBQUksT0FBTyxJQUFJLENBQUMsS0FBSyxLQUFLLFFBQVEsRUFBRTtZQUNoQyxJQUFJLENBQUMsS0FBSyxHQUFHLENBQUMsSUFBSSxDQUFDLEtBQUssQ0FBQyxDQUFDO1NBQzdCO1FBRUQsT0FBTyxJQUFJLENBQUMsS0FBSyxDQUFDO0lBQ3RCLENBQUM7SUFFRCwyREFBMkQ7SUFDM0QsSUFBVyxNQUFNO1FBQ2IsSUFBSSxPQUFPLElBQUksQ0FBQyxHQUFHLEtBQUssUUFBUSxFQUFFO1lBQzlCLElBQUksQ0FBQyxHQUFHLEdBQUcsQ0FBQyxJQUFJLENBQUMsR0FBRyxDQUFDLENBQUM7U0FDekI7UUFFRCxPQUFPLElBQUksQ0FBQyxHQUFHLENBQUM7SUFDcEIsQ0FBQztJQUVELGdFQUFnRTtJQUNoRSxJQUFXLE1BQU07UUFDYixPQUFPLElBQUksQ0FBQyxPQUFPLENBQUM7SUFDeEIsQ0FBQztJQUVELCtEQUErRDtJQUMvRCxJQUFXLE1BQU0sQ0FBQyxLQUF3QjtRQUN0QyxJQUFJLENBQUMsT0FBTyxHQUFHLElBQUksaUJBQWlCLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDaEQsQ0FBQztJQUVEOzs7T0FHRztJQUNILFlBQVksWUFBb0I7UUFDNUIsTUFBTSxTQUFTLEdBQUcsWUFBWSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQztRQUM3QyxNQUFNLE1BQU0sR0FBRyxTQUFTLENBQUMsT0FBTyxDQUFDLElBQUksRUFBRSxHQUFHLENBQUM7YUFDdEMsT0FBTyxDQUFDLElBQUksRUFBRSxHQUFHLENBQUMsQ0FBQztRQUN4QixNQUFNLFdBQVcsR0FBRyxrQkFBa0IsQ0FBQyxJQUFJLENBQUMsTUFBTSxDQUFDO2FBQzlDLEtBQUssQ0FBQyxFQUFFLENBQUM7YUFDVCxHQUFHLENBQUMsQ0FBQyxDQUFDLEVBQUU7UUFDTCxtRUFBbUU7UUFDbkUsR0FBRyxHQUFHLENBQUMsSUFBSSxHQUFHLENBQUMsQ0FBQyxVQUFVLENBQUMsQ0FBQyxDQUFDO2FBQ3hCLFFBQVEsQ0FBQyxFQUFFLENBQUMsQ0FBQzthQUNiLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO2FBQ2xCLElBQUksQ0FBQyxFQUFFLENBQUMsQ0FBQyxDQUFDO1FBQ2YsTUFBTSxZQUFZLEdBQXVCLElBQUksQ0FBQyxLQUFLLENBQUMsV0FBVyxDQUFDLENBQUM7UUFDakUsSUFBSSxDQUFDLFdBQVcsQ0FBQyxZQUFZLENBQUMsQ0FBQztRQUMvQixJQUFJLENBQUMsbUJBQW1CLEVBQUUsQ0FBQztJQUMvQixDQUFDO0lBRUQsa0RBQWtEO0lBQzFDLG1CQUFtQjtRQUN2QixJQUFJLENBQUMsTUFBTSxDQUFDO1FBQ1osSUFBSSxDQUFDLFFBQVEsQ0FBQztJQUNsQixDQUFDO0lBRUQ7OztPQUdHO0lBQ0ssV0FBVyxDQUFDLFlBQWdDO1FBQ2hELElBQUksQ0FBQyxHQUFHLEdBQUcsWUFBWSxDQUFDLEdBQUcsQ0FBQztRQUM1QixJQUFJLENBQUMsR0FBRyxHQUFHLFlBQVksQ0FBQyxHQUFHLENBQUM7UUFDNUIsSUFBSSxDQUFDLFNBQVMsR0FBRyxZQUFZLENBQUMsU0FBUyxDQUFDO1FBQ3hDLElBQUksQ0FBQyxTQUFTLEdBQUcsWUFBWSxDQUFDLFNBQVMsQ0FBQztRQUN4QyxJQUFJLENBQUMsR0FBRyxHQUFHLFlBQVksQ0FBQyxHQUFHLENBQUM7UUFDNUIsSUFBSSxDQUFDLEdBQUcsR0FBRyxZQUFZLENBQUMsR0FBRyxDQUFDO1FBQzVCLElBQUksQ0FBQyxHQUFHLEdBQUcsWUFBWSxDQUFDLEdBQUcsQ0FBQztRQUM1QixJQUFJLENBQUMsR0FBRyxHQUFHLFlBQVksQ0FBQyxHQUFHLENBQUM7UUFDNUIsSUFBSSxDQUFDLEtBQUssR0FBRyxZQUFZLENBQUMsS0FBSyxDQUFDO1FBQ2hDLElBQUksQ0FBQyxHQUFHLEdBQUcsWUFBWSxDQUFDLEdBQUcsQ0FBQztJQUNoQyxDQUFDO0NBRUoiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBBY2Nlc3NUb2tlbkNsYWltcyB9IGZyb20gJy4vYWNjZXNzLXRva2VuLWNsYWltcyc7XHJcblxyXG4vLyB0c2xpbnQ6ZGlzYWJsZTogdmFyaWFibGUtbmFtZSBuby11bnVzZWQtZXhwcmVzc2lvblxyXG4vKiogVGhlIGFjY2VzcyB0b2tlbiBjbGFpbXMgY2xhc3MgKi9cclxuZXhwb3J0IGNsYXNzIERlY29kZWRBY2Nlc3NUb2tlbiB7XHJcblxyXG4gICAgcHJpdmF0ZSBhdWQ6IHN0cmluZyB8IEFycmF5PHN0cmluZz47XHJcbiAgICBwcml2YXRlIHNjb3BlOiBzdHJpbmcgfCBBcnJheTxzdHJpbmc+O1xyXG4gICAgcHJpdmF0ZSBfY2xhaW1zOiBBY2Nlc3NUb2tlbkNsYWltcztcclxuXHJcbiAgICAvKiogVGhlIGF1dGhlbnRpY2F0aW9uIG1ldGhvZHMgYXJyYXkgKi9cclxuICAgIHB1YmxpYyBhbXI6IEFycmF5PHN0cmluZz47XHJcblxyXG4gICAgLyoqIFRpbWUgd2hlbiBhdXRoZW50aWNhdGlvbiBvY2N1cnJlZCAqL1xyXG4gICAgcHVibGljIGF1dGhfdGltZTogbnVtYmVyO1xyXG5cclxuICAgIC8qKiBUaGUgY2xpZW50IHVzZWQgdG8gZ2V0IHRoZSB0b2tlbiAqL1xyXG4gICAgcHVibGljIGNsaWVudF9pZDogc3RyaW5nO1xyXG5cclxuICAgIC8qKiBFeHBpcmF0aW9uIHRpbWUsIHNlY29uZHMgc2luY2UgVW5peCBlcG9jaCAqL1xyXG4gICAgcHVibGljIGV4cDogbnVtYmVyO1xyXG5cclxuICAgIC8qKiBUaGUgaWRlbnRpdHkgcHJvdmlkZXIgICovXHJcbiAgICBwdWJsaWMgaWRwOiBzdHJpbmc7XHJcblxyXG4gICAgLyoqIElzc3Vlciwgd2hvIGNyZWF0ZWQgYW5kIHNpZ25lZCB0aGlzIHRva2VuICovXHJcbiAgICBwdWJsaWMgaXNzOiBzdHJpbmc7XHJcblxyXG4gICAgLyoqIE5vdCB2YWxpZCBiZWZvcmUsIHNlY29uZHMgc2luY2UgVW5peCBlcG9jaCAqL1xyXG4gICAgcHVibGljIG5iZjogbnVtYmVyO1xyXG5cclxuICAgIC8qKiBTdWJqZWN0LCB3aG9tIHRoZSB0b2tlbiByZWZlcnMgdG8gKi9cclxuICAgIHB1YmxpYyBzdWI6IHN0cmluZztcclxuXHJcbiAgICAvKiogVGhlIHNjb3BlcyB0aGUgdG9rZW4gd2FzIHJlcXVlc3RlZCB3aXRoICovXHJcbiAgICBwdWJsaWMgZ2V0IGdldFNjb3BlKCk6IEFycmF5PHN0cmluZz4ge1xyXG4gICAgICAgIGlmICh0eXBlb2YgdGhpcy5zY29wZSA9PT0gJ3N0cmluZycpIHtcclxuICAgICAgICAgICAgdGhpcy5zY29wZSA9IFt0aGlzLnNjb3BlXTtcclxuICAgICAgICB9XHJcblxyXG4gICAgICAgIHJldHVybiB0aGlzLnNjb3BlO1xyXG4gICAgfVxyXG5cclxuICAgIC8qKiBUaGUgYXVkaWVuY2UsIHdobyBvciB3aGF0IHRoZSB0b2tlbiBpcyBpbnRlbmRlZCBmb3IgICovXHJcbiAgICBwdWJsaWMgZ2V0IGdldEF1ZCgpOiBBcnJheTxzdHJpbmc+IHtcclxuICAgICAgICBpZiAodHlwZW9mIHRoaXMuYXVkID09PSAnc3RyaW5nJykge1xyXG4gICAgICAgICAgICB0aGlzLmF1ZCA9IFt0aGlzLmF1ZF07XHJcbiAgICAgICAgfVxyXG5cclxuICAgICAgICByZXR1cm4gdGhpcy5hdWQ7XHJcbiAgICB9XHJcblxyXG4gICAgLyoqIEdldHMgY2xhaW1zIGZvciB0aGUgdXNlciBhc3NvY2lhdGVkIHdpdGggdGhlIGFjY2VzcyB0b2tlbiAqL1xyXG4gICAgcHVibGljIGdldCBjbGFpbXMoKTogQWNjZXNzVG9rZW5DbGFpbXMge1xyXG4gICAgICAgIHJldHVybiB0aGlzLl9jbGFpbXM7XHJcbiAgICB9XHJcblxyXG4gICAgLyoqIFNldHMgY2xhaW1zIGZvciB0aGUgdXNlciBhc3NvY2lhdGUgd2l0aCB0aGUgYWNjZXNzIHRva2VuICovXHJcbiAgICBwdWJsaWMgc2V0IGNsYWltcyh2YWx1ZTogQWNjZXNzVG9rZW5DbGFpbXMpIHtcclxuICAgICAgICB0aGlzLl9jbGFpbXMgPSBuZXcgQWNjZXNzVG9rZW5DbGFpbXModmFsdWUpO1xyXG4gICAgfVxyXG5cclxuICAgIC8qKlxyXG4gICAgICogQ29uc3RydWN0cyB0aGUgYWNjZXNzIFRva2VuXHJcbiAgICAgKiBAcGFyYW0gZW5jb2RlZFRva2VuIFRoZSBlbmNvZGVkIEF1dGggVG9rZW5cclxuICAgICAqL1xyXG4gICAgY29uc3RydWN0b3IoZW5jb2RlZFRva2VuOiBzdHJpbmcpIHtcclxuICAgICAgICBjb25zdCBiYXNlNjRVcmwgPSBlbmNvZGVkVG9rZW4uc3BsaXQoJy4nKVsxXTtcclxuICAgICAgICBjb25zdCBiYXNlNjQgPSBiYXNlNjRVcmwucmVwbGFjZSgvLS9nLCAnKycpXHJcbiAgICAgICAgICAgIC5yZXBsYWNlKC9fL2csICcvJyk7XHJcbiAgICAgICAgY29uc3QganNvblBheWxvYWQgPSBkZWNvZGVVUklDb21wb25lbnQoYXRvYihiYXNlNjQpXHJcbiAgICAgICAgICAgIC5zcGxpdCgnJylcclxuICAgICAgICAgICAgLm1hcChjID0+XHJcbiAgICAgICAgICAgICAgICAvLyB0c2xpbnQ6ZGlzYWJsZS1uZXh0LWxpbmU6IHJlc3RyaWN0LXBsdXMtb3BlcmFuZHMgcHJlZmVyLXRlbXBsYXRlXHJcbiAgICAgICAgICAgICAgICAnJScgKyAoJzAwJyArIGMuY2hhckNvZGVBdCgwKVxyXG4gICAgICAgICAgICAgICAgICAgIC50b1N0cmluZygxNikpXHJcbiAgICAgICAgICAgICAgICAgICAgLnNsaWNlKC0yKSlcclxuICAgICAgICAgICAgLmpvaW4oJycpKTtcclxuICAgICAgICBjb25zdCBkZWNvZGVkVG9rZW46IERlY29kZWRBY2Nlc3NUb2tlbiA9IEpTT04ucGFyc2UoanNvblBheWxvYWQpO1xyXG4gICAgICAgIHRoaXMuc2V0QWxsUHJvcHMoZGVjb2RlZFRva2VuKTtcclxuICAgICAgICB0aGlzLmNvbnZlcnRBbGxEdWFsVHlwZXMoKTtcclxuICAgIH1cclxuXHJcbiAgICAvKiogQ29udmVydHMgYWxsIHRoZSBkdWFsIHR5cGVzIHRvIHNpbmdsZSB0eXBlcyAqL1xyXG4gICAgcHJpdmF0ZSBjb252ZXJ0QWxsRHVhbFR5cGVzKCk6IHZvaWQge1xyXG4gICAgICAgIHRoaXMuZ2V0QXVkO1xyXG4gICAgICAgIHRoaXMuZ2V0U2NvcGU7XHJcbiAgICB9XHJcblxyXG4gICAgLyoqXHJcbiAgICAgKiBTZXRzIGFsbCB0aGUgcHJvcGVydGllcyBmcm9tIGFuIGV4aXN0aW5nIG9iamVjdFxyXG4gICAgICogQHBhcmFtIGRlY29kZWRUb2tlbiBUaGUgZGVjb2RlZCB0b2tlbiBvYmplY3RcclxuICAgICAqL1xyXG4gICAgcHJpdmF0ZSBzZXRBbGxQcm9wcyhkZWNvZGVkVG9rZW46IERlY29kZWRBY2Nlc3NUb2tlbik6IHZvaWQge1xyXG4gICAgICAgIHRoaXMuYW1yID0gZGVjb2RlZFRva2VuLmFtcjtcclxuICAgICAgICB0aGlzLmF1ZCA9IGRlY29kZWRUb2tlbi5hdWQ7XHJcbiAgICAgICAgdGhpcy5hdXRoX3RpbWUgPSBkZWNvZGVkVG9rZW4uYXV0aF90aW1lO1xyXG4gICAgICAgIHRoaXMuY2xpZW50X2lkID0gZGVjb2RlZFRva2VuLmNsaWVudF9pZDtcclxuICAgICAgICB0aGlzLmV4cCA9IGRlY29kZWRUb2tlbi5leHA7XHJcbiAgICAgICAgdGhpcy5pZHAgPSBkZWNvZGVkVG9rZW4uaWRwO1xyXG4gICAgICAgIHRoaXMuaXNzID0gZGVjb2RlZFRva2VuLmlzcztcclxuICAgICAgICB0aGlzLm5iZiA9IGRlY29kZWRUb2tlbi5uYmY7XHJcbiAgICAgICAgdGhpcy5zY29wZSA9IGRlY29kZWRUb2tlbi5zY29wZTtcclxuICAgICAgICB0aGlzLnN1YiA9IGRlY29kZWRUb2tlbi5zdWI7XHJcbiAgICB9XHJcblxyXG59XHJcbiJdfQ==

package/esm2020/lib/rbac/models/rbac-config.mjs

@@ -0,0 +1,4 @@
+/** The Role Based Access Control (RBAC) configuration */
+export class RbacConfig {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmJhYy1jb25maWcuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hcm1hdHVyZS9zcmMvbGliL3JiYWMvbW9kZWxzL3JiYWMtY29uZmlnLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLHlEQUF5RDtBQUN6RCxNQUFNLE9BQU8sVUFBVTtDQVl0QiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IFJvbGVBY2Nlc3MgfSBmcm9tICcuL3JvbGUtYWNjZXNzJztcclxuaW1wb3J0IHsgT2JzZXJ2YWJsZSB9IGZyb20gJ3J4anMnO1xyXG5cclxuLyoqIFRoZSBSb2xlIEJhc2VkIEFjY2VzcyBDb250cm9sIChSQkFDKSBjb25maWd1cmF0aW9uICovXHJcbmV4cG9ydCBjbGFzcyBSYmFjQ29uZmlnIHtcclxuICAgIC8qKiBUaGUgcm9sZSBjb25maWd1cmF0aW9uICovXHJcbiAgICBwdWJsaWMgcm9sZUNvbmZpZzogeyBba2V5OiBzdHJpbmddOiBSb2xlQWNjZXNzIH07XHJcblxyXG4gICAgLyoqIERpc2FibGVzIHRoZSByb2xlIGFjdGlvbnMgaW4gdGhlIGRpcmVjdGl2ZSAqL1xyXG4gICAgcHVibGljIGRpc2FibGVSb2xlQWN0aW9uczogYm9vbGVhbjtcclxuXHJcbiAgICAvKiogVGhlIGFjY2VzcyB0b2tlbiBvYnNlcnZhYmxlICovXHJcbiAgICBwdWJsaWMgYWNjZXNzVG9rZW4kOiBPYnNlcnZhYmxlPHN0cmluZz47XHJcblxyXG4gICAgLyoqIFRoZSB1c2VyIGluZm8gZW5kcG9pbnQgKi9cclxuICAgIHB1YmxpYyB1c2VySW5mb0VuZHBvaW50OiBzdHJpbmc7XHJcbn1cclxuIl19

package/esm2020/lib/rbac/models/role-access.mjs

@@ -0,0 +1,10 @@
+/** The role access class */
+export class RoleAccess {
+    constructor() {
+        /** The pages the role has access to */
+        this.pages = [];
+        /** The actions the role has access to */
+        this.actions = [];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm9sZS1hY2Nlc3MuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hcm1hdHVyZS9zcmMvbGliL3JiYWMvbW9kZWxzL3JvbGUtYWNjZXNzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLDRCQUE0QjtBQUM1QixNQUFNLE9BQU8sVUFBVTtJQUF2QjtRQUNJLHVDQUF1QztRQUNoQyxVQUFLLEdBQW1CLEVBQUUsQ0FBQztRQUVsQyx5Q0FBeUM7UUFDbEMsWUFBTyxHQUFtQixFQUFFLENBQUM7SUFDeEMsQ0FBQztDQUFBIiwic291cmNlc0NvbnRlbnQiOlsiLyoqIFRoZSByb2xlIGFjY2VzcyBjbGFzcyAqL1xyXG5leHBvcnQgY2xhc3MgUm9sZUFjY2VzcyB7XHJcbiAgICAvKiogVGhlIHBhZ2VzIHRoZSByb2xlIGhhcyBhY2Nlc3MgdG8gKi9cclxuICAgIHB1YmxpYyBwYWdlcz86IEFycmF5PHN0cmluZz4gPSBbXTtcclxuXHJcbiAgICAvKiogVGhlIGFjdGlvbnMgdGhlIHJvbGUgaGFzIGFjY2VzcyB0byAqL1xyXG4gICAgcHVibGljIGFjdGlvbnM/OiBBcnJheTxzdHJpbmc+ID0gW107XHJcbn0iXX0=

package/esm2020/lib/rbac/rbac-api.mjs

@@ -0,0 +1,15 @@
+/** Public API Surface of armature */
+export * from './rbac.module';
+// services
+export * from './services/oauth2-role.service';
+export * from './services/role-nav.service';
+export * from './services/ar-role-nav.service';
+// models
+export { RBAC_CONFIG } from './models/constants';
+export * from './models/decoded-access-token';
+export * from './models/access-token-claims';
+export * from './models/rbac-config';
+export * from './models/role-access';
+// directives
+export * from './directives/rbac-action.directive';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmJhYy1hcGkuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9hcm1hdHVyZS9zcmMvbGliL3JiYWMvcmJhYy1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEscUNBQXFDO0FBQ3JDLGNBQWUsZUFBZSxDQUFDO0FBRS9CLFdBQVc7QUFDWCxjQUFjLGdDQUFnQyxDQUFDO0FBQy9DLGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxnQ0FBZ0MsQ0FBQztBQUUvQyxTQUFTO0FBQ1QsT0FBTyxFQUFFLFdBQVcsRUFBRSxNQUFNLG9CQUFvQixDQUFDO0FBQ2pELGNBQWMsK0JBQStCLENBQUM7QUFDOUMsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLHNCQUFzQixDQUFDO0FBQ3JDLGNBQWMsc0JBQXNCLENBQUM7QUFFckMsYUFBYTtBQUNiLGNBQWMsb0NBQW9DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKiogUHVibGljIEFQSSBTdXJmYWNlIG9mIGFybWF0dXJlICovXHJcbmV4cG9ydCAqIGZyb20gICcuL3JiYWMubW9kdWxlJztcclxuXHJcbi8vIHNlcnZpY2VzXHJcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvb2F1dGgyLXJvbGUuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvcm9sZS1uYXYuc2VydmljZSc7XHJcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvYXItcm9sZS1uYXYuc2VydmljZSc7XHJcblxyXG4vLyBtb2RlbHNcclxuZXhwb3J0IHsgUkJBQ19DT05GSUcgfSBmcm9tICcuL21vZGVscy9jb25zdGFudHMnO1xyXG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9kZWNvZGVkLWFjY2Vzcy10b2tlbic7XHJcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL2FjY2Vzcy10b2tlbi1jbGFpbXMnO1xyXG5leHBvcnQgKiBmcm9tICcuL21vZGVscy9yYmFjLWNvbmZpZyc7XHJcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWxzL3JvbGUtYWNjZXNzJztcclxuXHJcbi8vIGRpcmVjdGl2ZXNcclxuZXhwb3J0ICogZnJvbSAnLi9kaXJlY3RpdmVzL3JiYWMtYWN0aW9uLmRpcmVjdGl2ZSc7XHJcbiJdfQ==

package/esm2020/lib/rbac/rbac.module.mjs

@@ -0,0 +1,51 @@
+import { CommonModule } from '@angular/common';
+import { NgModule } from '@angular/core';
+import { Oauth2RoleService } from './services/oauth2-role.service';
+import { ArRoleNavService } from './services/ar-role-nav.service';
+import { RoleNavService } from './services/role-nav.service';
+import { RbacActionDirective } from './directives/rbac-action.directive';
+import { RbacConfig } from './models/rbac-config';
+import * as i0 from "@angular/core";
+/** The role based access control module */
+export class RbacModule {
+    /**
+     * True if role actions should be disabled
+     * @param options the options for the module
+     */
+    static forRoot(options) {
+        const provider = options.config ? { provide: RbacConfig, useValue: options.config } : options.rbacConfigProvider;
+        return {
+            ngModule: RbacModule,
+            providers: [
+                provider,
+                Oauth2RoleService,
+                { provide: RoleNavService, useClass: ArRoleNavService }
+            ]
+        };
+    }
+}
+RbacModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: RbacModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+RbacModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "15.1.5", ngImport: i0, type: RbacModule, declarations: [RbacActionDirective], imports: [CommonModule], exports: [RbacActionDirective] });
+RbacModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: RbacModule, providers: [
+        Oauth2RoleService,
+        { provide: RoleNavService, useClass: ArRoleNavService }
+    ], imports: [CommonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: RbacModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [
+                        RbacActionDirective
+                    ],
+                    imports: [
+                        CommonModule
+                    ],
+                    providers: [
+                        Oauth2RoleService,
+                        { provide: RoleNavService, useClass: ArRoleNavService }
+                    ],
+                    exports: [
+                        RbacActionDirective
+                    ]
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/rbac/services/ar-role-nav.service.mjs

@@ -0,0 +1,91 @@
+import { Injectable } from '@angular/core';
+import * as i0 from "@angular/core";
+/** The armature role navigation service */
+export class ArRoleNavService {
+    /** Constructs the service */
+    constructor() { }
+    /**
+     * Creates a new navigation configuration using the provided RBAC configuration
+     * @param defaultNav The default navigation configuration
+     * @param rbacConfig The rbac configuration
+     * @param roles The roles
+     */
+    createRoleControlledNavigation(defaultNav, rbacConfig, roles) {
+        const controlledNav = [];
+        // flatten role config into one set of pages for all the roles for the user
+        const flattenedPages = new Set();
+        let roleFound = false;
+        roles.forEach(role => {
+            const roleConfig = rbacConfig.roleConfig[role];
+            if (roleConfig) {
+                roleFound = true;
+                // if they have at least one role where they have access to everything give access to everything
+                if (!roleConfig.pages || roleConfig.pages.length === 0) {
+                    flattenedPages.clear();
+                    return;
+                }
+                roleConfig.pages.forEach(page => {
+                    flattenedPages.add(page);
+                });
+            }
+        });
+        if (flattenedPages.size === 0 && !roleFound) {
+            console.warn(`no role matching: ${roles.join(', ')} found, no access is provided`);
+            return controlledNav;
+        }
+        // if the user has no pages, give them access to all of the stuff
+        if (flattenedPages.size === 0 && roleFound) {
+            return defaultNav;
+        }
+        // loop over each level 1 node
+        const deepCopyDefaultNav = JSON.parse(JSON.stringify(defaultNav));
+        deepCopyDefaultNav.forEach(n1 => {
+            // first check which n2 are listed
+            const foundSubNodes = [];
+            n1.subNodes.forEach(sn => {
+                if (this.isRouteMatch(Array.from(flattenedPages.values()), sn.route)) {
+                    foundSubNodes.push(sn);
+                }
+            });
+            n1.subNodes = foundSubNodes;
+            // if level 2 nodes found or level 1 is a route match, add the level 1 node
+            if (foundSubNodes.length > 0 || (n1.route && this.isRouteMatch(Array.from(flattenedPages.values()), n1.route))) {
+                controlledNav.push(n1);
+            }
+        });
+        return controlledNav;
+    }
+    /**
+     * Determines if the route is found in the pages array
+     * @param pages The pages
+     * @param route The route
+     */
+    isRouteMatch(pages, route) {
+        // check wild card
+        return pages.some(p => {
+            if (p.indexOf('**') > -1) {
+                const baseRoute = p.replace('/**/', '')
+                    .replace('**/', '')
+                    .replace('/**', '')
+                    .replace('**', '')
+                    .toLowerCase();
+                if (route.toLowerCase()
+                    .indexOf(baseRoute) > -1) {
+                    return true;
+                }
+            }
+            else if (route.toLowerCase() === p.toLowerCase()) {
+                return true;
+            }
+        });
+    }
+}
+ArRoleNavService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: ArRoleNavService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+ArRoleNavService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: ArRoleNavService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: ArRoleNavService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return []; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"ar-role-nav.service.js","sourceRoot":"","sources":["../../../../../../../projects/armature/src/lib/rbac/services/ar-role-nav.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\r\nimport { NavNode } from '../../navigation/models/navigation';\r\nimport { RbacConfig } from '../models/rbac-config';\r\nimport { RoleNavService } from './role-nav.service';\r\n\r\n/** The armature role navigation service */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class ArRoleNavService implements RoleNavService {\r\n\r\n  /** Constructs the service */\r\n  constructor() { }\r\n\r\n  /**\r\n   * Creates a new navigation configuration using the provided RBAC configuration\r\n   * @param defaultNav The default navigation configuration\r\n   * @param rbacConfig The rbac configuration\r\n   * @param roles The roles\r\n   */\r\n  public createRoleControlledNavigation(defaultNav: Array<NavNode>, rbacConfig: RbacConfig, roles: Array<string>): Array<NavNode> {\r\n    const controlledNav: Array<NavNode> = [];\r\n    // flatten role config into one set of pages for all the roles for the user\r\n    const flattenedPages: Set<string> = new Set<string>();\r\n    let roleFound = false;\r\n    roles.forEach(role => {\r\n      const roleConfig = rbacConfig.roleConfig[role];\r\n      if (roleConfig) {\r\n        roleFound = true;\r\n        // if they have at least one role where they have access to everything give access to everything\r\n        if (!roleConfig.pages || roleConfig.pages.length === 0) {\r\n          flattenedPages.clear();\r\n\r\n          return;\r\n        }\r\n        roleConfig.pages.forEach(page => {\r\n          flattenedPages.add(page);\r\n        });\r\n      }\r\n    });\r\n    if (flattenedPages.size === 0 && !roleFound) {\r\n      console.warn(`no role matching: ${roles.join(', ')} found, no access is provided`);\r\n\r\n      return controlledNav;\r\n    }\r\n\r\n    // if the user has no pages, give them access to all of the stuff\r\n    if (flattenedPages.size === 0 && roleFound) {\r\n      return defaultNav;\r\n    }\r\n\r\n    // loop over each level 1 node\r\n    const deepCopyDefaultNav: Array<NavNode> = JSON.parse(JSON.stringify(defaultNav));\r\n    deepCopyDefaultNav.forEach(n1 => {\r\n      // first check which n2 are listed\r\n      const foundSubNodes = [];\r\n      n1.subNodes.forEach(sn => {\r\n        if (this.isRouteMatch(Array.from(flattenedPages.values()), sn.route)) {\r\n          foundSubNodes.push(sn);\r\n        }\r\n      });\r\n\r\n      n1.subNodes = foundSubNodes;\r\n      // if level 2 nodes found or level 1 is a route match, add the level 1 node\r\n      if (foundSubNodes.length > 0 || (n1.route && this.isRouteMatch(Array.from(flattenedPages.values()), n1.route))) {\r\n        controlledNav.push(n1);\r\n      }\r\n    });\r\n\r\n    return controlledNav;\r\n  }\r\n\r\n  /**\r\n   * Determines if the route is found in the pages array\r\n   * @param pages The pages\r\n   * @param route The route\r\n   */\r\n  private isRouteMatch(pages: Array<string>, route: string): boolean {\r\n    // check wild card\r\n    return pages.some(p => {\r\n      if (p.indexOf('**') > -1) {\r\n        const baseRoute = p.replace('/**/', '')\r\n          .replace('**/', '')\r\n          .replace('/**', '')\r\n          .replace('**', '')\r\n          .toLowerCase();\r\n\r\n        if (route.toLowerCase()\r\n          .indexOf(baseRoute) > -1) {\r\n          return true;\r\n        }\r\n      }\r\n      else if (route.toLowerCase() === p.toLowerCase()) {\r\n        return true;\r\n      }\r\n    });\r\n  }\r\n}\r\n"]}

package/esm2020/lib/rbac/services/oauth2-role.service.mjs

@@ -0,0 +1,114 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Injectable, Optional } from '@angular/core';
+import { of, ReplaySubject } from 'rxjs';
+import { catchError, map } from 'rxjs/operators';
+import { DecodedAccessToken } from '../models/decoded-access-token';
+import * as i0 from "@angular/core";
+import * as i1 from "../models/rbac-config";
+import * as i2 from "@angular/common/http";
+import * as i3 from "./role-nav.service";
+/**
+ * The oauth 2 role service
+ * Supplies the role using an OAuth 2.0 access token
+ */
+export class Oauth2RoleService {
+    /**
+     * Constructs the service
+     * @param rbacConfig The rbac configurations
+     * @param httpClient The http client
+     * @param roleNavService The role nav service
+     */
+    constructor(rbacConfig, httpClient, roleNavService) {
+        this.rbacConfig = rbacConfig;
+        this.httpClient = httpClient;
+        this.roleNavService = roleNavService;
+        /** True if configs were provided at construction */
+        this.configsProvidedAtConstruction = false;
+        /** The decoded access token behavior subject */
+        this.decodeToken = new ReplaySubject(undefined);
+        // get the token initially then update it based on injected refresh time
+        this.decodedToken$ = this.decodeToken.asObservable();
+        if (this.rbacConfig) {
+            this.configsProvidedAtConstruction = true;
+            this.init();
+        }
+    }
+    /**
+     * Gets the role controlled navigation configuration
+     * @param defaultNav The default navigation
+     * @param roles The roles of the user
+     */
+    getControlledNavObject(defaultNav, roles) {
+        return this.roleNavService.createRoleControlledNavigation(defaultNav, this.rbacConfig, roles);
+    }
+    /**
+     * Configures the service
+     * @param rbacConfig The rbac config
+     */
+    configure(rbacConfig) {
+        this.rbacConfig = rbacConfig;
+        this.init();
+    }
+    /**
+     * Determines if the current token has access to the action
+     * @param action The action to check access for
+     */
+    hasActionAccess(action) {
+        if (this.rbacConfig.disableRoleActions) {
+            return of(true);
+        }
+        return this.decodedToken$.pipe(map(token => {
+            const roles = token.claims.getRole;
+            // if no roles, no action access
+            if (!roles || roles.length === 0) {
+                return false;
+            }
+            // flatten role config into one set of actions for all the actions for the user
+            const flattenedActions = new Set();
+            roles.forEach(role => {
+                const roleConfig = this.rbacConfig.roleConfig[role];
+                if (!roleConfig || !roleConfig.actions || !roleConfig.actions.length) {
+                    return false;
+                }
+                roleConfig.actions.forEach(a => flattenedActions.add(a.toLowerCase()));
+            });
+            return flattenedActions.has(action.toLowerCase());
+        }));
+    }
+    /** Initializer logic for the service */
+    async init() {
+        this.rbacConfig.accessToken$.subscribe(token => {
+            this.token = token;
+            if (!this.token) {
+                return;
+            }
+            const decoded = new DecodedAccessToken(this.token);
+            // create the headers for the user info call with the existing access token
+            const headers = new HttpHeaders({ Authorization: `Bearer ${this.token}`, 'Access-Control-Allow-Origin': '*' });
+            this.httpClient.get(this.rbacConfig.userInfoEndpoint, { headers })
+                .pipe(
+            // map the results to the props
+            map(res => {
+                decoded.claims = res;
+                this.decodeToken.next(decoded);
+            }), 
+            // continue on error and log to console
+            catchError(error => {
+                console.error(`Unable to retrieve user info for: ${this.token}`, error);
+                return of(error);
+            }))
+                .subscribe();
+        });
+    }
+}
+Oauth2RoleService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: Oauth2RoleService, deps: [{ token: i1.RbacConfig, optional: true }, { token: i2.HttpClient }, { token: i3.RoleNavService }], target: i0.ɵɵFactoryTarget.Injectable });
+Oauth2RoleService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: Oauth2RoleService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: Oauth2RoleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.RbacConfig, decorators: [{
+                    type: Optional
+                }] }, { type: i2.HttpClient }, { type: i3.RoleNavService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"oauth2-role.service.js","sourceRoot":"","sources":["../../../../../../../projects/armature/src/lib/rbac/services/oauth2-role.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpHeaders } from '@angular/common/http';\r\nimport { Inject, Injectable, Optional } from '@angular/core';\r\nimport { Observable, of, ReplaySubject } from 'rxjs';\r\nimport { catchError, map } from 'rxjs/operators';\r\nimport { NavNode } from '../../navigation/navigation-api';\r\nimport { AccessTokenClaims } from '../models/access-token-claims';\r\nimport { RBAC_CONFIG } from '../models/constants';\r\nimport { DecodedAccessToken } from '../models/decoded-access-token';\r\nimport { RbacConfig } from '../models/rbac-config';\r\nimport { RoleNavService } from './role-nav.service';\r\n\r\n/**\r\n * The oauth 2 role service\r\n * Supplies the role using an OAuth 2.0 access token\r\n */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class Oauth2RoleService {\r\n\r\n  /** True if configs were provided at construction */\r\n  private configsProvidedAtConstruction: boolean = false;\r\n\r\n  /** The decoded access token behavior subject */\r\n  private readonly decodeToken: ReplaySubject<DecodedAccessToken> = new ReplaySubject(undefined);\r\n\r\n  /** The current access token */\r\n  public token: string;\r\n\r\n  /** The decoded access token */\r\n  public decodedToken$: Observable<DecodedAccessToken>;\r\n\r\n  /**\r\n   * Constructs the service\r\n   * @param rbacConfig The rbac configurations\r\n   * @param httpClient The http client\r\n   * @param roleNavService The role nav service\r\n   */\r\n  constructor(\r\n    @Optional() private rbacConfig: RbacConfig,\r\n    private readonly httpClient: HttpClient,\r\n    private readonly roleNavService: RoleNavService\r\n  ) {\r\n    // get the token initially then update it based on injected refresh time\r\n    this.decodedToken$ = this.decodeToken.asObservable();\r\n    if (this.rbacConfig) {\r\n      this.configsProvidedAtConstruction = true;\r\n      this.init();\r\n    }\r\n  }\r\n\r\n  /**\r\n   * Gets the role controlled navigation configuration\r\n   * @param defaultNav The default navigation\r\n   * @param roles The roles of the user\r\n   */\r\n  public getControlledNavObject(defaultNav: Array<NavNode>, roles: Array<string>): Array<NavNode> {\r\n      return this.roleNavService.createRoleControlledNavigation(defaultNav, this.rbacConfig, roles);\r\n  }\r\n\r\n  /**\r\n   * Configures the service\r\n   * @param rbacConfig The rbac config\r\n   */\r\n  public configure(rbacConfig: RbacConfig): void {\r\n    this.rbacConfig = rbacConfig;\r\n    this.init();\r\n  }\r\n\r\n  /**\r\n   * Determines if the current token has access to the action\r\n   * @param action The action to check access for\r\n   */\r\n  public hasActionAccess(action: string): Observable<boolean> {\r\n    if (this.rbacConfig.disableRoleActions) {\r\n      return of(true);\r\n    }\r\n\r\n    return this.decodedToken$.pipe(map(token => {\r\n      const roles = token.claims.getRole;\r\n      // if no roles, no action access\r\n      if (!roles || roles.length === 0) {\r\n        return false;\r\n      }\r\n      // flatten role config into one set of actions for all the actions for the user\r\n      const flattenedActions: Set<string> = new Set<string>();\r\n      roles.forEach(role => {\r\n        const roleConfig = this.rbacConfig.roleConfig[role];\r\n        if (!roleConfig || !roleConfig.actions || !roleConfig.actions.length) {\r\n          return false;\r\n        }\r\n        roleConfig.actions.forEach(a => flattenedActions.add(a.toLowerCase()));\r\n      });\r\n\r\n      return flattenedActions.has(action.toLowerCase());\r\n    }));\r\n  }\r\n\r\n  /** Initializer logic for the service */\r\n  private async init(): Promise<any> {\r\n    this.rbacConfig.accessToken$.subscribe(token => {\r\n      this.token = token;\r\n      if (!this.token) {\r\n        return;\r\n      }\r\n      const decoded = new DecodedAccessToken(this.token);\r\n\r\n      // create the headers for the user info call with the existing access token\r\n      const headers = new HttpHeaders({ Authorization: `Bearer ${this.token}`, 'Access-Control-Allow-Origin': '*' });\r\n      this.httpClient.get<AccessTokenClaims>(this.rbacConfig.userInfoEndpoint, { headers })\r\n        .pipe(\r\n          // map the results to the props\r\n          map(res => {\r\n            decoded.claims = res;\r\n            this.decodeToken.next(decoded);\r\n          }),\r\n          // continue on error and log to console\r\n          catchError(error => {\r\n            console.error(`Unable to retrieve user info for: ${this.token}`, error);\r\n\r\n            return of(error);\r\n          }))\r\n        .subscribe();\r\n    });\r\n  }\r\n\r\n}\r\n"]}

package/esm2020/lib/rbac/services/role-nav.service.mjs

@@ -0,0 +1,4 @@
+/** The role navigation service interface */
+export class RoleNavService {
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicm9sZS1uYXYuc2VydmljZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FybWF0dXJlL3NyYy9saWIvcmJhYy9zZXJ2aWNlcy9yb2xlLW5hdi5zZXJ2aWNlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLDRDQUE0QztBQUM1QyxNQUFNLE9BQWdCLGNBQWM7Q0FRbkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBOYXZOb2RlIH0gZnJvbSAnLi4vLi4vbmF2aWdhdGlvbi9tb2RlbHMvbmF2aWdhdGlvbic7XHJcbmltcG9ydCB7IFJiYWNDb25maWcgfSBmcm9tICcuLi9tb2RlbHMvcmJhYy1jb25maWcnO1xyXG5cclxuLyoqIFRoZSByb2xlIG5hdmlnYXRpb24gc2VydmljZSBpbnRlcmZhY2UgKi9cclxuZXhwb3J0IGFic3RyYWN0IGNsYXNzIFJvbGVOYXZTZXJ2aWNlIHtcclxuICAgIC8qKlxyXG4gICAgICogQ3JlYXRlcyBhIG5ldyBuYXZpZ2F0aW9uIGNvbmZpZyB1c2luZyB0aGUgcHJvdmlkZWQgZGVmYXVsdCBuYXZpZ2F0aW9uIGNvbmZpZyBhbmQgdGhlIFJBQkMgY29uZmlndXJhdGlvblxyXG4gICAgICogQHBhcmFtIGRlZmF1bHROYXYgVGhlIGRlZmF1bHQgbmF2aWdhdGlvbiBjb25maWdcclxuICAgICAqIEBwYXJhbSByYmFjQ29uZmlnIFRoZSByYmFjIGNvbmZpZyB1c2VkIGZvciBsaW1pdGluZyB0aGUgbmF2aWdhdGlvblxyXG4gICAgICogQHBhcmFtIHJvbGVzIHRoZSBhcnJheSBvZiByb2xlc1xyXG4gICAgICovXHJcbiAgICBwdWJsaWMgYWJzdHJhY3QgY3JlYXRlUm9sZUNvbnRyb2xsZWROYXZpZ2F0aW9uKGRlZmF1bHROYXY6IEFycmF5PE5hdk5vZGU+LCByYmFjQ29uZmlnOiBSYmFjQ29uZmlnLCByb2xlczogQXJyYXk8c3RyaW5nPik6IEFycmF5PE5hdk5vZGU+O1xyXG59XHJcbiJdfQ==