Merge pull request #112 from hmrc/MTDSA-17424

MTDSA-17424 reformat code
hmrc · Jul 6, 2023 · 3f0f1a2 · 3f0f1a2
2 parents 330d161 + eabd85a
commit 3f0f1a2
Show file tree

Hide file tree

Showing 199 changed files with 880 additions and 694 deletions.
diff --git a/.scalafmt.conf b/.scalafmt.conf
@@ -1,19 +1,23 @@
-align = more    // For pretty alignment.
+version = 3.4.3
 
-align.openParenDefnSite = true
+runner.dialect = scala213
+
+align = more
 
-danglingParentheses: false
+align.openParenDefnSite = true
 
-docstrings = ScalaDoc
+danglingParentheses.preset: false
 
-maxColumn = 150 // For my wide 30" display.
+docstrings.style = SpaceAsterisk
 
-//newlines.afterCurlyLambda = always
+maxColumn = 150
 
-newlines.alwaysBeforeTopLevelStatements = true
+newlines.topLevelStatementBlankLines = [
+  {
+    blanks = 1
+  }
+]
 
-spaces.inImportCurlyBraces: true
+spaces.inImportCurlyBraces: false
 
 style: defaultWithAlign
-
-unindentTopLevelOperators = true
diff --git a/app/api/connectors/BaseDownstreamConnector.scala b/app/api/connectors/BaseDownstreamConnector.scala
@@ -17,13 +17,13 @@
 package api.connectors
 
 import api.connectors.DownstreamUri._
-import config.{ AppConfig, FeatureSwitches }
+import config.{AppConfig, FeatureSwitches}
 import play.api.Logger
-import play.api.http.{ HeaderNames, MimeTypes }
+import play.api.http.{HeaderNames, MimeTypes}
 import play.api.libs.json.Writes
-import uk.gov.hmrc.http.{ HeaderCarrier, HttpClient, HttpReads }
+import uk.gov.hmrc.http.{HeaderCarrier, HttpClient, HttpReads}
 
-import scala.concurrent.{ ExecutionContext, Future }
+import scala.concurrent.{ExecutionContext, Future}
 
 trait BaseDownstreamConnector {
   val http: HttpClient
@@ -35,10 +35,11 @@ trait BaseDownstreamConnector {
 
   private val jsonContentTypeHeader = HeaderNames.CONTENT_TYPE -> MimeTypes.JSON
 
-  def post[Body: Writes, Resp](body: Body, uri: DownstreamUri[Resp])(implicit ec: ExecutionContext,
-                                                                     hc: HeaderCarrier,
-                                                                     httpReads: HttpReads[DownstreamOutcome[Resp]],
-                                                                     correlationId: String): Future[DownstreamOutcome[Resp]] = {
+  def post[Body: Writes, Resp](body: Body, uri: DownstreamUri[Resp])(implicit
+      ec: ExecutionContext,
+      hc: HeaderCarrier,
+      httpReads: HttpReads[DownstreamOutcome[Resp]],
+      correlationId: String): Future[DownstreamOutcome[Resp]] = {
 
     def doPost(implicit hc: HeaderCarrier): Future[DownstreamOutcome[Resp]] = {
       http.POST(getBackendUri(uri), body)
@@ -47,21 +48,23 @@ trait BaseDownstreamConnector {
     doPost(getBackendHeaders(uri, hc, correlationId, jsonContentTypeHeader))
   }
 
-  def get[Resp](uri: DownstreamUri[Resp], queryParams: Seq[(String, String)] = Seq.empty)(implicit ec: ExecutionContext,
-                                                                                          hc: HeaderCarrier,
-                                                                                          httpReads: HttpReads[DownstreamOutcome[Resp]],
-                                                                                          correlationId: String): Future[DownstreamOutcome[Resp]] = {
+  def get[Resp](uri: DownstreamUri[Resp], queryParams: Seq[(String, String)] = Seq.empty)(implicit
+      ec: ExecutionContext,
+      hc: HeaderCarrier,
+      httpReads: HttpReads[DownstreamOutcome[Resp]],
+      correlationId: String): Future[DownstreamOutcome[Resp]] = {
 
     def doGet(implicit hc: HeaderCarrier): Future[DownstreamOutcome[Resp]] =
       http.GET(getBackendUri(uri), queryParams = queryParams)
 
     doGet(getBackendHeaders(uri, hc, correlationId))
   }
 
-  def delete[Resp](uri: DownstreamUri[Resp])(implicit ec: ExecutionContext,
-                                             hc: HeaderCarrier,
-                                             httpReads: HttpReads[DownstreamOutcome[Resp]],
-                                             correlationId: String): Future[DownstreamOutcome[Resp]] = {
+  def delete[Resp](uri: DownstreamUri[Resp])(implicit
+      ec: ExecutionContext,
+      hc: HeaderCarrier,
+      httpReads: HttpReads[DownstreamOutcome[Resp]],
+      correlationId: String): Future[DownstreamOutcome[Resp]] = {
 
     def doDelete(implicit hc: HeaderCarrier): Future[DownstreamOutcome[Resp]] = {
       http.DELETE(getBackendUri(uri))
@@ -70,10 +73,11 @@ trait BaseDownstreamConnector {
     doDelete(getBackendHeaders(uri, hc, correlationId))
   }
 
-  def put[Body: Writes, Resp](body: Body, uri: DownstreamUri[Resp])(implicit ec: ExecutionContext,
-                                                                    hc: HeaderCarrier,
-                                                                    httpReads: HttpReads[DownstreamOutcome[Resp]],
-                                                                    correlationId: String): Future[DownstreamOutcome[Resp]] = {
+  def put[Body: Writes, Resp](body: Body, uri: DownstreamUri[Resp])(implicit
+      ec: ExecutionContext,
+      hc: HeaderCarrier,
+      httpReads: HttpReads[DownstreamOutcome[Resp]],
+      correlationId: String): Future[DownstreamOutcome[Resp]] = {
 
     def doPut(implicit hc: HeaderCarrier): Future[DownstreamOutcome[Resp]] = {
       http.PUT(getBackendUri(uri), body)
@@ -113,4 +117,5 @@ trait BaseDownstreamConnector {
         passThroughHeaders
     )
   }
+
 }
diff --git a/app/api/connectors/MtdIdLookupConnector.scala b/app/api/connectors/MtdIdLookupConnector.scala
@@ -17,17 +17,18 @@
 package api.connectors
 
 import config.AppConfig
-import uk.gov.hmrc.http.{ HeaderCarrier, HttpClient }
+import uk.gov.hmrc.http.{HeaderCarrier, HttpClient}
 
-import javax.inject.{ Inject, Singleton }
-import scala.concurrent.{ ExecutionContext, Future }
+import javax.inject.{Inject, Singleton}
+import scala.concurrent.{ExecutionContext, Future}
 
 @Singleton
-class MtdIdLookupConnector @Inject()(http: HttpClient, appConfig: AppConfig) {
+class MtdIdLookupConnector @Inject() (http: HttpClient, appConfig: AppConfig) {
 
   def getMtdId(nino: String)(implicit hc: HeaderCarrier, ec: ExecutionContext): Future[MtdIdLookupOutcome] = {
     import api.connectors.httpparsers.MtdIdLookupHttpParser.mtdIdLookupHttpReads
 
     http.GET[MtdIdLookupOutcome](s"${appConfig.mtdIdBaseUrl}/mtd-identifier-lookup/nino/$nino")
   }
+
 }
diff --git a/app/api/connectors/httpparsers/HttpParser.scala b/app/api/connectors/httpparsers/HttpParser.scala
@@ -16,12 +16,12 @@
 
 package api.connectors.httpparsers
 
-import api.models.errors.{ BVRError, DownstreamError, DownstreamErrorCode, DownstreamErrors, InternalError, OutboundError }
+import api.models.errors.{BVRError, DownstreamError, DownstreamErrorCode, DownstreamErrors, InternalError, OutboundError}
 import play.api.Logger
 import play.api.libs.json._
 import uk.gov.hmrc.http.HttpResponse
 
-import scala.util.{ Success, Try }
+import scala.util.{Success, Try}
 
 trait HttpParser {
   private val logger: Logger = Logger(this.getClass)
@@ -43,6 +43,7 @@ trait HttpParser {
         logger.warn(s"[KnownJsonResponse][validateJson] Unable to parse JSON: $error")
         None
     }
+
   }
 
   def retrieveCorrelationId(response: HttpResponse): String = response.header("CorrelationId").getOrElse("")
@@ -65,4 +66,5 @@ trait HttpParser {
 
     singleError orElse multipleErrors orElse bvrErrors getOrElse unableToParseJsonError
   }
+
 }
diff --git a/app/api/connectors/httpparsers/MtdIdLookupHttpParser.scala b/app/api/connectors/httpparsers/MtdIdLookupHttpParser.scala
@@ -17,10 +17,10 @@
 package api.connectors.httpparsers
 
 import api.connectors.MtdIdLookupOutcome
-import api.models.errors.{ InternalError, InvalidBearerTokenError, NinoFormatError }
-import play.api.http.Status.{ FORBIDDEN, OK, UNAUTHORIZED }
-import play.api.libs.json.{ Reads, __ }
-import uk.gov.hmrc.http.{ HttpReads, HttpResponse }
+import api.models.errors.{InternalError, InvalidBearerTokenError, NinoFormatError}
+import play.api.http.Status.{FORBIDDEN, OK, UNAUTHORIZED}
+import play.api.libs.json.{Reads, __}
+import uk.gov.hmrc.http.{HttpReads, HttpResponse}
 
 object MtdIdLookupHttpParser extends HttpParser {
 
@@ -38,4 +38,5 @@ object MtdIdLookupHttpParser extends HttpParser {
       case _            => Left(InternalError)
     }
   }
+
 }
diff --git a/app/api/connectors/httpparsers/StandardDownstreamHttpParser.scala b/app/api/connectors/httpparsers/StandardDownstreamHttpParser.scala
@@ -23,7 +23,7 @@ import api.models.outcomes.ResponseWrapper
 import play.api.Logger
 import play.api.http.Status._
 import play.api.libs.json.Reads
-import uk.gov.hmrc.http.{ HttpReads, HttpResponse }
+import uk.gov.hmrc.http.{HttpReads, HttpResponse}
 
 object StandardDownstreamHttpParser extends HttpParser {
 
@@ -36,7 +36,7 @@ object StandardDownstreamHttpParser extends HttpParser {
     (_: String, url: String, response: HttpResponse) =>
       doRead(url, response) { correlationId =>
         Right(ResponseWrapper(correlationId, ()))
-    }
+      }
 
   implicit def reads[A: Reads](implicit successCode: SuccessCode = SuccessCode(OK)): HttpReads[DownstreamOutcome[A]] =
     (_: String, url: String, response: HttpResponse) =>
@@ -45,10 +45,10 @@ object StandardDownstreamHttpParser extends HttpParser {
           case Some(ref) => Right(ResponseWrapper(correlationId, ref))
           case None      => Left(ResponseWrapper(correlationId, errors.OutboundError(InternalError)))
         }
-    }
+      }
 
-  private def doRead[A](url: String, response: HttpResponse)(successOutcomeFactory: String => DownstreamOutcome[A])(
-      implicit successCode: SuccessCode): DownstreamOutcome[A] = {
+  private def doRead[A](url: String, response: HttpResponse)(successOutcomeFactory: String => DownstreamOutcome[A])(implicit
+      successCode: SuccessCode): DownstreamOutcome[A] = {
 
     val correlationId = retrieveCorrelationId(response)
 
@@ -66,7 +66,8 @@ object StandardDownstreamHttpParser extends HttpParser {
             s"Success response received from Downstream with correlationId: $correlationId when calling $url")
         successOutcomeFactory(correlationId)
       case BAD_REQUEST | NOT_FOUND | FORBIDDEN | CONFLICT | UNPROCESSABLE_ENTITY => Left(ResponseWrapper(correlationId, parseErrors(response)))
-      case _                                                                     => Left(ResponseWrapper(correlationId, errors.OutboundError(InternalError)))
+      case _ => Left(ResponseWrapper(correlationId, errors.OutboundError(InternalError)))
     }
   }
+
 }
diff --git a/app/api/connectors/package.scala b/app/api/connectors/package.scala
@@ -16,7 +16,7 @@
 
 package api
 
-import api.models.errors.{ DownstreamError, MtdError }
+import api.models.errors.{DownstreamError, MtdError}
 import api.models.outcomes.ResponseWrapper
 
 package object connectors {

diff --git a/app/api/controllers/AuditHandler.scala b/app/api/controllers/AuditHandler.scala
@@ -16,21 +16,21 @@
 
 package api.controllers
 
-import api.models.audit.{ AuditEvent, AuditResponse, GenericAuditDetail }
+import api.models.audit.{AuditEvent, AuditResponse, GenericAuditDetail}
 import api.models.auth.UserDetails
 import api.models.errors.ErrorWrapper
 import api.services.AuditService
 import cats.syntax.either._
-import play.api.libs.json.{ JsValue, Writes }
+import play.api.libs.json.{JsValue, Writes}
 
 import scala.Function.const
 import scala.concurrent.ExecutionContext
 
 trait AuditHandler extends RequestContextImplicits {
 
   def performAudit(userDetails: UserDetails, httpStatus: Int, response: Either[ErrorWrapper, Option[JsValue]])(implicit
-                                                                                                               ctx: RequestContext,
-                                                                                                               ec: ExecutionContext): Unit
+      ctx: RequestContext,
+      ec: ExecutionContext): Unit
 
 }
 
@@ -79,8 +79,8 @@ object AuditHandler {
       extends AuditHandler {
 
     def performAudit(userDetails: UserDetails, httpStatus: Int, response: Either[ErrorWrapper, Option[JsValue]])(implicit
-                                                                                                                 ctx: RequestContext,
-                                                                                                                 ec: ExecutionContext): Unit = {
+        ctx: RequestContext,
+        ec: ExecutionContext): Unit = {
 
       val auditEvent = {
         val auditResponse = AuditResponse(httpStatus, response.map(responseBodyMap).leftMap(ew => ew.auditErrors))

diff --git a/app/api/controllers/AuthorisedController.scala b/app/api/controllers/AuthorisedController.scala
@@ -18,16 +18,16 @@ package api.controllers
 
 import api.models.auth.UserDetails
 import api.models.errors
-import api.models.errors.{ InvalidBearerTokenError, NinoFormatError, ClientNotAuthorisedError }
-import api.services.{ EnrolmentsAuthService, MtdIdLookupService }
+import api.models.errors.{ClientNotAuthorisedError, InvalidBearerTokenError, NinoFormatError}
+import api.services.{EnrolmentsAuthService, MtdIdLookupService}
 import play.api.libs.json.Json
 import play.api.mvc._
 import uk.gov.hmrc.auth.core.Enrolment
 import uk.gov.hmrc.auth.core.authorise.Predicate
 import uk.gov.hmrc.http.HeaderCarrier
 import uk.gov.hmrc.play.bootstrap.backend.controller.BackendController
 
-import scala.concurrent.{ ExecutionContext, Future }
+import scala.concurrent.{ExecutionContext, Future}
 
 case class UserRequest[A](userDetails: UserDetails, request: Request[A]) extends WrappedRequest[A](request)
 
@@ -47,8 +47,8 @@ abstract class AuthorisedController(cc: ControllerComponents)(implicit ec: Execu
         .withIdentifier("MTDITID", mtdId)
         .withDelegatedAuthRule("mtd-it-auth")
 
-    def invokeBlockWithAuthCheck[A](mtdId: String, request: Request[A], block: UserRequest[A] => Future[Result])(
-        implicit headerCarrier: HeaderCarrier): Future[Result] = {
+    def invokeBlockWithAuthCheck[A](mtdId: String, request: Request[A], block: UserRequest[A] => Future[Result])(implicit
+        headerCarrier: HeaderCarrier): Future[Result] = {
       authService.authorised(predicate(mtdId)).flatMap[Result] {
         case Right(userDetails)             => block(UserRequest(userDetails.copy(mtdId = mtdId), request))
         case Left(ClientNotAuthorisedError) => Future.successful(Forbidden(Json.toJson(ClientNotAuthorisedError)))
@@ -67,5 +67,7 @@ abstract class AuthorisedController(cc: ControllerComponents)(implicit ec: Execu
         case Left(_)                        => Future.successful(InternalServerError(Json.toJson(errors.InternalError)))
       }
     }
+
   }
+
 }
diff --git a/app/api/controllers/ErrorHandling.scala b/app/api/controllers/ErrorHandling.scala
@@ -25,9 +25,8 @@ case class ErrorHandling(errorHandler: PartialFunction[ErrorWrapper, Result])
 
 object ErrorHandling {
 
-  val Default: ErrorHandling = ErrorHandling {
-    case errorWrapper: ErrorWrapper =>
-      Status(errorWrapper.error.httpStatus)(Json.toJson(errorWrapper))
+  val Default: ErrorHandling = ErrorHandling { case errorWrapper: ErrorWrapper =>
+    Status(errorWrapper.error.httpStatus)(Json.toJson(errorWrapper))
   }
 
 }