add findAll and findOne for admin only usage

apps/api/src/campaign-application/__mocks__/campaign-application-mocks.ts

@@ -1,5 +1,5 @@
 import { CampaignApplicationState, CampaignTypeCategory } from '@prisma/client'
 import { CreateCampaignApplicationDto } from '../dto/create-campaign-application.dto'
 
 export const mockNewCampaignApplication = {
   campaignName: 'Test Campaign',
@@ -18,6 +18,31 @@
   category: CampaignTypeCategory.medical,
 }
 
+export const mockSingleCampaignApplication = {
+  id: '1',
+  createdAt: new Date('2022-04-08T06:36:33.661Z'),
+  updatedAt: new Date('2022-04-08T06:36:33.662Z'),
+  description: 'Test description1',
+  organizerId: 'ffdbcc41-85ec-476c-9e59-0662f3b433af',
+  organizerName: 'Test Organizer1',
+  organizerEmail: 'organizer1@example.com',
+  beneficiary: 'test beneficary1',
+  organizerPhone: '123456789',
+  organizerBeneficiaryRel: 'Test Relation1',
+  campaignName: 'Test Campaign1',
+  goal: 'Test Goal1',
+  history: 'test history1',
+  amount: '1000',
+  campaignGuarantee: 'test campaignGuarantee1',
+  otherFinanceSources: 'test otherFinanceSources1',
+  otherNotes: 'test otherNotes1',
+  state: CampaignApplicationState.review,
+  category: CampaignTypeCategory.medical,
+  ticketURL: 'testsodifhso1',
+  archived: false,
+  documents: [{ id: 'fileId' }],
+}
+
 export const mockCampaigns = [
   {
     id: '1',
@@ -95,7 +120,7 @@
   category: CampaignTypeCategory.medical,
 }
 
 const mockUpdateCampaignApplicationResponceOrganizer = {
   amount: '1000',
   beneficiary: 'Test beneficary',
   campaignGuarantee: 'Test guarantee',

apps/api/src/campaign-application/campaign-application.controller.spec.ts

@@ -18,6 +18,7 @@
   let controller: CampaignApplicationController
   let service: CampaignApplicationService
   let personService: PersonService
+  const { isAdmin } = require('../auth/keycloak')
 
   const mockPerson = {
     ...personMock,
@@ -26,6 +27,10 @@
     organizer: { id: 'personOrganaizerId' },
   }
 
+  jest.mock('../auth/keycloak', () => ({
+    isAdmin: jest.fn(),
+  }))
+
   const mockCreateNewCampaignApplication = {
     ...mockNewCampaignApplication,
     acceptTermsAndConditions: true,
@@ -110,25 +115,31 @@
     // Act & Assert
     expect(() => controller.findAll(user)).toThrow(ForbiddenException)
   })
-  it('when findAll called by an admin user it should delegate to the service findAll', () => {
-    jest.mock('../auth/keycloak', () => ({
-      isAdmin: jest.fn().mockImplementation((user: KeycloakTokenParsed) => {
-        return user.resource_access?.account?.roles.includes('account-view-supporters')
-      }),
-    }))
 
-    // Act & Assert
-    expect(() => controller.findAll(mockUserAdmin)).not.toThrow(ForbiddenException)
-    controller.findAll(mockUserAdmin)
-    expect(service.findAll).toHaveBeenCalled()
+  it('when findOne is called by an organizer, it should delegate to the service findOne', async () => {
+    // Arrange
+    jest.spyOn(personService, 'findOneByKeycloakId').mockResolvedValue(mockUser)
+    isAdmin.mockReturnValue(false) // Non-admin user
+
+    // Act
+    await controller.findOne('id', mockUser)
+
+    // Assert
+    expect(personService.findOneByKeycloakId).toHaveBeenCalledWith(mockUser.sub)
+    expect(service.findOne).toHaveBeenCalledWith('id', false, mockUser)
   })
 
-  it('when findOne called it should delegate to the service findOne', () => {
+  it('when findOne is called by an admin user, it should delegate to the service with isAdmin true', async () => {
+    // Arrange
+    jest.spyOn(personService, 'findOneByKeycloakId').mockResolvedValue(mockUserAdmin)
+    isAdmin.mockReturnValue(true) // Admin user
+
     // Act
-    controller.findOne('id')
+    await controller.findOne('id', mockUserAdmin)
 
     // Assert
-    expect(service.findOne).toHaveBeenCalledWith('id')
+    expect(personService.findOneByKeycloakId).toHaveBeenCalledWith(mockUserAdmin.sub)
+    expect(service.findOne).toHaveBeenCalledWith('id', true, mockUserAdmin)
   })
 
   it('when update called by an user it should delegate to the service update', async () => {

apps/api/src/campaign-application/campaign-application.controller.ts

@@ -10,6 +10,7 @@ import {
   Logger,
   UploadedFiles,
   UseInterceptors,
+  Delete,
 } from '@nestjs/common'
 import { CampaignApplicationService } from './campaign-application.service'
 import { CreateCampaignApplicationDto } from './dto/create-campaign-application.dto'
@@ -76,8 +77,29 @@ export class CampaignApplicationController {
   }
 
   @Get('byId/:id')
-  findOne(@Param('id') id: string) {
-    return this.campaignApplicationService.findOne(id)
+  async findOne(@Param('id') id: string, @AuthenticatedUser() user: KeycloakTokenParsed) {
+    const person = await this.personService.findOneByKeycloakId(user.sub)
+    if (!person) {
+      Logger.error('No person found in database')
+      throw new NotFoundException('No person found in database')
+    }
+
+    const isAdminFlag = isAdmin(user)
+
+    return this.campaignApplicationService.findOne(id, isAdminFlag, person)
+  }
+
+  @Delete('fileById/:id')
+  async deleteFile(@Param('id') id: string, @AuthenticatedUser() user: KeycloakTokenParsed) {
+    const person = await this.personService.findOneByKeycloakId(user.sub)
+    if (!person) {
+      Logger.error('No person found in database')
+      throw new NotFoundException('No person found in database')
+    }
+
+    const isAdminFlag = isAdmin(user)
+
+    return this.campaignApplicationService.deleteFile(id, isAdminFlag, person)
   }
 
   @Patch(':id')

apps/api/src/campaign-application/campaign-application.service.spec.ts

@@ -10,6 +10,7 @@ import {
   mockCampaigns,
   mockCreatedCampaignApplication,
   mockNewCampaignApplication,
+  mockSingleCampaignApplication,
   mockUpdateCampaignApplication,
 } from './__mocks__/campaign-application-mocks'
 import { S3Service } from '../s3/s3.service'
@@ -38,6 +39,7 @@ describe('CampaignApplicationService', () => {
 
   const mockS3Service = {
     uploadObject: jest.fn(),
+    deleteObject: jest.fn(),
   }
 
   beforeEach(async () => {
@@ -202,6 +204,63 @@ describe('CampaignApplicationService', () => {
     })
   })
 
+  describe('findOne', () => {
+    it('should return a single campaign-application', async () => {
+      prismaMock.campaignApplication.findUnique.mockResolvedValue(mockSingleCampaignApplication)
+
+      const result = await service.findOne('id', false, mockPerson)
+
+      expect(result).toEqual(mockSingleCampaignApplication)
+      expect(prismaMock.campaignApplication.findUnique).toHaveBeenCalledTimes(1)
+    })
+
+    it('should throw a NotFoundException if no campaign-application is found', async () => {
+      prismaMock.campaignApplication.findUnique.mockResolvedValue(null)
+
+      await expect(service.findOne('id', false, mockPerson)).rejects.toThrow(
+        new NotFoundException('Campaign application doesnt exist'),
+      )
+      expect(prismaMock.campaignApplication.findUnique).toHaveBeenCalledTimes(1)
+    })
+
+    it('should handle errors and throw an exception', async () => {
+      const errorMessage = 'error'
+      prismaMock.campaignApplication.findUnique.mockRejectedValue(new Error(errorMessage))
+
+      await expect(service.findOne('id', false, mockPerson)).rejects.toThrow(errorMessage)
+      expect(prismaMock.campaignApplication.findUnique).toHaveBeenCalledTimes(1)
+    })
+  })
+
+  describe('deleteFile', () => {
+    it('should return a message on successful deletion', async () => {
+      prismaMock.campaignApplication.findFirst.mockResolvedValue(mockSingleCampaignApplication)
+
+      const result = await service.deleteFile('fileId', false, mockPerson)
+
+      expect(result).toEqual('Successfully deleted file')
+      expect(prismaMock.campaignApplication.findFirst).toHaveBeenCalledTimes(1)
+    })
+
+    it('should throw a NotFoundException if no campaign-application is found', async () => {
+      prismaMock.campaignApplication.findUnique.mockResolvedValue(null)
+
+      await expect(service.deleteFile('fileId', false, mockPerson)).rejects.toThrow(
+        new NotFoundException('File does not exist'),
+      )
+      expect(prismaMock.campaignApplication.findFirst).toHaveBeenCalledTimes(1)
+    })
+
+    it('should handle errors and throw an exception', async () => {
+      const errorMessage = 'error'
+      prismaMock.campaignApplication.findFirst.mockRejectedValue(new Error(errorMessage))
+
+      await expect(service.deleteFile('fileId', false, mockPerson)).rejects.toThrow(errorMessage)
+      expect(prismaMock.campaignApplication.findFirst).toHaveBeenCalledTimes(1)
+      expect(prismaMock.campaignApplicationFile.delete).not.toHaveBeenCalled()
+    })
+  })
+
   describe('updateCampaignApplication', () => {
     it('should update a campaign application if the user is the organizer', async () => {
       const mockCampaignApplication = {

apps/api/src/campaign-application/campaign-application.service.ts

@@ -86,12 +86,66 @@ export class CampaignApplicationService {
     }
   }
 
-  findAll() {
-    return this.prisma.campaignApplication.findMany()
+  async findAll() {
+    try {
+      const campaignApplications = await this.prisma.campaignApplication.findMany()
+      return campaignApplications
+    } catch (error) {
+      Logger.error('Error in findAll():', error)
+      throw error
+    }
+  }
+
+  async findOne(id: string, isAdminFlag: boolean, person: Person) {
+    try {
+      const singleCampaignApplication = await this.prisma.campaignApplication.findUnique({
+        where: { id },
+      })
+      if (!singleCampaignApplication) {
+        throw new NotFoundException('Campaign application doesnt exist')
+      }
+
+      if (isAdminFlag === false && singleCampaignApplication.organizerId !== person.organizer.id) {
+        throw new ForbiddenException('User is not admin or organizer of the campaignApplication')
+      }
+
+      return singleCampaignApplication
+    } catch (error) {
+      Logger.error('Error in findOne():', error)
+      throw error
+    }
   }
 
-  findOne(id: string) {
-    return `This action returns a #${id} campaignApplication`
+  async deleteFile(id: string, isAdminFlag: boolean, person: Person) {
+    try {
+      const campaignApplication = await this.prisma.campaignApplication.findFirst({
+        where: {
+          documents: {
+            some: {
+              id: id,
+            },
+          },
+        },
+      })
+
+      if (!campaignApplication) {
+        throw new NotFoundException('File does not exist')
+      }
+
+      if (isAdminFlag === false && campaignApplication.organizerId !== person.organizer.id) {
+        throw new ForbiddenException('User is not admin or organizer of the campaignApplication')
+      }
+
+      await this.prisma.campaignApplicationFile.delete({
+        where: { id },
+      })
+
+      await this.s3.deleteObject(this.bucketName, id)
+    } catch (error) {
+      Logger.error('Error in deleteFile():', error)
+      throw error
+    }
+    return 'Successfully deleted file'
   }
 
   async updateCampaignApplication(
@@ -182,20 +236,25 @@ export class CampaignApplicationService {
       role: CampaignApplicationFileRole.document,
     }
 
-    const createFileInDb = await this.prisma.campaignApplicationFile.create({
-      data: fileDto,
-    })
+    try {
+      const createFileInDb = await this.prisma.campaignApplicationFile.create({
+        data: fileDto,
+      })
 
-    await this.s3.uploadObject(
-      this.bucketName,
-      createFileInDb.id,
-      file.originalname,
-      file.mimetype,
-      file.buffer,
-      'CampaignApplicationFile',
-      campaignApplicationId,
-      personId,
-    )
-    return createFileInDb
+      await this.s3.uploadObject(
+        this.bucketName,
+        createFileInDb.id,
+        file.originalname,
+        file.mimetype,
+        file.buffer,
+        'CampaignApplicationFile',
+        campaignApplicationId,
+        personId,
+      )
+      return createFileInDb
+    } catch (error) {
+      Logger.error('Error in campaignApplicationFilesCreate():', error)
+      throw error
+    }
   }
 }