Implemented business logic for Query Permissions API

server/ee

@@ -1 +1 @@
-Subproject commit f61295c5f85c354048f15275d4b3af52019d95b3
+Subproject commit c4ffed54bc928820c832c831aab5d2a42cfba154

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

@@ -10,4 +10,8 @@ export interface IUtilService {
   createPagePermission(pageId: string, body: CreatePermissionDto): Promise<any>;
 
   updatePagePermission(pageId: string, body: CreatePermissionDto): Promise<any>;
+
+  createQueryPermission(queryId: string, body: CreatePermissionDto): Promise<any>;
+
+  updateQueryPermission(queryId: string, body: CreatePermissionDto): Promise<any>;
 }

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

@@ -7,8 +7,12 @@ import { User } from '@entities/user.entity';
 import { RolesRepository } from '@modules/roles/repository';
 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 { 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';
 
 export class AppPermissionsModule {
   static async register(configs: { IS_GET_CONTEXT: boolean }): Promise<DynamicModule> {
@@ -19,7 +23,9 @@ export class AppPermissionsModule {
 
     return {
       module: AppPermissionsModule,
-      imports: [TypeOrmModule.forFeature([GroupPermissions, User, PageUser, PagePermission])],
+      imports: [
+        TypeOrmModule.forFeature([GroupPermissions, User, PageUser, PagePermission, QueryUser, QueryPermission]),
+      ],
       controllers: [AppPermissionsController],
       providers: [
         AppPermissionsService,
@@ -27,6 +33,8 @@ export class AppPermissionsModule {
         RolesRepository,
         PageUsersRepository,
         PagePermissionsRepository,
+        QueryUsersRepository,
+        QueryPermissionsRepository,
         FeatureAbilityFactory,
       ],
       exports: [AppPermissionsUtilService, AppPermissionsService],

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

@@ -0,0 +1,58 @@
+import { QueryPermission } from '@entities/query_permissions.entity';
+import { Injectable } from '@nestjs/common';
+import { DataSource, EntityManager, Repository } from 'typeorm';
+import { QueryUsersRepository } from './query-users.repository';
+import { dbTransactionWrap } from '@helpers/database.helper';
+import { PAGE_PERMISSION_TYPE } from '../constants';
+
+@Injectable()
+export class QueryPermissionsRepository extends Repository<QueryPermission> {
+  constructor(private dataSource: DataSource, private readonly queryUsersRepository: QueryUsersRepository) {
+    super(QueryPermission, dataSource.createEntityManager());
+  }
+
+  async getQueryPermissions(queryId: string, manager?: EntityManager): Promise<QueryPermission[]> {
+    return dbTransactionWrap(async (manager: EntityManager) => {
+      const queryPermissions = await manager.find(QueryPermission, {
+        where: { queryId },
+        relations: ['users', 'users.user', 'users.permissionGroup'],
+      });
+
+      return queryPermissions.map((permission) => {
+        if (permission.type === PAGE_PERMISSION_TYPE.GROUP) {
+          return {
+            ...permission,
+            groups: permission.users,
+            users: undefined,
+          };
+        }
+        return permission;
+      });
+    }, manager || this.manager);
+  }
+
+  async createQueryPermissions(
+    queryId: string,
+    type: PAGE_PERMISSION_TYPE,
+    manager?: EntityManager
+  ): Promise<QueryPermission> {
+    return dbTransactionWrap(async (manager: EntityManager) => {
+      const existingPermission = await manager.findOne(QueryPermission, { where: { queryId } });
+      if (existingPermission) {
+        throw new Error(`Query permission already exists for Query id: ${queryId}`);
+      }
+
+      const queryPermission = manager.create(QueryPermission, {
+        queryId,
+        type,
+      });
+      return manager.save(queryPermission);
+    }, manager || this.manager);
+  }
+
+  async deleteQueryPermissions(queryId: string, manager?: EntityManager): Promise<void> {
+    return dbTransactionWrap(async (manager: EntityManager) => {
+      await manager.delete(QueryPermission, { queryId });
+    }, manager || this.manager);
+  }
+}

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

@@ -0,0 +1,45 @@
+import { QueryUser } from '@entities/query_users.entity';
+import { Injectable } from '@nestjs/common';
+import { DataSource, EntityManager, Repository } from 'typeorm';
+import { dbTransactionWrap } from '@helpers/database.helper';
+
+@Injectable()
+export class QueryUsersRepository extends Repository<QueryUser> {
+  constructor(private dataSource: DataSource) {
+    super(QueryUser, dataSource.createEntityManager());
+  }
+
+  async createQueryUsersWithSingle(
+    queryPermissionsId: string,
+    users: string[],
+    manager?: EntityManager
+  ): Promise<QueryUser[]> {
+    return dbTransactionWrap(async (manager: EntityManager) => {
+      const queryUsers = users.map((userId) => {
+        return manager.create(QueryUser, {
+          queryPermissionsId,
+          userId,
+          permissionGroupsId: null,
+        });
+      });
+      return manager.save(queryUsers);
+    }, manager || this.manager);
+  }
+
+  async createQueryUsersWithGroup(
+    queryPermissionsId: string,
+    groups: string[],
+    manager?: EntityManager
+  ): Promise<QueryUser[]> {
+    return dbTransactionWrap(async (manager: EntityManager) => {
+      const queryUsers = groups.map((permissionGroupsId) => {
+        return manager.create(QueryUser, {
+          queryPermissionsId,
+          permissionGroupsId,
+          userId: null,
+        });
+      });
+      return manager.save(queryUsers);
+    }, manager || this.manager);
+  }
+}

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

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