Merge pull request #420 from hmrc/DDCNL-9316

Ddcnl 9316 - SCA Wrapper update and Migrated to HTTPClientV2
hmrc · Aug 19, 2024 · 791b08e · 791b08e
2 parents f50ea7c + c37b341
commit 791b08e
Show file tree

Hide file tree

Showing 25 changed files with 116 additions and 297 deletions.
diff --git a/app/config/ApplicationConfig.scala b/app/config/ApplicationConfig.scala
@@ -122,6 +122,5 @@ class ApplicationConfig @Inject()(configuration: Configuration, servicesConfig:
 
   val pertaxAuthBaseUrl = servicesConfig.baseUrl("pertax-auth")
 
-  lazy val internalAuthResourceType: String =
-    servicesConfig.getConfString("internal-auth.resource-type", "ddcn-live-admin-frontend")
+
 }
diff --git a/app/config/ApplicationStartUp.scala b/app/config/ApplicationStartUp.scala
diff --git a/app/config/TamcModule.scala b/app/config/TamcModule.scala
@@ -29,7 +29,6 @@ class TamcModule extends Module {
     Seq(
       bind[AuthConnector].to[TamcAuthConnector],
       bind[CurrentTaxYear].toInstance(TaxYear),
-      bind[TaxBandReader].to[TaxBandReaderImpl],
-      bind[ApplicationStartUp].toSelf.eagerly()
+      bind[TaxBandReader].to[TaxBandReaderImpl]
     )
 }
diff --git a/app/connectors/MarriageAllowanceConnector.scala b/app/connectors/MarriageAllowanceConnector.scala
@@ -18,26 +18,26 @@ package connectors
 
 import com.google.inject.Inject
 import config.ApplicationConfig
-import play.api.libs.json.Json
 import errors.ErrorResponseStatus.{BAD_REQUEST, CITIZEN_NOT_FOUND, TRANSFEROR_NOT_FOUND}
 import errors.{BadFetchRequest, CitizenNotFound, MarriageAllowanceError, TransferorNotFound}
 import models._
+import play.api.libs.json.Json
 import uk.gov.hmrc.domain.Nino
 import uk.gov.hmrc.http._
+import uk.gov.hmrc.http.client.HttpClientV2
 import uk.gov.hmrc.http.HttpReads.Implicits._
 
 import scala.concurrent.{ExecutionContext, Future}
 
-class MarriageAllowanceConnector @Inject()(httpClient: HttpClient, applicationConfig: ApplicationConfig) {
+class MarriageAllowanceConnector @Inject()(httpClient: HttpClientV2, applicationConfig: ApplicationConfig) {
 
   def marriageAllowanceUrl = applicationConfig.marriageAllowanceUrl
 
   def listRelationship(nino: Nino)(
-    implicit hc: HeaderCarrier, ec: ExecutionContext): Future[RelationshipRecordList] =
+    implicit hc: HeaderCarrier, ec: ExecutionContext): Future[RelationshipRecordList] = {
     httpClient
-      .GET[HttpResponse](
-        s"$marriageAllowanceUrl/paye/$nino/list-relationship"
-      )
+      .get(url"$marriageAllowanceUrl/paye/$nino/list-relationship")
+      .execute[HttpResponse]
       .flatMap {
         response =>
           val relationshipRecordWrapper = response.json.as[RelationshipRecordStatusWrapper]
@@ -58,44 +58,47 @@ class MarriageAllowanceConnector @Inject()(httpClient: HttpClient, applicationCo
       }.recoverWith {
       case t: Throwable => Future.failed(t)
     }
+  }
 
   def getRecipientRelationship(transferorNino: Nino, recipientData: RegistrationFormInput)
-                              (implicit hc: HeaderCarrier, ec: ExecutionContext): Future[Either[MarriageAllowanceError, GetRelationshipResponse]] =
+                              (implicit hc: HeaderCarrier, ec: ExecutionContext): Future[Either[MarriageAllowanceError, GetRelationshipResponse]] = {
     httpClient
-      .POST[RegistrationFormInput, HttpResponse](
-        s"$marriageAllowanceUrl/paye/$transferorNino/get-recipient-relationship", body = recipientData
-      )
+      .post(url"$marriageAllowanceUrl/paye/$transferorNino/get-recipient-relationship")
+      .withBody(Json.toJson(recipientData))
+      .execute[HttpResponse]
       .map {
         case response if response.status == 200 => Right(response.json.as[GetRelationshipResponse])
         case errorResponse => Left(errorResponse.json.as[MarriageAllowanceError])
       }.recoverWith {
-          case t: Throwable =>
-            Future.failed(t)
+      case t: Throwable => Future.failed(t)
     }
+  }
 
   def createRelationship(transferorNino: Nino, data: CreateRelationshipRequestHolder)(
-    implicit hc: HeaderCarrier, ec: ExecutionContext): Future[Either[MarriageAllowanceError, Option[CreateRelationshipResponse]]] =
+    implicit hc: HeaderCarrier, ec: ExecutionContext): Future[Either[MarriageAllowanceError, Option[CreateRelationshipResponse]]] = {
     httpClient
-      .PUT[CreateRelationshipRequestHolder, HttpResponse](
-        s"$marriageAllowanceUrl/paye/$transferorNino/create-multi-year-relationship/pta", data
-      )
+      .put(url"$marriageAllowanceUrl/paye/$transferorNino/create-multi-year-relationship/pta")
+      .withBody(Json.toJson(data))
+      .execute[HttpResponse]
       .map {
         case response if response.status == 200 => Right(Json.fromJson[CreateRelationshipResponse](response.json).asOpt)
         case errorResponse => Left(errorResponse.json.as[MarriageAllowanceError])
       }.recoverWith {
-        case t: Throwable => Future.failed(t)
-      }
+      case t: Throwable => Future.failed(t)
+    }
+  }
 
   def updateRelationship(transferorNino: Nino, data: UpdateRelationshipRequestHolder)(
-    implicit hc: HeaderCarrier, ec: ExecutionContext): Future[Either[MarriageAllowanceError, Option[UpdateRelationshipResponse]]] =
+    implicit hc: HeaderCarrier, ec: ExecutionContext): Future[Either[MarriageAllowanceError, Option[UpdateRelationshipResponse]]] = {
     httpClient
-      .PUT[UpdateRelationshipRequestHolder, HttpResponse](
-        s"$marriageAllowanceUrl/paye/$transferorNino/update-relationship", data
-      )
+      .put(url"$marriageAllowanceUrl/paye/$transferorNino/update-relationship")
+      .withBody(Json.toJson(data))
+      .execute[HttpResponse]
       .map {
         case response if response.status == 200 => Right(Json.fromJson[UpdateRelationshipResponse](response.json).asOpt)
         case errorResponse => Left(errorResponse.json.as[MarriageAllowanceError])
       }.recoverWith {
-        case t: Throwable => Future.failed(t)
-      }
+      case t: Throwable => Future.failed(t)
+    }
+  }
 }
diff --git a/app/connectors/PertaxAuthConnector.scala b/app/connectors/PertaxAuthConnector.scala
@@ -22,26 +22,27 @@ import com.google.inject.ImplementedBy
 import config.ApplicationConfig
 import play.api.Logging
 import play.api.http.HeaderNames
-import uk.gov.hmrc.http.{HeaderCarrier, HttpClient, HttpException, HttpResponse, UpstreamErrorResponse}
+import uk.gov.hmrc.http.{HeaderCarrier, HttpException, HttpResponse, StringContextOps, UpstreamErrorResponse}
 import uk.gov.hmrc.play.partials.HtmlPartial
 import uk.gov.hmrc.http.HttpReads.Implicits._
 
 import javax.inject.Inject
 import scala.concurrent.{ExecutionContext, Future}
 import connectors.httpParsers.PertaxAuthenticationHttpParser._
 import models.pertaxAuth.PertaxAuthResponseModel
+import uk.gov.hmrc.http.client.HttpClientV2
 
-class PertaxAuthConnectorImpl @Inject()(http: HttpClient, appConfig: ApplicationConfig, httpClientResponse: HttpClientResponse)(
-                                   implicit ec: ExecutionContext
+class PertaxAuthConnectorImpl @Inject()(http: HttpClientV2, appConfig: ApplicationConfig, httpClientResponse: HttpClientResponse)(
+  implicit ec: ExecutionContext
 ) extends PertaxAuthConnector with Logging {
 
   override def authorise(nino: String)(implicit hc: HeaderCarrier): Future[Either[UpstreamErrorResponse, PertaxAuthResponseModel]] = {
     val authUrl = appConfig.pertaxAuthBaseUrl + s"/pertax/$nino/authorise"
 
-    http.GET[Either[UpstreamErrorResponse, PertaxAuthResponseModel]](
-      url = authUrl,
-      headers = Seq(HeaderNames.ACCEPT -> "application/vnd.hmrc.1.0+json")
-    )
+    http
+      .get(url = url"$authUrl")
+      .setHeader(HeaderNames.ACCEPT -> "application/vnd.hmrc.1.0+json")
+      .execute[Either[UpstreamErrorResponse, PertaxAuthResponseModel]]
   }
 
   def pertaxPostAuthorise(implicit
@@ -53,10 +54,9 @@ class PertaxAuthConnectorImpl @Inject()(http: HttpClient, appConfig: Application
     httpClientResponse
       .read(
         http
-          .POSTEmpty[Either[UpstreamErrorResponse, HttpResponse]](
-            s"$pertaxUrl/pertax/authorise",
-            Seq(HeaderNames.ACCEPT -> "application/vnd.hmrc.2.0+json")
-          )
+          .post(url= url"$pertaxUrl/pertax/authorise")
+          .setHeader(HeaderNames.ACCEPT -> "application/vnd.hmrc.2.0+json")
+          .execute[Either[UpstreamErrorResponse, HttpResponse]]
       )
       .map(_.json.as[PertaxAuthResponseModel])
   }
@@ -65,13 +65,16 @@ class PertaxAuthConnectorImpl @Inject()(http: HttpClient, appConfig: Application
     val partialUrl =
       appConfig.pertaxAuthBaseUrl + s"${if (partialContextUrl.charAt(0).toString == "/") partialContextUrl else s"/$partialContextUrl"}"
 
-    http.GET[HtmlPartial](partialUrl).map {
-      case partialSuccess: HtmlPartial.Success => partialSuccess
-      case partialFailure: HtmlPartial.Failure =>
-        logger.error(s"[PertaxAuthConnector][loadPartial] Failed to load Partial from partial url '$partialUrl'. " +
-          s"Partial info: $partialFailure, body: ${partialFailure.body}")
-        partialFailure
-    }.recover {
+    http
+      .get(url"$partialUrl")
+      .execute[HtmlPartial]
+      .map {
+        case partialSuccess: HtmlPartial.Success => partialSuccess
+        case partialFailure: HtmlPartial.Failure =>
+          logger.error(s"[PertaxAuthConnector][loadPartial] Failed to load Partial from partial url '$partialUrl'. " +
+            s"Partial info: $partialFailure, body: ${partialFailure.body}")
+          partialFailure
+      }.recover {
       case exception: HttpException => HtmlPartial.Failure(Some(exception.responseCode))
       case _ => HtmlPartial.Failure(None)
     }

diff --git a/app/connectors/TamcAuthConnector.scala b/app/connectors/TamcAuthConnector.scala
@@ -16,12 +16,14 @@
 
 package connectors
 
-import com.google.inject.Inject
-import config.ApplicationConfig
+ import config.ApplicationConfig
+
+import javax.inject.Inject
 import uk.gov.hmrc.auth.core.PlayAuthConnector
-import uk.gov.hmrc.http.HttpClient
+import uk.gov.hmrc.http.client.HttpClientV2
 
-class TamcAuthConnector @Inject()(val http: HttpClient, applicationConfig: ApplicationConfig) extends PlayAuthConnector {
+ class TamcAuthConnector @Inject()(val httpClientV2: HttpClientV2, applicationConfig: ApplicationConfig)
+  extends PlayAuthConnector {
 
   override val serviceUrl: String = applicationConfig.authURL
 

diff --git a/app/errorHandler/ErrorHandler.scala b/app/errorHandler/ErrorHandler.scala
@@ -18,21 +18,33 @@ package errorHandler
 
 import com.google.inject.Inject
 import play.api.i18n.MessagesApi
-import play.api.mvc.Request
+import play.api.mvc.{Request, RequestHeader}
 import play.twirl.api.Html
-import uk.gov.hmrc.http.HttpClient
 import uk.gov.hmrc.play.bootstrap.frontend.http.FrontendErrorHandler
-import uk.gov.hmrc.play.partials.HeaderCarrierForPartialsConverter
+
+import scala.concurrent.{ExecutionContext, Future}
 
 class ErrorHandler @Inject()(
-  val messagesApi: MessagesApi,
-  val httpGet: HttpClient,
-  val headerCarrierForPartialsConverter: HeaderCarrierForPartialsConverter,
-  errorTemplate: views.html.templates.error_template,
-  pageNotFoundTemplate: views.html.templates.page_not_found_template) extends FrontendErrorHandler {
+                              override implicit val messagesApi: MessagesApi,
+                              errorTemplate: views.html.templates.error_template,
+                              pageNotFoundTemplate: views.html.templates.page_not_found_template)
+                            (
+                              implicit val ec: ExecutionContext
+                            ) extends FrontendErrorHandler {
+
+  //FIXME sca-wrapper > 9.0.0 will have some breaking changes, views will be based on RequestHeader instead of Request[_]
+  private def rhToRequest(rh: RequestHeader): Request[_] = Request(rh, "")
+
+
+  override def standardErrorTemplate(pageTitle: String, heading: String, message: String)(implicit request: RequestHeader): Future[Html] = {
+    implicit val req: Request[_] = rhToRequest(request)
+    Future.successful(errorTemplate(pageTitle, heading, message))
+  }
+
+  override def notFoundTemplate(implicit request: RequestHeader): Future[Html] = {
+    implicit val req: Request[_] =  rhToRequest(request)
+    Future.successful(pageNotFoundTemplate())
+  }
 
-  override def standardErrorTemplate(pageTitle: String, heading: String, message: String)(implicit request: Request[_]): Html =
-    errorTemplate(pageTitle, heading, message)
 
-  override def notFoundTemplate(implicit request: Request[_]): Html = pageNotFoundTemplate()
 }
diff --git a/app/models/admin/FeatureFlag.scala b/app/models/admin/FeatureFlag.scala
diff --git a/app/views/Main.scala b/app/views/Main.scala
@@ -17,19 +17,14 @@
 package views
 
 import com.google.inject.{ImplementedBy, Inject}
-import config.ApplicationConfig
 import play.api.Logging
 import play.api.i18n.Messages
 import play.api.mvc.Request
 import play.twirl.api.{Html, HtmlFormat}
 import uk.gov.hmrc.hmrcfrontend.views.viewmodels.hmrcstandardpage.ServiceURLs
-import uk.gov.hmrc.mongoFeatureToggles.services.FeatureFlagService
 import uk.gov.hmrc.sca.models.BannerConfig
-import uk.gov.hmrc.sca.models.auth.AuthenticatedRequest
 import uk.gov.hmrc.sca.services.WrapperService
 
-import scala.util.{Failure, Success, Try}
-
 @ImplementedBy(classOf[MainImpl])
 trait Main {
   def apply(
@@ -50,8 +45,6 @@ trait Main {
 }
 
 class MainImpl @Inject() (
-                           appConfig: ApplicationConfig,
-                           featureFlagService: FeatureFlagService,
                            wrapperService: WrapperService,
                            additionalStyles: views.html.components.additionalStyles,
                            additionalScripts: views.html.components.additionalScripts
@@ -70,19 +63,9 @@ class MainImpl @Inject() (
                       contentBlock: Html
                     )(implicit BaseUserRequest: Request[_], messages: Messages): HtmlFormat.Appendable = {
 
-    val trustedHelper = Try(BaseUserRequest.asInstanceOf[AuthenticatedRequest[_]]) match {
-      case Failure(_: java.lang.ClassCastException) => None
-      case Success(value) => value.trustedHelper
-      case Failure(exception) => throw exception
-    }
-
-    val fullPageTitle =
-    {
-      s"""$pageTitle - ${messages(serviceTitle)}"""
-    }
     wrapperService.standardScaLayout(
       content = contentBlock,
-      pageTitle = Some(fullPageTitle),
+      pageTitle = Some(s"$pageTitle - ${messages(serviceTitle)}"),
       serviceNameKey = Some("tamc.apply"),
       serviceURLs = ServiceURLs(
         signOutUrl = Some(controllers.routes.AuthorisationController.logout().url)
@@ -99,7 +82,7 @@ class MainImpl @Inject() (
         showBetaBanner = true,
         showHelpImproveBanner = false
       ),
-      optTrustedHelper = trustedHelper,
+      optTrustedHelper = None,
       fullWidth = false
     )(messages, BaseUserRequest)
   }