Reverted refactoring of RoleBasedSecuredBindingHandler.

Author: azaslonov

src/ko/bindingHandlers/bindingHandlers.roleBasedSecured.ts

@@ -1,8 +1,7 @@
 import * as ko from "knockout";
-import { UserService } from "@paperbits/common/user";
+import { BuiltInRoles, UserService } from "@paperbits/common/user";
 import { EventManager } from "@paperbits/common/events";
 import { RoleBasedSecurityModel } from "@paperbits/common/security/roleBasedSecurityModel";
-import { RoleBasedSecuredBehavior, RoleBasedSecuredBehaviorConfig } from "@paperbits/common/behaviors/behavior.roleBasedSecured";
 
 
 export class RoleBasedSecuredBindingHandler {
@@ -11,45 +10,48 @@ export class RoleBasedSecuredBindingHandler {
         private readonly userService: UserService
     ) {
         ko.bindingHandlers["secured"] = {
-            init: (element: HTMLElement, valueAccessor: () => ko.Observable<RoleBasedSecurityModel> | RoleBasedSecurityModel) => {
-                const securityModelObservableOrStatic = valueAccessor();
-                const initialSecurityModel = ko.unwrap(securityModelObservableOrStatic);
-
-                const dataRoleObservable: ko.Observable<string | null> = ko.observable(null);
+            init: (element: HTMLElement, valueAccessor: any) => {
+                const securityModel = ko.unwrap(valueAccessor());
+                const initiallyAssignedRoles = securityModel?.roles;
+                const dataRoleObservable: ko.Observable<string> = ko.observable(initiallyAssignedRoles);
                 const hiddenObservable: ko.Observable<boolean> = ko.observable(false);
 
-                const behaviorConfig: RoleBasedSecuredBehaviorConfig = {
-                    initialSecurityModel: initialSecurityModel,
-                    userService: this.userService,
-                    eventManager: this.eventManager,
-                    onUpdate: (roles, isHidden) => {
-                        dataRoleObservable(roles);
-                        hiddenObservable(isHidden);
-                    }
+                const applyRoles = (securityModel: RoleBasedSecurityModel) => { // has to be synchronous to be applied during publishing
+                    const widgetRoles = securityModel?.roles || [BuiltInRoles.everyone.key];
+
+                    const roles = widgetRoles
+                        && widgetRoles.length === 1
+                        && widgetRoles[0] === BuiltInRoles.everyone.key
+                        ? null
+                        : widgetRoles.join(",");
+
+                    dataRoleObservable(roles);
+                    applyVisibility();
+                };
+
+                const applyVisibility = async () => { // doesn't have to be synchronous, used in design- and run-time only
+                    const widgetRolesString = dataRoleObservable();
+                    const widgetRoles = !!widgetRolesString ? widgetRolesString.split(",") : [BuiltInRoles.everyone.key];
+                    const userRoles = await this.userService.getUserRoles();
+                    const visibleToUser = userRoles.some(x => widgetRoles.includes(x)) || widgetRoles.includes(BuiltInRoles.everyone.key);
+
+                    hiddenObservable(!visibleToUser);
                 };
 
-                const behaviorHandle = RoleBasedSecuredBehavior.attach(element, behaviorConfig);
+                this.eventManager.addEventListener("onUserRoleChange", applyVisibility);
 
                 ko.applyBindingsToNode(element, {
                     attr: { "data-role": dataRoleObservable },
                     css: { hidden: hiddenObservable }
                 }, null);
 
-                let subscription: ko.Subscription | undefined;
-                if (ko.isObservable(securityModelObservableOrStatic)) {
-                    subscription = securityModelObservableOrStatic.subscribe((newModel) => {
-                        behaviorHandle.update && behaviorHandle.update(newModel);
-                    });
-                }
-
                 ko.utils.domNodeDisposal.addDisposeCallback(element, () => {
-                    if (subscription) {
-                        subscription.dispose();
-                    }
-                    if (behaviorHandle && behaviorHandle.detach) {
-                        behaviorHandle.detach();
-                    }
+                    this.eventManager.removeEventListener("onUserRoleChange", applyVisibility);
                 });
+
+                const assignedRolesObsevable: ko.Observable<RoleBasedSecurityModel> = valueAccessor();
+                assignedRolesObsevable.subscribe(applyRoles);
+                applyRoles(securityModel);
             }
         };
     }