Implemented business logic for Component Permissions API

server/ee

@@ -1 +1 @@
-Subproject commit dd0462d3c3acf4b8e6856209eee52bc3cc78a02e
+Subproject commit 5865a18fe87e545b9b6a8f40f998117edc403c3f

server/src/modules/app-permissions/interfaces/IUtilService.ts

@@ -14,4 +14,8 @@ export interface IUtilService {
   createQueryPermission(queryId: string, body: CreatePermissionDto): Promise<any>;
 
   updateQueryPermission(queryId: string, body: CreatePermissionDto): Promise<any>;
+
+  createComponentPermission(componentId: string, body: CreatePermissionDto): Promise<any>;
+
+  updateComponentPermission(componentId: string, body: CreatePermissionDto): Promise<any>;
 }

server/src/modules/app-permissions/module.ts

@@ -9,10 +9,14 @@ import { PageUsersRepository } from './repositories/page-users.repository';
 import { PagePermissionsRepository } from './repositories/page-permissions.repository';
 import { QueryUsersRepository } from './repositories/query-users.repository';
 import { QueryPermissionsRepository } from './repositories/query-permissions.repository';
+import { ComponentUsersRepository } from './repositories/component-users.repository';
+import { ComponentPermissionsRepository } from './repositories/component-permissions.repository';
 import { PageUser } from '@entities/page_users.entity';
 import { PagePermission } from '@entities/page_permissions.entity';
 import { QueryUser } from '@entities/query_users.entity';
 import { QueryPermission } from '@entities/query_permissions.entity';
+import { ComponentUser } from '@entities/component_users.entity';
+import { ComponentPermission } from '@entities/component_permissions.entity';
 
 export class AppPermissionsModule {
   static async register(configs: { IS_GET_CONTEXT: boolean }): Promise<DynamicModule> {
@@ -24,7 +28,16 @@ export class AppPermissionsModule {
     return {
       module: AppPermissionsModule,
       imports: [
-        TypeOrmModule.forFeature([GroupPermissions, User, PageUser, PagePermission, QueryUser, QueryPermission]),
+        TypeOrmModule.forFeature([
+          GroupPermissions,
+          User,
+          PageUser,
+          PagePermission,
+          QueryUser,
+          QueryPermission,
+          ComponentUser,
+          ComponentPermission,
+        ]),
       ],
       controllers: [AppPermissionsController],
       providers: [
@@ -35,6 +48,8 @@ export class AppPermissionsModule {
         PagePermissionsRepository,
         QueryUsersRepository,
         QueryPermissionsRepository,
+        ComponentUsersRepository,
+        ComponentPermissionsRepository,
         FeatureAbilityFactory,
       ],
       exports: [AppPermissionsUtilService, AppPermissionsService],

server/src/modules/app-permissions/repositories/component-permissions.repository.ts

@@ -0,0 +1,58 @@
+import { ComponentPermission } from '@entities/component_permissions.entity';
+import { Injectable } from '@nestjs/common';
+import { DataSource, EntityManager, Repository } from 'typeorm';
+import { ComponentUsersRepository } from './component-users.repository';
+import { dbTransactionWrap } from '@helpers/database.helper';
+import { PAGE_PERMISSION_TYPE } from '../constants';
+
+@Injectable()
+export class ComponentPermissionsRepository extends Repository<ComponentPermission> {
+  constructor(private dataSource: DataSource, private readonly componentUsersRepository: ComponentUsersRepository) {
+    super(ComponentPermission, dataSource.createEntityManager());
+  }
+
+  async getComponentPermissions(componentId: string, manager?: EntityManager): Promise<ComponentPermission[]> {
+    return dbTransactionWrap(async (manager: EntityManager) => {
+      const componentPermissions = await manager.find(ComponentPermission, {
+        where: { componentId },
+        relations: ['users', 'users.user', 'users.permissionGroup'],
+      });
+
+      return componentPermissions.map((permission) => {
+        if (permission.type === PAGE_PERMISSION_TYPE.GROUP) {
+          return {
+            ...permission,
+            groups: permission.users,
+            users: undefined,
+          };
+        }
+        return permission;
+      });
+    }, manager || this.manager);
+  }
+
+  async createComponentPermissions(
+    componentId: string,
+    type: PAGE_PERMISSION_TYPE,
+    manager?: EntityManager
+  ): Promise<ComponentPermission> {
+    return dbTransactionWrap(async (manager: EntityManager) => {
+      const existingPermission = await manager.findOne(ComponentPermission, { where: { componentId } });
+      if (existingPermission) {
+        throw new Error(`Component permission already exists for Component id: ${componentId}`);
+      }
+
+      const componentPermission = manager.create(ComponentPermission, {
+        componentId,
+        type,
+      });
+      return manager.save(componentPermission);
+    }, manager || this.manager);
+  }
+
+  async deleteComponentPermissions(componentId: string, manager?: EntityManager): Promise<void> {
+    return dbTransactionWrap(async (manager: EntityManager) => {
+      await manager.delete(ComponentPermission, { componentId });
+    }, manager || this.manager);
+  }
+}

server/src/modules/app-permissions/repositories/component-users.repository.ts

@@ -0,0 +1,83 @@
+import { ComponentUser } from '@entities/component_users.entity';
+import { Injectable } from '@nestjs/common';
+import { DataSource, EntityManager, Repository } from 'typeorm';
+import { dbTransactionWrap } from '@helpers/database.helper';
+import { ComponentPermission } from '@entities/component_permissions.entity';
+
+@Injectable()
+export class ComponentUsersRepository extends Repository<ComponentUser> {
+  constructor(private dataSource: DataSource) {
+    super(ComponentUser, dataSource.createEntityManager());
+  }
+
+  async createComponentUsersWithSingle(
+    componentPermissionsId: string,
+    users: string[],
+    manager?: EntityManager
+  ): Promise<ComponentUser[]> {
+    return dbTransactionWrap(async (manager: EntityManager) => {
+      const componentUsers = users.map((userId) => {
+        return manager.create(ComponentUser, {
+          componentPermissionsId,
+          userId,
+          permissionGroupsId: null,
+        });
+      });
+      return manager.save(componentUsers);
+    }, manager || this.manager);
+  }
+
+  async createComponentUsersWithGroup(
+    componentPermissionsId: string,
+    groups: string[],
+    manager?: EntityManager
+  ): Promise<ComponentUser[]> {
+    return dbTransactionWrap(async (manager: EntityManager) => {
+      const componentUsers = groups.map((permissionGroupsId) => {
+        return manager.create(ComponentUser, {
+          componentPermissionsId,
+          permissionGroupsId,
+          userId: null,
+        });
+      });
+      return manager.save(componentUsers);
+    }, manager || this.manager);
+  }
+
+  async checkComponentUserWithGroup(
+    componentPermission: ComponentPermission,
+    userId: string,
+    manager?: EntityManager
+  ): Promise<boolean> {
+    return dbTransactionWrap(async (manager: EntityManager) => {
+      const result = await manager
+        .createQueryBuilder(ComponentUser, 'component_users')
+        .innerJoin('component_users.permissionGroup', 'group')
+        .innerJoin('group.groupUsers', 'groupUser')
+        .where('component_users.componentPermission = :permissionId', {
+          permissionId: componentPermission.id,
+        })
+        .andWhere('groupUser.userId = :userId', { userId })
+        .getOne();
+
+      return !!result;
+    }, manager || this.manager);
+  }
+
+  async checkComponentUserWithSingle(
+    componentPermission: ComponentPermission,
+    userId: string,
+    manager?: EntityManager
+  ): Promise<boolean> {
+    return dbTransactionWrap(async (manager: EntityManager) => {
+      const componentUser = await manager.findOne(ComponentUser, {
+        where: {
+          componentPermission: { id: componentPermission.id },
+          userId,
+        },
+      });
+
+      return !!componentUser;
+    }, manager || this.manager);
+  }
+}

server/src/modules/app-permissions/util.service.ts

@@ -31,4 +31,12 @@ export class AppPermissionsUtilService implements IUtilService {
   async updateQueryPermission(queryId: string, body: CreatePermissionDto): Promise<any> {
     throw new Error('Method not implemented.');
   }
+
+  async createComponentPermission(componentId: string, body: CreatePermissionDto): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
+
+  async updateComponentPermission(componentId: string, body: CreatePermissionDto): Promise<any> {
+    throw new Error('Method not implemented.');
+  }
 }