source.dussan.org Git - archiva.git/blob

   1 import { Component, OnInit } from '@angular/core';
   2 import { Role } from '@app/model/role';
   3 import {UserService} from "@app/services/user.service";
   4 import {ActivatedRoute} from "@angular/router";
   5 import {filter, map, switchMap} from "rxjs/operators";
   6 import {RoleTree} from "@app/model/role-tree";
   7 import {RoleService} from "@app/services/role.service";
   8 import {RoleTemplate} from "@app/model/role-template";
   9 import {Observable} from "rxjs";
  10 import {Util} from "@app/modules/shared/shared.module";
  11
  12 @Component({
  13   selector: 'app-manage-users-roles',
  14   templateUrl: './manage-users-roles.component.html',
  15   styleUrls: ['./manage-users-roles.component.scss']
  16 })
  17 export class ManageUsersRolesComponent implements OnInit {
  18
  19   baseRoles : Array<Role>
  20   guest: Role
  21   registered: Role
  22   // Map of (resource, [roles])
  23   templateRoleInstances: Map<string, Array<Role>>
  24   templateRoles$: Observable<RoleTemplate[]>;
  25
  26   constructor(private route : ActivatedRoute, private userService : UserService, private roleService : RoleService) {
  27     this.route.params.pipe(
  28         map(params => params.userid), filter(userid => userid!=null), switchMap(userid => userService.userRoleTree(userid))).subscribe(roleTree => {
  29       this.parseRoleTree(roleTree);
  30     });
  31
  32   }
  33
  34   ngOnInit(): void {
  35     this.templateRoles$ = this.roleService.getTemplates();
  36   }
  37
  38   private parseRoleTree(roleTree:RoleTree): void {
  39     let roleTable = [];
  40     for(let rootRole of roleTree.root_roles) {
  41       roleTable = this.recurseRoleTree(rootRole, roleTable, 0);
  42     }
  43     this.baseRoles = roleTable;
  44     let templateMap : Map<string,Array<Role>> = new Map<string, Array<Role>>();
  45     for (let rootRole of roleTree.root_roles) {
  46       templateMap = this.recurseTemplates(rootRole, templateMap, 0);
  47     }
  48     this.templateRoleInstances = templateMap;
  49   }
  50
  51   private recurseRoleTree(role:Role, roles : Array<Role>, level:number) : Array<Role> {
  52     if (role.id=='guest') {
  53       this.guest = role;
  54     } else if (role.id=='registered-user') {
  55       this.registered = role;
  56     }
  57     role.enabled=true;
  58     let newLevel;
  59     if (!role.template_instance && role.assignable) {
  60       role.level=level
  61       roles.push(role);
  62       newLevel = level+1;
  63     } else {
  64       newLevel = level;
  65     }
  66     for(let childRole of role.children) {
  67       roles = this.recurseRoleTree(childRole, roles, newLevel);
  68     }
  69     return roles;
  70   }
  71
  72   private recurseTemplates(role:Role, roles : Map<string, Array<Role>>, level:number) : Map<string, Array<Role>> {
  73     role.enabled=true;
  74     if (role.template_instance && role.assignable) {
  75       role.level=level
  76       let roleList = roles.get(role.resource)
  77       if (roleList==null) {
  78         roleList = []
  79       }
  80       roleList.push(role);
  81       roles.set(role.resource, roleList);
  82     }
  83     for(let childRole of role.children) {
  84       roles = this.recurseTemplates(childRole, roles, level+1);
  85     }
  86     return roles;
  87   }
  88
  89   getRoleContent(role:Role) : string {
  90     let level = role.level
  91     let result = "";
  92     for(let _i=0; _i<level; _i++) {
  93       result = result + "&nbsp;<i class='fas fa-angle-double-right'></i>&nbsp;";
  94     }
  95     if (role.child) {
  96       return result + role.name;
  97     } else {
  98       return "<strong>"+result+role.name+"</strong>"
  99     }
 100   }
 101
 102   changeBaseAssignment(role : Role, event) {
 103     let cLevel=-1
 104     let assignStatus;
 105     if (role.id==this.guest.id) {
 106       if (role.assigned) {
 107         for (let cRole of this.baseRoles) {
 108           if (cRole.id != this.guest.id) {
 109             cRole.assigned = false;
 110             cRole.enabled=true;
 111           }
 112         }
 113         role.enabled = false;
 114       }
 115     } else {
 116       this.guest.enabled = true;
 117       for (let cRole of this.baseRoles) {
 118         if (cRole.id == role.id) {
 119           console.log("Value: " + cRole.assigned);
 120           cLevel = cRole.level;
 121           assignStatus = cRole.assigned;
 122           if (assignStatus) {
 123             this.guest.assigned = false;
 124           } else {
 125             if (!this.baseRoles.find(role=>role.assigned)) {
 126               this.guest.assigned=true;
 127             }
 128           }
 129         } else {
 130           console.log("Level " + cLevel);
 131           if (cLevel >= 0 && cLevel < cRole.level) {
 132             if (assignStatus) {
 133               cRole.assigned = true;
 134               cRole.enabled = false;
 135             } else {
 136               cRole.enabled = true;
 137             }
 138           } else if (cLevel >= 0) {
 139             break;
 140           }
 141         }
 142       }
 143     }
 144   }
 145
 146   changeInstAssignment(role : Role, event) {
 147     console.log("Change " + role.id);
 148     console.log("Assignment changed "+JSON.stringify(event));
 149     console.log("Event target "+event.target);
 150   }
 151
 152   getInstanceContent(template:RoleTemplate, roles:Array<Role>) : Role {
 153       return roles.find(role=>role.model_id==template.id)
 154   }
 155 }