feat: return roles

src/modules/private-share-folder/dto/create-private-sharing.dto.ts

@@ -8,21 +8,21 @@ import { PrivateSharingFolderRole } from '../private-sharing-folder-roles.domain
 export class CreatePrivateSharingDto {
   @IsEmail()
   @IsNotEmpty()
-  @ApiProperty({ required: true })
+  @ApiProperty({ required: true, default: '' })
   email: User['email'];
 
   @IsUUID()
   @IsNotEmpty()
-  @ApiProperty({ required: true })
+  @ApiProperty({ required: true, default: '' })
   folderId: Folder['uuid'];
 
   @IsUUID()
   @IsNotEmpty()
-  @ApiProperty({ required: true })
+  @ApiProperty({ required: true, default: '' })
   roleId: PrivateSharingFolderRole['id'];
 
   @IsString()
   @IsNotEmpty()
-  @ApiProperty({ required: true })
+  @ApiProperty({ required: true, default: '' })
   encryptionKey: PrivateSharingFolder['encryptionKey'];
 }

src/modules/private-share-folder/private-sharing.controller.ts

@@ -27,15 +27,12 @@ import { Pagination } from 'src/lib/pagination';
 import { Response } from 'express';
 import { GrantPrivilegesDto } from './dto/grant-privileges.dto';
 import { CreatePrivateSharingDto } from './dto/create-private-sharing.dto';
-import { UserNotFoundError, UserUseCases } from '../user/user.usecase';
+import { PrivateSharingRole } from './private-sharing-role.domain';
 
 @ApiTags('Private Sharing')
 @Controller('private-sharing')
 export class PrivateSharingController {
-  constructor(
-    private readonly privateSharingUseCase: PrivateSharingUseCase,
-    private readonly userUseCase: UserUseCases,
-  ) {}
+  constructor(private readonly privateSharingUseCase: PrivateSharingUseCase) {}
 
   @Post('grant-privileges')
   @ApiOperation({
@@ -256,25 +253,17 @@ export class PrivateSharingController {
     @Body() CreatePrivateSharingDto: CreatePrivateSharingDto,
   ) {
     try {
-      const invitedUser = await this.userUseCase.getUserByUsername(
-        CreatePrivateSharingDto.email,
-      );
-
-      if (!invitedUser) {
-        new UserNotFoundError();
-      }
-
       const privateSharingFolder =
         await this.privateSharingUseCase.createPrivateSharingFolder(
           user,
           CreatePrivateSharingDto.folderId,
-          invitedUser.uuid,
+          CreatePrivateSharingDto.email,
           CreatePrivateSharingDto.encryptionKey,
         );
 
       await this.privateSharingUseCase.grantPrivileges(
         user,
-        invitedUser.uuid,
+        privateSharingFolder.userId,
         privateSharingFolder.id,
         CreatePrivateSharingDto.roleId,
       );
@@ -289,4 +278,27 @@ export class PrivateSharingController {
       throw error;
     }
   }
+
+  @Get('/roles')
+  @ApiOperation({
+    summary: 'Get all roles',
+  })
+  @ApiOkResponse({ description: 'Get all roles' })
+  @ApiBearerAuth()
+  async getAllRoles(): Promise<Record<'roles', PrivateSharingRole[]>> {
+    try {
+      return {
+        roles: await this.privateSharingUseCase.getAllRoles(),
+      };
+    } catch (error) {
+      const err = error as Error;
+      Logger.error(
+        `[PRIVATESHARING/GETALLROLES] Error while getting all roles, ${
+          err.stack || 'No stack trace'
+        }`,
+      );
+
+      throw error;
+    }
+  }
 }

src/modules/private-share-folder/private-sharing.module.ts

@@ -1,4 +1,4 @@
-import { Module, forwardRef } from '@nestjs/common';
+import { Module } from '@nestjs/common';
 import { PrivateSharingController } from './private-sharing.controller';
 import { PrivateSharingUseCase } from './private-sharing.usecase';
 import { SequelizePrivateSharingRepository } from './private-sharing.repository';
@@ -8,26 +8,22 @@ import { FolderModule } from '../folder/folder.module';
 import { FolderModel } from '../folder/folder.repository';
 import { PrivateSharingFolderRolesModel } from './private-sharing-folder-roles.model';
 import { SequelizeUserRepository, UserModel } from '../user/user.repository';
-import { UserModule } from '../user/user.module';
 import { PrivateSharingRoleModel } from './private-sharing-role.model';
-import { UserUseCases } from '../user/user.usecase';
 @Module({
   imports: [
     SequelizeModule.forFeature([
       PrivateSharingFolderModel,
       PrivateSharingFolderRolesModel,
       PrivateSharingRoleModel,
-      UserModel,
       FolderModel,
+      UserModel,
     ]),
-    forwardRef(() => FolderModule),
-    forwardRef(() => UserModule),
+    FolderModule,
   ],
   controllers: [PrivateSharingController],
   providers: [
-    PrivateSharingUseCase,
-    UserUseCases,
     SequelizePrivateSharingRepository,
+    PrivateSharingUseCase,
     SequelizeUserRepository,
   ],
   exports: [],

src/modules/private-share-folder/private-sharing.repository.ts

@@ -7,6 +7,7 @@ import { PrivateSharingFolder } from './private-sharing-folder.domain';
 import { User } from '../user/user.domain';
 import { PrivateSharingFolderRolesModel } from './private-sharing-folder-roles.model';
 import { PrivateSharingRole } from './private-sharing-role.domain';
+import { PrivateSharingRoleModel } from './private-sharing-role.model';
 
 export interface PrivateSharingRepository {
   findByOwner(
@@ -34,6 +35,8 @@ export class SequelizePrivateSharingRepository
     private folderModel: typeof FolderModel,
     @InjectModel(PrivateSharingFolderRolesModel)
     private privateSharingFolderRole: typeof PrivateSharingFolderRolesModel,
+    @InjectModel(PrivateSharingRoleModel)
+    private privateSharingRole: typeof PrivateSharingRoleModel,
   ) {}
 
   async findById(
@@ -127,4 +130,10 @@ export class SequelizePrivateSharingRepository
 
     return privateFolder.get({ plain: true });
   }
+
+  async getAllRoles(): Promise<PrivateSharingRole[]> {
+    const roles = await this.privateSharingRole.findAll();
+
+    return roles.map((role) => role.get({ plain: true }));
+  }
 }

src/modules/private-share-folder/private-sharing.usecase.ts

@@ -6,6 +6,7 @@ import { SequelizeUserRepository } from '../user/user.repository';
 import { SequelizeFolderRepository } from '../folder/folder.repository';
 import { PrivateSharingFolder } from './private-sharing-folder.domain';
 import { PrivateSharingRole } from './private-sharing-role.domain';
+import { UserNotFoundError } from '../user/user.usecase';
 
 export class InvalidOwnerError extends Error {
   constructor() {
@@ -18,7 +19,7 @@ export class InvalidOwnerError extends Error {
 export class PrivateSharingUseCase {
   constructor(
     private privateSharingRespository: SequelizePrivateSharingRepository,
-    private userRespository: SequelizeUserRepository,
+    private userRepository: SequelizeUserRepository,
     private folderRespository: SequelizeFolderRepository,
   ) {}
   async grantPrivileges(
@@ -76,11 +77,19 @@ export class PrivateSharingUseCase {
   async createPrivateSharingFolder(
     owner: User,
     folderId: Folder['uuid'],
-    sharedWithId: User['uuid'],
+    invatedUserEmail: User['email'],
     encryptionKey: PrivateSharingFolder['encryptionKey'],
   ) {
     const folder = await this.folderRespository.findByUuid(folderId);
 
+    const sharedWith = await this.userRepository.findByUsername(
+      invatedUserEmail,
+    );
+
+    if (!sharedWith) {
+      new UserNotFoundError();
+    }
+
     if (folder.userId !== owner.id) {
       throw new InvalidOwnerError();
     }
@@ -92,10 +101,16 @@ export class PrivateSharingUseCase {
       await this.privateSharingRespository.createPrivateFolder(
         folderId,
         owner.uuid,
-        sharedWithId,
+        sharedWith.uuid,
         encryptionKey,
       );
 
     return privateFolder;
   }
+
+  async getAllRoles(): Promise<PrivateSharingRole[]> {
+    const roles = await this.privateSharingRespository.getAllRoles();
+
+    return roles;
+  }
 }

src/modules/user/user.module.ts

@@ -56,6 +56,6 @@ import { SharedWorkspaceModule } from 'src/shared-workspace/shared-workspace.mod
     PaymentsService,
     NewsletterService,
   ],
-  exports: [UserUseCases],
+  exports: [UserUseCases, SequelizeUserRepository],
 })
 export class UserModule {}