[APB-11045][APB-APB-11015] Success and FailedNonFixable emails

app/uk/gov/hmrc/agentregistrationrisking/config/AppConfig.scala

@@ -42,6 +42,7 @@ class AppConfig @Inject() (
   def getConfString(key: String): String = servicesConfig.getConfString(key, throw new RuntimeException(s"config '$key' not found"))
 
   val appName: String = config.get[String]("appName")
+  val emailBaseUrl: String = servicesConfig.baseUrl("email")
   val enrolmentStoreProxyBaseUrl: String = servicesConfig.baseUrl("enrolment-store-proxy")
   val hmrcAsAgentEnrolment: Enrolment = Enrolment(key = "HMRC-AS-AGENT")
   val hipBaseUrl: String = servicesConfig.baseUrl("hip")

app/uk/gov/hmrc/agentregistrationrisking/connectors/EmailConnector.scala

@@ -0,0 +1,56 @@
+/*
+ * Copyright 2026 HM Revenue & Customs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package uk.gov.hmrc.agentregistrationrisking.connectors
+
+import play.api.http.Status.ACCEPTED
+import uk.gov.hmrc.agentregistration.shared.util.Errors
+import uk.gov.hmrc.agentregistrationrisking.config.AppConfig
+import uk.gov.hmrc.agentregistrationrisking.model.EmailInformation
+import uk.gov.hmrc.agentregistrationrisking.util.FutureUtil.andLogOnFailure
+import uk.gov.hmrc.http.client.HttpClientV2
+
+import javax.inject.Inject
+import javax.inject.Singleton
+import scala.concurrent.ExecutionContext
+
+@Singleton
+class EmailConnector @Inject() (
+  appConfig: AppConfig,
+  httpClient: HttpClientV2
+)(using ExecutionContext)
+extends Connector:
+
+  def sendEmail(emailInformation: EmailInformation)(using RequestHeader): Future[Unit] =
+    val url: URL = url"$baseUrl/hmrc/email"
+    httpClient
+      .post(url)
+      .withBody(Json.toJson(emailInformation))
+      .execute[HttpResponse]
+      .map: response =>
+        response.status match
+          case ACCEPTED => ()
+          case status =>
+            Errors.throwUpstreamErrorResponse(
+              httpMethod = "POST",
+              url = url,
+              status = status,
+              response = response,
+              info = s"Failed to send email for template ${emailInformation.templateId}"
+            )
+      .andLogOnFailure(s"Failed to send email for template ${emailInformation.templateId}")
+
+  private val baseUrl: String = appConfig.emailBaseUrl

app/uk/gov/hmrc/agentregistrationrisking/controllers/SdesNotificationController.scala

@@ -20,21 +20,21 @@ import com.google.inject.Inject
 import play.api.mvc.Action
 import play.api.mvc.ControllerComponents
 import play.api.mvc.RequestHeader
-
-import scala.concurrent.Future
-import scala.concurrent.ExecutionContext
 import uk.gov.hmrc.agentregistrationrisking.action.Actions
 import uk.gov.hmrc.agentregistrationrisking.model.sdes.*
+import uk.gov.hmrc.agentregistrationrisking.services.EmailService
 import uk.gov.hmrc.agentregistrationrisking.services.RiskingResultsService
-import uk.gov.hmrc.agentregistrationrisking.services.SdesProxyService
 import uk.gov.hmrc.agentregistrationrisking.services.SubscriptionService
-import uk.gov.hmrc.agentregistrationrisking.util.ProcessInSequence
+
+import scala.concurrent.ExecutionContext
+import scala.concurrent.Future
 
 class SdesNotificationController @Inject() (
   cc: ControllerComponents,
   actions: Actions,
   riskingResultsService: RiskingResultsService,
-  subscriptionService: SubscriptionService
+  subscriptionService: SubscriptionService,
+  emailService: EmailService
 )(using ExecutionContext)
 extends BackendController(cc):
 
@@ -59,4 +59,6 @@ extends BackendController(cc):
     (for
       _ <- riskingResultsService.processResultsFiles()
       _ <- subscriptionService.subscribeApprovedApplications()
+      _ <- emailService.findAndSendRegisteredEmail()
+      _ <- emailService.findAndSendNonFixableFailureEmails()
     yield ()).recover { case ex: Exception => logger.error(s"Error processing file ready notification", ex) }

app/uk/gov/hmrc/agentregistrationrisking/model/EmailInformation.scala

@@ -0,0 +1,32 @@
+/*
+ * Copyright 2026 HM Revenue & Customs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package uk.gov.hmrc.agentregistrationrisking.model
+
+import play.api.libs.json.Json
+import play.api.libs.json.OFormat
+
+final case class EmailInformation(
+  to: Seq[String],
+  templateId: String,
+  parameters: Map[String, String],
+  force: Boolean = false,
+  eventUrl: Option[String] = None,
+  onSendUrl: Option[String] = None
+)
+
+object EmailInformation:
+  given OFormat[EmailInformation] = Json.format[EmailInformation]

app/uk/gov/hmrc/agentregistrationrisking/repository/ApplicationForRiskingRepo.scala

@@ -78,6 +78,23 @@ extends Repo[ApplicationReference, ApplicationForRisking](
       )
     ).toFuture()
 
+//  def findReadyForSubscription(): Future[Seq[ApplicationForRisking]] = collection
+//    .find(
+//      Filters.and(
+//        Filters.size("failures", 0),
+//        Filters.eq("isSubscribed", false)
+//      )
+//    ).toFuture()
+
+  def findApplicationsPendingAction(): Future[Seq[ApplicationForRisking]] = collection
+    .find(
+      Filters.and(
+        Filters.exists(FieldNames.entityRiskingResult),
+        Filters.eq(FieldNames.isSubscribed, false),
+        Filters.eq("isEmailSent", false)
+      )
+    ).toFuture()
+
 //  def findReadyForSubscription(): Future[Seq[ApplicationForRisking]] = collection
 //    .find(
 //      Filters.and(
@@ -95,6 +112,22 @@ extends Repo[ApplicationReference, ApplicationForRisking](
         )
       ).toFuture()
   }
+  def findSubscribedReadyForSuccessEmail(): Future[Seq[ApplicationForRisking]] = collection
+    .find(
+      Filters.and(
+        Filters.eq("isSubscribed", true),
+        Filters.eq("isEmailSent", false)
+      )
+    ).toFuture()
+
+  def updateEmailSent(applicationReference: ApplicationReference): Future[UpdateResult] = collection
+    .updateOne(
+      Filters.eq(FieldNames.applicationReference, applicationReference.value),
+      Updates.combine(
+        Updates.set("isEmailSent", true),
+        Updates.set(FieldNames.lastUpdatedAt, Instant.now(clock).toString)
+      )
+    ).toFuture()
 
 // when named ApplicationForRiskingRepo, Scala 3 compiler complains
 // about cyclic reference error during compilation ...

app/uk/gov/hmrc/agentregistrationrisking/services/ApplicationStatusService.scala

@@ -0,0 +1,84 @@
+/*
+ * Copyright 2026 HM Revenue & Customs
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package uk.gov.hmrc.agentregistrationrisking.services
+
+import uk.gov.hmrc.agentregistration.shared.risking.RiskingOutcome
+import uk.gov.hmrc.agentregistration.shared.util.SafeEquals.===
+import uk.gov.hmrc.agentregistrationrisking.model.*
+import uk.gov.hmrc.agentregistrationrisking.repository.ApplicationForRiskingRepo
+import uk.gov.hmrc.agentregistrationrisking.repository.IndividualForRiskingRepo
+import uk.gov.hmrc.agentregistrationrisking.util.RequestAwareLogging
+import uk.gov.hmrc.agentregistrationrisking.services.RiskingOutcomeHelper._
+
+import java.time.Clock
+import javax.inject.Inject
+import javax.inject.Singleton
+import scala.concurrent.ExecutionContext
+import scala.concurrent.Future
+
+@Singleton
+class ApplicationStatusService @Inject() (
+  applicationForRiskingRepo: ApplicationForRiskingRepo,
+  individualForRiskingRepo: IndividualForRiskingRepo
+)(using
+  ExecutionContext,
+  Clock
+)
+extends RequestAwareLogging:
+
+  def findApprovedReadyToSubscribe(): Future[Seq[ApplicationForRisking]] = getApplicationsPendingActionWithIndividuals
+    .map(filterApprovedApplicationsWithIndividuals)
+    .map(_.map(_.application))
+
+  def findNonFixableReadyForFailureEmail(): Future[Seq[ApplicationWithIndividuals]] = getApplicationsPendingActionWithIndividuals
+    .map(filterNonFixableApplicationsWithIndividuals)
+
+  private def getApplicationsPendingActionWithIndividuals: Future[Seq[ApplicationWithIndividuals]] =
+    for
+      applications <- applicationForRiskingRepo.findApplicationsPendingAction()
+      individuals <- individualForRiskingRepo.findByApplicationReferences(applications.map(_.applicationReference))
+    yield ApplicationWithIndividuals
+      .merge(applications, individuals)
+      .filter(_.individuals.forall(_.individualRiskingResult.isDefined))
+
+  private def filterApprovedApplicationsWithIndividuals(applicationsWithIndividuals: Seq[ApplicationWithIndividuals]): Seq[ApplicationWithIndividuals] =
+    applicationsWithIndividuals.filter: appWithIndividuals =>
+      RiskingOutcomeHelper
+        .computeRiskingOutcome(appWithIndividuals)
+        .exists(_ === RiskingOutcome.Approved)
+
+  private def filterNonFixableApplicationsWithIndividuals(applicationsWithIndividuals: Seq[ApplicationWithIndividuals]): Seq[ApplicationWithIndividuals] =
+    applicationsWithIndividuals
+      .filter: appWithIndividuals =>
+        RiskingOutcomeHelper
+          .computeRiskingOutcome(appWithIndividuals)
+          .exists(_ === RiskingOutcome.FailedNonFixable)
+      .map: appWithIndividuals =>
+        val nonFixableIndividuals = appWithIndividuals.individuals.filter: individual =>
+          individual.individualRiskingResult.exists(_.failures.outcome === RiskingOutcome.FailedNonFixable)
+        ApplicationWithIndividuals(appWithIndividuals.application, nonFixableIndividuals)
+
+  private def filterFixableApplicationsWithIndividuals(applicationsWithIndividuals: Seq[ApplicationWithIndividuals]): Seq[ApplicationWithIndividuals] =
+    applicationsWithIndividuals
+      .filter: appWithIndividuals =>
+        RiskingOutcomeHelper
+          .computeRiskingOutcome(appWithIndividuals)
+          .exists(_ === RiskingOutcome.FailedFixable)
+      .map: appWithIndividuals =>
+        val fixableIndividuals = appWithIndividuals.individuals.filter: individual =>
+          individual.individualRiskingResult.exists(_.failures.outcome === RiskingOutcome.FailedFixable)
+        ApplicationWithIndividuals(appWithIndividuals.application, fixableIndividuals)