[ADF-4738] [Process -Cloud] Move GroupCloudService to adf-core (#4928)

* [ADF-4738] [Process -Cloud] Move GroupCloudService to adf-core lib.

* * Changed GroupModel to IdentityGroupModel
* Updated unit tests the recent changes.

* * Added documentation to the identityGroupService
* Updated GroupInitial and GroupCoudcomponent doc.

* * Created groupCount model. * Updated unit test to the recent changes

* * After rebase updated doc

* * Fixed comments.

lib/core/userinfo/models/identity-group.model.ts

@@ -14,6 +14,9 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
+import { Pagination } from '@alfresco/js-api';
+
 export class IdentityGroupModel {
 
     id: string;
@@ -36,3 +39,30 @@ export class IdentityGroupModel {
         }
     }
 }
+
+export interface IdentityGroupSearchParam {
+    name?: string;
+}
+
+export interface IdentityGroupQueryResponse {
+
+    entries: IdentityGroupModel[];
+    pagination: Pagination;
+}
+
+export class IdentityGroupQueryCloudRequestModel {
+
+    first: number;
+    max: number;
+
+    constructor(obj?: any) {
+        if (obj) {
+            this.first = obj.first;
+            this.max = obj.max;
+        }
+    }
+}
+
+export interface IdentityGroupCountModel {
+    count: number;
+}

lib/core/userinfo/public-api.ts

@@ -19,8 +19,10 @@ export * from './components/user-info.component';
 export * from './services/bpm-user.service';
 export * from './services/ecm-user.service';
 export * from './services/identity-user.service';
+export * from './services/identity-group.service';
 export * from './models/bpm-user.model';
 export * from './models/ecm-user.model';
+export * from './models/identity-group.model';
 export * from './models/identity-user.model';
 export * from './models/identity-role.model';
 export * from './models/identity-group.model';

lib/core/userinfo/services/identity-group.service.spec.ts

@@ -0,0 +1,450 @@
+/*!
+ * @license
+ * Copyright 2019 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { async } from '@angular/core/testing';
+import { TestBed } from '@angular/core/testing';
+import {
+    AlfrescoApiServiceMock,
+    CoreModule,
+    setupTestBed,
+    AlfrescoApiService,
+    LogService,
+    IdentityGroupService,
+    IdentityGroupSearchParam,
+    groupAPIMockError
+} from '@alfresco/adf-core';
+import { HttpErrorResponse } from '@angular/common/http';
+import { throwError, of } from 'rxjs';
+import {
+    noRoleMappingApi,
+    mockIdentityRoles,
+    groupsMockApi,
+    roleMappingApi,
+    clientRoles,
+    returnCallQueryParameters,
+    returnCallUrl,
+    applicationDetailsMockApi,
+    mockApiError,
+    mockIdentityGroup1,
+    createGroupMappingApi,
+    updateGroupMappingApi,
+    deleteGroupMappingApi,
+    mockIdentityGroupsCount
+} from '../../mock/identity-group.service.mock';
+
+describe('IdentityGroupService', () => {
+    let service: IdentityGroupService;
+    let apiService: AlfrescoApiService;
+    let logService: LogService;
+
+    setupTestBed({
+        imports: [CoreModule.forRoot()],
+        providers: [
+            { provide: AlfrescoApiService, useClass: AlfrescoApiServiceMock }
+        ]
+    });
+
+    beforeEach(async(() => {
+        service = TestBed.get(IdentityGroupService);
+        apiService = TestBed.get(AlfrescoApiService);
+        logService = TestBed.get(LogService);
+    }));
+
+    it('should be able to fetch groups based on group name', (done) => {
+        spyOn(apiService, 'getInstance').and.returnValue(groupsMockApi);
+        service.findGroupsByName(<IdentityGroupSearchParam> {name: 'mock'}).subscribe((res) => {
+            expect(res).toBeDefined();
+            expect(res).not.toBeNull();
+            expect(res.length).toBe(5);
+            expect(res[0].id).toBe('mock-group-id-1');
+            expect(res[0].name).toBe('Mock Group 1');
+            expect(res[1].id).toBe('mock-group-id-2');
+            expect(res[1].name).toBe('Mock Group 2');
+            expect(res[2].id).toBe('mock-group-id-3');
+            expect(res[2].name).toBe('Mock Group 3');
+            done();
+        });
+    });
+
+    it('should return true if group has client role mapping', (done) => {
+        spyOn(apiService, 'getInstance').and.returnValue(roleMappingApi);
+        service.checkGroupHasClientApp('mock-group-id', 'mock-app-id').subscribe((hasRole) => {
+            expect(hasRole).toBeDefined();
+            expect(hasRole).toBe(true);
+            done();
+        });
+    });
+
+    it('should return false if group does not have client role mapping', (done) => {
+        spyOn(apiService, 'getInstance').and.returnValue(noRoleMappingApi);
+        service.checkGroupHasClientApp('mock-group-id', 'mock-app-id').subscribe((hasRole) => {
+            expect(hasRole).toBeDefined();
+            expect(hasRole).toBe(false);
+            done();
+        });
+    });
+
+    it('should able to fetch group roles by groupId', (done) => {
+        spyOn(service, 'getGroupRoles').and.returnValue(of(mockIdentityRoles));
+        service.getGroupRoles('mock-group-id').subscribe(
+            (res: any) => {
+                expect(res).toBeDefined();
+                expect(res.length).toEqual(3);
+                expect(res[0].name).toEqual('MOCK-ADMIN-ROLE');
+                expect(res[1].name).toEqual('MOCK-USER-ROLE');
+                expect(res[2].name).toEqual('MOCK-ROLE-1');
+                done();
+            }
+        );
+    });
+
+    it('Should not able to fetch group roles if error occurred', (done) => {
+        const errorResponse = new HttpErrorResponse({
+            error: 'Mock Error',
+            status: 404, statusText: 'Not Found'
+        });
+
+        spyOn(service, 'getGroupRoles').and.returnValue(throwError(errorResponse));
+
+        service.getGroupRoles('mock-group-id')
+            .subscribe(
+                () => {
+                    fail('expected an error, not group roles');
+                },
+                (error) => {
+                    expect(error.status).toEqual(404);
+                    expect(error.statusText).toEqual('Not Found');
+                    expect(error.error).toEqual('Mock Error');
+                    done();
+                }
+            );
+    });
+
+    it('should return true if group has given role', (done) => {
+        spyOn(service, 'getGroupRoles').and.returnValue(of(mockIdentityRoles));
+        service.checkGroupHasRole('mock-group-id', ['MOCK-ADMIN-ROLE']).subscribe(
+            (res: boolean) => {
+                expect(res).toBeDefined();
+                expect(res).toBeTruthy();
+                done();
+            }
+        );
+    });
+
+    it('should return false if group does not have given role', (done) => {
+        spyOn(service, 'getGroupRoles').and.returnValue(of(mockIdentityRoles));
+        service.checkGroupHasRole('mock-group-id', ['MOCK-ADMIN-MODELER']).subscribe(
+            (res: boolean) => {
+                expect(res).toBeDefined();
+                expect(res).toBeFalsy();
+                done();
+            }
+        );
+    });
+
+    it('should fetch client roles by groupId and clientId', (done) => {
+        spyOn(service, 'getClientRoles').and.returnValue(of(clientRoles));
+        service.getClientRoles('mock-group-id', 'mock-client-id').subscribe(
+            (res: any) => {
+                expect(res).toBeDefined();
+                expect(res.length).toEqual(2);
+                expect(res).toEqual(clientRoles);
+                done();
+            }
+        );
+    });
+
+    it('Should not fetch client roles if error occurred', (done) => {
+        const errorResponse = new HttpErrorResponse({
+            error: 'Mock Error',
+            status: 404, statusText: 'Not Found'
+        });
+
+        spyOn(service, 'getClientRoles').and.returnValue(throwError(errorResponse));
+
+        service.getClientRoles('mock-group-id', 'mock-client-id')
+            .subscribe(
+                () => {
+                    fail('expected an error, not client roles');
+                },
+                (error) => {
+                    expect(error.status).toEqual(404);
+                    expect(error.statusText).toEqual('Not Found');
+                    expect(error.error).toEqual('Mock Error');
+                    done();
+                }
+            );
+    });
+
+    it('should return true if group has client access', (done) => {
+        spyOn(service, 'getClientRoles').and.returnValue(of(clientRoles));
+        service.checkGroupHasClientApp('mock-group-id', 'mock-client-id').subscribe(
+            (res: boolean) => {
+                expect(res).toBeDefined();
+                expect(res).toBeTruthy();
+                done();
+            }
+        );
+    });
+
+    it('should return false if group does not have client access', (done) => {
+        spyOn(service, 'getClientRoles').and.returnValue(of([]));
+        service.checkGroupHasClientApp('mock-group-id', 'mock-client-id').subscribe(
+            (res: boolean) => {
+                expect(res).toBeDefined();
+                expect(res).toBeFalsy();
+                done();
+            }
+        );
+    });
+
+    it('should return true if group has any client role', (done) => {
+        spyOn(service, 'checkGroupHasAnyClientAppRole').and.returnValue(of(true));
+        service.checkGroupHasAnyClientAppRole('mock-group-id', 'mock-client-id', ['MOCK-USER-ROLE']).subscribe(
+            (res: boolean) => {
+                expect(res).toBeDefined();
+                expect(res).toBeTruthy();
+                done();
+            }
+        );
+    });
+
+    it('should return false if group does not have any client role', (done) => {
+        spyOn(service, 'getClientRoles').and.returnValue(of([]));
+        service.checkGroupHasAnyClientAppRole('mock-group-id', 'mock-client-id', ['MOCK-ADMIN-MODELER']).subscribe(
+            (res: boolean) => {
+                expect(res).toBeDefined();
+                expect(res).toBeFalsy();
+                done();
+            }
+        );
+    });
+
+    it('should append to the call all the parameters', (done) => {
+        spyOn(apiService, 'getInstance').and.returnValue(returnCallQueryParameters);
+        service.findGroupsByName(<IdentityGroupSearchParam> {name: 'mock'}).subscribe((res) => {
+            expect(res).toBeDefined();
+            expect(res).not.toBeNull();
+            expect(res.search).toBe('mock');
+            done();
+        });
+    });
+
+    it('should request groups api url', (done) => {
+        spyOn(apiService, 'getInstance').and.returnValue(returnCallUrl);
+        service.findGroupsByName(<IdentityGroupSearchParam> {name: 'mock'}).subscribe((requestUrl) => {
+            expect(requestUrl).toBeDefined();
+            expect(requestUrl).not.toBeNull();
+            expect(requestUrl).toContain('/groups');
+            done();
+        });
+    });
+
+    it('should be able to fetch the client id', (done) => {
+        spyOn(apiService, 'getInstance').and.returnValue(applicationDetailsMockApi);
+        service.getClientIdByApplicationName('mock-app-name').subscribe((clientId) => {
+            expect(clientId).toBeDefined();
+            expect(clientId).not.toBeNull();
+            expect(clientId).toBe('mock-app-id');
+            done();
+        });
+    });
+
+    it('should notify errors returned from the API', (done) => {
+        const logServiceSpy = spyOn(logService, 'error').and.callThrough();
+        spyOn(apiService, 'getInstance').and.returnValue(mockApiError);
+        service.findGroupsByName(<IdentityGroupSearchParam> {name: 'mock'}).subscribe(
+            () => {},
+            (res: any) => {
+                expect(res).toBeDefined();
+                expect(res).toEqual(groupAPIMockError);
+                expect(logServiceSpy).toHaveBeenCalled();
+                done();
+            }
+        );
+    });
+
+    it('should be able to all fetch groups', (done) => {
+        spyOn(apiService, 'getInstance').and.returnValue(groupsMockApi);
+        service.getGroups().subscribe((res) => {
+            expect(res).toBeDefined();
+            expect(res).not.toBeNull();
+            expect(res.length).toBe(5);
+            expect(res[0].id).toBe('mock-group-id-1');
+            expect(res[0].name).toBe('Mock Group 1');
+            expect(res[1].id).toBe('mock-group-id-2');
+            expect(res[1].name).toBe('Mock Group 2');
+            expect(res[2].id).toBe('mock-group-id-3');
+            expect(res[2].name).toBe('Mock Group 3');
+            done();
+        });
+    });
+
+    it('Should not able to fetch all group if error occurred', (done) => {
+        const errorResponse = new HttpErrorResponse({
+            error: 'Mock Error',
+            status: 404, statusText: 'Not Found'
+        });
+
+        spyOn(service, 'getGroups').and.returnValue(throwError(errorResponse));
+
+        service.getGroups()
+            .subscribe(
+                () => {
+                    fail('expected an error, not groups');
+                },
+                (error) => {
+                    expect(error.status).toEqual(404);
+                    expect(error.statusText).toEqual('Not Found');
+                    expect(error.error).toEqual('Mock Error');
+                    done();
+                }
+            );
+    });
+
+    it('should be able to query groups based on first & max params', (done) => {
+        spyOn(service, 'getTotalGroupsCount').and.returnValue(of(mockIdentityGroupsCount));
+        spyOn(apiService, 'getInstance').and.returnValue(groupsMockApi);
+        service.queryGroups({first: 0, max: 5}).subscribe((res) => {
+            expect(res).toBeDefined();
+            expect(res).not.toBeNull();
+            expect(res.entries.length).toBe(5);
+            expect(res.entries[0].id).toBe('mock-group-id-1');
+            expect(res.entries[0].name).toBe('Mock Group 1');
+            expect(res.entries[1].id).toBe('mock-group-id-2');
+            expect(res.entries[1].name).toBe('Mock Group 2');
+            expect(res.entries[2].id).toBe('mock-group-id-3');
+            expect(res.entries[2].name).toBe('Mock Group 3');
+            expect(res.pagination.totalItems).toBe(10);
+            expect(res.pagination.skipCount).toBe(0);
+            expect(res.pagination.maxItems).toBe(5);
+            done();
+        });
+    });
+
+    it('Should not able to query groups if error occurred', (done) => {
+        const errorResponse = new HttpErrorResponse({
+            error: 'Mock Error',
+            status: 404, statusText: 'Not Found'
+        });
+
+        spyOn(service, 'queryGroups').and.returnValue(throwError(errorResponse));
+
+        service.queryGroups({first: 0, max: 5})
+            .subscribe(
+                () => {
+                    fail('expected an error, not query groups');
+                },
+                (error) => {
+                    expect(error.status).toEqual(404);
+                    expect(error.statusText).toEqual('Not Found');
+                    expect(error.error).toEqual('Mock Error');
+                    done();
+                }
+            );
+    });
+
+    it('should be able to create group', (done) => {
+        const createCustomApiSpy = spyOn(apiService, 'getInstance').and.returnValue(createGroupMappingApi);
+        service.createGroup(mockIdentityGroup1).subscribe((res) => {
+            expect(createCustomApiSpy).toHaveBeenCalled();
+            done();
+        });
+    });
+
+    it('Should not able to create group if error occurred', (done) => {
+        const errorResponse = new HttpErrorResponse({
+            error: 'Mock Error',
+            status: 404, statusText: 'Not Found'
+        });
+
+        spyOn(service, 'createGroup').and.returnValue(throwError(errorResponse));
+
+        service.createGroup(mockIdentityGroup1)
+            .subscribe(
+                () => {
+                    fail('expected an error, not to create group');
+                },
+                (error) => {
+                    expect(error.status).toEqual(404);
+                    expect(error.statusText).toEqual('Not Found');
+                    expect(error.error).toEqual('Mock Error');
+                    done();
+                }
+            );
+    });
+
+    it('should be able to update group', (done) => {
+        const updateCustomApiSpy = spyOn(apiService, 'getInstance').and.returnValue(updateGroupMappingApi);
+        service.updateGroup('mock-group-id', mockIdentityGroup1).subscribe((res) => {
+            expect(updateCustomApiSpy).toHaveBeenCalled();
+            done();
+        });
+    });
+
+    it('Should not able to update group if error occurred', (done) => {
+        const errorResponse = new HttpErrorResponse({
+            error: 'Mock Error',
+            status: 404, statusText: 'Not Found'
+        });
+
+        spyOn(service, 'updateGroup').and.returnValue(throwError(errorResponse));
+
+        service.updateGroup('mock-group-id', mockIdentityGroup1)
+            .subscribe(
+                () => {
+                    fail('expected an error, not to update group');
+                },
+                (error) => {
+                    expect(error.status).toEqual(404);
+                    expect(error.statusText).toEqual('Not Found');
+                    expect(error.error).toEqual('Mock Error');
+                    done();
+                }
+            );
+    });
+
+    it('should be able to delete group', (done) => {
+        const deleteCustomApiSpy = spyOn(apiService, 'getInstance').and.returnValue(deleteGroupMappingApi);
+        service.deleteGroup('mock-group-id').subscribe((res) => {
+            expect(deleteCustomApiSpy).toHaveBeenCalled();
+            done();
+        });
+    });
+
+    it('Should not able to delete group if error occurred', (done) => {
+        const errorResponse = new HttpErrorResponse({
+            error: 'Mock Error',
+            status: 404, statusText: 'Not Found'
+        });
+
+        spyOn(service, 'deleteGroup').and.returnValue(throwError(errorResponse));
+
+        service.deleteGroup('mock-group-id')
+            .subscribe(
+                () => {
+                    fail('expected an error, not to delete group');
+                },
+                (error) => {
+                    expect(error.status).toEqual(404);
+                    expect(error.statusText).toEqual('Not Found');
+                    expect(error.error).toEqual('Mock Error');
+                    done();
+                }
+            );
+    });
+});

lib/core/userinfo/services/identity-group.service.ts

@@ -0,0 +1,347 @@
+/*!
+ * @license
+ * Copyright 2019 Alfresco Software, Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import { Injectable } from '@angular/core';
+import { Observable, of, from, throwError } from 'rxjs';
+import { catchError, map, switchMap } from 'rxjs/operators';
+import { AppConfigService } from '../../app-config/app-config.service';
+import { AlfrescoApiService } from '../../services/alfresco-api.service';
+import { LogService } from '../../services/log.service';
+import {
+    IdentityGroupSearchParam,
+    IdentityGroupQueryCloudRequestModel,
+    IdentityGroupModel,
+    IdentityGroupQueryResponse,
+    IdentityGroupCountModel
+} from '../models/identity-group.model';
+import { IdentityRoleModel } from '../models/identity-role.model';
+
+@Injectable({
+  providedIn: 'root'
+})
+export class IdentityGroupService {
+
+    constructor(
+        private alfrescoApiService: AlfrescoApiService,
+        private appConfigService: AppConfigService,
+        private logService: LogService
+    ) {}
+
+    /**
+     * Gets all groups.
+     * @returns Array of group information objects
+     */
+    getGroups(): Observable<IdentityGroupModel[]> {
+        const url = this.getGroupsApi();
+        const httpMethod = 'GET', pathParams = {},
+        queryParams = {}, bodyParam = {}, headerParams = {},
+        formParams = {}, authNames = [], contentTypes = ['application/json'];
+
+        return from(this.alfrescoApiService.getInstance().oauth2Auth.callCustomApi(
+                    url, httpMethod, pathParams, queryParams,
+                    headerParams, formParams, bodyParam, authNames,
+                    contentTypes, null, null, null
+                    )).pipe(
+                        catchError((error) => this.handleError(error))
+                    );
+    }
+
+    /**
+     * Queries groups.
+     * @returns Array of user information objects
+     */
+    queryGroups(requestQuery: IdentityGroupQueryCloudRequestModel): Observable<IdentityGroupQueryResponse> {
+        const url = this.getGroupsApi();
+        const httpMethod = 'GET', pathParams = {},
+        queryParams = { first: requestQuery.first || 0, max: requestQuery.max || 5 }, bodyParam = {}, headerParams = {},
+        formParams = {}, authNames = [], contentTypes = ['application/json'];
+        return this.getTotalGroupsCount().pipe(
+            switchMap((totalCount: IdentityGroupCountModel) =>
+            from(this.alfrescoApiService.getInstance().oauth2Auth.callCustomApi(
+                url, httpMethod, pathParams, queryParams,
+                headerParams, formParams, bodyParam, authNames,
+                contentTypes, null, null, null)
+            ).pipe(
+                map((response: any[]) => {
+                    return <IdentityGroupQueryResponse> {
+                        entries: response,
+                        pagination: {
+                            skipCount: requestQuery.first,
+                            maxItems: requestQuery.max,
+                            count: totalCount.count,
+                            hasMoreItems: false,
+                            totalItems: totalCount.count
+                        }
+                        };
+                    }),
+                catchError((error) => this.handleError(error))
+                ))
+            );
+    }
+
+    /**
+     * Gets groups total count.
+     * @returns Number of groups count.
+     */
+    getTotalGroupsCount(): Observable<IdentityGroupCountModel> {
+        const url = this.getGroupsApi() + `/count`;
+        const contentTypes = ['application/json'], accepts = ['application/json'];
+        return from(this.alfrescoApiService.getInstance()
+            .oauth2Auth.callCustomApi(url, 'GET',
+              null, null, null,
+              null, null, contentTypes,
+              accepts, null, null, null)).pipe(
+                catchError((error) => this.handleError(error))
+            );
+    }
+
+    /**
+     * Creates new group.
+     * @param newGroup Object of containing the new group details.
+     * @returns Empty response when the group created.
+     */
+    createGroup(newGroup: IdentityGroupModel): Observable<any> {
+        const url = this.getGroupsApi();
+        const httpMethod = 'POST', pathParams = {}, queryParams = {}, bodyParam = newGroup, headerParams = {},
+        formParams = {}, contentTypes = ['application/json'], accepts = ['application/json'];
+
+        return from(this.alfrescoApiService.getInstance().oauth2Auth.callCustomApi(
+        url, httpMethod, pathParams, queryParams,
+        headerParams, formParams, bodyParam,
+        contentTypes, accepts, null, null, null
+        )).pipe(
+            catchError((error) => this.handleError(error))
+        );
+    }
+
+    /**
+     * Updates group details.
+     * @param groupId Id of the targeted group.
+     * @param updatedGroup Object of containing the group details
+     * @returns Empty response when the group updated.
+     */
+    updateGroup(groupId: string, updatedGroup: IdentityGroupModel): Observable<any> {
+        const url = this.getGroupsApi() + `/${groupId}`;
+        const request = JSON.stringify(updatedGroup);
+        const httpMethod = 'PUT', pathParams = {} , queryParams = {}, bodyParam = request, headerParams = {},
+        formParams = {}, contentTypes = ['application/json'], accepts = ['application/json'];
+
+        return from(this.alfrescoApiService.getInstance().oauth2Auth.callCustomApi(
+        url, httpMethod, pathParams, queryParams,
+        headerParams, formParams, bodyParam,
+        contentTypes, accepts, null, null, null
+        )).pipe(
+            catchError((error) => this.handleError(error))
+        );
+    }
+
+    /**
+     * Deletes Group.
+     * @param groupId Id of the group.
+     * @returns Empty response when the group deleted.
+     */
+    deleteGroup(groupId: string): Observable<any> {
+        const url = this.getGroupsApi() + `/${groupId}`;
+        const httpMethod = 'DELETE', pathParams = {} , queryParams = {}, bodyParam = {}, headerParams = {},
+        formParams = {}, contentTypes = ['application/json'], accepts = ['application/json'];
+
+        return from(this.alfrescoApiService.getInstance().oauth2Auth.callCustomApi(
+        url, httpMethod, pathParams, queryParams,
+        headerParams, formParams, bodyParam,
+        contentTypes, accepts, null, null, null
+        )).pipe(
+            catchError((error) => this.handleError(error))
+        );
+    }
+
+    /**
+     * Finds groups filtered by name.
+     * @param searchParams Object containing the name filter string
+     * @returns List of group information
+     */
+    findGroupsByName(searchParams: IdentityGroupSearchParam): Observable<any> {
+        if (searchParams.name === '') {
+            return of([]);
+        }
+        const url = this.getGroupsApi();
+        const httpMethod = 'GET', pathParams = {}, queryParams = {search: searchParams.name}, bodyParam = {}, headerParams = {},
+            formParams = {}, contentTypes = ['application/json'], accepts = ['application/json'];
+
+        return (from(this.alfrescoApiService.getInstance().oauth2Auth.callCustomApi(
+            url, httpMethod, pathParams, queryParams,
+            headerParams, formParams, bodyParam,
+            contentTypes, accepts, Object, null, null)
+        )).pipe(
+            catchError((error) => this.handleError(error))
+        );
+    }
+
+    /**
+     * Gets details for a specified group.
+     * @param groupId Id of the target group
+     * @returns Group details
+     */
+    getGroupRoles(groupId: string): Observable<IdentityRoleModel[]> {
+        const url = this.buildRolesUrl(groupId);
+        const httpMethod = 'GET', pathParams = {}, queryParams = {}, bodyParam = {}, headerParams = {},
+            formParams = {}, contentTypes = ['application/json'], accepts = ['application/json'];
+
+        return (from(this.alfrescoApiService.getInstance().oauth2Auth.callCustomApi(
+            url, httpMethod, pathParams, queryParams,
+            headerParams, formParams, bodyParam,
+            contentTypes, accepts, Object, null, null)
+        )).pipe(
+            catchError((error) => this.handleError(error))
+        );
+    }
+
+    /**
+     * Check that a group has one or more roles from the supplied list.
+     * @param groupId Id of the target group
+     * @param roleNames Array of role names
+     * @returns True if the group has one or more of the roles, false otherwise
+     */
+    checkGroupHasRole(groupId: string, roleNames: string[]): Observable<boolean>  {
+        return this.getGroupRoles(groupId).pipe(map((groupRoles: IdentityRoleModel[]) => {
+            let hasRole = false;
+            if (groupRoles && groupRoles.length > 0) {
+                roleNames.forEach((roleName: string) => {
+                    const role = groupRoles.find((groupRole) => {
+                        return roleName === groupRole.name;
+                    });
+                    if (role) {
+                        hasRole = true;
+                        return;
+                    }
+                });
+            }
+            return hasRole;
+        }));
+    }
+
+    /**
+     * Gets the client Id using the app name.
+     * @param applicationName Name of the app
+     * @returns client Id string
+     */
+    getClientIdByApplicationName(applicationName: string): Observable<string> {
+        const url = this.getApplicationIdApi();
+        const httpMethod = 'GET', pathParams = {}, queryParams = {clientId: applicationName}, bodyParam = {}, headerParams = {}, formParams = {},
+              contentTypes = ['application/json'], accepts = ['application/json'];
+        return from(this.alfrescoApiService.getInstance()
+                        .oauth2Auth.callCustomApi(url, httpMethod, pathParams, queryParams, headerParams,
+                                              formParams, bodyParam, contentTypes,
+                                              accepts, Object, null, null)
+            ).pipe(
+                map((response: any[]) => {
+                    const clientId = response && response.length > 0 ? response[0].id : '';
+                    return clientId;
+                }),
+                catchError((error) => this.handleError(error))
+            );
+    }
+
+    /**
+     * Gets client roles.
+     * @param groupId Id of the target group
+     * @param clientId Id of the client
+     * @returns List of roles
+     */
+    getClientRoles(groupId: string, clientId: string): Observable<IdentityRoleModel[]> {
+        const url = this.groupClientRoleMappingApi(groupId, clientId);
+        const httpMethod = 'GET', pathParams = {}, queryParams = {}, bodyParam = {}, headerParams = {},
+            formParams = {}, contentTypes = ['application/json'], accepts = ['application/json'];
+
+        return from(this.alfrescoApiService.getInstance().oauth2Auth.callCustomApi(
+                    url, httpMethod, pathParams, queryParams,
+                    headerParams, formParams, bodyParam,
+                    contentTypes, accepts, Object, null, null)
+                );
+    }
+
+    /**
+     * Checks if a group has a client app.
+     * @param groupId Id of the target group
+     * @param clientId Id of the client
+     * @returns True if the group has the client app, false otherwise
+     */
+    checkGroupHasClientApp(groupId: string, clientId: string): Observable<boolean> {
+        return this.getClientRoles(groupId, clientId).pipe(
+                    map((response: any[]) => {
+                        if (response && response.length > 0) {
+                            return true;
+                        }
+                        return false;
+                    }),
+                    catchError((error) => this.handleError(error))
+            );
+    }
+
+    /**
+     * Check if a group has any of the client app roles in the supplied list.
+     * @param groupId Id of the target group
+     * @param clientId Id of the client
+     * @param roleNames Array of role names to check
+     * @returns True if the group has one or more of the roles, false otherwise
+     */
+    checkGroupHasAnyClientAppRole(groupId: string, clientId: string, roleNames: string[]): Observable<boolean> {
+        return this.getClientRoles(groupId, clientId).pipe(
+            map((clientRoles: any[]) => {
+                let hasRole = false;
+                if (clientRoles.length > 0) {
+                    roleNames.forEach((roleName) => {
+                        const role = clientRoles.find((availableRole) => {
+                            return availableRole.name === roleName;
+                        });
+
+                        if (role) {
+                            hasRole = true;
+                            return;
+                        }
+                    });
+                }
+                return hasRole;
+            }),
+            catchError((error) => this.handleError(error))
+        );
+    }
+
+    private groupClientRoleMappingApi(groupId: string, clientId: string): string {
+        return `${this.appConfigService.get('identityHost')}/groups/${groupId}/role-mappings/clients/${clientId}`;
+    }
+
+    private getApplicationIdApi(): string {
+        return `${this.appConfigService.get('identityHost')}/clients`;
+    }
+
+    private getGroupsApi(): string {
+        return `${this.appConfigService.get('identityHost')}/groups`;
+    }
+
+    private buildRolesUrl(groupId: string): string {
+        return `${this.appConfigService.get('identityHost')}/groups/${groupId}/role-mappings/realm/composite`;
+    }
+
+    /**
+     * Throw the error
+     * @param error
+     */
+    private handleError(error: Response) {
+        this.logService.error(error);
+        return throwError(error || 'Server error');
+    }
+}

lib/core/userinfo/services/identity-user.service.ts

@@ -667,19 +667,19 @@ export class IdentityUserService {
         );
     }
 
-    private buildUserUrl(): any {
+    private buildUserUrl(): string {
         return `${this.appConfigService.get('identityHost')}/users`;
     }
 
-    private buildUserClientRoleMapping(userId: string, clientId: string): any {
+    private buildUserClientRoleMapping(userId: string, clientId: string): string {
         return `${this.appConfigService.get('identityHost')}/users/${userId}/role-mappings/clients/${clientId}`;
     }
 
-    private buildRolesUrl(userId: string): any {
+    private buildRolesUrl(userId: string): string {
         return `${this.appConfigService.get('identityHost')}/users/${userId}/role-mappings/realm/composite`;
     }
 
-    private buildGetClientsUrl() {
+    private buildGetClientsUrl(): string {
         return `${this.appConfigService.get('identityHost')}/clients`;
     }