feat(j-s): Subpoena delivery and endpoint for updates

apps/judicial-system/backend/migrations/20240827132504-create-subpoena.js

@@ -0,0 +1,68 @@
+'use strict'
+
+module.exports = {
+  up: (queryInterface, Sequelize) => {
+    return queryInterface.sequelize.transaction((t) =>
+      queryInterface.createTable(
+        'subpoena',
+        {
+          id: {
+            type: Sequelize.UUID,
+            primaryKey: true,
+            allowNull: false,
+            defaultValue: Sequelize.UUIDV4,
+          },
+          created: {
+            type: 'TIMESTAMP WITH TIME ZONE',
+            defaultValue: Sequelize.literal('CURRENT_TIMESTAMP'),
+            allowNull: false,
+          },
+          modified: {
+            type: 'TIMESTAMP WITH TIME ZONE',
+            defaultValue: Sequelize.literal('CURRENT_TIMESTAMP'),
+            allowNull: false,
+          },
+          defendant_id: {
+            type: Sequelize.UUID,
+            references: {
+              model: 'defendant',
+              key: 'id',
+            },
+            allowNull: false,
+          },
+          case_id: {
+            type: Sequelize.UUID,
+            references: {
+              model: 'case',
+              key: 'id',
+            },
+            allowNull: true,
+          },
+          subpoena_id: {
+            type: Sequelize.STRING,
+            allowNull: true,
+          },
+          acknowledged: {
+            type: Sequelize.BOOLEAN,
+            allowNull: true,
+          },
+          acknowledged_date: {
+            type: 'TIMESTAMP WITH TIME ZONE',
+            allowNull: true,
+          },
+          comment: {
+            type: Sequelize.STRING,
+            allowNull: true,
+          },
+        },
+        { transaction: t },
+      ),
+    )
+  },
+
+  down: (queryInterface) => {
+    return queryInterface.sequelize.transaction((t) =>
+      queryInterface.dropTable('subpoena', { transaction: t }),
+    )
+  },
+}

apps/judicial-system/backend/src/app/app.module.ts

@@ -30,6 +30,7 @@ import {
   notificationModuleConfig,
   PoliceModule,
   policeModuleConfig,
+  SubpoenaModule,
   UserModule,
   userModuleConfig,
 } from './modules'
@@ -50,6 +51,7 @@ import { SequelizeConfigService } from './sequelizeConfig.service'
     NotificationModule,
     PoliceModule,
     EventLogModule,
+    SubpoenaModule,
     ProblemModule.forRoot({ logAllErrors: true }),
     ConfigModule.forRoot({
       isGlobal: true,

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

@@ -597,7 +597,7 @@ export class CaseService {
     ]
   }
 
-  private addMessagesForSubmittedIndicitmentCaseToQueue(
+  private addMessagesForSubmittedIndictmentCaseToQueue(
     theCase: Case,
     user: TUser,
   ): Promise<void> {
@@ -1181,7 +1181,7 @@ export class CaseService {
           await this.addMessagesForCompletedCaseToQueue(updatedCase, user)
         }
       } else if (updatedCase.state === CaseState.SUBMITTED && isIndictment) {
-        await this.addMessagesForSubmittedIndicitmentCaseToQueue(
+        await this.addMessagesForSubmittedIndictmentCaseToQueue(
           updatedCase,
           user,
         )

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

@@ -203,6 +203,22 @@ export class DefendantService {
   ): Promise<Defendant> {
     const formattedNationalId = formatNationalId(defendantNationalId)
 
+    const defendant = await this.defendantModel.findOne({
+      where: {
+        caseId,
+        [Op.or]: [
+          { nationalId: formattedNationalId },
+          { nationalId: defendantNationalId },
+        ],
+      },
+    })
+
+    if (!defendant) {
+      throw new InternalServerErrorException(
+        `Could not find defendant with national id ${defendantNationalId} for case ${caseId}`,
+      )
+    }
+
     const [numberOfAffectedRows, defendants] = await this.defendantModel.update(
       update,
       {

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

@@ -65,15 +65,15 @@ export class InternalDefendantController {
   @Patch('defense/:defendantNationalId')
   @ApiOkResponse({
     type: Defendant,
-    description: 'Assigns defense choice to defendant',
+    description: 'Updates defendant information by case and national id',
   })
-  async assignDefender(
+  async updateDefendant(
     @Param('caseId') caseId: string,
     @Param('defendantNationalId') defendantNationalId: string,
     @CurrentCase() theCase: Case,
     @Body() updatedDefendantChoice: UpdateDefendantDto,
   ): Promise<Defendant> {
-    this.logger.debug(`Assigning defense choice to defendant in case ${caseId}`)
+    this.logger.debug(`Updating defendant info for ${caseId}`)
 
     const updatedDefendant = await this.defendantService.updateByNationalId(
       theCase.id,

apps/judicial-system/backend/src/app/modules/index.ts

@@ -18,3 +18,4 @@ export { CourtModule } from './court/court.module'
 export { AwsS3Module } from './aws-s3/awsS3.module'
 export { EventModule } from './event/event.module'
 export { EventLogModule } from './event-log/eventLog.module'
+export { SubpoenaModule } from './subpoena/subpoena.module'

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

@@ -69,6 +69,14 @@ export class NotificationService {
           ]
         } else {
           messages = [this.getNotificationMessage(type, user, theCase)]
+          theCase.defendants?.forEach((defendant) => {
+            messages.push({
+              type: MessageType.DELIVERY_TO_POLICE_SUBPOENA,
+              user,
+              caseId: theCase.id,
+              elementId: defendant.id,
+            })
+          })
         }
         break
       case NotificationType.HEADS_UP:

apps/judicial-system/backend/src/app/modules/police/models/createSubpoena.response.ts

@@ -0,0 +1,6 @@
+import { ApiProperty } from '@nestjs/swagger'
+
+export class CreateSubpoenaResponse {
+  @ApiProperty({ type: String })
+  subpoenaId!: string
+}

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

@@ -26,8 +26,11 @@ import { CaseState, CaseType } from '@island.is/judicial-system/types'
 
 import { nowFactory } from '../../factories'
 import { AwsS3Service } from '../aws-s3'
+import { Case } from '../case'
+import { Defendant } from '../defendant/models/defendant.model'
 import { EventService } from '../event'
 import { UploadPoliceCaseFileDto } from './dto/uploadPoliceCaseFile.dto'
+import { CreateSubpoenaResponse } from './models/createSubpoena.response'
 import { PoliceCaseFile } from './models/policeCaseFile.model'
 import { PoliceCaseInfo } from './models/policeCaseInfo.model'
 import { UploadPoliceCaseFileResponse } from './models/uploadPoliceCaseFile.response'
@@ -505,4 +508,72 @@ export class PoliceService {
         return false
       })
   }
+
+  async createSubpoena(
+    workingCase: Case,
+    defendant: Defendant,
+    subpoena: string,
+    user: User,
+  ): Promise<CreateSubpoenaResponse> {
+    const { courtCaseNumber, dateLogs, prosecutor, policeCaseNumbers, court } =
+      workingCase
+    const { nationalId: defendantNationalId } = defendant
+    const { name: actor } = user
+
+    const documentName = `Fyrirkall í máli ${workingCase.courtCaseNumber}`
+    const arraignmentInfo = dateLogs?.find(
+      (dateLog) => dateLog.dateType === 'ARRAIGNMENT_DATE',
+    )
+    try {
+      const res = await this.fetchPoliceCaseApi(
+        `${this.xRoadPath}/CreateSubpoena`,
+        {
+          method: 'POST',
+          headers: {
+            accept: '*/*',
+            'Content-Type': 'application/json',
+            'X-Road-Client': this.config.clientId,
+            'X-API-KEY': this.config.policeApiKey,
+          },
+          agent: this.agent,
+          body: JSON.stringify({
+            documentName: documentName,
+            documentBase64: subpoena,
+            courtRegistrationDate: arraignmentInfo?.date,
+            prosecutorSsn: prosecutor?.nationalId,
+            prosecutedSsn: defendantNationalId,
+            courtAddress: court?.address,
+            courtRoomNumber: arraignmentInfo?.location || '',
+            courtCeremony: 'Þingfesting',
+            lokeCaseNumber: policeCaseNumbers?.[0],
+            courtCaseNumber: courtCaseNumber,
+            fileTypeCode: 'BRTNG',
+          }),
+        } as RequestInit,
+      )
+
+      if (!res.ok) {
+        throw await res.json()
+      }
+
+      const subpoenaId = await res.json()
+      return { subpoenaId }
+    } catch (error) {
+      this.logger.error(`Failed create subpoena for case ${workingCase.id}`, {
+        error,
+      })
+
+      this.eventService.postErrorEvent(
+        'Failed to create subpoena',
+        {
+          caseId: workingCase.id,
+          defendantId: defendant?.nationalId,
+          actor,
+        },
+        error,
+      )
+
+      throw error
+    }
+  }
 }

apps/judicial-system/backend/src/app/modules/subpoena/dto/deliver.dto.ts

@@ -0,0 +1,12 @@
+import { IsNotEmpty, IsObject } from 'class-validator'
+
+import { ApiProperty } from '@nestjs/swagger'
+
+import type { User } from '@island.is/judicial-system/types'
+
+export class DeliverDto {
+  @IsNotEmpty()
+  @IsObject()
+  @ApiProperty({ type: Object })
+  readonly user!: User
+}

apps/judicial-system/backend/src/app/modules/subpoena/dto/updateSubpoena.dto.ts

@@ -0,0 +1,42 @@
+import { IsBoolean, IsEnum, IsOptional, IsString } from 'class-validator'
+
+import { ApiPropertyOptional } from '@nestjs/swagger'
+
+import { DefenderChoice } from '@island.is/judicial-system/types'
+
+export class UpdateSubpoenaDto {
+  @IsOptional()
+  @IsBoolean()
+  @ApiPropertyOptional({ type: Boolean })
+  readonly acknowledged?: boolean
+
+  @IsOptional()
+  @IsString()
+  @ApiPropertyOptional({ type: String })
+  readonly comment?: string
+
+  @IsOptional()
+  @IsEnum(DefenderChoice)
+  @ApiPropertyOptional({ enum: DefenderChoice })
+  readonly defenderChoice?: DefenderChoice
+
+  @IsOptional()
+  @IsString()
+  @ApiPropertyOptional({ type: String })
+  readonly defenderNationalId?: string
+
+  @IsOptional()
+  @IsString()
+  @ApiPropertyOptional({ type: String })
+  readonly defenderName?: string
+
+  @IsOptional()
+  @IsString()
+  @ApiPropertyOptional({ type: String })
+  readonly defenderEmail?: string
+
+  @IsOptional()
+  @IsString()
+  @ApiPropertyOptional({ type: String })
+  readonly defenderPhoneNumber?: string
+}

apps/judicial-system/backend/src/app/modules/subpoena/guards/subpoena.decorator.ts

@@ -0,0 +1,7 @@
+import { createParamDecorator } from '@nestjs/common'
+
+import { Subpoena } from '../models/subpoena.model'
+
+export const CurrentSubpoena = createParamDecorator(
+  (data, { args: [_1, { req }] }): Subpoena => req.subpoena,
+)

apps/judicial-system/backend/src/app/modules/subpoena/guards/subpoenaExists.guard.ts

@@ -0,0 +1,27 @@
+import {
+  BadRequestException,
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+} from '@nestjs/common'
+
+import { SubpoenaService } from '../subpoena.service'
+
+@Injectable()
+export class SubpoenaExistsGuard implements CanActivate {
+  constructor(private readonly subpoenaService: SubpoenaService) {}
+
+  async canActivate(context: ExecutionContext): Promise<boolean> {
+    const request = context.switchToHttp().getRequest()
+
+    const subpoenaId = request.params.subpoenaId
+
+    if (!subpoenaId) {
+      throw new BadRequestException('Missing subpoena id')
+    }
+
+    request.subpoena = await this.subpoenaService.findBySubpoenaId(subpoenaId)
+
+    return true
+  }
+}