Implement resource member administration

smp-angular/src/app/app.module.ts

@@ -150,6 +150,8 @@ import {GroupResourcePanelComponent} from "./edit/edit-group/group-resource-pane
 import {
   ResourceDialogComponent
 } from "./edit/edit-group/group-resource-panel/resource-dialog/resource-dialog.component";
+import {EditResourceComponent} from "./edit/edit-resources/edit-resource.component";
+import {EditResourceService} from "./edit/edit-resources/edit-resource.service";
 
 
 @NgModule({
@@ -188,6 +190,7 @@ import {
     DomainSelectorComponent,
     EditDomainComponent,
     EditGroupComponent,
+    EditResourceComponent,
     ExpiredPasswordDialogComponent,
     ExtensionComponent,
     ExtensionPanelComponent,
@@ -285,6 +288,7 @@ import {
     DownloadService,
     EditDomainService,
     EditGroupService,
+    EditResourceService,
     ExtensionService,
     GlobalLookups,
     HttpEventService,

smp-angular/src/app/app.routes.ts

@@ -15,6 +15,7 @@ import {dirtyDeactivateGuard} from "./guards/dirty.guard";
 import {AdminUserComponent} from "./system-settings/admin-users/admin-user.component";
 import {EditDomainComponent} from "./edit/edit-domain/edit-domain.component";
 import {EditGroupComponent} from "./edit/edit-group/edit-group.component";
+import {EditResourceComponent} from "./edit/edit-resources/edit-resource.component";
 
 
 const appRoutes: Routes = [
@@ -28,7 +29,7 @@ const appRoutes: Routes = [
     children: [
       {path: 'edit-domain', component: EditDomainComponent, canDeactivate: [dirtyDeactivateGuard]},
       {path: 'edit-group', component: EditGroupComponent, canDeactivate: [dirtyDeactivateGuard]},
-      {path: 'edit-resource', component: PropertyComponent, canDeactivate: [dirtyDeactivateGuard]}
+      {path: 'edit-resource', component: EditResourceComponent, canDeactivate: [dirtyDeactivateGuard]}
     ]
   },
   {

smp-angular/src/app/common/dialogs/member-dialog/member-dialog.component.ts

@@ -10,6 +10,7 @@ import {DomainRo} from "../../model/domain-ro.model";
 import {MemberTypeEnum} from "../../enums/member-type.enum";
 import {AlertMessageService} from "../../alert-message/alert-message.service";
 import {GroupRo} from "../../model/group-ro.model";
+import {ResourceRo} from "../../model/resource-ro.model";
 
 
 @Component({
@@ -28,6 +29,7 @@ export class MemberDialogComponent implements OnInit {
   _currentMember: MemberRo;
   _currentDomain: DomainRo;
   _currentGroup: GroupRo;
+  _currentResource: ResourceRo;
   membershipType: MemberTypeEnum = MemberTypeEnum.DOMAIN;
 
   filteredOptions: Observable<SearchUserRo[]>;
@@ -46,6 +48,7 @@ export class MemberDialogComponent implements OnInit {
     dialogRef.disableClose = true;//disable default close operation
     this._currentDomain = data.domain;
     this._currentGroup = data.group;
+    this._currentResource = data.resource;
     this.membershipType= data.membershipType;
 
     this.memberForm = formBuilder.group({
@@ -113,7 +116,7 @@ export class MemberDialogComponent implements OnInit {
       case MemberTypeEnum.GROUP:
         return " group ["+this._currentGroup?.groupName+"]"
       case MemberTypeEnum.RESOURCE:
-        return " resource"
+        return " resource ["+this._currentResource?.resourceTypeIdentifier+"]"
     }
     return " target not selected!"
   }
@@ -160,7 +163,7 @@ export class MemberDialogComponent implements OnInit {
       case MemberTypeEnum.GROUP:
         return  this.membershipService.addEditMemberToGroup(this._currentGroup.groupId,this._currentDomain.domainId, this.member)
       case MemberTypeEnum.RESOURCE:
-        return null;
+        return  this.membershipService.addEditMemberToResource(this._currentResource, this._currentGroup,this._currentDomain, this.member)
     }
   }
 }

smp-angular/src/app/common/panels/membership-panel/membership-panel.component.ts

@@ -16,6 +16,7 @@ import {GroupRo} from "../../model/group-ro.model";
 import {Observable} from "rxjs";
 import {SearchTableResult} from "../../search-table/search-table-result.model";
 import {ConfirmationDialogComponent} from "../../dialogs/confirmation-dialog/confirmation-dialog.component";
+import {ResourceRo} from "../../model/resource-ro.model";
 
 
 @Component({
@@ -29,6 +30,7 @@ export class MembershipPanelComponent implements BeforeLeaveGuard {
 
   private _domain: DomainRo;
   private _group: GroupRo;
+  private _resource: ResourceRo;
 
 
   displayedColumns: string[] = ['username', 'fullName', 'roleType', 'memberOf'];
@@ -94,7 +96,21 @@ export class MembershipPanelComponent implements BeforeLeaveGuard {
       this.isLoadingResults = false;
     }
   }
+  get resource(): ResourceRo {
+    return this._resource;
+  }
+
+  @Input() set resource(value: ResourceRo) {
+    this._resource = value;
 
+    if (!!value) {
+      if (this.membershipType == MemberTypeEnum.RESOURCE) {
+        this.loadMembershipData();
+      }
+    } else {
+      this.isLoadingResults = false;
+    }
+  }
 
   onPageChanged(page: PageEvent) {
     this.loadMembershipData();
@@ -162,6 +178,7 @@ export class MembershipPanelComponent implements BeforeLeaveGuard {
         membershipType: this.membershipType,
         domain: this._domain,
         group: this._group,
+        resource: this._resource,
         member: member,
       }
     }).afterClosed().subscribe(value => {
@@ -201,7 +218,7 @@ export class MembershipPanelComponent implements BeforeLeaveGuard {
       case MemberTypeEnum.GROUP:
         return !this._group;
       case MemberTypeEnum.RESOURCE:
-        return false;
+        return !this._resource;
     }
   }
 
@@ -212,7 +229,8 @@ export class MembershipPanelComponent implements BeforeLeaveGuard {
       case MemberTypeEnum.GROUP:
         return this.membershipService.getGroupMembersObservable(this._group.groupId, this._domain.domainId, this.filter, this.paginator.pageIndex, this.paginator.pageSize);
       case MemberTypeEnum.RESOURCE:
-        return null;
+        return this.membershipService.getResourceMembersObservable(this._resource, this._group, this._domain, this.filter, this.paginator.pageIndex, this.paginator.pageSize);
+
     }
   }
 
@@ -223,7 +241,7 @@ export class MembershipPanelComponent implements BeforeLeaveGuard {
       case MemberTypeEnum.GROUP:
         return this.membershipService.deleteMemberFromGroup(this._group.groupId, this._domain.domainId, this.selectedMember);
       case MemberTypeEnum.RESOURCE:
-        return null;
+        return this.membershipService.deleteMemberFromResource(this._resource, this._group, this._domain, this.selectedMember);
     }
   }
 }

smp-angular/src/app/common/panels/membership-panel/membership.service.ts

@@ -9,6 +9,9 @@ import {AlertMessageService} from "../../alert-message/alert-message.service";
 import {MemberRo} from "../../model/member-ro.model";
 import {TableResult} from "../../model/table-result.model";
 import {SearchUserRo} from "../../model/search-user-ro.model";
+import {ResourceRo} from "../../model/resource-ro.model";
+import {GroupRo} from "../../model/group-ro.model";
+import {DomainRo} from "../../model/domain-ro.model";
 
 
 @Injectable()
@@ -54,13 +57,32 @@ export class MembershipService {
         params = params.set(filterProperty, encodeURIComponent(filter[filterProperty]));
       }
     }
-
     return this.http.get<TableResult<MemberRo>>(SmpConstants.REST_EDIT_GROUP_MEMBER
       .replace(SmpConstants.PATH_PARAM_ENC_USER_ID, currentUser.userId)
       .replace(SmpConstants.PATH_PARAM_ENC_DOMAIN_ID, domainId)
       .replace(SmpConstants.PATH_PARAM_ENC_GROUP_ID, groupId), {params});
   }
 
+  getResourceMembersObservable(resource: ResourceRo, group: GroupRo, domain: DomainRo, filter: any, page: number, pageSize: number): Observable<SearchTableResult> {
+    const currentUser: User = this.securityService.getCurrentUser();
+
+    let params: HttpParams = new HttpParams()
+      .set('page', page.toString())
+      .set('pageSize', pageSize.toString());
+
+    for (let filterProperty in filter) {
+      if (filter.hasOwnProperty(filterProperty)) {
+        // must encode else problem with + sign
+        params = params.set(filterProperty, encodeURIComponent(filter[filterProperty]));
+      }
+    }
+    return this.http.get<TableResult<MemberRo>>(SmpConstants.REST_EDIT_RESOURCE_MEMBER
+      .replace(SmpConstants.PATH_PARAM_ENC_USER_ID, currentUser.userId)
+      .replace(SmpConstants.PATH_PARAM_ENC_DOMAIN_ID, domain.domainId)
+      .replace(SmpConstants.PATH_PARAM_ENC_GROUP_ID, group.groupId)
+      .replace(SmpConstants.PATH_PARAM_ENC_RESOURCE_ID, resource.resourceId), {params});
+  }
+
   getUserLookupObservable(filter: string): Observable<SearchUserRo[]> {
     const currentUser: User = this.securityService.getCurrentUser();
     let params: HttpParams = new HttpParams()
@@ -77,6 +99,7 @@ export class MembershipService {
       .replace(SmpConstants.PATH_PARAM_ENC_USER_ID, currentUser.userId)
       .replace(SmpConstants.PATH_PARAM_ENC_DOMAIN_ID, domainId), member);
   }
+
   addEditMemberToGroup(groupId: string, domainId: string, member: MemberRo): Observable<MemberRo> {
     const currentUser: User = this.securityService.getCurrentUser();
 
@@ -86,6 +109,16 @@ export class MembershipService {
       .replace(SmpConstants.PATH_PARAM_ENC_GROUP_ID, groupId), member);
   }
 
+  addEditMemberToResource(resource: ResourceRo, group: GroupRo, domain: DomainRo, member: MemberRo): Observable<MemberRo> {
+    const currentUser: User = this.securityService.getCurrentUser();
+
+    return this.http.put<MemberRo>(SmpConstants.REST_EDIT_RESOURCE_MEMBER_PUT
+      .replace(SmpConstants.PATH_PARAM_ENC_USER_ID, currentUser.userId)
+      .replace(SmpConstants.PATH_PARAM_ENC_DOMAIN_ID, domain.domainId)
+      .replace(SmpConstants.PATH_PARAM_ENC_GROUP_ID, group.groupId)
+      .replace(SmpConstants.PATH_PARAM_ENC_RESOURCE_ID, resource.resourceId), member);
+  }
+
   deleteMemberFromDomain(domainId: string, member: MemberRo): Observable<MemberRo> {
     const currentUser: User = this.securityService.getCurrentUser();
 
@@ -95,7 +128,7 @@ export class MembershipService {
       .replace(SmpConstants.PATH_PARAM_ENC_MEMBER_ID, member.memberId));
   }
 
-  deleteMemberFromGroup(groupId: string,domainId: string,  member: MemberRo): Observable<MemberRo> {
+  deleteMemberFromGroup(groupId: string, domainId: string, member: MemberRo): Observable<MemberRo> {
     const currentUser: User = this.securityService.getCurrentUser();
 
     return this.http.delete<MemberRo>(SmpConstants.REST_EDIT_GROUP_MEMBER_DELETE
@@ -105,4 +138,15 @@ export class MembershipService {
       .replace(SmpConstants.PATH_PARAM_ENC_MEMBER_ID, member.memberId));
   }
 
+  deleteMemberFromResource(resource:ResourceRo, group:GroupRo, domain: DomainRo, member: MemberRo): Observable<MemberRo> {
+    const currentUser: User = this.securityService.getCurrentUser();
+
+    return this.http.delete<MemberRo>(SmpConstants.REST_EDIT_RESOURCE_MEMBER_DELETE
+      .replace(SmpConstants.PATH_PARAM_ENC_USER_ID, currentUser.userId)
+      .replace(SmpConstants.PATH_PARAM_ENC_DOMAIN_ID, domain.domainId)
+      .replace(SmpConstants.PATH_PARAM_ENC_GROUP_ID, group.groupId)
+      .replace(SmpConstants.PATH_PARAM_ENC_RESOURCE_ID, resource.resourceId)
+      .replace(SmpConstants.PATH_PARAM_ENC_MEMBER_ID, member.memberId));
+  }
+
 }

smp-angular/src/app/edit/edit-domain/edit-domain.service.ts

@@ -34,6 +34,13 @@ export class EditDomainService {
     return this.getDomainsForUserRoleTypeObservable("group-admin")
   }
 
+  /**
+   * Method fetches all domains where logged user is admin
+   */
+  public getDomainsForResourceAdminUserObservable():Observable<DomainRo[]>  {
+    return this.getDomainsForUserRoleTypeObservable("resource-admin")
+  }
+
   public getDomainsForUserRoleTypeObservable(type: string) :Observable<DomainRo[]> {
     let params: HttpParams = new HttpParams()
       .set(SmpConstants.PATH_QUERY_FILTER_TYPE, type);

smp-angular/src/app/edit/edit-group/edit-group.component.ts

@@ -75,7 +75,7 @@ export class EditGroupComponent implements AfterViewInit, BeforeLeaveGuard {
       this.updateGroupList([]);
       return;
     }
-    this.groupService.getDomainGroupsForGroupAdmin(this.selectedDomain)
+    this.groupService.getDomainGroupsForGroupAdminObservable(this.selectedDomain)
       .subscribe((result: GroupRo[]) => {
         this.updateGroupList(result)
       }, (error: any) => {
@@ -107,11 +107,6 @@ export class EditGroupComponent implements AfterViewInit, BeforeLeaveGuard {
     }
   }
 
-  public onGroupSelected(event) {
-    this.selectedGroup = event.value;
-  }
-
-
   isDirty(): boolean {
     return false;
   }

smp-angular/src/app/edit/edit-group/edit-group.service.ts

@@ -3,7 +3,6 @@ import {Observable} from 'rxjs';
 
 import {HttpClient, HttpParams} from '@angular/common/http';
 import {SecurityService} from "../../security/security.service";
-import {AlertMessageService} from "../../common/alert-message/alert-message.service";
 import {User} from "../../security/user.model";
 import {SmpConstants} from "../../smp.constants";
 import {GroupRo} from "../../common/model/group-ro.model";
@@ -17,13 +16,20 @@ export class EditGroupService {
 
   constructor(
     private http: HttpClient,
-    private securityService: SecurityService,
-    private alertService: AlertMessageService) {
+    private securityService: SecurityService) {
   }
 
-  public getDomainGroupsForGroupAdmin(domain: DomainRo): Observable<GroupRo[]> {
+  public getDomainGroupsForGroupAdminObservable(domain: DomainRo): Observable<GroupRo[]> {
+    return this.getDomainGroupsForUserRoleTypeObservable('group-admin', domain);
+  }
+
+  public getDomainGroupsForResourceAdminObservable(domain: DomainRo): Observable<GroupRo[]> {
+    return this.getDomainGroupsForUserRoleTypeObservable('resource-admin', domain);
+  }
+
+  public getDomainGroupsForUserRoleTypeObservable(userType: string, domain: DomainRo): Observable<GroupRo[]> {
     let params: HttpParams = new HttpParams()
-      .set(SmpConstants.PATH_QUERY_FILTER_TYPE, 'group-admin');
+      .set(SmpConstants.PATH_QUERY_FILTER_TYPE, userType);
 
     const currentUser: User = this.securityService.getCurrentUser();
     return this.http.get<GroupRo[]>(SmpConstants.REST_EDIT_DOMAIN_GROUP
@@ -31,9 +37,15 @@ export class EditGroupService {
       .replace(SmpConstants.PATH_PARAM_ENC_DOMAIN_ID, domain?.domainId), {params});
   }
 
+
   public getGroupResourcesForGroupAdminObservable(group: GroupRo, domain: DomainRo, filter: any, page: number, pageSize: number): Observable<TableResult<ResourceRo>> {
+    return this.getGroupResourcesForUserTypeObservable('group-admin',group, domain, filter, page, pageSize);
+
+  }
+
+  public getGroupResourcesForUserTypeObservable(userType: string, group: GroupRo, domain: DomainRo, filter: any, page: number, pageSize: number): Observable<TableResult<ResourceRo>> {
     let params: HttpParams = new HttpParams()
-      .set(SmpConstants.PATH_QUERY_FILTER_TYPE, 'resource-admin')
+      .set(SmpConstants.PATH_QUERY_FILTER_TYPE, userType)
       .set('page', page.toString())
       .set('pageSize', pageSize.toString());
 

smp-angular/src/app/edit/edit-group/group-resource-panel/group-resource-panel.component.ts

@@ -24,6 +24,7 @@ export class GroupResourcePanelComponent implements BeforeLeaveGuard {
 
   title: string = "Group resources";
   private _group: GroupRo;
+  @Input() resource: ResourceRo;
   @Input() domain: DomainRo;
   @Input() domainResourceDefs: ResourceDefinitionRo[];
   displayedColumns: string[] = ['identifierValue', 'identifierScheme'];
@@ -37,8 +38,6 @@ export class GroupResourcePanelComponent implements BeforeLeaveGuard {
   constructor(private editGroupService: EditGroupService,
               private alertService: AlertMessageService,
               private dialog: MatDialog) {
-
-
   }
 
 

smp-angular/src/app/edit/edit-resources/edit-resource.component.css

+
+#admin-resource--panel {
+  display: flex;
+  flex-flow: column;
+  align-items: center;
+  height: 100%;
+  min-height: 600px;
+  padding: 0 2em;
+}
+#resource--filter {
+  width: 100%;
+  padding-top: 1em;
+}
+
+
+#admin-resource--table {
+  width: 100%;
+  padding-top: 1em;
+}

smp-angular/src/app/edit/edit-resources/edit-resource.component.html

+<div id="admin-resource-panel">
+  <data-panel id="admin-resource-data-panel"
+              title="Edit Resource"
+              text="Edit resource administration panel is a tool for resource administrators to administer the resource"
+              [labelColumnContent]="searchGroupPanel">
+
+    <mat-tab-group #domainTabs style="height: 100%">
+      <mat-tab>
+        <ng-template mat-tab-label>
+          <smp-label icon="groups" label="Members"></smp-label>
+        </ng-template>
+        <domain-member-panel #groupMemberPanelComponent
+                             [membershipType]="groupMembershipType"
+                             [domain]="selectedDomain"
+                             [group]="selectedGroup"
+                             [resource]="selectedResource"
+
+        ></domain-member-panel>
+      </mat-tab>
+      <mat-tab>
+        <ng-template mat-tab-label>
+          <smp-label icon="group" label="Resources"></smp-label>
+        </ng-template>
+        <group-resource-panel
+          [domainResourceDefs]="_selectedDomainResourceDef"
+          [domain]="selectedDomain"
+          [group]="selectedGroup"
+          [resource]="selectedResource"
+        ></group-resource-panel>
+      </mat-tab>
+    </mat-tab-group>
+  </data-panel>
+</div>
+
+<ng-template #searchGroupPanel>
+  <mat-form-field style="width:100%">
+    <mat-label>Selected domain</mat-label>
+    <mat-select placeholder="Select domain"
+                matTooltip="Select domain."
+                id="domain_id"
+                [value]="selectedDomain"
+                required>
+      <mat-option *ngFor="let domain of domainList"
+                  [value]="domain"
+      >
+        {{domain.domainCode}}
+      </mat-option>
+
+    </mat-select>
+  </mat-form-field>
+
+  <mat-form-field style="width:100%">
+    <mat-label>Selected Group</mat-label>
+    <mat-select placeholder="Select group"
+                matTooltip="Select group."
+                id="group_id"
+                [value]="selectedGroup"
+                required>
+      <mat-option *ngFor="let group of groupList"
+                  [value]="group">{{group.groupName}}</mat-option>
+    </mat-select>
+  </mat-form-field>
+
+  <div class="edit-resource-container mat-elevation-z2">
+    <div class="edit-resource-loading-shade"
+         *ngIf="isLoadingResults">
+      <mat-spinner *ngIf="isLoadingResults"></mat-spinner>
+    </div>
+
+    <div class="edit-resource-table-container">
+
+      <mat-form-field id="edit-resource-filter" style="width: 100%">
+        <mat-label>Resource filter</mat-label>
+        <input matInput (keyup)="applyResourceFilter($event)"
+               placeholder="Resource filter"
+               [disabled]="disabledResourceFilter"
+               #inputDomainMemberFilter>
+      </mat-form-field>
+
+      <table class="mat-elevation-z2" mat-table [dataSource]="data">
+
+        <ng-container matColumnDef="identifierScheme">
+          <th mat-header-cell *matHeaderCellDef>Scheme</th>
+          <td mat-cell *matCellDef="let row">{{row.identifierScheme}}</td>
+        </ng-container>
+
+        <ng-container matColumnDef="identifierValue">
+          <th mat-header-cell *matHeaderCellDef>Identifier</th>
+          <td mat-cell *matCellDef="let row">{{row.identifierValue}}</td>
+        </ng-container>
+
+
+
+        <tr mat-header-row *matHeaderRowDef="displayedColumns"></tr>
+        <tr mat-row *matRowDef="let odd = odd; let row; columns: displayedColumns;"
+            (click)="onResourceSelected(row)"
+            [ngClass]="{'datatable-row-selected': row==selectedResource,'datatable-row-odd': odd}"
+        ></tr>
+
+        <tr class="mat-row" *matNoDataRow>
+          <td *ngIf="inputDomainMemberFilter.value;else noDataFound" class="mat-cell" colspan="2">No resources
+            matching the filter
+            "{{inputDomainMemberFilter.value}}"
+          </td>
+          <ng-template #noDataFound>
+            <td class="mat-cell" colspan="2">No direct members for the domain</td>
+          </ng-template>
+        </tr>
+      </table>
+    </div>
+
+    <mat-paginator class="mat-elevation-z2" [length]="resultsLength"
+                   (page)="onPageChanged($event)"
+                   [pageSize]="5"
+                   [pageSizeOptions]="[5, 10, 25]"
+                   [disabled]="disabledForm"
+                   aria-label="Select pages"></mat-paginator>
+  </div>
+
+</ng-template>

smp-angular/src/app/edit/edit-resources/edit-resource.component.ts

+import {AfterViewInit, Component, Input, ViewChild} from '@angular/core';
+import {BeforeLeaveGuard} from "../../window/sidenav/navigation-on-leave-guard";
+import {MatPaginator} from "@angular/material/paginator";
+import {AlertMessageService} from "../../common/alert-message/alert-message.service";
+import {EditDomainService} from "../edit-domain/edit-domain.service";
+import {DomainRo} from "../../common/model/domain-ro.model";
+import {GroupRo} from "../../common/model/group-ro.model";
+import {MemberTypeEnum} from "../../common/enums/member-type.enum";
+import {ResourceDefinitionRo} from "../../system-settings/admin-extension/resource-definition-ro.model";
+import {EditGroupService} from "../edit-group/edit-group.service";
+import {ResourceRo} from "../../common/model/resource-ro.model";
+import {EditResourceService} from "./edit-resource.service";
+import {group} from "@angular/animations";
+import {TableResult} from "../../common/model/table-result.model";
+
+
+@Component({
+  moduleId: module.id,
+  templateUrl: './edit-resource.component.html',
+  styleUrls: ['./edit-resource.component.css']
+})
+export class EditResourceComponent implements AfterViewInit, BeforeLeaveGuard {
+  groupMembershipType: MemberTypeEnum = MemberTypeEnum.RESOURCE;
+  domainList: DomainRo[] = [];
+  groupList: GroupRo[] = [];
+  resourceList: ResourceRo[] = [];
+
+  _selectedDomain: DomainRo;
+  _selectedGroup: GroupRo;
+
+  _selectedResource: ResourceRo;
+  _selectedDomainResourceDef: ResourceDefinitionRo[];
+
+  displayedColumns: string[] = ['identifierValue', 'identifierScheme'];
+
+  data: ResourceRo[] = [];
+  selected: ResourceRo;
+  filter: any = {};
+  resultsLength = 0;
+  isLoadingResults = false;
+
+  @ViewChild(MatPaginator) paginator: MatPaginator;
+
+  get selectedDomain(): DomainRo {
+    return this._selectedDomain;
+  };
+
+  @Input() set selectedDomain(domain: DomainRo) {
+    this._selectedDomain = domain;
+    if (!!this.selectedDomain) {
+      this.refreshGroups();
+      this.refreshDomainsResourceDefinitions();
+    } else {
+      this.groupList = [];
+      this._selectedDomainResourceDef = [];
+    }
+
+  };
+
+  get selectedGroup(): GroupRo {
+    return this._selectedGroup;
+  };
+
+  @Input() set selectedGroup(resource: GroupRo) {
+    this._selectedGroup = resource;
+    if (!!this._selectedGroup) {
+      this.refreshResources();
+    } else {
+      this.resourceList = [];
+    }
+  };
+  get selectedResource(): ResourceRo {
+    return this._selectedResource;
+  };
+
+  @Input() set selectedResource(resource: ResourceRo) {
+    this._selectedResource = resource;
+  };
+
+  onResourceSelected(resource: ResourceRo){
+    this.selectedResource = resource;
+  }
+
+  constructor(private domainService: EditDomainService,
+              private groupService: EditGroupService,
+              private resourceService: EditResourceService,
+              private alertService: AlertMessageService) {
+
+  }
+
+  ngAfterViewInit() {
+    this.refreshDomains();
+  }
+
+  refreshDomains() {
+    this.domainService.getDomainsForResourceAdminUserObservable()
+      .subscribe((result: DomainRo[]) => {
+        this.updateDomainList(result)
+      }, (error: any) => {
+        this.alertService.error(error.error?.errorDescription)
+      });
+  }
+
+  refreshGroups() {
+    if (!this.selectedDomain) {
+      this.updateGroupList([]);
+      return;
+    }
+    this.groupService.getDomainGroupsForResourceAdminObservable(this.selectedDomain)
+      .subscribe((result: GroupRo[]) => {
+        this.updateGroupList(result)
+      }, (error: any) => {
+        this.alertService.error(error.error?.errorDescription)
+      });
+  }
+
+  refreshResources() {
+    if (!this.selectedGroup) {
+      this.updateResourceList([]);
+      return;
+    }
+
+    this.resourceService.getGroupResourcesForResourceAdminObservable(this.selectedGroup, this.selectedDomain,  this.filter, this.paginator.pageIndex, this.paginator.pageSize)
+      .subscribe((result: TableResult<ResourceRo>) => {
+        console.log("got resources: " + JSON.stringify(result))
+        this.updateResourceList(result.serviceEntities)
+        this.data = [...result.serviceEntities];
+        this.resultsLength = result.count;
+      }, (error: any) => {
+        this.alertService.error(error.error?.errorDescription)
+      });
+
+
+  }
+
+  refreshDomainsResourceDefinitions() {
+    this.domainService.getDomainResourceDefinitionsObservable(this.selectedDomain)
+      .subscribe((result: ResourceDefinitionRo[]) => {
+        this._selectedDomainResourceDef = result
+      }, (error: any) => {
+        this.alertService.error(error.error?.errorDescription)
+      });
+  }
+
+  updateDomainList(list: DomainRo[]) {
+    this.domainList = list;
+    if (!!this.domainList && this.domainList.length > 0) {
+
+      this.selectedDomain = this.domainList[0];
+    }
+  }
+
+  updateGroupList(list: GroupRo[]) {
+    this.groupList = list
+    if (!!this.groupList && this.groupList.length > 0) {
+      this.selectedGroup = this.groupList[0];
+    }
+  }
+
+  updateResourceList(list: ResourceRo[]) {
+    this.resourceList = list
+    if (!!this.resourceList && this.resourceList.length > 0) {
+      this.selectedResource = this.resourceList[0];
+    }
+  }
+
+  applyResourceFilter(event: Event) {
+    const filterValue = (event.target as HTMLInputElement).value;
+    this.filter["filter"] = filterValue.trim().toLowerCase();
+    this.refreshResources();
+  }
+
+  get disabledResourceFilter(): boolean{
+    return !this._selectedGroup;
+  }
+
+  isDirty(): boolean {
+    return false;
+  }
+
+}

smp-angular/src/app/edit/edit-resources/edit-resource.service.ts

+import {Injectable} from '@angular/core';
+import {Observable} from 'rxjs';
+
+import {HttpClient, HttpParams} from '@angular/common/http';
+import {SecurityService} from "../../security/security.service";
+import {User} from "../../security/user.model";
+import {SmpConstants} from "../../smp.constants";
+import {GroupRo} from "../../common/model/group-ro.model";
+import {ResourceRo} from "../../common/model/resource-ro.model";
+import {TableResult} from "../../common/model/table-result.model";
+import {DomainRo} from "../../common/model/domain-ro.model";
+
+@Injectable()
+export class EditResourceService {
+
+
+  constructor(
+    private http: HttpClient,
+    private securityService: SecurityService) {
+  }
+
+
+  public getGroupResourcesForGroupAdminObservable(group: GroupRo, domain: DomainRo, filter: any, page: number, pageSize: number): Observable<TableResult<ResourceRo>> {
+    return this.getGroupResourcesForUserTypeObservable('group-admin', group, domain, filter, page, pageSize);
+  }
+
+  public getGroupResourcesForResourceAdminObservable(group: GroupRo, domain: DomainRo, filter: any, page: number, pageSize: number): Observable<TableResult<ResourceRo>> {
+    return this.getGroupResourcesForUserTypeObservable('resource-admin', group, domain, filter, page, pageSize);
+  }
+
+  public getGroupResourcesForUserTypeObservable(userType: string, group: GroupRo, domain: DomainRo, filter: any, page: number, pageSize: number): Observable<TableResult<ResourceRo>> {
+
+    let params: HttpParams = new HttpParams()
+      .set(SmpConstants.PATH_QUERY_FILTER_TYPE, userType)
+      .set('page', page.toString())
+      .set('pageSize', pageSize.toString());
+
+    if (!!filter) {
+      for (let filterProperty in filter) {
+        if (filter.hasOwnProperty(filterProperty)) {
+          // must encode else problem with + sign
+          params = params.set(filterProperty, encodeURIComponent(filter[filterProperty]));
+        }
+      }
+    }
+
+
+    const currentUser: User = this.securityService.getCurrentUser();
+    return this.http.get<TableResult<ResourceRo>>(SmpConstants.REST_EDIT_RESOURCE
+      .replace(SmpConstants.PATH_PARAM_ENC_USER_ID, currentUser.userId)
+      .replace(SmpConstants.PATH_PARAM_ENC_DOMAIN_ID, domain?.domainId)
+      .replace(SmpConstants.PATH_PARAM_ENC_GROUP_ID, group?.groupId), {params});
+  }
+
+  deleteResourceFromGroup(resource: ResourceRo, group: GroupRo, domain: DomainRo): Observable<ResourceRo> {
+    const currentUser: User = this.securityService.getCurrentUser();
+    return this.http.delete<ResourceRo>(SmpConstants.REST_EDIT_RESOURCE_DELETE
+      .replace(SmpConstants.PATH_PARAM_ENC_USER_ID, currentUser.userId)
+      .replace(SmpConstants.PATH_PARAM_ENC_GROUP_ID, group?.groupId)
+      .replace(SmpConstants.PATH_PARAM_ENC_DOMAIN_ID, domain?.domainId)
+      .replace(SmpConstants.PATH_PARAM_ENC_RESOURCE_ID, resource.resourceId));
+  }
+
+  createResourceForGroup(resource: ResourceRo, group: GroupRo, domain: DomainRo): Observable<ResourceRo> {
+    const currentUser: User = this.securityService.getCurrentUser();
+    return this.http.put<ResourceRo>(SmpConstants.REST_EDIT_RESOURCE_CREATE
+      .replace(SmpConstants.PATH_PARAM_ENC_USER_ID, currentUser.userId)
+      .replace(SmpConstants.PATH_PARAM_ENC_DOMAIN_ID, domain?.domainId)
+      .replace(SmpConstants.PATH_PARAM_ENC_GROUP_ID, group?.groupId), resource);
+  }
+
+  updateResourceForGroup(resource: ResourceRo, group: GroupRo, domain: DomainRo): Observable<ResourceRo> {
+    const currentUser: User = this.securityService.getCurrentUser();
+
+    return this.http.post<ResourceRo>(SmpConstants.REST_EDIT_RESOURCE_UPDATE
+      .replace(SmpConstants.PATH_PARAM_ENC_USER_ID, currentUser.userId)
+      .replace(SmpConstants.PATH_PARAM_ENC_DOMAIN_ID, domain?.domainId)
+      .replace(SmpConstants.PATH_PARAM_ENC_GROUP_ID, group?.groupId)
+      .replace(SmpConstants.PATH_PARAM_ENC_RESOURCE_ID, resource?.resourceId), resource);
+  }
+}

smp-angular/src/app/smp.constants.ts

@@ -78,6 +78,11 @@ export class SmpConstants {
   public static readonly REST_EDIT_RESOURCE_DELETE = SmpConstants.REST_EDIT_RESOURCE  + '/' + SmpConstants.PATH_PARAM_ENC_RESOURCE_ID
     + '/' + SmpConstants.PATH_ACTION_DELETE;
 
+  public static readonly REST_EDIT_RESOURCE_MEMBER = SmpConstants.REST_EDIT_RESOURCE  + '/' + SmpConstants.PATH_PARAM_ENC_RESOURCE_ID
+    + '/' + SmpConstants.PATH_RESOURCE_TYPE_MEMBER ;
+  public static readonly REST_EDIT_RESOURCE_MEMBER_PUT = SmpConstants.REST_EDIT_RESOURCE_MEMBER  + '/' + SmpConstants.PATH_ACTION_PUT;
+  public static readonly REST_EDIT_RESOURCE_MEMBER_DELETE = SmpConstants.REST_EDIT_RESOURCE_MEMBER + '/' + SmpConstants.PATH_PARAM_ENC_MEMBER_ID
+    + '/' + SmpConstants.PATH_ACTION_DELETE;
 
 
 

smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/conversion/DBResourceMemberToMemberROConverter.java

+package eu.europa.ec.edelivery.smp.conversion;
+
+import eu.europa.ec.edelivery.smp.data.model.user.DBResourceMember;
+import eu.europa.ec.edelivery.smp.data.ui.MemberRO;
+import eu.europa.ec.edelivery.smp.utils.SessionSecurityUtils;
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.stereotype.Component;
+
+
+/**
+ *
+ */
+@Component
+public class DBResourceMemberToMemberROConverter implements Converter<DBResourceMember, MemberRO> {
+
+    @Override
+    public MemberRO convert(DBResourceMember source) {
+        MemberRO target = new MemberRO();
+        target.setMemberOf("RESOURCE");
+        target.setUsername(source.getUser().getUsername());
+        target.setFullName(source.getUser().getFullName());
+        target.setRoleType(source.getRole());
+        target.setMemberId(SessionSecurityUtils.encryptedEntityId(source.getId()));
+        return target;
+    }
+}

smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/DomainDao.java

@@ -142,6 +142,23 @@ public class DomainDao extends BaseDao<DBDomain> {
         query.setParameter(PARAM_MEMBERSHIP_ROLES, toList(roleTypes));
         return query.getResultList();
     }
+
+    public Long getDomainsByUserIdAndResourceRolesCount(Long userId, MembershipRoleType ... roleTypes) {
+
+        TypedQuery<Long> query = memEManager.createNamedQuery(QUERY_DOMAIN_BY_USER_RESOURCE_ROLES_COUNT, Long.class);
+        query.setParameter(PARAM_USER_ID, userId);
+        query.setParameter(PARAM_MEMBERSHIP_ROLES, toList(roleTypes));
+        return query.getSingleResult();
+    }
+
+    public List<DBDomain> getDomainsByUserIdAndResourceRoles(Long userId, MembershipRoleType ... roleTypes) {
+
+        TypedQuery<DBDomain> query = memEManager.createNamedQuery(QUERY_DOMAIN_BY_USER_RESOURCE_ROLES, DBDomain.class);
+        query.setParameter(PARAM_USER_ID, userId);
+        query.setParameter(PARAM_MEMBERSHIP_ROLES, toList(roleTypes));
+        return query.getResultList();
+    }
+
     public List<MembershipRoleType> toList(MembershipRoleType ... roleTypes){
         return Arrays.asList(roleTypes ==null || roleTypes.length==0 ?MembershipRoleType.values(): roleTypes);
     }

smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/DomainMemberDao.java

@@ -71,7 +71,7 @@ public class DomainMemberDao extends BaseDao<DBDomainMember> {
     }
 
     public boolean isUserResourceAdministrator(Long userId){
-        return false;
+        return domainDao.getDomainsByUserIdAndResourceRolesCount(userId, MembershipRoleType.ADMIN)>0;
     }
 
     public List<DBDomainMember> getDomainMembers(Long domainId, int iPage, int iPageSize, String filter) {

smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/GroupDao.java

@@ -135,20 +135,30 @@ public class GroupDao extends BaseDao<DBGroup> {
     }
 
     public List<DBGroup> getGroupsByUserIdAndRoles(Long userId, MembershipRoleType... roleTypes) {
-        TypedQuery<DBGroup> query = memEManager.createNamedQuery(QUERY_GROUP_BY_USER_ROLES, DBGroup.class);
+        TypedQuery<DBGroup> query = memEManager.createNamedQuery(QUERY_GROUP_BY_USER_GROUP_ROLES, DBGroup.class);
         query.setParameter(PARAM_USER_ID, userId);
         query.setParameter(PARAM_MEMBERSHIP_ROLES, toList(roleTypes));
         return query.getResultList();
     }
 
-    public List<DBGroup> getGroupsByDomainUserIdAndRoles(Long domainId, Long userId, MembershipRoleType... roleTypes) {
+    public List<DBGroup> getGroupsByDomainUserIdAndGroupRoles(Long domainId, Long userId, MembershipRoleType... roleTypes) {
 
-        TypedQuery<DBGroup> query = memEManager.createNamedQuery(QUERY_GROUP_BY_DOMAIN_USER_ROLES, DBGroup.class);
+        TypedQuery<DBGroup> query = memEManager.createNamedQuery(QUERY_GROUP_BY_DOMAIN_USER_GROUP_ROLES, DBGroup.class);
         query.setParameter(PARAM_DOMAIN_ID, domainId);
         query.setParameter(PARAM_USER_ID, userId);
         query.setParameter(PARAM_MEMBERSHIP_ROLES, toList(roleTypes));
         return query.getResultList();
     }
+
+    public List<DBGroup> getGroupsByDomainUserIdAndResourceRoles(Long domainId, Long userId, MembershipRoleType... roleTypes) {
+
+        TypedQuery<DBGroup> query = memEManager.createNamedQuery(QUERY_GROUP_BY_DOMAIN_USER_RESOURCE_ROLES, DBGroup.class);
+        query.setParameter(PARAM_DOMAIN_ID, domainId);
+        query.setParameter(PARAM_USER_ID, userId);
+        query.setParameter(PARAM_MEMBERSHIP_ROLES, toList(roleTypes));
+        return query.getResultList();
+    }
+
     /**
      * Removes Entity by given domain code
      *

smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/GroupMemberDao.java

@@ -122,7 +122,7 @@ public class GroupMemberDao extends BaseDao<DBGroupMember> {
     }
 
 
-    public DBGroupMember addMemberToDomain(DBGroup group, DBUser user, MembershipRoleType role) {
+    public DBGroupMember addMemberToGroup(DBGroup group, DBUser user, MembershipRoleType role) {
         DBGroupMember groupMember = new DBGroupMember();
         groupMember.setRole(role);
         groupMember.setUser(user);

smp-server-library/src/main/java/eu/europa/ec/edelivery/smp/data/dao/QueryNames.java

@@ -19,6 +19,9 @@ public class QueryNames {
 
     public static final String QUERY_DOMAIN_BY_USER_GROUP_ROLES_COUNT = "DBDomain.getByUserAndGroupRolesCount";
     public static final String QUERY_DOMAIN_BY_USER_GROUP_ROLES = "DBDomain.getByUserAndGroupRoles";
+
+    public static final String QUERY_DOMAIN_BY_USER_RESOURCE_ROLES_COUNT = "DBDomain.getByUserAndResourceRolesCount";
+    public static final String QUERY_DOMAIN_BY_USER_RESOURCE_ROLES = "DBDomain.getByUserAndResourceRoles";
     public static final String QUERY_EXTENSION_ALL = "DBExtension.getAll";
     public static final String QUERY_EXTENSION_BY_IDENTIFIER = "DBExtension.getByIdentifier";
 
@@ -27,13 +30,15 @@ public class QueryNames {
     public static final String QUERY_GROUP_BY_NAME_DOMAIN = "DBGroup.getByNameDomain";
     public static final String QUERY_GROUP_BY_NAME_DOMAIN_CODE = "DBGroup.getByNameDomainCode";
 
-    public static final String QUERY_GROUP_BY_USER_ROLES = "DBGroup.getByUserAndRoles";
-    public static final String QUERY_GROUP_BY_DOMAIN_USER_ROLES = "DBGroup.getByDomainAndUserAndRoles";
-    public static final String QUERY_GROUP_BY_USER_ROLES_COUNT = "DBGroup.getByUserAndRolesCount";
-    public static final String QUERY_GROUP_MEMBERS_COUNT = "DBGroup.getByGroupCount";
-    public static final String QUERY_GROUP_MEMBERS_FILTER_COUNT = "DBGroup.getByGroupFilterCount";
-    public static final String QUERY_GROUP_MEMBERS = "DBGroup.getByGroup";
-    public static final String QUERY_GROUP_MEMBERS_FILTER = "DBGroup.getByGroupFilter";
+    public static final String QUERY_GROUP_BY_USER_GROUP_ROLES = "DBGroup.getByUserAndRoles";
+    public static final String QUERY_GROUP_BY_DOMAIN_USER_GROUP_ROLES = "DBGroup.getByDomainAndUserAndGroupRoles";
+
+    public static final String QUERY_GROUP_BY_DOMAIN_USER_RESOURCE_ROLES = "DBGroup.getByDomainAndUserAndResourceRoles";
+    public static final String QUERY_GROUP_BY_USER_ROLES_COUNT = "DBGroup.getByUserAndGrouRolesCount";
+    public static final String QUERY_GROUP_MEMBERS_COUNT = "DBGroupMember.getByGroupCount";
+    public static final String QUERY_GROUP_MEMBERS_FILTER_COUNT = "DBGroupMember.getByGroupFilterCount";
+    public static final String QUERY_GROUP_MEMBERS = "DBGroupMember.getByGroup";
+    public static final String QUERY_GROUP_MEMBERS_FILTER = "DBGroupMember.getByGroupFilter";
 
     public static final String QUERY_DOMAIN_MEMBER_ALL = "DBDomainMember.getAll";
     public static final String QUERY_DOMAIN_MEMBER_BY_USER_DOMAINS_COUNT = "DBDomainMember.getByUserAndDomainsCount";
@@ -66,6 +71,11 @@ public class QueryNames {
     public static final String QUERY_RESOURCE_MEMBER_BY_USER_DOMAIN_RESOURCE_ROLE_COUNT = "DBResourceMember.getByUserAndDomainRoleResourceCount";
     public static final String QUERY_RESOURCE_MEMBER_BY_USER_GROUP_RESOURCES_ROLE_COUNT = "DBResourceMember.getByUserAndGroupsResourcesAndRoleCount";
 
+    public static final String QUERY_RESOURCE_MEMBERS_COUNT = "DBResourceMember.getByResourceCount";
+    public static final String QUERY_RESOURCE_MEMBERS_FILTER_COUNT = "DBResourceMember.getByResourceFilterCount";
+    public static final String QUERY_RESOURCE_MEMBERS = "DBResourceMember.getByResource";
+    public static final String QUERY_RESOURCE_MEMBERS_FILTER = "DBResourceMember.getByResourceFilter";
+
     public static final String QUERY_RESOURCE_MEMBER_BY_USER_RESOURCE= "DBResourceMember.getByUserAndResource";
 
     public static final String QUERY_SUBRESOURCE_BY_IDENTIFIER_RESOURCE_SUBRESDEF = "DBSubresource.getByIdentifierAndResourceAndSubresourceDef";
@@ -93,6 +103,8 @@ public class QueryNames {
     public static final String QUERY_GROUP_MEMBER_BY_USER_GROUPS_COUNT = "DBGroupMember.getByUserAndGroupsCount";
     public static final String QUERY_GROUP_MEMBER_BY_USER_DOMAIN_GROUPS_COUNT = "DBGroupMember.getByUserAndDomainGroupsCount";
     public static final String QUERY_GROUP_MEMBER_BY_USER_GROUPS = "DBGroupMember.getByUserAndGroups";
+
+    public static final String QUERY_RESOURCE_MEMBER_BY_USER_RESOURCES = "DBResourceMember.getByUserAndResources";
     public static final String QUERY_GROUP_MEMBER_BY_USER_DOMAIN_GROUPS_ROLE_COUNT = "DBGroupMember.getByUserAndDomainGroupsAndRoleCount";
 
     public static final String QUERY_USER_BY_CI_USERNAME = "DBUser.getUserByUsernameInsensitive";
@@ -122,6 +134,7 @@ public class QueryNames {
     public static final String PARAM_CERTIFICATE_IDENTIFIER = "certificate_identifier";
 
     public static final String PARAM_RESOURCE_ID = "resource_id";
+    public static final String PARAM_RESOURCE_IDS = "resource_ids";
     public static final String PARAM_SUBRESOURCE_ID = "subresource_id";
     // resource identifier value
     public static final String PARAM_RESOURCE_IDENTIFIER = "resource_identifier";