Merge branch 'main' of github.com:island-is/island.is into j-s/revoke-send-to-prison-admin-modal

Author: oddsson

apps/application-system/api/src/app/modules/application/lifecycle/application-lifecycle.service.ts

@@ -151,39 +151,52 @@ export class ApplicationLifeCycleService {
   private async preparePrunedNotification(
     application: PruningApplication,
   ): Promise<CreateHnippNotificationDto | null> {
-    const template = await getApplicationTemplateByTypeId(application.typeId)
-    const stateConfig = template.stateMachineConfig.states[application.state]
-    const lifeCycle = stateConfig.meta?.lifecycle
-    if (lifeCycle && lifeCycle.shouldBePruned && lifeCycle.pruneMessage) {
-      try {
-        const pruneMessage =
-          typeof lifeCycle.pruneMessage === 'function'
-            ? lifeCycle.pruneMessage(application as ApplicationWithAttachments)
-            : lifeCycle.pruneMessage
-        const notification = {
-          recipient: application.applicant,
-          templateId: pruneMessage.notificationTemplateId,
-          args: [
-            {
-              key: 'externalBody',
-              value: pruneMessage.externalBody || '',
-            },
-            {
-              key: 'internalBody',
-              value: pruneMessage.internalBody || '',
-            },
-          ],
-        }
-        return notification
-      } catch (error) {
-        this.logger.error(
-          `Failed to prepare pruning notification for application ${application.id}`,
-          error,
-        )
+    try {
+      const template = await getApplicationTemplateByTypeId(application.typeId)
+      if (!template) {
         return null
       }
+      const stateConfig = template.stateMachineConfig.states[application.state]
+      const lifeCycle = stateConfig.meta?.lifecycle
+      if (lifeCycle && lifeCycle.shouldBePruned && lifeCycle.pruneMessage) {
+        try {
+          const pruneMessage =
+            typeof lifeCycle.pruneMessage === 'function'
+              ? lifeCycle.pruneMessage(
+                  application as ApplicationWithAttachments,
+                )
+              : lifeCycle.pruneMessage
+          const notification = {
+            recipient: application.applicant,
+            templateId: pruneMessage.notificationTemplateId,
+            args: [
+              {
+                key: 'externalBody',
+                value: pruneMessage.externalBody || '',
+              },
+              {
+                key: 'internalBody',
+                value: pruneMessage.internalBody || '',
+              },
+            ],
+          }
+          return notification
+        } catch (error) {
+          this.logger.error(
+            `Failed to prepare pruning notification for application ${application.id}`,
+            error,
+          )
+          return null
+        }
+      }
+      return null
+    } catch (error) {
+      this.logger.error(
+        `Failed to get application template for application typeId ${application.typeId}`,
+        error,
+      )
+      return null
     }
-    return null
   }
 
   private async sendPrunedNotification(

apps/judicial-system/api/infra/judicial-system-api.ts

@@ -47,8 +47,8 @@ export const serviceSetup = (services: {
       },
       HIDDEN_FEATURES: {
         dev: '',
-        staging: '',
-        prod: '',
+        staging: 'MULTIPLE_INDICTMENT_SUBTYPES',
+        prod: 'MULTIPLE_INDICTMENT_SUBTYPES',
       },
     })
     .secrets({

apps/judicial-system/api/src/app/modules/indictment-count/dto/updateIndictmentCount.input.ts

@@ -4,7 +4,10 @@ import { GraphQLJSONObject } from 'graphql-type-json'
 import { Field, ID, InputType } from '@nestjs/graphql'
 
 import type { SubstanceMap } from '@island.is/judicial-system/types'
-import { IndictmentCountOffense } from '@island.is/judicial-system/types'
+import {
+  IndictmentCountOffense,
+  IndictmentSubtype,
+} from '@island.is/judicial-system/types'
 
 @InputType()
 export class UpdateIndictmentCountInput {
@@ -53,4 +56,11 @@ export class UpdateIndictmentCountInput {
   @IsOptional()
   @Field(() => String, { nullable: true })
   readonly legalArguments?: string
+
+  @Allow()
+  @IsOptional()
+  @IsArray()
+  @IsEnum(IndictmentSubtype, { each: true })
+  @Field(() => [IndictmentSubtype], { nullable: true })
+  readonly indictmentCountSubtypes?: IndictmentSubtype[]
 }

apps/judicial-system/api/src/app/modules/indictment-count/models/indictmentCount.model.ts

@@ -3,9 +3,13 @@ import { GraphQLJSONObject } from 'graphql-type-json'
 import { Field, ID, ObjectType, registerEnumType } from '@nestjs/graphql'
 
 import type { SubstanceMap } from '@island.is/judicial-system/types'
-import { IndictmentCountOffense } from '@island.is/judicial-system/types'
+import {
+  IndictmentCountOffense,
+  IndictmentSubtype,
+} from '@island.is/judicial-system/types'
 
 registerEnumType(IndictmentCountOffense, { name: 'IndictmentCountOffense' })
+registerEnumType(IndictmentSubtype, { name: 'IndictmentSubtype' })
 
 @ObjectType()
 export class IndictmentCount {
@@ -41,4 +45,7 @@ export class IndictmentCount {
 
   @Field(() => String, { nullable: true })
   readonly legalArguments?: string
+
+  @Field(() => [IndictmentSubtype], { nullable: true })
+  readonly indictmentCountSubtypes?: IndictmentSubtype[]
 }

apps/judicial-system/backend/migrations/20241204124025-update-indictment-count.js

@@ -0,0 +1,25 @@
+'use strict'
+
+module.exports = {
+  async up(queryInterface, Sequelize) {
+    await queryInterface.sequelize.transaction((transaction) =>
+      queryInterface.addColumn(
+        'indictment_count',
+        'indictment_count_subtypes',
+        {
+          type: Sequelize.ARRAY(Sequelize.STRING),
+          allowNull: true,
+          defaultValue: [],
+        },
+        { transaction },
+      ),
+    )
+  },
+
+  async down(queryInterface) {
+    await queryInterface.removeColumn(
+      'indictment_count',
+      'indictment_count_subtypes',
+    )
+  },
+}

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

@@ -70,6 +70,7 @@ import { CurrentCase } from './guards/case.decorator'
 import { CaseCompletedGuard } from './guards/caseCompleted.guard'
 import { CaseExistsGuard } from './guards/caseExists.guard'
 import { CaseReadGuard } from './guards/caseRead.guard'
+import { CaseTransitionGuard } from './guards/caseTransition.guard'
 import { CaseTypeGuard } from './guards/caseType.guard'
 import { CaseWriteGuard } from './guards/caseWrite.guard'
 import { MergedCaseExistsGuard } from './guards/mergedCaseExists.guard'
@@ -273,7 +274,13 @@ export class CaseController {
     return this.caseService.update(theCase, update, user) as Promise<Case> // Never returns undefined
   }
 
-  @UseGuards(JwtAuthGuard, CaseExistsGuard, RolesGuard, CaseWriteGuard)
+  @UseGuards(
+    JwtAuthGuard,
+    CaseExistsGuard,
+    RolesGuard,
+    CaseWriteGuard,
+    CaseTransitionGuard,
+  )
   @RolesRules(
     prosecutorTransitionRule,
     prosecutorRepresentativeTransitionRule,

apps/judicial-system/backend/src/app/modules/case/guards/caseTransition.guard.ts

@@ -0,0 +1,37 @@
+import {
+  CanActivate,
+  ExecutionContext,
+  ForbiddenException,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common'
+
+import { User } from '@island.is/judicial-system/types'
+
+import { getTransitionRule } from './caseTransitionRules'
+
+@Injectable()
+// Used for more complex cases than just whether a role can perform a
+// transition overall, which is handled in the transition roles rules
+export class CaseTransitionGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest()
+
+    const { transition } = request.body
+    const theCase = request.case
+    const user: User = request.user
+
+    // This shouldn't happen
+    if (!theCase || !user) {
+      throw new InternalServerErrorException('Missing case or user')
+    }
+
+    const transitionRule = getTransitionRule(transition)
+
+    if (!transitionRule(theCase, user)) {
+      throw new ForbiddenException('Forbidden transition')
+    }
+
+    return true
+  }
+}

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

@@ -0,0 +1,41 @@
+import { ForbiddenException } from '@nestjs/common'
+
+import {
+  CaseIndictmentRulingDecision,
+  CaseTransition,
+  CaseType,
+  User,
+} from '@island.is/judicial-system/types'
+
+import { Case } from '..'
+
+type TransitionRule = (theCase: Case, user: User) => boolean
+
+const defaultTransitionRule: TransitionRule = () => true
+
+const completeTransitionRule: TransitionRule = (theCase, user) => {
+  if (theCase.type !== CaseType.INDICTMENT) {
+    throw new ForbiddenException(
+      `Forbidden transition for ${theCase.type} cases`,
+    )
+  }
+
+  if (
+    theCase.indictmentRulingDecision === CaseIndictmentRulingDecision.RULING ||
+    theCase.indictmentRulingDecision === CaseIndictmentRulingDecision.DISMISSAL
+  ) {
+    return user.id === theCase.judgeId
+  }
+
+  return true
+}
+
+const transitionRuleMap: Partial<Record<CaseTransition, TransitionRule>> = {
+  [CaseTransition.COMPLETE]: completeTransitionRule,
+}
+
+export const getTransitionRule = (
+  transition: CaseTransition,
+): TransitionRule => {
+  return transitionRuleMap[transition] || defaultTransitionRule
+}

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

@@ -211,7 +211,7 @@ export const prosecutorTransitionRule: RolesRule = {
     const dto: TransitionCaseDto = request.body
     const theCase: Case = request.case
 
-    // Deny if something is missing - shuould never happen
+    // Deny if something is missing - should never happen
     if (!user || !dto || !theCase) {
       return false
     }
@@ -258,7 +258,7 @@ export const defenderTransitionRule: RolesRule = {
     const dto: TransitionCaseDto = request.body
     const theCase: Case = request.case
 
-    // Deny if something is missing - shuould never happen
+    // Deny if something is missing - should never happen
     if (!dto || !theCase) {
       return false
     }
@@ -393,7 +393,7 @@ export const districtCourtJudgeSignRulingRule: RolesRule = {
     const user: User = request.user
     const theCase: Case = request.case
 
-    // Deny if something is missing - shuould never happen
+    // Deny if something is missing - should never happen
     if (!user || !theCase) {
       return false
     }

apps/judicial-system/backend/src/app/modules/case/guards/test/caseTransitionGuard.spec.ts

@@ -0,0 +1,98 @@
+import {
+  ExecutionContext,
+  ForbiddenException,
+  InternalServerErrorException,
+} from '@nestjs/common'
+
+import {
+  CaseIndictmentRulingDecision,
+  CaseTransition,
+  CaseType,
+} from '@island.is/judicial-system/types'
+
+import { CaseTransitionGuard } from '../caseTransition.guard'
+
+describe('CaseTransitionGuard', () => {
+  let guard: CaseTransitionGuard
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  let mockRequest: jest.Mock
+
+  beforeEach(() => {
+    guard = new CaseTransitionGuard()
+    mockRequest = jest.fn()
+  })
+
+  const mockExecutionContext = (requestMock: unknown): ExecutionContext =>
+    ({
+      switchToHttp: () => ({
+        getRequest: () => requestMock,
+      }),
+    } as unknown as ExecutionContext)
+
+  const createMockCase = (
+    type: CaseType,
+    rulingDecision: unknown,
+    judgeId: string,
+  ) => ({
+    type,
+    indictmentRulingDecision: rulingDecision,
+    judgeId,
+  })
+
+  it('should activate when the judge is the assigned judge', () => {
+    const mockCase = createMockCase(
+      CaseType.INDICTMENT,
+      CaseIndictmentRulingDecision.RULING,
+      'judgeId',
+    )
+    const context = mockExecutionContext({
+      body: { transition: CaseTransition.COMPLETE },
+      case: mockCase,
+      user: { id: 'judgeId' },
+    })
+
+    const result = guard.canActivate(context)
+
+    expect(result).toBe(true)
+  })
+
+  it('should not activate when the user is not the assigned judge', () => {
+    const mockCase = createMockCase(
+      CaseType.INDICTMENT,
+      CaseIndictmentRulingDecision.RULING,
+      'judgeId',
+    )
+    const context = mockExecutionContext({
+      body: { transition: CaseTransition.COMPLETE },
+      case: mockCase,
+      user: { id: 'differentJudgeId' },
+    })
+
+    expect(() => guard.canActivate(context)).toThrow(ForbiddenException)
+  })
+
+  it('should activate using the default rule for transitions not in the rule map', () => {
+    const mockCase = createMockCase(CaseType.CUSTODY, null, 'someId')
+    const context = mockExecutionContext({
+      body: { transition: CaseTransition.SUBMIT },
+      case: mockCase,
+      user: { id: 'someId' },
+    })
+
+    const result = guard.canActivate(context)
+
+    expect(result).toBe(true)
+  })
+
+  it('should throw InternalServerErrorException when case or user is missing', () => {
+    const context = mockExecutionContext({
+      body: { transition: CaseTransition.COMPLETE },
+      case: null,
+      user: null,
+    })
+
+    expect(() => guard.canActivate(context)).toThrow(
+      InternalServerErrorException,
+    )
+  })
+})