chore(j-s): Send notifications when subpoena changes

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

@@ -0,0 +1,22 @@
+import { IsEnum, IsNotEmpty, IsOptional, IsUUID } from 'class-validator'
+
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger'
+
+import { NotificationType } from '@island.is/judicial-system/types'
+
+export class NotificationBodyDto {
+  @IsNotEmpty()
+  @IsEnum(NotificationType)
+  @ApiProperty({ enum: NotificationType })
+  readonly type!: NotificationType
+
+  @IsOptional()
+  @IsUUID()
+  @ApiPropertyOptional({ type: String })
+  readonly prosecutorsOfficeId?: string
+
+  @IsOptional()
+  @IsUUID()
+  @ApiPropertyOptional({ type: String })
+  readonly subpoenaId?: string
+}

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

@@ -46,8 +46,12 @@ export class InstitutionNotificationService extends BaseNotificationService {
   }
 
   private async sendIndictmentsWaitingForConfirmationNotification(
-    prosecutorsOfficeId: string,
+    prosecutorsOfficeId?: string,
   ): Promise<unknown> {
+    if (!prosecutorsOfficeId) {
+      return
+    }
+
     const count =
       await this.internalCaseService.countIndictmentsWaitingForConfirmation(
         prosecutorsOfficeId,
@@ -87,7 +91,7 @@ export class InstitutionNotificationService extends BaseNotificationService {
 
   async sendNotification(
     type: NotificationType,
-    prosecutorsOfficeId: string,
+    prosecutorsOfficeId?: string,
   ): Promise<DeliverResponse> {
     try {
       switch (type) {

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

@@ -19,12 +19,12 @@ import {
 
 import { Case, CaseHasExistedGuard, CurrentCase } from '../case'
 import { CaseNotificationDto } from './dto/caseNotification.dto'
-import { InstitutionNotificationDto } from './dto/institutionNotification.dto'
-import { NotificationDto } from './dto/notification.dto'
+import { NotificationBodyDto } from './dto/notificationBody.dto'
 import { DeliverResponse } from './models/deliver.response'
 import { InstitutionNotificationService } from './institutionNotification.service'
 import { InternalNotificationService } from './internalNotification.service'
 import { NotificationDispatchService } from './notificationDispatch.service'
+import { SubpoenaNotificationService } from './subpoenaNotification.service'
 
 @UseGuards(TokenGuard)
 @Controller('api/internal')
@@ -34,6 +34,7 @@ export class InternalNotificationController {
     private readonly internalNotificationService: InternalNotificationService,
     private readonly notificationDispatchService: NotificationDispatchService,
     private readonly institutionNotificationService: InstitutionNotificationService,
+    private readonly subpoenaNotificationService: SubpoenaNotificationService,
     @Inject(LOGGER_PROVIDER) private readonly logger: Logger,
   ) {}
 
@@ -65,14 +66,19 @@ export class InternalNotificationController {
     description: 'Sends a new notification',
   })
   sendNotification(
-    @Body() notificationDto: InstitutionNotificationDto,
+    @Body() notificationDto: NotificationBodyDto,
   ): Promise<DeliverResponse> {
     this.logger.debug(`Sending ${notificationDto.type} notification`)
 
-    return this.institutionNotificationService.sendNotification(
-      notificationDto.type,
-      notificationDto.prosecutorsOfficeId,
-    )
+    return notificationDto.prosecutorsOfficeId
+      ? this.institutionNotificationService.sendNotification(
+          notificationDto.type,
+          notificationDto.prosecutorsOfficeId,
+        )
+      : this.subpoenaNotificationService.sendNotification(
+          notificationDto.type,
+          notificationDto.subpoenaId,
+        )
   }
 
   @Post(messageEndpoint[MessageType.NOTIFICATION_DISPATCH])
@@ -81,7 +87,7 @@ export class InternalNotificationController {
     description: 'Dispatches notifications',
   })
   dispatchNotification(
-    @Body() notificationDto: NotificationDto,
+    @Body() notificationDto: NotificationBodyDto,
   ): Promise<DeliverResponse> {
     this.logger.debug(`Dispatching ${notificationDto.type} notification`)
 

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

@@ -13,6 +13,7 @@ import {
   DefendantModule,
   EventModule,
   InstitutionModule,
+  SubpoenaModule,
   UserModule,
 } from '../index'
 import { Notification } from './models/notification.model'
@@ -22,6 +23,7 @@ import { InternalNotificationService } from './internalNotification.service'
 import { NotificationController } from './notification.controller'
 import { NotificationService } from './notification.service'
 import { NotificationDispatchService } from './notificationDispatch.service'
+import { SubpoenaNotificationService } from './subpoenaNotification.service'
 
 @Module({
   imports: [
@@ -31,6 +33,7 @@ import { NotificationDispatchService } from './notificationDispatch.service'
     MessageModule,
     InstitutionModule,
     UserModule,
+    forwardRef(() => SubpoenaModule),
     forwardRef(() => CaseModule),
     forwardRef(() => CourtModule),
     forwardRef(() => EventModule),
@@ -43,6 +46,7 @@ import { NotificationDispatchService } from './notificationDispatch.service'
     InternalNotificationService,
     NotificationDispatchService,
     InstitutionNotificationService,
+    SubpoenaNotificationService,
   ],
 })
 export class NotificationModule {}

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

@@ -0,0 +1,222 @@
+import {
+  Inject,
+  Injectable,
+  InternalServerErrorException,
+} from '@nestjs/common'
+import { InjectModel } from '@nestjs/sequelize'
+
+import { IntlService } from '@island.is/cms-translations'
+import { EmailService } from '@island.is/email-service'
+import { type Logger, LOGGER_PROVIDER } from '@island.is/logging'
+import { type ConfigType } from '@island.is/nest/config'
+
+import { INDICTMENTS_COURT_OVERVIEW_ROUTE } from '@island.is/judicial-system/consts'
+import { NotificationType } from '@island.is/judicial-system/types'
+
+import { CaseService } from '../case'
+import { EventService } from '../event'
+import { SubpoenaService } from '../subpoena'
+import { DeliverResponse } from './models/deliver.response'
+import { Notification, Recipient } from './models/notification.model'
+import { BaseNotificationService } from './baseNotification.service'
+import { notificationModuleConfig } from './notification.config'
+import { strings } from './subpoenaNotification.strings'
+
+@Injectable()
+export class SubpoenaNotificationService extends BaseNotificationService {
+  constructor(
+    @InjectModel(Notification)
+    notificationModel: typeof Notification,
+    @Inject(notificationModuleConfig.KEY)
+    config: ConfigType<typeof notificationModuleConfig>,
+    @Inject(LOGGER_PROVIDER) logger: Logger,
+    intlService: IntlService,
+    emailService: EmailService,
+    eventService: EventService,
+    private readonly caseService: CaseService,
+    private readonly subpoenaService: SubpoenaService,
+  ) {
+    super(
+      notificationModel,
+      emailService,
+      intlService,
+      config,
+      eventService,
+      logger,
+    )
+  }
+
+  private async sendServiceSuccessfulNotification(
+    subpoenaId?: string,
+  ): Promise<unknown> {
+    if (!subpoenaId) {
+      return
+    }
+
+    const theCase = await this.getCase(subpoenaId)
+
+    await this.refreshFormatMessage()
+
+    const subject = this.formatMessage(strings.serviceSuccessfulSubject, {
+      courtCaseNumber: theCase.courtCaseNumber,
+    })
+
+    const body = this.formatMessage(strings.serviceSuccessfulBody, {
+      courtCaseNumber: theCase.courtCaseNumber,
+      linkStart: `<a href="${this.config.clientUrl}${INDICTMENTS_COURT_OVERVIEW_ROUTE}/${theCase.id}">`,
+      linkEnd: '</a>',
+    })
+
+    return this.sendEmails(
+      subject,
+      body,
+      theCase.judge?.name,
+      theCase.judge?.email,
+      theCase.registrar?.name,
+      theCase.registrar?.email,
+    )
+  }
+
+  private async sendServiceFailedNotification(
+    subpoenaId?: string,
+  ): Promise<unknown> {
+    if (!subpoenaId) {
+      return
+    }
+
+    const theCase = await this.getCase(subpoenaId)
+
+    await this.refreshFormatMessage()
+
+    const subject = this.formatMessage(strings.serviceFailedSubject, {
+      courtCaseNumber: theCase.courtCaseNumber,
+    })
+
+    const body = this.formatMessage(strings.serviceFailedBody, {
+      courtCaseNumber: theCase.courtCaseNumber,
+      linkStart: `<a href="${this.config.clientUrl}${INDICTMENTS_COURT_OVERVIEW_ROUTE}/${theCase.id}">`,
+      linkEnd: '</a>',
+    })
+
+    return this.sendEmails(
+      subject,
+      body,
+      theCase.judge?.name,
+      theCase.judge?.email,
+      theCase.registrar?.name,
+      theCase.registrar?.email,
+    )
+  }
+
+  private async sendDefendantSelectedDefenderNotification(
+    subpoenaId?: string,
+  ): Promise<unknown> {
+    if (!subpoenaId) {
+      return
+    }
+
+    const theCase = await this.getCase(subpoenaId)
+
+    await this.refreshFormatMessage()
+
+    const subject = this.formatMessage(
+      strings.defendantSelectedDefenderSubject,
+      {
+        courtCaseNumber: theCase.courtCaseNumber,
+      },
+    )
+
+    const body = this.formatMessage(strings.defendantSelectedDefenderBody, {
+      courtCaseNumber: theCase.courtCaseNumber,
+      linkStart: `<a href="${this.config.clientUrl}${INDICTMENTS_COURT_OVERVIEW_ROUTE}/${theCase.id}">`,
+      linkEnd: '</a>',
+    })
+
+    return this.sendEmails(
+      subject,
+      body,
+      theCase.judge?.name,
+      theCase.judge?.email,
+      theCase.registrar?.name,
+      theCase.registrar?.email,
+    )
+  }
+
+  private async getCase(subpoenaId: string) {
+    const subpoena = await this.subpoenaService.findBySubpoenaId(subpoenaId)
+    const theCase = await this.caseService.findById(subpoena.caseId)
+
+    if (!theCase.id) {
+      throw new InternalServerErrorException(`Case not found`)
+    }
+
+    if (!theCase.courtCaseNumber || !theCase.id) {
+      throw new InternalServerErrorException(
+        `Unable to find courtCaseNumber for case ${theCase.id}`,
+      )
+    }
+
+    return theCase
+  }
+
+  private sendEmails(
+    subject: string,
+    body: string,
+    judgeName?: string,
+    judgeEmail?: string,
+    registrarName?: string,
+    registrarEmail?: string,
+  ) {
+    const promises: Promise<Recipient>[] = []
+
+    if (judgeName && judgeEmail) {
+      promises.push(
+        this.sendEmail(subject, body, judgeName, judgeEmail, undefined, true),
+      )
+    }
+
+    if (registrarName && registrarEmail) {
+      promises.push(
+        this.sendEmail(
+          subject,
+          body,
+          registrarName,
+          registrarEmail,
+          undefined,
+          true,
+        ),
+      )
+    }
+
+    return Promise.all(promises)
+  }
+
+  async sendNotification(
+    type: NotificationType,
+    subpoenaId?: string,
+  ): Promise<DeliverResponse> {
+    try {
+      switch (type) {
+        case NotificationType.SERVICE_SUCCESSFUL:
+          await this.sendServiceSuccessfulNotification(subpoenaId)
+          break
+        case NotificationType.SERVICE_FAILED:
+          await this.sendServiceFailedNotification(subpoenaId)
+          break
+        case NotificationType.DEFENDANT_SELECTED_DEFENDER:
+          await this.sendDefendantSelectedDefenderNotification(subpoenaId)
+          break
+        default:
+          throw new InternalServerErrorException(
+            `Invalid notification type ${type}`,
+          )
+      }
+    } catch (error) {
+      this.logger.error('Failed to send notification', error)
+
+      return { delivered: false }
+    }
+
+    return { delivered: true }
+  }
+}