@alfresco/adf-core 8.1.0-16295248176 → 8.1.0-16320806191

package/esm2022/lib/auth/services/identity-role.service.mjs

@@ -0,0 +1,99 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * 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 { HttpClient } from '@angular/common/http';
+import { of } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { AppConfigService } from '../../app-config/app-config.service';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../../app-config/app-config.service";
+export class IdentityRoleService {
+    constructor(http, appConfig) {
+        this.http = http;
+        this.appConfig = appConfig;
+        this.contextRoot = '';
+        this.identityHost = '';
+        this.contextRoot = this.appConfig.get('apiHost', '');
+        this.identityHost = this.appConfig.get('identityHost');
+    }
+    /**
+     * Ret all roles
+     *
+     * @param skipCount skip count
+     * @param size page size
+     * @returns List of roles
+     */
+    getRoles(skipCount = 0, size = 5) {
+        return this.http.get(`${this.identityHost}/roles`).pipe(map((res) => this.preparePaginationWithRoles(res, skipCount, size)));
+    }
+    preparePaginationWithRoles(roles, skipCount = 0, size = 5) {
+        return {
+            entries: roles.slice(skipCount, skipCount + size),
+            pagination: {
+                skipCount,
+                maxItems: size,
+                count: roles.length,
+                hasMoreItems: false,
+                totalItems: roles.length
+            }
+        };
+    }
+    /**
+     * Add new role
+     *
+     * @param newRole Role model
+     * @returns Server result payload
+     */
+    addRole(newRole) {
+        if (newRole) {
+            return this.http.post(`${this.identityHost}/roles`, newRole);
+        }
+        return of();
+    }
+    /**
+     * Delete existing role
+     *
+     * @param deletedRole Role model
+     * @returns Server result payload
+     */
+    deleteRole(deletedRole) {
+        return this.http.delete(`${this.identityHost}/roles-by-id/${deletedRole.id}`);
+    }
+    /**
+     * Update existing role
+     *
+     * @param updatedRole Role model
+     * @param roleId Role id
+     * @returns Server result payload
+     */
+    updateRole(updatedRole, roleId) {
+        if (updatedRole && roleId) {
+            return this.http.put(`${this.identityHost}/roles-by-id/${roleId}`, updatedRole);
+        }
+        return of();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdentityRoleService, deps: [{ token: i1.HttpClient }, { token: i2.AppConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdentityRoleService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdentityRoleService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.AppConfigService }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/auth/services/identity-user.service.mjs

@@ -0,0 +1,443 @@
+/*!
+ * @license
+ * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.
+ *
+ * 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 { of } from 'rxjs';
+import { map, switchMap } from 'rxjs/operators';
+import { AppConfigService } from '../../app-config/app-config.service';
+import { JwtHelperService } from './jwt-helper.service';
+import { OAuth2Service } from './oauth2.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./jwt-helper.service";
+import * as i2 from "./oauth2.service";
+import * as i3 from "../../app-config/app-config.service";
+export class IdentityUserService {
+    constructor(jwtHelperService, oAuth2Service, appConfigService) {
+        this.jwtHelperService = jwtHelperService;
+        this.oAuth2Service = oAuth2Service;
+        this.appConfigService = appConfigService;
+    }
+    get identityHost() {
+        return `${this.appConfigService.get('identityHost')}`;
+    }
+    buildUserUrl() {
+        return `${this.identityHost}/users`;
+    }
+    /**
+     * Gets the name and other basic details of the current user.
+     *
+     * @returns The user's details
+     */
+    getCurrentUserInfo() {
+        const familyName = this.jwtHelperService.getValueFromLocalToken(JwtHelperService.FAMILY_NAME);
+        const givenName = this.jwtHelperService.getValueFromLocalToken(JwtHelperService.GIVEN_NAME);
+        const email = this.jwtHelperService.getValueFromLocalToken(JwtHelperService.USER_EMAIL);
+        const username = this.jwtHelperService.getValueFromLocalToken(JwtHelperService.USER_PREFERRED_USERNAME);
+        return { firstName: givenName, lastName: familyName, email, username };
+    }
+    /**
+     * Find users based on search input.
+     *
+     * @param search Search query string
+     * @returns List of users
+     */
+    findUsersByName(search) {
+        if (search === '') {
+            return of([]);
+        }
+        const url = this.buildUserUrl();
+        const queryParams = { search };
+        return this.oAuth2Service.get({ url, queryParams });
+    }
+    /**
+     * Find users based on username input.
+     *
+     * @param username Search query string
+     * @returns List of users
+     */
+    findUserByUsername(username) {
+        if (username === '') {
+            return of([]);
+        }
+        const url = this.buildUserUrl();
+        const queryParams = { username };
+        return this.oAuth2Service.get({ url, queryParams });
+    }
+    /**
+     * Find users based on email input.
+     *
+     * @param email Search query string
+     * @returns List of users
+     */
+    findUserByEmail(email) {
+        if (email === '') {
+            return of([]);
+        }
+        const url = this.buildUserUrl();
+        const queryParams = { email };
+        return this.oAuth2Service.get({ url, queryParams });
+    }
+    /**
+     * Find users based on id input.
+     *
+     * @param id Search query string
+     * @returns users object
+     */
+    findUserById(id) {
+        if (id === '') {
+            return of([]);
+        }
+        const url = this.buildUserUrl() + '/' + id;
+        return this.oAuth2Service.get({ url });
+    }
+    /**
+     * Get client roles of a user for a particular client.
+     *
+     * @param userId ID of the target user
+     * @param clientId ID of the client app
+     * @returns List of client roles
+     */
+    getClientRoles(userId, clientId) {
+        const url = `${this.identityHost}/users/${userId}/role-mappings/clients/${clientId}/composite`;
+        return this.oAuth2Service.get({ url });
+    }
+    /**
+     * Checks whether user has access to a client app.
+     *
+     * @param userId ID of the target user
+     * @param clientId ID of the client app
+     * @returns True if the user has access, false otherwise
+     */
+    checkUserHasClientApp(userId, clientId) {
+        return this.getClientRoles(userId, clientId).pipe(map((clientRoles) => clientRoles.length > 0));
+    }
+    /**
+     * Checks whether a user has any of the client app roles.
+     *
+     * @param userId ID of the target user
+     * @param clientId ID of the client app
+     * @param roleNames List of role names to check for
+     * @returns True if the user has one or more of the roles, false otherwise
+     */
+    checkUserHasAnyClientAppRole(userId, clientId, roleNames) {
+        return this.getClientRoles(userId, clientId).pipe(map((clientRoles) => {
+            let hasRole = false;
+            if (clientRoles.length > 0) {
+                roleNames.forEach((roleName) => {
+                    const role = clientRoles.find(({ name }) => name === roleName);
+                    if (role) {
+                        hasRole = true;
+                        return;
+                    }
+                });
+            }
+            return hasRole;
+        }));
+    }
+    /**
+     * Gets the client ID for an application.
+     *
+     * @param applicationName Name of the application
+     * @returns Client ID string
+     */
+    getClientIdByApplicationName(applicationName) {
+        const url = `${this.identityHost}/clients`;
+        const queryParams = { clientId: applicationName };
+        return this.oAuth2Service.get({ url, queryParams }).pipe(map((response) => (response && response.length > 0 ? response[0].id : '')));
+    }
+    /**
+     * Checks if a user has access to an application.
+     *
+     * @param userId ID of the user
+     * @param applicationName Name of the application
+     * @returns True if the user has access, false otherwise
+     */
+    checkUserHasApplicationAccess(userId, applicationName) {
+        return this.getClientIdByApplicationName(applicationName).pipe(switchMap((clientId) => this.checkUserHasClientApp(userId, clientId)));
+    }
+    /**
+     * Checks if a user has any application role.
+     *
+     * @param userId ID of the target user
+     * @param applicationName Name of the application
+     * @param roleNames List of role names to check for
+     * @returns True if the user has one or more of the roles, false otherwise
+     */
+    checkUserHasAnyApplicationRole(userId, applicationName, roleNames) {
+        return this.getClientIdByApplicationName(applicationName).pipe(switchMap((clientId) => this.checkUserHasAnyClientAppRole(userId, clientId, roleNames)));
+    }
+    /**
+     * Gets details for all users.
+     *
+     * @returns Array of user info objects
+     */
+    getUsers() {
+        const url = this.buildUserUrl();
+        return this.oAuth2Service.get({ url });
+    }
+    /**
+     * Gets a list of roles for a user.
+     *
+     * @param userId ID of the user
+     * @returns Array of role info objects
+     */
+    getUserRoles(userId) {
+        const url = `${this.identityHost}/users/${userId}/role-mappings/realm/composite`;
+        return this.oAuth2Service.get({ url });
+    }
+    /**
+     * Gets an array of users (including the current user) who have any of the roles in the supplied list.
+     *
+     * @param roleNames List of role names to look for
+     * @returns Array of user info objects
+     */
+    async getUsersByRolesWithCurrentUser(roleNames) {
+        const filteredUsers = [];
+        if (roleNames && roleNames.length > 0) {
+            const users = await this.getUsers().toPromise();
+            for (let i = 0; i < users.length; i++) {
+                const hasAnyRole = await this.userHasAnyRole(users[i].id, roleNames);
+                if (hasAnyRole) {
+                    filteredUsers.push(users[i]);
+                }
+            }
+        }
+        return filteredUsers;
+    }
+    /**
+     * Gets an array of users (not including the current user) who have any of the roles in the supplied list.
+     *
+     * @param roleNames List of role names to look for
+     * @returns Array of user info objects
+     */
+    async getUsersByRolesWithoutCurrentUser(roleNames) {
+        const filteredUsers = [];
+        if (roleNames && roleNames.length > 0) {
+            const currentUser = this.getCurrentUserInfo();
+            let users = await this.getUsers().toPromise();
+            users = users.filter(({ username }) => username !== currentUser.username);
+            for (let i = 0; i < users.length; i++) {
+                const hasAnyRole = await this.userHasAnyRole(users[i].id, roleNames);
+                if (hasAnyRole) {
+                    filteredUsers.push(users[i]);
+                }
+            }
+        }
+        return filteredUsers;
+    }
+    async userHasAnyRole(userId, roleNames) {
+        const userRoles = await this.getUserRoles(userId).toPromise();
+        const hasAnyRole = roleNames.some((roleName) => {
+            const filteredRoles = userRoles.filter((userRole) => userRole.name.toLocaleLowerCase() === roleName.toLocaleLowerCase());
+            return filteredRoles.length > 0;
+        });
+        return hasAnyRole;
+    }
+    /**
+     * Checks if a user has one of the roles from a list.
+     *
+     * @param userId ID of the target user
+     * @param roleNames Array of roles to check for
+     * @returns True if the user has one of the roles, false otherwise
+     */
+    checkUserHasRole(userId, roleNames) {
+        return this.getUserRoles(userId).pipe(map((userRoles) => {
+            let hasRole = false;
+            if (userRoles && userRoles.length > 0) {
+                roleNames.forEach((roleName) => {
+                    const role = userRoles.find(({ name }) => roleName === name);
+                    if (role) {
+                        hasRole = true;
+                        return;
+                    }
+                });
+            }
+            return hasRole;
+        }));
+    }
+    /**
+     * Gets details for all users.
+     *
+     * @param requestQuery query model
+     * @returns Array of user information objects.
+     */
+    queryUsers(requestQuery) {
+        const url = this.buildUserUrl();
+        const queryParams = { first: requestQuery.first, max: requestQuery.max };
+        return this.getTotalUsersCount().pipe(switchMap((totalCount) => this.oAuth2Service.get({ url, queryParams }).pipe(map((response) => ({
+            entries: response,
+            pagination: {
+                skipCount: requestQuery.first,
+                maxItems: requestQuery.max,
+                count: totalCount,
+                hasMoreItems: false,
+                totalItems: totalCount
+            }
+        })))));
+    }
+    /**
+     * Gets users total count.
+     *
+     * @returns Number of users count.
+     */
+    getTotalUsersCount() {
+        const url = this.buildUserUrl() + `/count`;
+        return this.oAuth2Service.get({ url });
+    }
+    /**
+     * Creates new user.
+     *
+     * @param newUser Object containing the new user details.
+     * @returns Empty response when the user created.
+     */
+    createUser(newUser) {
+        const url = this.buildUserUrl();
+        const bodyParam = JSON.stringify(newUser);
+        return this.oAuth2Service.post({ url, bodyParam });
+    }
+    /**
+     * Updates user details.
+     *
+     * @param userId Id of the user.
+     * @param updatedUser Object containing the user details.
+     * @returns Empty response when the user updated.
+     */
+    updateUser(userId, updatedUser) {
+        const url = this.buildUserUrl() + '/' + userId;
+        const bodyParam = JSON.stringify(updatedUser);
+        return this.oAuth2Service.put({ url, bodyParam });
+    }
+    /**
+     * Deletes User.
+     *
+     * @param userId Id of the  user.
+     * @returns Empty response when the user deleted.
+     */
+    deleteUser(userId) {
+        const url = this.buildUserUrl() + '/' + userId;
+        return this.oAuth2Service.delete({ url });
+    }
+    /**
+     * Changes user password.
+     *
+     * @param userId Id of the user.
+     * @param newPassword Details of user Credentials.
+     * @returns Empty response when the password changed.
+     */
+    changePassword(userId, newPassword) {
+        const url = this.buildUserUrl() + '/' + userId + '/reset-password';
+        const bodyParam = JSON.stringify(newPassword);
+        return this.oAuth2Service.put({ url, bodyParam });
+    }
+    /**
+     * Gets involved groups.
+     *
+     * @param userId Id of the user.
+     * @returns Array of involved groups information objects.
+     */
+    getInvolvedGroups(userId) {
+        const url = this.buildUserUrl() + '/' + userId + '/groups/';
+        const pathParams = { id: userId };
+        return this.oAuth2Service.get({ url, pathParams });
+    }
+    /**
+     * Joins group.
+     *
+     * @param joinGroupRequest Details of join group request (IdentityJoinGroupRequestModel).
+     * @returns Empty response when the user joined the group.
+     */
+    joinGroup(joinGroupRequest) {
+        const url = this.buildUserUrl() + '/' + joinGroupRequest.userId + '/groups/' + joinGroupRequest.groupId;
+        const bodyParam = JSON.stringify(joinGroupRequest);
+        return this.oAuth2Service.put({ url, bodyParam });
+    }
+    /**
+     * Leaves group.
+     *
+     * @param userId Id of the user.
+     * @param groupId Id of the  group.
+     * @returns Empty response when the user left the group.
+     */
+    leaveGroup(userId, groupId) {
+        const url = this.buildUserUrl() + '/' + userId + '/groups/' + groupId;
+        return this.oAuth2Service.delete({ url });
+    }
+    /**
+     * Gets available roles
+     *
+     * @param userId Id of the user.
+     * @returns Array of available roles information objects
+     */
+    getAvailableRoles(userId) {
+        const url = this.buildUserUrl() + '/' + userId + '/role-mappings/realm/available';
+        return this.oAuth2Service.get({ url });
+    }
+    /**
+     * Gets assigned roles.
+     *
+     * @param userId Id of the user.
+     * @returns Array of assigned roles information objects
+     */
+    getAssignedRoles(userId) {
+        const url = this.buildUserUrl() + '/' + userId + '/role-mappings/realm';
+        const pathParams = { id: userId };
+        return this.oAuth2Service.get({ url, pathParams });
+    }
+    /**
+     * Gets effective roles.
+     *
+     * @param userId Id of the user.
+     * @returns Array of composite roles information objects
+     */
+    getEffectiveRoles(userId) {
+        const url = this.buildUserUrl() + '/' + userId + '/role-mappings/realm/composite';
+        const pathParams = { id: userId };
+        return this.oAuth2Service.get({ url, pathParams });
+    }
+    /**
+     * Assigns roles to the user.
+     *
+     * @param userId Id of the user.
+     * @param roles Array of roles.
+     * @returns Empty response when the role assigned.
+     */
+    assignRoles(userId, roles) {
+        const url = this.buildUserUrl() + '/' + userId + '/role-mappings/realm';
+        const bodyParam = JSON.stringify(roles);
+        return this.oAuth2Service.post({ url, bodyParam });
+    }
+    /**
+     * Removes assigned roles.
+     *
+     * @param userId Id of the user.
+     * @param removedRoles Array of roles.
+     * @returns Empty response when the role removed.
+     */
+    removeRoles(userId, removedRoles) {
+        const url = this.buildUserUrl() + '/' + userId + '/role-mappings/realm';
+        const bodyParam = JSON.stringify(removedRoles);
+        return this.oAuth2Service.delete({ url, bodyParam });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdentityUserService, deps: [{ token: i1.JwtHelperService }, { token: i2.OAuth2Service }, { token: i3.AppConfigService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdentityUserService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: IdentityUserService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ type: i1.JwtHelperService }, { type: i2.OAuth2Service }, { type: i3.AppConfigService }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"identity-user.service.js","sourceRoot":"","sources":["../../../../../../../lib/core/src/lib/auth/services/identity-user.service.ts"],"names":[],"mappings":"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","sourcesContent":["/*!\n * @license\n * Copyright © 2005-2025 Hyland Software, Inc. and its affiliates. All rights reserved.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n *     http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { Injectable } from '@angular/core';\nimport { Observable, of } from 'rxjs';\nimport { map, switchMap } from 'rxjs/operators';\nimport { AppConfigService } from '../../app-config/app-config.service';\nimport { IdentityGroupModel } from '../models/identity-group.model';\nimport { IdentityRoleModel } from '../models/identity-role.model';\nimport { IdentityUserModel } from '../models/identity-user.model';\nimport {\n    IdentityJoinGroupRequestModel,\n    IdentityUserServiceInterface,\n    IdentityUserPasswordModel,\n    IdentityUserQueryCloudRequestModel,\n    IdentityUserQueryResponse\n} from '../interfaces/identity-user.service.interface';\nimport { JwtHelperService } from './jwt-helper.service';\nimport { OAuth2Service } from './oauth2.service';\n\n@Injectable({\n    providedIn: 'root'\n})\nexport class IdentityUserService implements IdentityUserServiceInterface {\n    constructor(private jwtHelperService: JwtHelperService, private oAuth2Service: OAuth2Service, private appConfigService: AppConfigService) {}\n\n    private get identityHost(): string {\n        return `${this.appConfigService.get('identityHost')}`;\n    }\n\n    private buildUserUrl(): string {\n        return `${this.identityHost}/users`;\n    }\n\n    /**\n     * Gets the name and other basic details of the current user.\n     *\n     * @returns The user's details\n     */\n    getCurrentUserInfo(): IdentityUserModel {\n        const familyName = this.jwtHelperService.getValueFromLocalToken<string>(JwtHelperService.FAMILY_NAME);\n        const givenName = this.jwtHelperService.getValueFromLocalToken<string>(JwtHelperService.GIVEN_NAME);\n        const email = this.jwtHelperService.getValueFromLocalToken<string>(JwtHelperService.USER_EMAIL);\n        const username = this.jwtHelperService.getValueFromLocalToken<string>(JwtHelperService.USER_PREFERRED_USERNAME);\n        return { firstName: givenName, lastName: familyName, email, username };\n    }\n\n    /**\n     * Find users based on search input.\n     *\n     * @param search Search query string\n     * @returns List of users\n     */\n    findUsersByName(search: string): Observable<IdentityUserModel[]> {\n        if (search === '') {\n            return of([]);\n        }\n        const url = this.buildUserUrl();\n        const queryParams = { search };\n\n        return this.oAuth2Service.get({ url, queryParams });\n    }\n\n    /**\n     * Find users based on username input.\n     *\n     * @param username Search query string\n     * @returns List of users\n     */\n    findUserByUsername(username: string): Observable<IdentityUserModel[]> {\n        if (username === '') {\n            return of([]);\n        }\n        const url = this.buildUserUrl();\n        const queryParams = { username };\n\n        return this.oAuth2Service.get({ url, queryParams });\n    }\n\n    /**\n     * Find users based on email input.\n     *\n     * @param email Search query string\n     * @returns List of users\n     */\n    findUserByEmail(email: string): Observable<IdentityUserModel[]> {\n        if (email === '') {\n            return of([]);\n        }\n        const url = this.buildUserUrl();\n        const queryParams = { email };\n\n        return this.oAuth2Service.get({ url, queryParams });\n    }\n\n    /**\n     * Find users based on id input.\n     *\n     * @param id Search query string\n     * @returns users object\n     */\n    findUserById(id: string): Observable<any> {\n        if (id === '') {\n            return of([]);\n        }\n        const url = this.buildUserUrl() + '/' + id;\n        return this.oAuth2Service.get({ url });\n    }\n\n    /**\n     * Get client roles of a user for a particular client.\n     *\n     * @param userId ID of the target user\n     * @param clientId ID of the client app\n     * @returns List of client roles\n     */\n    getClientRoles(userId: string, clientId: string): Observable<any[]> {\n        const url = `${this.identityHost}/users/${userId}/role-mappings/clients/${clientId}/composite`;\n        return this.oAuth2Service.get({ url });\n    }\n\n    /**\n     * Checks whether user has access to a client app.\n     *\n     * @param userId ID of the target user\n     * @param clientId ID of the client app\n     * @returns True if the user has access, false otherwise\n     */\n    checkUserHasClientApp(userId: string, clientId: string): Observable<boolean> {\n        return this.getClientRoles(userId, clientId).pipe(map((clientRoles) => clientRoles.length > 0));\n    }\n\n    /**\n     * Checks whether a user has any of the client app roles.\n     *\n     * @param userId ID of the target user\n     * @param clientId ID of the client app\n     * @param roleNames List of role names to check for\n     * @returns True if the user has one or more of the roles, false otherwise\n     */\n    checkUserHasAnyClientAppRole(userId: string, clientId: string, roleNames: string[]): Observable<boolean> {\n        return this.getClientRoles(userId, clientId).pipe(\n            map((clientRoles: any[]) => {\n                let hasRole = false;\n                if (clientRoles.length > 0) {\n                    roleNames.forEach((roleName) => {\n                        const role = clientRoles.find(({ name }) => name === roleName);\n\n                        if (role) {\n                            hasRole = true;\n                            return;\n                        }\n                    });\n                }\n                return hasRole;\n            })\n        );\n    }\n\n    /**\n     * Gets the client ID for an application.\n     *\n     * @param applicationName Name of the application\n     * @returns Client ID string\n     */\n    getClientIdByApplicationName(applicationName: string): Observable<string> {\n        const url = `${this.identityHost}/clients`;\n        const queryParams = { clientId: applicationName };\n\n        return this.oAuth2Service.get<any[]>({ url, queryParams }).pipe(map((response) => (response && response.length > 0 ? response[0].id : '')));\n    }\n\n    /**\n     * Checks if a user has access to an application.\n     *\n     * @param userId ID of the user\n     * @param applicationName Name of the application\n     * @returns True if the user has access, false otherwise\n     */\n    checkUserHasApplicationAccess(userId: string, applicationName: string): Observable<boolean> {\n        return this.getClientIdByApplicationName(applicationName).pipe(switchMap((clientId: string) => this.checkUserHasClientApp(userId, clientId)));\n    }\n\n    /**\n     * Checks if a user has any application role.\n     *\n     * @param userId ID of the target user\n     * @param applicationName Name of the application\n     * @param roleNames List of role names to check for\n     * @returns True if the user has one or more of the roles, false otherwise\n     */\n    checkUserHasAnyApplicationRole(userId: string, applicationName: string, roleNames: string[]): Observable<boolean> {\n        return this.getClientIdByApplicationName(applicationName).pipe(\n            switchMap((clientId: string) => this.checkUserHasAnyClientAppRole(userId, clientId, roleNames))\n        );\n    }\n\n    /**\n     * Gets details for all users.\n     *\n     * @returns Array of user info objects\n     */\n    getUsers(): Observable<IdentityUserModel[]> {\n        const url = this.buildUserUrl();\n        return this.oAuth2Service.get({ url });\n    }\n\n    /**\n     * Gets a list of roles for a user.\n     *\n     * @param userId ID of the user\n     * @returns Array of role info objects\n     */\n    getUserRoles(userId: string): Observable<IdentityRoleModel[]> {\n        const url = `${this.identityHost}/users/${userId}/role-mappings/realm/composite`;\n        return this.oAuth2Service.get({ url });\n    }\n\n    /**\n     * Gets an array of users (including the current user) who have any of the roles in the supplied list.\n     *\n     * @param roleNames List of role names to look for\n     * @returns Array of user info objects\n     */\n    async getUsersByRolesWithCurrentUser(roleNames: string[]): Promise<IdentityUserModel[]> {\n        const filteredUsers: IdentityUserModel[] = [];\n        if (roleNames && roleNames.length > 0) {\n            const users = await this.getUsers().toPromise();\n\n            for (let i = 0; i < users.length; i++) {\n                const hasAnyRole = await this.userHasAnyRole(users[i].id, roleNames);\n                if (hasAnyRole) {\n                    filteredUsers.push(users[i]);\n                }\n            }\n        }\n\n        return filteredUsers;\n    }\n\n    /**\n     * Gets an array of users (not including the current user) who have any of the roles in the supplied list.\n     *\n     * @param roleNames List of role names to look for\n     * @returns Array of user info objects\n     */\n    async getUsersByRolesWithoutCurrentUser(roleNames: string[]): Promise<IdentityUserModel[]> {\n        const filteredUsers: IdentityUserModel[] = [];\n        if (roleNames && roleNames.length > 0) {\n            const currentUser = this.getCurrentUserInfo();\n            let users = await this.getUsers().toPromise();\n\n            users = users.filter(({ username }) => username !== currentUser.username);\n\n            for (let i = 0; i < users.length; i++) {\n                const hasAnyRole = await this.userHasAnyRole(users[i].id, roleNames);\n                if (hasAnyRole) {\n                    filteredUsers.push(users[i]);\n                }\n            }\n        }\n\n        return filteredUsers;\n    }\n\n    private async userHasAnyRole(userId: string, roleNames: string[]): Promise<boolean> {\n        const userRoles = await this.getUserRoles(userId).toPromise();\n        const hasAnyRole = roleNames.some((roleName) => {\n            const filteredRoles = userRoles.filter((userRole) => userRole.name.toLocaleLowerCase() === roleName.toLocaleLowerCase());\n\n            return filteredRoles.length > 0;\n        });\n\n        return hasAnyRole;\n    }\n\n    /**\n     * Checks if a user has one of the roles from a list.\n     *\n     * @param userId ID of the target user\n     * @param roleNames Array of roles to check for\n     * @returns True if the user has one of the roles, false otherwise\n     */\n    checkUserHasRole(userId: string, roleNames: string[]): Observable<boolean> {\n        return this.getUserRoles(userId).pipe(\n            map((userRoles: IdentityRoleModel[]) => {\n                let hasRole = false;\n                if (userRoles && userRoles.length > 0) {\n                    roleNames.forEach((roleName: string) => {\n                        const role = userRoles.find(({ name }) => roleName === name);\n                        if (role) {\n                            hasRole = true;\n                            return;\n                        }\n                    });\n                }\n                return hasRole;\n            })\n        );\n    }\n\n    /**\n     * Gets details for all users.\n     *\n     * @param requestQuery query model\n     * @returns Array of user information objects.\n     */\n    queryUsers(requestQuery: IdentityUserQueryCloudRequestModel): Observable<IdentityUserQueryResponse> {\n        const url = this.buildUserUrl();\n        const queryParams = { first: requestQuery.first, max: requestQuery.max };\n\n        return this.getTotalUsersCount().pipe(\n            switchMap((totalCount) =>\n                this.oAuth2Service.get<IdentityUserModel[]>({ url, queryParams }).pipe(\n                    map(\n                        (response) =>\n                            ({\n                                entries: response,\n                                pagination: {\n                                    skipCount: requestQuery.first,\n                                    maxItems: requestQuery.max,\n                                    count: totalCount,\n                                    hasMoreItems: false,\n                                    totalItems: totalCount\n                                }\n                            } as IdentityUserQueryResponse)\n                    )\n                )\n            )\n        );\n    }\n\n    /**\n     * Gets users total count.\n     *\n     * @returns Number of users count.\n     */\n    getTotalUsersCount(): Observable<number> {\n        const url = this.buildUserUrl() + `/count`;\n        return this.oAuth2Service.get({ url });\n    }\n\n    /**\n     * Creates new user.\n     *\n     * @param newUser Object containing the new user details.\n     * @returns Empty response when the user created.\n     */\n    createUser(newUser: IdentityUserModel): Observable<any> {\n        const url = this.buildUserUrl();\n        const bodyParam = JSON.stringify(newUser);\n\n        return this.oAuth2Service.post({ url, bodyParam });\n    }\n\n    /**\n     * Updates user details.\n     *\n     * @param userId Id of the user.\n     * @param updatedUser Object containing the user details.\n     * @returns Empty response when the user updated.\n     */\n    updateUser(userId: string, updatedUser: IdentityUserModel): Observable<any> {\n        const url = this.buildUserUrl() + '/' + userId;\n        const bodyParam = JSON.stringify(updatedUser);\n\n        return this.oAuth2Service.put({ url, bodyParam });\n    }\n\n    /**\n     * Deletes User.\n     *\n     * @param userId Id of the  user.\n     * @returns Empty response when the user deleted.\n     */\n    deleteUser(userId: string): Observable<any> {\n        const url = this.buildUserUrl() + '/' + userId;\n        return this.oAuth2Service.delete({ url });\n    }\n\n    /**\n     * Changes user password.\n     *\n     * @param userId Id of the user.\n     * @param newPassword Details of user Credentials.\n     * @returns Empty response when the password changed.\n     */\n    changePassword(userId: string, newPassword: IdentityUserPasswordModel): Observable<any> {\n        const url = this.buildUserUrl() + '/' + userId + '/reset-password';\n        const bodyParam = JSON.stringify(newPassword);\n\n        return this.oAuth2Service.put({ url, bodyParam });\n    }\n\n    /**\n     * Gets involved groups.\n     *\n     * @param userId Id of the user.\n     * @returns Array of involved groups information objects.\n     */\n    getInvolvedGroups(userId: string): Observable<IdentityGroupModel[]> {\n        const url = this.buildUserUrl() + '/' + userId + '/groups/';\n        const pathParams = { id: userId };\n\n        return this.oAuth2Service.get({ url, pathParams });\n    }\n\n    /**\n     * Joins group.\n     *\n     * @param joinGroupRequest Details of join group request (IdentityJoinGroupRequestModel).\n     * @returns Empty response when the user joined the group.\n     */\n    joinGroup(joinGroupRequest: IdentityJoinGroupRequestModel): Observable<any> {\n        const url = this.buildUserUrl() + '/' + joinGroupRequest.userId + '/groups/' + joinGroupRequest.groupId;\n        const bodyParam = JSON.stringify(joinGroupRequest);\n\n        return this.oAuth2Service.put({ url, bodyParam });\n    }\n\n    /**\n     * Leaves group.\n     *\n     * @param userId Id of the user.\n     * @param groupId Id of the  group.\n     * @returns Empty response when the user left the group.\n     */\n    leaveGroup(userId: any, groupId: string): Observable<any> {\n        const url = this.buildUserUrl() + '/' + userId + '/groups/' + groupId;\n        return this.oAuth2Service.delete({ url });\n    }\n\n    /**\n     * Gets available roles\n     *\n     * @param userId Id of the user.\n     * @returns Array of available roles information objects\n     */\n    getAvailableRoles(userId: string): Observable<IdentityRoleModel[]> {\n        const url = this.buildUserUrl() + '/' + userId + '/role-mappings/realm/available';\n        return this.oAuth2Service.get({ url });\n    }\n\n    /**\n     * Gets assigned roles.\n     *\n     * @param userId Id of the user.\n     * @returns Array of assigned roles information objects\n     */\n    getAssignedRoles(userId: string): Observable<IdentityRoleModel[]> {\n        const url = this.buildUserUrl() + '/' + userId + '/role-mappings/realm';\n        const pathParams = { id: userId };\n\n        return this.oAuth2Service.get({ url, pathParams });\n    }\n\n    /**\n     * Gets effective roles.\n     *\n     * @param userId Id of the user.\n     * @returns Array of composite roles information objects\n     */\n    getEffectiveRoles(userId: string): Observable<IdentityRoleModel[]> {\n        const url = this.buildUserUrl() + '/' + userId + '/role-mappings/realm/composite';\n        const pathParams = { id: userId };\n\n        return this.oAuth2Service.get({ url, pathParams });\n    }\n\n    /**\n     * Assigns roles to the user.\n     *\n     * @param userId Id of the user.\n     * @param roles Array of roles.\n     * @returns Empty response when the role assigned.\n     */\n    assignRoles(userId: string, roles: IdentityRoleModel[]): Observable<any> {\n        const url = this.buildUserUrl() + '/' + userId + '/role-mappings/realm';\n        const bodyParam = JSON.stringify(roles);\n\n        return this.oAuth2Service.post({ url, bodyParam });\n    }\n\n    /**\n     * Removes assigned roles.\n     *\n     * @param userId Id of the user.\n     * @param removedRoles Array of roles.\n     * @returns Empty response when the role removed.\n     */\n    removeRoles(userId: string, removedRoles: IdentityRoleModel[]): Observable<any> {\n        const url = this.buildUserUrl() + '/' + userId + '/role-mappings/realm';\n        const bodyParam = JSON.stringify(removedRoles);\n\n        return this.oAuth2Service.delete({ url, bodyParam });\n    }\n}\n"]}