feat(j-s): Connect case files to defendant or civil claimants

apps/judicial-system/api/src/app/modules/backend/backend.service.ts

@@ -266,8 +266,19 @@ export class BackendService extends DataSource<{ req: Request }> {
     return this.post(`case/${id}/file/url`, createPresignedPost)
   }
 
-  createCaseFile(id: string, createFile: unknown): Promise<CaseFile> {
-    return this.post(`case/${id}/file`, createFile)
+  createCaseFile(
+    id: string,
+    createFile: unknown,
+    defendantId?: string,
+    civilClaimantId?: string,
+  ): Promise<CaseFile> {
+    const connectionInjection = defendantId
+      ? `/defendant/${defendantId}`
+      : civilClaimantId
+      ? `/civilClaimant/${civilClaimantId}`
+      : ''
+
+    return this.post(`case/${id}${connectionInjection}/file`, createFile)
   }
 
   getCaseFileSignedUrl(
@@ -435,8 +446,15 @@ export class BackendService extends DataSource<{ req: Request }> {
   limitedAccessCreateCaseFile(
     id: string,
     createFile: unknown,
+    civilClaimantId?: string,
   ): Promise<CaseFile> {
-    return this.post(`case/${id}/limitedAccess/file`, createFile)
+    const connectionInjection = civilClaimantId
+      ? `/civilClaimant/${civilClaimantId}`
+      : ''
+    return this.post(
+      `case/${id}/limitedAccess${connectionInjection}/file`,
+      createFile,
+    )
   }
 
   limitedAccessGetCaseFileSignedUrl(

apps/judicial-system/api/src/app/modules/file/dto/createFile.input.ts

@@ -70,4 +70,14 @@ export class CreateFileInput {
   @IsOptional()
   @Field(() => String, { nullable: true })
   readonly userGeneratedFilename?: string
+
+  @Allow()
+  @IsOptional()
+  @Field(() => ID, { nullable: true })
+  readonly defendantId?: string
+
+  @Allow()
+  @IsOptional()
+  @Field(() => ID, { nullable: true })
+  readonly civilClaimantId?: string
 }

apps/judicial-system/api/src/app/modules/file/file.resolver.ts

@@ -65,14 +65,19 @@ export class FileResolver {
     @Context('dataSources')
     { backendService }: { backendService: BackendService },
   ): Promise<CaseFile> {
-    const { caseId, ...createFile } = input
+    const { caseId, defendantId, civilClaimantId, ...createFile } = input
 
     this.logger.debug(`Creating a file for case ${caseId}`)
 
     return this.auditTrailService.audit(
       user.id,
       AuditedAction.CREATE_FILE,
-      backendService.createCaseFile(caseId, createFile),
+      backendService.createCaseFile(
+        caseId,
+        createFile,
+        defendantId,
+        civilClaimantId,
+      ),
       (file) => file.id,
     )
   }

apps/judicial-system/api/src/app/modules/file/limitedAccessFile.resolver.ts

@@ -64,14 +64,18 @@ export class LimitedAccessFileResolver {
     @Context('dataSources')
     { backendService }: { backendService: BackendService },
   ): Promise<CaseFile> {
-    const { caseId, ...createFile } = input
+    const { caseId, civilClaimantId, ...createFile } = input
 
     this.logger.debug(`Creating a file for case ${caseId}`)
 
     return this.auditTrailService.audit(
       user.id,
       AuditedAction.CREATE_FILE,
-      backendService.limitedAccessCreateCaseFile(caseId, createFile),
+      backendService.limitedAccessCreateCaseFile(
+        caseId,
+        createFile,
+        civilClaimantId,
+      ),
       (file) => file.id,
     )
   }

apps/judicial-system/backend/migrations/20241122091513-update-case-file.js

@@ -0,0 +1,44 @@
+'use strict'
+
+module.exports = {
+  up: (queryInterface, Sequelize) => {
+    return queryInterface.sequelize.transaction(async (t) => {
+      await queryInterface.addColumn(
+        'case_file',
+        'defendant_id',
+        {
+          type: Sequelize.UUID,
+          references: {
+            model: 'defendant',
+            key: 'id',
+          },
+          allowNull: true,
+        },
+        { transaction: t },
+      )
+      await queryInterface.addColumn(
+        'case_file',
+        'civil_claimant_id',
+        {
+          type: Sequelize.UUID,
+          references: {
+            model: 'civil_claimant',
+            key: 'id',
+          },
+          allowNull: true,
+        },
+        { transaction: t },
+      )
+    })
+  },
+  down: (queryInterface) => {
+    return queryInterface.sequelize.transaction(async (t) => {
+      await queryInterface.removeColumn('case_file', 'civil_claimant_id', {
+        transaction: t,
+      })
+      await queryInterface.removeColumn('case_file', 'defendant_id', {
+        transaction: t,
+      })
+    })
+  },
+}

apps/judicial-system/backend/src/app/modules/file/file.controller.ts

@@ -49,6 +49,14 @@ import {
   CurrentCase,
 } from '../case'
 import { MergedCaseExistsGuard } from '../case/guards/mergedCaseExists.guard'
+import {
+  CivilClaimant,
+  CivilClaimantExistsGuard,
+  CurrentCivilClaimant,
+  CurrentDefendant,
+  Defendant,
+  DefendantExistsGuard,
+} from '../defendant'
 import { CreateFileDto } from './dto/createFile.dto'
 import { CreatePresignedPostDto } from './dto/createPresignedPost.dto'
 import { UpdateFilesDto } from './dto/updateFile.dto'
@@ -126,6 +134,61 @@ export class FileController {
     return this.fileService.createCaseFile(theCase, createFile, user)
   }
 
+  @UseGuards(RolesGuard, CaseExistsGuard, DefendantExistsGuard, CaseWriteGuard)
+  @RolesRules(publicProsecutorStaffRule)
+  @Post('defendant/:defendantId/file')
+  @ApiCreatedResponse({
+    type: CaseFile,
+    description: 'Creates a new case file connected to a defendant',
+  })
+  async createDefendantCaseFile(
+    @Param('caseId') caseId: string,
+    @Param('defendantId') defendantId: string,
+    @CurrentHttpUser() user: User,
+    @CurrentCase() theCase: Case,
+    @CurrentDefendant() defendant: Defendant,
+    @Body() createFile: CreateFileDto,
+  ): Promise<CaseFile> {
+    this.logger.debug(
+      `Creating a file for case ${caseId} for defendant ${defendantId}`,
+    )
+
+    return this.fileService.createCaseFile(theCase, createFile, user, defendant)
+  }
+
+  @UseGuards(
+    RolesGuard,
+    CaseExistsGuard,
+    CivilClaimantExistsGuard,
+    CaseWriteGuard,
+  )
+  @RolesRules() // This endpoint is not used by any role at the moment
+  @Post('civilClaimant/:civilClaimantId/file')
+  @ApiCreatedResponse({
+    type: CaseFile,
+    description: 'Creates a new case file connected to a civil claimant',
+  })
+  async createCivilClaimantCaseFile(
+    @Param('caseId') caseId: string,
+    @Param('civilClaimantId') civilClaimantId: string,
+    @CurrentHttpUser() user: User,
+    @CurrentCase() theCase: Case,
+    @CurrentCivilClaimant() civilClaimant: CivilClaimant,
+    @Body() createFile: CreateFileDto,
+  ): Promise<CaseFile> {
+    this.logger.debug(
+      `Creating a file for case ${caseId} for civil claimant ${civilClaimantId}`,
+    )
+
+    return this.fileService.createCaseFile(
+      theCase,
+      createFile,
+      user,
+      undefined,
+      civilClaimant,
+    )
+  }
+
   @UseGuards(
     RolesGuard,
     CaseExistsGuard,

apps/judicial-system/backend/src/app/modules/file/file.service.ts

@@ -31,6 +31,7 @@ import { createConfirmedPdf } from '../../formatters'
 import { AwsS3Service } from '../aws-s3'
 import { Case } from '../case'
 import { CourtDocumentFolder, CourtService } from '../court'
+import { CivilClaimant, Defendant } from '../defendant'
 import { UserService } from '../user'
 import { CreateFileDto } from './dto/createFile.dto'
 import { CreatePresignedPostDto } from './dto/createPresignedPost.dto'
@@ -339,6 +340,8 @@ export class FileService {
     theCase: Case,
     createFile: CreateFileDto,
     user: User,
+    defendant?: Defendant,
+    civilClaimant?: CivilClaimant,
   ): Promise<CaseFile> {
     const { key } = createFile
 
@@ -360,6 +363,8 @@ export class FileService {
       userGeneratedFilename:
         createFile.userGeneratedFilename ?? fileName.replace(/\.pdf$/, ''),
       submittedBy: user.name,
+      defendantId: defendant?.id,
+      civilClaimantId: civilClaimant?.id,
     })
 
     if (

apps/judicial-system/backend/src/app/modules/file/guards/test/limitedAccessWriteCaseFileGuard.spec.ts

@@ -48,7 +48,7 @@ describe('LimitedAccess Write Case File Guard', () => {
   })
 
   describe.each(allowedCaseFileCategories)(
-    'a defender can view %s',
+    'a defender can write %s',
     (category) => {
       describe('when creating a case file', () => {
         let then: Then
@@ -93,7 +93,7 @@ describe('LimitedAccess Write Case File Guard', () => {
       (category) =>
         !allowedCaseFileCategories.includes(category as CaseFileCategory),
     ),
-  )('a defender can not view %s', (category) => {
+  )('a defender can not write %s', (category) => {
     describe('when creating a case file', () => {
       let then: Then
 
@@ -137,7 +137,7 @@ describe('LimitedAccess Write Case File Guard', () => {
     Object.keys(UserRole).filter((role) => role !== UserRole.DEFENDER),
   )('role %s', (role) => {
     describe.each(Object.keys(CaseFileCategory))(
-      'can not view %s',
+      'can not write %s',
       (category) => {
         describe('when creating a case file', () => {
           let then: Then
@@ -225,7 +225,7 @@ describe('LimitedAccess Write Case File Guard', () => {
     })
   })
 
-  describe('a defender can view DEFENDANT_CASE_FILE in indictment cases', () => {
+  describe('a defender can write DEFENDANT_CASE_FILE in indictment cases', () => {
     describe('when creating a case file', () => {
       let then: Then
 
@@ -265,7 +265,7 @@ describe('LimitedAccess Write Case File Guard', () => {
 
   describe.each(
     Object.keys(CaseType).filter((ct) => ct !== CaseType.INDICTMENT),
-  )('a defender can not view DEFENDANT_CASE_FILE in %s cases', (caseType) => {
+  )('a defender can not write DEFENDANT_CASE_FILE in %s cases', (caseType) => {
     describe('when creating a case file', () => {
       let then: Then
 

apps/judicial-system/backend/src/app/modules/file/limitedAccessFile.controller.ts

@@ -37,6 +37,11 @@ import {
   LimitedAccessCaseExistsGuard,
 } from '../case'
 import { MergedCaseExistsGuard } from '../case/guards/mergedCaseExists.guard'
+import {
+  CivilClaimant,
+  CivilClaimantExistsGuard,
+  CurrentCivilClaimant,
+} from '../defendant'
 import { CreateFileDto } from './dto/createFile.dto'
 import { CreatePresignedPostDto } from './dto/createPresignedPost.dto'
 import { CurrentCaseFile } from './guards/caseFile.decorator'
@@ -108,6 +113,39 @@ export class LimitedAccessFileController {
     return this.fileService.createCaseFile(theCase, createFile, user)
   }
 
+  @UseGuards(
+    new CaseTypeGuard([...indictmentCases]),
+    CivilClaimantExistsGuard,
+    CaseWriteGuard,
+    LimitedAccessWriteCaseFileGuard,
+  )
+  @RolesRules(defenderRule)
+  @Post('civilClaimant/:civilClaimantId/file')
+  @ApiCreatedResponse({
+    type: CaseFile,
+    description: 'Creates a new case file for a civil claimant',
+  })
+  createCivilClaimantCaseFile(
+    @Param('caseId') caseId: string,
+    @Param('civilClaimantId') civilClaimantId: string,
+    @CurrentHttpUser() user: User,
+    @CurrentCase() theCase: Case,
+    @CurrentCivilClaimant() civilClaimant: CivilClaimant,
+    @Body() createFile: CreateFileDto,
+  ): Promise<CaseFile> {
+    this.logger.debug(
+      `Creating a file for case ${caseId} and civil claimant ${civilClaimantId}`,
+    )
+
+    return this.fileService.createCaseFile(
+      theCase,
+      createFile,
+      user,
+      undefined,
+      civilClaimant,
+    )
+  }
+
   @UseGuards(
     CaseReadGuard,
     MergedCaseExistsGuard,

apps/judicial-system/backend/src/app/modules/file/models/file.model.ts

@@ -17,6 +17,7 @@ import {
 
 // TODO Find a way to import from an index file
 import { Case } from '../../case/models/case.model'
+import { CivilClaimant, Defendant } from '../../defendant'
 
 @Table({
   tableName: 'case_file',
@@ -45,6 +46,16 @@ export class CaseFile extends Model {
   @ApiProperty({ type: String })
   caseId!: string
 
+  @ForeignKey(() => Defendant)
+  @Column({ type: DataType.UUID, allowNull: true })
+  @ApiProperty({ type: String })
+  defendantId?: string
+
+  @ForeignKey(() => CivilClaimant)
+  @Column({ type: DataType.UUID, allowNull: true })
+  @ApiProperty({ type: String })
+  civilClaimantId?: string
+
   @Column({ type: DataType.STRING, allowNull: false })
   @ApiProperty({ type: String })
   name!: string