chore(j-s): Civil claimant spokesperson assigned notifications

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

@@ -668,49 +668,6 @@ export const formatCustodyRestrictions = (
   })
 }
 
-export const formatAdvocateAssignedEmailNotification = (
-  formatMessage: FormatMessage,
-  theCase: Case,
-  advocateType: AdvocateType,
-  overviewUrl?: string,
-): SubjectAndBody => {
-  const subject =
-    advocateType === AdvocateType.DEFENDER
-      ? formatMessage(
-          notifications.advocateAssignedEmail.subjectAccessToCaseFiles,
-          {
-            court: capitalize(theCase.court?.name ?? ''),
-          },
-        )
-      : formatMessage(notifications.advocateAssignedEmail.subjectAccess, {
-          courtCaseNumber: theCase.courtCaseNumber,
-        })
-
-  const body =
-    advocateType === AdvocateType.DEFENDER
-      ? formatMessage(
-          notifications.advocateAssignedEmail.bodyAccessToCaseFiles,
-          {
-            defenderHasAccessToRVG: Boolean(overviewUrl),
-            courtCaseNumber: capitalize(theCase.courtCaseNumber ?? ''),
-            court: theCase.court?.name ?? '',
-            courtName: theCase.court?.name.replace('dómur', 'dómi') ?? '',
-            linkStart: `<a href="${overviewUrl}">`,
-            linkEnd: '</a>',
-          },
-        )
-      : formatMessage(notifications.advocateAssignedEmail.bodyAccess, {
-          defenderHasAccessToRVG: Boolean(overviewUrl),
-          court: theCase.court?.name,
-          advocateType,
-          courtCaseNumber: capitalize(theCase.courtCaseNumber ?? ''),
-          linkStart: `<a href="${overviewUrl}">`,
-          linkEnd: '</a>',
-        })
-
-  return { body, subject }
-}
-
 export const formatCourtOfAppealJudgeAssignedEmailNotification = (
   formatMessage: FormatMessage,
   caseNumber: string,

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

@@ -21,7 +21,6 @@ export {
   formatProsecutorReceivedByCourtSmsNotification,
   formatDefenderCourtDateLinkEmailNotification,
   formatDefenderResubmittedToCourtEmailNotification,
-  formatAdvocateAssignedEmailNotification,
   formatCourtIndictmentReadyForCourtEmailNotification,
   formatDefenderRoute,
   formatDefenderReadyForCourtEmailNotification,

apps/judicial-system/backend/src/app/messages/notifications.ts

@@ -607,32 +607,6 @@ export const notifications = {
         'Notaður sem texti í tölvupósti til verjanda vegna breytingar á lengd gæslu/einangrunar/vistunar þar sem úrskurðað var í einangrun.',
     },
   }),
-  advocateAssignedEmail: defineMessages({
-    subjectAccessToCaseFiles: {
-      id: 'judicial.system.backend:notifications.defender_assigned_email.subject_access_to_case_files',
-      defaultMessage: '{court} - aðgangur að málsgögnum',
-      description:
-        'Fyrirsögn í pósti til verjanda þegar hann er skráður á mál.',
-    },
-    subjectAccess: {
-      id: 'judicial.system.backend:notifications.defender_assigned_email.subject_access',
-      defaultMessage: 'Skráning í máli {courtCaseNumber}',
-      description:
-        'Fyrirsögn í pósti til verjanda þegar hann er skráður á mál.',
-    },
-    bodyAccessToCaseFiles: {
-      id: 'judicial.system.backend:notifications.defender_assigned_email.body_access_to_case_files',
-      defaultMessage:
-        '{court} hefur skráð þig verjanda í máli {courtCaseNumber}.<br /><br />{defenderHasAccessToRVG, select, true {Gögn málsins eru aðgengileg á {linkStart}yfirlitssíðu málsins í Réttarvörslugátt{linkEnd}} other {Þú getur nálgast gögn málsins hjá {courtName} ef þau hafa ekki þegar verið afhent}}.',
-      description: 'Texti í pósti til verjanda þegar hann er skráður á mál.',
-    },
-    bodyAccess: {
-      id: 'judicial.system.backend:notifications.defender_assigned_email.body_access',
-      defaultMessage:
-        '{court} hefur skráð þig {advocateType, select, LAWYER {lögmann einkaréttarkröfuhafa} LEGAL_RIGHTS_PROTECTOR {réttargæslumann einkaréttarkröfuhafa} other {verjanda}} í máli {courtCaseNumber}.<br /><br />{defenderHasAccessToRVG, select, true {Sjá nánar á {linkStart}yfirlitssíðu málsins í Réttarvörslugátt{linkEnd}} other {Þú getur nálgast málið hjá {courtName}.}}.',
-      description: 'Texti í pósti til verjanda þegar hann er skráður á mál.',
-    },
-  }),
   defendantsNotUpdatedAtCourt: defineMessages({
     subject: {
       id: 'judicial.system.backend:notifications.defendants_not_updated_at_court.subject',

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

@@ -7,7 +7,11 @@ import type { Logger } from '@island.is/logging'
 import { LOGGER_PROVIDER } from '@island.is/logging'
 
 import { normalizeAndFormatNationalId } from '@island.is/judicial-system/formatters'
-import { CaseState } from '@island.is/judicial-system/types'
+import { MessageService, MessageType } from '@island.is/judicial-system/message'
+import {
+  CaseState,
+  CivilClaimantNotificationType,
+} from '@island.is/judicial-system/types'
 
 import { Case } from '../case/models/case.model'
 import { UpdateCivilClaimantDto } from './dto/updateCivilClaimant.dto'
@@ -18,6 +22,7 @@ export class CivilClaimantService {
   constructor(
     @InjectModel(CivilClaimant)
     private readonly civilClaimantModel: typeof CivilClaimant,
+    private readonly messageService: MessageService,
     @Inject(LOGGER_PROVIDER) private readonly logger: Logger,
   ) {}
 
@@ -27,6 +32,24 @@ export class CivilClaimantService {
     })
   }
 
+  private async sendUpdateCivilClaimantMessages(
+    update: UpdateCivilClaimantDto,
+    updatedCivilClaimant: CivilClaimant,
+  ): Promise<void> {
+    if (update.isSpokespersonConfirmed === true) {
+      await this.messageService.sendMessagesToQueue([
+        {
+          type: MessageType.CIVIL_CLAIMANT_NOTIFICATION,
+          caseId: updatedCivilClaimant.caseId,
+          body: {
+            type: CivilClaimantNotificationType.SPOKESPERSON_ASSIGNED,
+          },
+          elementId: updatedCivilClaimant.id,
+        },
+      ])
+    }
+  }
+
   async update(
     caseId: string,
     civilClaimantId: string,
@@ -49,6 +72,8 @@ export class CivilClaimantService {
       throw new Error(`Could not update civil claimant ${civilClaimantId}`)
     }
 
+    this.sendUpdateCivilClaimantMessages(update, civilClaimants[0])
+
     return civilClaimants[0]
   }
 

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

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

apps/judicial-system/backend/src/app/modules/defendant/guards/civilClaimantExists.guard.ts

@@ -0,0 +1,42 @@
+import {
+  BadRequestException,
+  CanActivate,
+  ExecutionContext,
+  Injectable,
+  NotFoundException,
+} from '@nestjs/common'
+
+import { Case } from '../../case'
+
+@Injectable()
+export class CivilClaimantExistsGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest()
+
+    const theCase: Case = request.case
+
+    if (!theCase) {
+      throw new BadRequestException('Missing case')
+    }
+
+    const civilClaimantId = request.params.civilClaimantId
+
+    if (!civilClaimantId) {
+      throw new BadRequestException('Missing civil id')
+    }
+
+    const civilClaimant = theCase.civilClaimants?.find(
+      (civilClaimants) => civilClaimants.id === civilClaimantId,
+    )
+
+    if (!civilClaimant) {
+      throw new NotFoundException(
+        `Civil claimant ${civilClaimantId} of case ${theCase.id} does not exist`,
+      )
+    }
+
+    request.civilClaimant = civilClaimant
+
+    return true
+  }
+}

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

@@ -1,6 +1,9 @@
 export { Defendant } from './models/defendant.model'
 export { DefendantService } from './defendant.service'
-export { CivilClaimant } from './models/civilClaimant.model'
 export { DefendantExistsGuard } from './guards/defendantExists.guard'
 export { CurrentDefendant } from './guards/defendant.decorator'
+
+export { CivilClaimant } from './models/civilClaimant.model'
 export { CivilClaimantService } from './civilClaimant.service'
+export { CivilClaimantExistsGuard } from './guards/civilClaimantExists.guard'
+export { CurrentCivilClaimant } from './guards/civilClaimaint.decorator'

apps/judicial-system/backend/src/app/modules/defendant/test/civilClaimantController/create.spec.ts

@@ -0,0 +1,80 @@
+import { uuid } from 'uuidv4'
+
+import { createTestingDefendantModule } from '../createTestingDefendantModule'
+
+import { Case } from '../../../case'
+import { CivilClaimant } from '../../models/civilClaimant.model'
+
+interface Then {
+  result: CivilClaimant
+  error: Error
+}
+
+type GivenWhenThen = (caseId?: string) => Promise<Then>
+
+describe('CivilClaimantController - Create', () => {
+  const caseId = uuid()
+  const civilClaimantId = uuid()
+  const theCase = { id: caseId } as Case
+  const civilClaimantToCreate = {
+    caseId,
+  }
+  const createdCivilClaimant = { id: civilClaimantId, caseId }
+
+  let mockCivilClaimantModel: typeof CivilClaimant
+  let givenWhenThen: GivenWhenThen
+
+  beforeEach(async () => {
+    const { civilClaimantModel, civilClaimantController } =
+      await createTestingDefendantModule()
+
+    mockCivilClaimantModel = civilClaimantModel
+
+    const mockCreate = mockCivilClaimantModel.create as jest.Mock
+    mockCreate.mockResolvedValue(createdCivilClaimant)
+
+    givenWhenThen = async () => {
+      const then = {} as Then
+
+      await civilClaimantController
+        .create(theCase.id, theCase)
+        .then((result) => (then.result = result))
+        .catch((error) => (then.error = error))
+
+      return then
+    }
+  })
+
+  describe('civil claimant creation', () => {
+    let then: Then
+
+    beforeEach(async () => {
+      then = await givenWhenThen(caseId)
+    })
+    it('should create a civil claimant', () => {
+      expect(mockCivilClaimantModel.create).toHaveBeenCalledWith(
+        civilClaimantToCreate,
+      )
+    })
+
+    it('should return the created civil claimant', () => {
+      expect(then.result).toEqual(createdCivilClaimant)
+    })
+  })
+
+  describe('civil claimant creation fails', () => {
+    let then: Then
+
+    beforeEach(async () => {
+      const mockCreate = mockCivilClaimantModel.create as jest.Mock
+      mockCreate.mockRejectedValue(new Error('Test error'))
+
+      then = await givenWhenThen(caseId)
+    })
+
+    it('should throw an error', () => {
+      expect(then.error).toBeInstanceOf(Error)
+      expect(then.error.message).toEqual('Test error')
+    })
+  })
+})

apps/judicial-system/backend/src/app/modules/defendant/test/civilClaimantController/createGuards.spec.ts

@@ -0,0 +1,25 @@
+import { CanActivate } from '@nestjs/common'
+
+import { CaseExistsGuard, CaseWriteGuard } from '../../../case'
+import { CivilClaimantController } from '../../civilClaimant.controller'
+
+describe('CivilClaimantController - Create guards', () => {
+  let guards: Array<new () => CanActivate>
+  const expectedGuards = [CaseExistsGuard, CaseWriteGuard]
+
+  beforeEach(() => {
+    guards = Reflect.getMetadata(
+      '__guards__',
+      CivilClaimantController.prototype.create,
+    )
+  })
+
+  it('should have the correct guards in the correct order', () => {
+    expect(guards).toHaveLength(expectedGuards.length)
+
+    expectedGuards.forEach((expectedGuard, index) => {
+      const guardInstance = new guards[index]()
+      expect(guardInstance).toBeInstanceOf(expectedGuard)
+    })
+  })
+})

apps/judicial-system/backend/src/app/modules/defendant/test/civilClaimantController/createRolesRules.spec.ts

@@ -0,0 +1,35 @@
+import {
+  districtCourtAssistantRule,
+  districtCourtJudgeRule,
+  districtCourtRegistrarRule,
+  prosecutorRepresentativeRule,
+  prosecutorRule,
+} from '../../../../guards'
+import { CivilClaimantController } from '../../civilClaimant.controller'
+
+describe('CivilClaimantController - Create rules', () => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  let rules: any[]
+
+  const expectedRules = [
+    prosecutorRule,
+    prosecutorRepresentativeRule,
+    districtCourtJudgeRule,
+    districtCourtRegistrarRule,
+    districtCourtAssistantRule,
+  ]
+
+  beforeEach(() => {
+    rules = Reflect.getMetadata(
+      'roles-rules',
+      CivilClaimantController.prototype.create,
+    )
+  })
+
+  it('should give permission to roles', () => {
+    expect(rules).toHaveLength(expectedRules.length)
+    expectedRules.forEach((expectedRule) =>
+      expect(rules).toContain(expectedRule),
+    )
+  })
+})