feat: Add role api keys in UI

api/api_keys/models.py

@@ -1,4 +1,6 @@
+from django.conf import settings
 from django.db import models
+from django_lifecycle import BEFORE_UPDATE, LifecycleModelMixin, hook
 from rest_framework_api_key.models import AbstractAPIKey, APIKeyManager
 from softdelete.models import SoftDeleteManager, SoftDeleteObject
 
@@ -9,7 +11,7 @@ class MasterAPIKeyManager(APIKeyManager, SoftDeleteManager):
     pass
 
 
-class MasterAPIKey(AbstractAPIKey, SoftDeleteObject):
+class MasterAPIKey(AbstractAPIKey, LifecycleModelMixin, SoftDeleteObject):
     organisation = models.ForeignKey(
         Organisation,
         on_delete=models.CASCADE,
@@ -18,3 +20,12 @@ class MasterAPIKey(AbstractAPIKey, SoftDeleteObject):
 
     objects = MasterAPIKeyManager()
     is_admin = models.BooleanField(default=True)
+
+    @hook(BEFORE_UPDATE, when="is_admin", was=False, is_now=True)
+    def delete_role_api_keys(
+        self,
+    ):
+        if settings.IS_RBAC_INSTALLED:
+            from rbac.models import MasterAPIKeyRole
+
+            MasterAPIKeyRole.objects.filter(master_api_key=self.id).delete()

api/api_keys/serializers.py

@@ -15,6 +15,7 @@ class MasterAPIKeySerializer(serializers.ModelSerializer):
     class Meta:
         model = MasterAPIKey
         fields = (
+            "id",
             "prefix",
             "created",
             "name",

frontend/common/services/useGroupWithRole.ts

@@ -10,7 +10,10 @@ export const groupWithRoleService = service
         Res['groupWithRole'],
         Req['deleteGroupWithRole']
       >({
-        invalidatesTags: [{ type: 'GroupWithRole' }, { type: 'RolePermissionGroup' }],
+        invalidatesTags: [
+          { type: 'GroupWithRole' },
+          { type: 'RolePermissionGroup' },
+        ],
         query: (query: Req['deleteGroupWithRole']) => ({
           body: query,
           method: 'DELETE',

frontend/common/services/useMasterAPIKeyWithMasterAPIKeyRole.ts

@@ -0,0 +1,102 @@
+import { Res } from 'common/types/responses'
+import { Req } from 'common/types/requests'
+import { service } from 'common/service'
+
+export const masterAPIKeyWithMasterAPIKeyRoleService = service
+  .enhanceEndpoints({ addTagTypes: ['MasterAPIKeyWithMasterAPIKeyRole'] })
+  .injectEndpoints({
+    endpoints: (builder) => ({
+      deleteMasterAPIKeyWithMasterAPIKeyRoles: builder.mutation<
+        Res['masterAPIKeyWithMasterAPIKeyRoles'],
+        Req['deleteMasterAPIKeyWithMasterAPIKeyRoles']
+      >({
+        invalidatesTags: ['MasterAPIKeyWithMasterAPIKeyRole'],
+        query: (query: Req['deleteMasterAPIKeyWithMasterAPIKeyRoles']) => ({
+          method: 'DELETE',
+          url: `organisations/${query.org_id}/master-api-keys/${query.prefix}/roles/${query.role_id}/detach-roles-from-master-api-key/`,
+        }),
+      }),
+      getMasterAPIKeyWithMasterAPIKeyRoles: builder.query<
+        Res['masterAPIKeyWithMasterAPIKeyRoles'],
+        Req['getMasterAPIKeyWithMasterAPIKeyRoles']
+      >({
+        providesTags: (res) => [
+          { id: res?.id, type: 'MasterAPIKeyWithMasterAPIKeyRole' },
+        ],
+        query: (query: Req['getMasterAPIKeyWithMasterAPIKeyRoles']) => ({
+          url: `organisations/${query.org_id}/master-api-keys/${query.prefix}/`,
+        }),
+      }),
+      getRolesMasterAPIKeyWithMasterAPIKeyRoles: builder.query<
+        Res['masterAPIKeyWithMasterAPIKeyRoles'],
+        Req['getMasterAPIKeyWithMasterAPIKeyRoles']
+      >({
+        providesTags: (res) => [
+          { id: res?.id, type: 'MasterAPIKeyWithMasterAPIKeyRole' },
+        ],
+        query: (query: Req['getMasterAPIKeyWithMasterAPIKeyRoles']) => ({
+          url: `organisations/${query.org_id}/master-api-keys/${query.prefix}/roles/`,
+        }),
+      }),
+      // END OF ENDPOINTS
+    }),
+  })
+
+export async function getMasterAPIKeyWithMasterAPIKeyRoles(
+  store: any,
+  data: Req['getMasterAPIKeyWithMasterAPIKeyRoles'],
+  options?: Parameters<
+    typeof masterAPIKeyWithMasterAPIKeyRoleService.endpoints.getMasterAPIKeyWithMasterAPIKeyRoles.initiate
+  >[1],
+) {
+  return store.dispatch(
+    masterAPIKeyWithMasterAPIKeyRoleService.endpoints.getMasterAPIKeyWithMasterAPIKeyRoles.initiate(
+      data,
+      options,
+    ),
+  )
+}
+
+export async function getRolesMasterAPIKeyWithMasterAPIKeyRoles(
+  store: any,
+  data: Req['getMasterAPIKeyWithMasterAPIKeyRoles'],
+  options?: Parameters<
+    typeof masterAPIKeyWithMasterAPIKeyRoleService.endpoints.getRolesMasterAPIKeyWithMasterAPIKeyRoles.initiate
+  >[1],
+) {
+  return store.dispatch(
+    masterAPIKeyWithMasterAPIKeyRoleService.endpoints.getRolesMasterAPIKeyWithMasterAPIKeyRoles.initiate(
+      data,
+      options,
+    ),
+  )
+}
+
+export async function deleteMasterAPIKeyWithMasterAPIKeyRoles(
+  store: any,
+  data: Req['getMasterAPIKeyWithMasterAPIKeyRoles'],
+  options?: Parameters<
+    typeof masterAPIKeyWithMasterAPIKeyRoleService.endpoints.deleteMasterAPIKeyWithMasterAPIKeyRoles.initiate
+  >[1],
+) {
+  return store.dispatch(
+    masterAPIKeyWithMasterAPIKeyRoleService.endpoints.deleteMasterAPIKeyWithMasterAPIKeyRoles.initiate(
+      data,
+      options,
+    ),
+  )
+}
+// END OF FUNCTION_EXPORTS
+
+export const {
+  useDeletexMasterAPIKeyWithMasterAPIKeyRolesMutation,
+  useGetMasterAPIKeyWithMasterAPIKeyRolesQuery,
+  useGetRolesMasterAPIKeyWithMasterAPIKeyRolesQuery,
+  // END OF EXPORTS
+} = masterAPIKeyWithMasterAPIKeyRoleService
+
+/* Usage examples:
+const { data, isLoading } = useGetMasterAPIKeyWithMasterAPIKeyRolesQuery({ id: 2 }, {}) //get hook
+const [createMasterAPIKeyWithMasterAPIKeyRoles, { isLoading, data, isSuccess }] = useCreateMasterAPIKeyWithMasterAPIKeyRolesMutation() //create hook
+masterAPIKeyWithMasterAPIKeyRoleService.endpoints.getMasterAPIKeyWithMasterAPIKeyRoles.select({id: 2})(store.getState()) //access data from any function
+*/

frontend/common/services/useRoleMasterApiKey.ts

@@ -0,0 +1,135 @@
+import { Res } from 'common/types/responses'
+import { Req } from 'common/types/requests'
+import { service } from 'common/service'
+
+export const roleMasterApiKeyService = service
+  .enhanceEndpoints({
+    addTagTypes: ['RoleMasterApiKey'],
+  })
+  .injectEndpoints({
+    endpoints: (builder) => ({
+      createRoleMasterApiKey: builder.mutation<
+        Res['roleMasterApiKey'],
+        Req['createRoleMasterApiKey']
+      >({
+        invalidatesTags: [
+          { id: 'LIST', type: 'RoleMasterApiKey' },
+          'MasterAPIKeyWithMasterAPIKeyRole',
+        ],
+        query: (query: Req['createRoleMasterApiKey']) => ({
+          body: query.body,
+          method: 'POST',
+          url: `organisations/${query.org_id}/roles/${query.role_id}/master-api-keys/`,
+        }),
+      }),
+      deleteRoleMasterApiKey: builder.mutation<
+        Res['roleMasterApiKey'],
+        Req['deleteRoleMasterApiKey']
+      >({
+        invalidatesTags: [
+          { id: 'LIST', type: 'RoleMasterApiKey' },
+          'MasterAPIKeyWithMasterAPIKeyRole',
+        ],
+        query: (query: Req['deleteRoleMasterApiKey']) => ({
+          method: 'DELETE',
+          url: `organisations/${query.org_id}/roles/${query.role_id}/master-api-keys/${query.id}`,
+        }),
+      }),
+      getRoleMasterApiKey: builder.query<
+        Res['roleMasterApiKey'],
+        Req['getRoleMasterApiKey']
+      >({
+        providesTags: (res) => [{ id: res?.id, type: 'RoleMasterApiKey' }],
+        query: (query: Req['getRoleMasterApiKey']) => ({
+          url: `organisations/${query.org_id}/roles/${query.role_id}/master-api-keys/${id}`,
+        }),
+      }),
+      updateRoleMasterApiKey: builder.mutation<
+        Res['roleMasterApiKey'],
+        Req['updateRoleMasterApiKey']
+      >({
+        invalidatesTags: (res) => [
+          { id: 'LIST', type: 'RoleMasterApiKey' },
+          { id: res?.id, type: 'RoleMasterApiKey' },
+        ],
+        query: (query: Req['updateRoleMasterApiKey']) => ({
+          body: query,
+          method: 'PUT',
+          url: `organisations/${query.org_id}/roles/${query.role_id}/master-api-keys/${id}`,
+        }),
+      }),
+      // END OF ENDPOINTS
+    }),
+  })
+
+export async function createRoleMasterApiKey(
+  store: any,
+  data: Req['createRoleMasterApiKey'],
+  options?: Parameters<
+    typeof roleMasterApiKeyService.endpoints.createRoleMasterApiKey.initiate
+  >[1],
+) {
+  return store.dispatch(
+    roleMasterApiKeyService.endpoints.createRoleMasterApiKey.initiate(
+      data,
+      options,
+    ),
+  )
+}
+export async function deleteRoleMasterApiKey(
+  store: any,
+  data: Req['deleteRoleMasterApiKey'],
+  options?: Parameters<
+    typeof roleMasterApiKeyService.endpoints.deleteRoleMasterApiKey.initiate
+  >[1],
+) {
+  return store.dispatch(
+    roleMasterApiKeyService.endpoints.deleteRoleMasterApiKey.initiate(
+      data,
+      options,
+    ),
+  )
+}
+export async function getRoleMasterApiKey(
+  store: any,
+  data: Req['getRoleMasterApiKey'],
+  options?: Parameters<
+    typeof roleMasterApiKeyService.endpoints.getRoleMasterApiKey.initiate
+  >[1],
+) {
+  return store.dispatch(
+    roleMasterApiKeyService.endpoints.getRoleMasterApiKey.initiate(
+      data,
+      options,
+    ),
+  )
+}
+export async function updateRoleMasterApiKey(
+  store: any,
+  data: Req['updateRoleMasterApiKey'],
+  options?: Parameters<
+    typeof roleMasterApiKeyService.endpoints.updateRoleMasterApiKey.initiate
+  >[1],
+) {
+  return store.dispatch(
+    roleMasterApiKeyService.endpoints.updateRoleMasterApiKey.initiate(
+      data,
+      options,
+    ),
+  )
+}
+// END OF FUNCTION_EXPORTS
+
+export const {
+  useCreateRoleMasterApiKeyMutation,
+  useDeleteRoleMasterApiKeyMutation,
+  useGetRoleMasterApiKeyQuery,
+  useUpdateRoleMasterApiKeyMutation,
+  // END OF EXPORTS
+} = roleMasterApiKeyService
+
+/* Usage examples:
+const { data, isLoading } = useGetRoleMasterApiKeyQuery({ id: 2 }, {}) //get hook
+const [createRoleMasterApiKey, { isLoading, data, isSuccess }] = useCreateRoleMasterApiKeyMutation() //create hook
+roleMasterApiKeyService.endpoints.getRoleMasterApiKey.select({id: 2})(store.getState()) //access data from any function
+*/

frontend/common/services/useRolesUser.ts

@@ -24,10 +24,7 @@ export const rolesUserService = service
         Res['rolesUsers'],
         Req['deleteRolesPermissionUsers']
       >({
-        invalidatesTags: [
-          { type: 'User-role' },
-          { type: 'RolesUser' },
-        ],
+        invalidatesTags: [{ type: 'User-role' }, { type: 'RolesUser' }],
         query: (query: Req['deleteRolesPermissionUsers']) => ({
           body: query,
           method: 'DELETE',

frontend/common/types/requests.ts

@@ -132,6 +132,17 @@ export type Req = {
   getGetSubscriptionMetadata: { id: string }
   getEnvironment: { id: string }
   getSubscriptionMetadata: { id: string }
+  getRoleMasterApiKey: { org_id: number; role_id: number; id: string }
+  updateRoleMasterApiKey: { org_id: number; role_id: number; id: string }
+  deleteRoleMasterApiKey: { org_id: number; role_id: number; id: string }
+  createRoleMasterApiKey: { org_id: number; role_id: number }
+  getMasterAPIKeyWithMasterAPIKeyRoles: { org_id: number; prefix: string }
+  deleteMasterAPIKeyWithMasterAPIKeyRoles: {
+    org_id: number
+    prefix: string
+    role_id: number
+  }
+  getRolesMasterAPIKeyWithMasterAPIKeyRoles: { org_id: number; prefix: string }
   createLaunchDarklyProjectImport: {
     project_id: string
     body: {

frontend/common/types/responses.ts

@@ -320,6 +320,7 @@ export type RolePermissionUser = {
   user: number
   role: number
   id: number
+  role_name: string
 }
 
 export type Res = {
@@ -393,6 +394,12 @@ export type Res = {
   environment: Environment
   launchDarklyProjectImport: LaunchDarklyProjectImport
   launchDarklyProjectsImport: LaunchDarklyProjectImport[]
+  roleMasterApiKey: { id: number; master_api_key: string; role: number }
+  masterAPIKeyWithMasterAPIKeyRoles: {
+    id: string
+    prefix: string
+    roles: RolePermissionUser[]
+  }
   userWithRoles: PagedResponse<Roles>
   groupWithRole: PagedResponse<Roles>
   changeRequests: PagedResponse<ChangeRequestSummary>