Client for RESTful API for managing roles

Former-commit-id: 280af3f6e7

ccm-core-apiclient/src/main/typescript/clients/groups-api.ts

@@ -6,22 +6,20 @@ import {
 
 import { buildIdentifierParam } from "@libreccm/ccm-apiclient-commons";
 
+import * as Constants from "../constants";
 import {
     Group,
     buildGroupFromRecord,
     buildGroupUserMembershipFromRecord,
     GroupUserMembership,
 } from "../entities/group";
-
-import * as Constants from "../constants";
 import {
     buildPartyRoleMembershipFromRecord,
     PartyRoleMembership,
 } from "../entities/party";
-import { buildRoleFromRecord } from "../entities/role";
 
 /**
- * Client for managaging users, groups and roles using the RESTful API of
+ * Client for managaging groups using the RESTful API of
  * LibreCCM.
  */
 export class GroupsApiClient {
@@ -145,38 +143,6 @@ export class GroupsApiClient {
         }
     }
 
-    async deleteGroupById(groupId: number): Promise<void> {
-        try {
-            const response: ApiResponse = await this.#apiClient.delete(
-                `${this.#GROUPS_API_PREFIX}/ID-${groupId}`
-            );
-            if (response.ok) {
-                return;
-            } else {
-                throw `Failed to delete group ${groupId}: 
-                ${response.status} ${response.statusText}`;
-            }
-        } catch (err) {
-            throw `Failed to delete group ${groupId}: ${err}`;
-        }
-    }
-
-    async deleteGroupByUuid(groupUuid: number): Promise<void> {
-        try {
-            const response: ApiResponse = await this.#apiClient.delete(
-                `${this.#GROUPS_API_PREFIX}/UUID-${groupUuid}`
-            );
-            if (response.ok) {
-                return;
-            } else {
-                throw `Failed to delete group ${groupUuid}: 
-                ${response.status} ${response.statusText}`;
-            }
-        } catch (err) {
-            throw `Failed to delete group ${groupUuid}: ${err}`;
-        }
-    }
-
     async getMembers(
         groupIdentifier: string,
         limit: number,
@@ -315,9 +281,7 @@ export class GroupsApiClient {
             const groupParam = buildIdentifierParam(groupIdentifier);
             const roleParam = buildIdentifierParam(roleIdentifier);
             const response: ApiResponse = await this.#apiClient.put(
-                `${
+                `${this.#GROUPS_API_PREFIX}/${groupParam}/roles/${roleParam}`
-                    this.#GROUPS_API_PREFIX
-                }/${groupParam}/roles/${roleParam}`
             );
             if (response.ok) {
                 return;
@@ -340,9 +304,7 @@ export class GroupsApiClient {
             const groupParam = buildIdentifierParam(groupIdentifier);
             const roleParam = buildIdentifierParam(roleIdentifier);
             const response: ApiResponse = await this.#apiClient.delete(
-                `${
+                `${this.#GROUPS_API_PREFIX}/${groupParam}/roles/${roleParam}`
-                    this.#GROUPS_API_PREFIX
-                }/${groupParam}/roles/${roleParam}`
             );
             if (response.ok) {
                 return;

ccm-core-apiclient/src/main/typescript/clients/roles-api.ts

@@ -0,0 +1,323 @@
+import {
+    ApiResponse,
+    LibreCcmApiClient,
+    ListView,
+} from "@libreccm/ccm-apiclient-commons";
+
+import { buildIdentifierParam } from "@libreccm/ccm-apiclient-commons";
+
+import * as Constants from "../constants";
+
+import {
+    Role,
+    buildRoleFromRecord,
+    buildRolePartyMembershipFromRecord,
+    buildRolePermissionFromRecord,
+    RolePartyMembership,
+    RolePermission,
+} from "../entities/role";
+
+/**
+ * Client for managing users using the RESTful API of
+ * LibreCCM.
+ */
+export class RolesApiClient {
+    #apiClient: LibreCcmApiClient;
+
+    readonly #ROLES_API_PREFIX = `${Constants.ADMIN_API_PREFIX}/roles`;
+
+    constructor(apiClient: LibreCcmApiClient) {
+        this.#apiClient = apiClient;
+    }
+
+    async getRoles(limit: number, offset: number): Promise<ListView<Role>> {
+        try {
+            const response: ApiResponse = await this.#apiClient.get(
+                this.#ROLES_API_PREFIX,
+                {
+                    limit: limit.toString(),
+                    offset: offset.toString(),
+                }
+            );
+            if (response.ok) {
+                const result: Record<
+                    string,
+                    unknown
+                > = (await response.json()) as Record<string, unknown>;
+                const list: Record<string, unknown>[] = result.list as Record<
+                    string,
+                    unknown
+                >[];
+                const roles: Role[] = list.map((record) =>
+                    buildRoleFromRecord(record)
+                );
+
+                return {
+                    list: roles,
+                    count: result.count as number,
+                    limit: result.limit as number,
+                    offset: result.offset as number,
+                };
+            } else {
+                throw `Failed to get roles: 
+                ${response.status} ${response.statusText}`;
+            }
+        } catch (err) {
+            throw `Failed to get roles: ${err}`;
+        }
+    }
+
+    async getRole(roleIdentifier: string): Promise<Role> {
+        try {
+            const roleParam: string = buildIdentifierParam(roleIdentifier);
+
+            const response: ApiResponse = await this.#apiClient.get(
+                `${this.#ROLES_API_PREFIX}/${roleParam}`
+            );
+            if (response.ok) {
+                return buildRoleFromRecord(
+                    (await response.json()) as Record<string, unknown>
+                );
+            } else {
+                throw `Failed to get role ${roleIdentifier}: 
+                ${response.status} ${response.statusText}`;
+            }
+        } catch (err) {
+            throw `Failed to get role: ${err}`;
+        }
+    }
+
+    async addRole(role: Role): Promise<string> {
+        try {
+            const response: ApiResponse = await this.#apiClient.post(
+                `${this.#ROLES_API_PREFIX}`,
+                JSON.stringify(role)
+            );
+            if (response.ok) {
+                return role.name;
+            } else {
+                throw `Failed to add role ${role.name}: 
+                ${response.status} ${response.statusText}`;
+            }
+        } catch (err) {
+            throw `Failed to add role ${role.name}: ${err}`;
+        }
+    }
+
+    async updateRole(roleIdentifier: string, role: Role): Promise<void> {
+        try {
+            const response: ApiResponse = await this.#apiClient.put(
+                `${this.#ROLES_API_PREFIX}/${buildIdentifierParam(
+                    roleIdentifier
+                )}`,
+                JSON.stringify(role)
+            );
+            if (response.ok) {
+                return;
+            } else {
+                throw `Failed to update role ${roleIdentifier}: 
+                ${response.status} ${response.statusText}`;
+            }
+        } catch (err) {
+            throw `Failed to update role ${roleIdentifier}: ${err}`;
+        }
+    }
+
+    async deleteRole(roleIdentifier: string): Promise<void> {
+        try {
+            const response: ApiResponse = await this.#apiClient.delete(
+                `${this.#ROLES_API_PREFIX}/${buildIdentifierParam(
+                    roleIdentifier
+                )}`
+            );
+            if (response.ok) {
+                return;
+            } else {
+                throw `Failed to delete role ${name}: 
+                ${response.status} ${response.statusText}`;
+            }
+        } catch (err) {
+            throw `Failed to delete role ${name}: ${err}`;
+        }
+    }
+
+    async getMembers(
+        roleIdentifier: string,
+        limit: number,
+        offset: number
+    ): Promise<ListView<RolePartyMembership>> {
+        try {
+            const roleParam: string = buildIdentifierParam(roleIdentifier);
+
+            const response: ApiResponse = await this.#apiClient.get(
+                `${this.#ROLES_API_PREFIX}/${roleParam}/members`,
+                {
+                    limit: limit.toString(),
+                    offset: offset.toString(),
+                }
+            );
+
+            if (response.ok) {
+                const result: Record<
+                    string,
+                    unknown
+                > = (await response.json()) as Record<string, unknown>;
+                const list: Record<string, unknown>[] = result.list as Record<
+                    string,
+                    unknown
+                >[];
+                const members: RolePartyMembership[] = list.map((record) =>
+                    buildRolePartyMembershipFromRecord(record)
+                );
+
+                return {
+                    list: members,
+                    count: result.count as number,
+                    limit: result.limit as number,
+                    offset: result.offset as number,
+                };
+            } else {
+                throw `Failed to get members of role ${roleIdentifier}: 
+                ${response.status} ${response.statusText}`;
+            }
+        } catch (err) {
+            throw `Failed to get members of role ${roleIdentifier}: ${err}`;
+        }
+    }
+
+    async addMember(
+        roleIdentifier: string | number,
+        userIdentifier: string | number
+    ): Promise<void> {
+        try {
+            const roleParam = buildIdentifierParam(roleIdentifier);
+            const memberParam = buildIdentifierParam(userIdentifier);
+            const response: ApiResponse = await this.#apiClient.put(
+                `${this.#ROLES_API_PREFIX}/${roleParam}/members/${memberParam}`
+            );
+            if (response.ok) {
+                return;
+            } else {
+                throw `Failed to add user ${userIdentifier} to 
+                role ${roleIdentifier}: 
+                ${response.status} ${response.statusText}`;
+            }
+        } catch (err) {
+            throw `Failed to add user ${userIdentifier} to 
+            role ${roleIdentifier}: ${err}`;
+        }
+    }
+
+    async removeMember(
+        roleIdentifier: string | number,
+        userIdentifier: string | number
+    ): Promise<void> {
+        try {
+            const roleParam = buildIdentifierParam(roleIdentifier);
+            const memberParam = buildIdentifierParam(userIdentifier);
+            const response: ApiResponse = await this.#apiClient.delete(
+                `${this.#ROLES_API_PREFIX}/${roleParam}/members/${memberParam}`
+            );
+            if (response.ok) {
+                return;
+            } else {
+                throw `Failed to remove user ${userIdentifier} from 
+                role ${roleIdentifier}: 
+                ${response.status} ${response.statusText}`;
+            }
+        } catch (err) {
+            throw `Failed to remote user ${userIdentifier} from 
+            role ${roleIdentifier}: ${err}`;
+        }
+    }
+
+    async getPermissions(
+        roleIdentifier: string,
+        limit: number,
+        offset: number
+    ): Promise<ListView<RolePermission>> {
+        try {
+            const roleParam: string = buildIdentifierParam(roleIdentifier);
+
+            const response: ApiResponse = await this.#apiClient.get(
+                `${this.#ROLES_API_PREFIX}/${roleParam}/permissions`,
+                {
+                    limit: limit.toString(),
+                    offset: offset.toString(),
+                }
+            );
+            if (response.ok) {
+                const result: Record<
+                    string,
+                    unknown
+                > = (await response.json()) as Record<string, unknown>;
+                const list: Record<string, unknown>[] = result.list as Record<
+                    string,
+                    unknown
+                >[];
+                const permissions: RolePermission[] = list.map((record) =>
+                    buildRolePermissionFromRecord(record)
+                );
+
+                return {
+                    list: permissions,
+                    count: result.count as number,
+                    limit: result.limit as number,
+                    offset: result.offset as number,
+                };
+            } else {
+                throw `Failed to get permissions of role ${roleIdentifier}: 
+                ${response.status} ${response.statusText}`;
+            }
+        } catch (err) {
+            throw `Failed to get permissions of role ${roleIdentifier}: ${err}`;
+        }
+    }
+
+    async addPermission(
+        roleIdentifier: string,
+        permission: RolePermission
+    ): Promise<void> {
+        try {
+            const roleParam: string = buildIdentifierParam(roleIdentifier);
+
+            const response: ApiResponse = await this.#apiClient.post(
+                `${this.#ROLES_API_PREFIX}/${roleParam}/permissions`,
+                JSON.stringify(permission)
+            );
+            if (response.ok) {
+                return;
+            } else {
+                throw `Failed to add permission to role ${roleIdentifier}: 
+                ${response.status} ${response.statusText}`;
+            }
+        } catch (err) {
+            throw `Failed to add permission to role ${roleIdentifier}: ${err}`;
+        }
+    }
+
+    async removePermission(
+        roleIdentifier: string | number,
+        permissionIdentifier: string | number
+    ): Promise<void> {
+        try {
+            const roleParam = buildIdentifierParam(roleIdentifier);
+            const permissionParam = buildIdentifierParam(permissionIdentifier);
+            const response: ApiResponse = await this.#apiClient.delete(
+                `${
+                    this.#ROLES_API_PREFIX
+                }/${roleParam}/permissions/${permissionParam}`
+            );
+            if (response.ok) {
+                return;
+            } else {
+                throw `Failed to remove permission ${permissionIdentifier} from 
+                role ${roleIdentifier}: 
+                ${response.status} ${response.statusText}`;
+            }
+        } catch (err) {
+            throw `Failed to remote permission ${permissionIdentifier} from 
+            role ${roleIdentifier}: ${err}`;
+        }
+    }
+}