Merge pull request #79 from hmrc/BDOG-356

BDOG-356 Check for dev-ops group for Shuttering

Author: colin-lamed

app/uk/gov/hmrc/cataloguefrontend/CatalogueController.scala

@@ -25,7 +25,7 @@ import play.api.libs.json.Json.toJson
 import play.api.libs.json.{Format, Json}
 import play.api.mvc._
 import uk.gov.hmrc.cataloguefrontend.DisplayableTeamMember._
-import uk.gov.hmrc.cataloguefrontend.actions.{UmpAuthenticated, VerifySignInStatus}
+import uk.gov.hmrc.cataloguefrontend.actions.{UmpAuthActionBuilder, VerifySignInStatus}
 import uk.gov.hmrc.cataloguefrontend.connector.RepoType.Library
 import uk.gov.hmrc.cataloguefrontend.connector.UserManagementConnector.UMPError
 import uk.gov.hmrc.cataloguefrontend.connector._
@@ -63,7 +63,7 @@ class CatalogueController @Inject()(
    eventService: EventService,
    readModelService: ReadModelService,
    verifySignInStatus: VerifySignInStatus,
-   umpAuthenticated: UmpAuthenticated,
+   umpAuthActionBuilder: UmpAuthActionBuilder,
    userManagementPortalConfig: UserManagementPortalConfig,
    mcc: MessagesControllerComponents,
    digitalServiceInfoPage: DigitalServiceInfoPage,
@@ -102,31 +102,31 @@ class CatalogueController @Inject()(
       .fold(NotFound(toJson(s"owner for $digitalService not found")))(ds => Ok(toJson(ds)))
   }
 
-  def saveServiceOwner(): Action[AnyContent] = umpAuthenticated.async { implicit request =>
-    request.body.asJson
-      .map { payload =>
-        val serviceOwnerSaveEventData: ServiceOwnerSaveEventData = payload.as[ServiceOwnerSaveEventData]
-        val serviceOwnerDisplayName: String                      = serviceOwnerSaveEventData.displayName
-        val optTeamMember: Option[TeamMember] =
-          readModelService.getAllUsers.find(_.displayName.getOrElse("") == serviceOwnerDisplayName)
-
-        optTeamMember.fold {
-          Future.successful(NotAcceptable(toJson(s"Invalid user: $serviceOwnerDisplayName")))
-        } { member =>
-          member.username.fold(
-            Future.successful(ExpectationFailed(toJson(s"Username was not set (by UMP) for $member!")))) {
-            serviceOwnerUsername =>
-              eventService
-                .saveServiceOwnerUpdatedEvent(
-                  ServiceOwnerUpdatedEventData(serviceOwnerSaveEventData.service, serviceOwnerUsername))
-                .map(_ => Ok(toJson(DisplayableTeamMember(member, userManagementProfileBaseUrl))))
+  def saveServiceOwner(): Action[AnyContent] =
+    umpAuthActionBuilder.whenAuthenticated.async { implicit request =>
+      request.body.asJson
+        .map { payload =>
+          val serviceOwnerSaveEventData: ServiceOwnerSaveEventData = payload.as[ServiceOwnerSaveEventData]
+          val serviceOwnerDisplayName: String                      = serviceOwnerSaveEventData.displayName
+          val optTeamMember: Option[TeamMember] =
+            readModelService.getAllUsers.find(_.displayName.getOrElse("") == serviceOwnerDisplayName)
+
+          optTeamMember.fold {
+            Future.successful(NotAcceptable(toJson(s"Invalid user: $serviceOwnerDisplayName")))
+          } { member =>
+            member.username.fold(
+              Future.successful(ExpectationFailed(toJson(s"Username was not set (by UMP) for $member!")))) {
+              serviceOwnerUsername =>
+                eventService
+                  .saveServiceOwnerUpdatedEvent(
+                    ServiceOwnerUpdatedEventData(serviceOwnerSaveEventData.service, serviceOwnerUsername))
+                  .map(_ => Ok(toJson(DisplayableTeamMember(member, userManagementProfileBaseUrl))))
+            }
           }
         }
-      }
-      .getOrElse(Future.successful(BadRequest(toJson(s"""Unable to parse json: "${request.body.asText
-        .getOrElse("No text in request body!")}""""))))
-
-  }
+        .getOrElse(Future.successful(BadRequest(
+          toJson(s"""Unable to parse json: "${request.body.asText.getOrElse("No text in request body!")}""""))))
+    }
 
   def allTeams(): Action[AnyContent] = Action.async { implicit request =>
     import SearchFiltering._

app/uk/gov/hmrc/cataloguefrontend/actions/UmpAuthActionBuilder.scala

@@ -0,0 +1,80 @@
+/*
+ * Copyright 2019 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.cataloguefrontend.actions
+
+import cats.data.EitherT
+import cats.implicits._
+import javax.inject.{Inject, Singleton}
+import play.api.mvc._
+import uk.gov.hmrc.cataloguefrontend.{ routes => appRoutes }
+import uk.gov.hmrc.cataloguefrontend.connector.UserManagementAuthConnector
+import uk.gov.hmrc.cataloguefrontend.connector.UserManagementAuthConnector.{UmpToken, User}
+import uk.gov.hmrc.cataloguefrontend.service.CatalogueErrorHandler
+import uk.gov.hmrc.http.Token
+import uk.gov.hmrc.play.HeaderCarrierConverter
+import play.api.mvc.Results._
+import uk.gov.hmrc.http.HeaderCarrier
+
+import scala.concurrent.{ExecutionContext, Future}
+
+final case class UmpAuthenticatedRequest[A](request: Request[A], token: Token)
+  extends WrappedRequest(request)
+
+
+/** Creates an Action will only proceed to invoke the action body, if there is a valid [[UmpToken]] in session.
+  * If there isn't, it will short circuit with a Redirect to SignIn page.
+  *
+  * Use [[VerifySignInStatus]] Action if you want to know if there is a valid token, but it should not terminate invocation.
+  */
+@Singleton
+class UmpAuthActionBuilder @Inject()(
+  userManagementAuthConnector: UserManagementAuthConnector,
+  cc                         : MessagesControllerComponents,
+  catalogueErrorHandler      : CatalogueErrorHandler
+)(implicit val ec: ExecutionContext) {
+
+  val whenAuthenticated =
+    withCheck(None)
+
+  def withGroup(group: String) =
+    withCheck(optGroup = Some(group))
+
+ private def withCheck(optGroup: Option[String]) =
+    new ActionBuilder[UmpAuthenticatedRequest, AnyContent]
+     with ActionRefiner[Request, UmpAuthenticatedRequest] {
+
+      def refine[A](request: Request[A]): Future[Either[Result, UmpAuthenticatedRequest[A]]] = {
+        implicit val hc: HeaderCarrier = HeaderCarrierConverter.fromHeadersAndSession(request.headers, None)
+        (for {
+           token   <- EitherT.fromOption[Future](request.session.get(UmpToken.SESSION_KEY_NAME)
+                        , Redirect(appRoutes.AuthController.showSignInPage(targetUrl = Some(request.target.uriString).filter(_ => request.method == "GET")))
+                        )
+           user    <- EitherT.fromOptionF[Future, Result, User](userManagementAuthConnector.getUser(UmpToken(token))
+                        , Redirect(appRoutes.AuthController.showSignInPage(targetUrl = Some(request.target.uriString).filter(_ => request.method == "GET")))
+                        )
+           _       <- if (optGroup.map(user.groups.contains(_)).getOrElse(true))
+                        EitherT.pure[Future, Result](())
+                      else EitherT.left[Result](Future(Forbidden(catalogueErrorHandler.forbiddenTemplate(request))))
+         } yield UmpAuthenticatedRequest(request, token = Token(token))
+        ).value
+      }
+
+      override def parser: BodyParser[AnyContent] = cc.parsers.anyContent
+
+      override protected def executionContext: ExecutionContext = cc.executionContext
+    }
+}

app/uk/gov/hmrc/cataloguefrontend/actions/UmpAuthenticated.scala

@@ -32,7 +32,7 @@ final case class UmpVerifiedRequest[A](request: Request[A], override val message
 /** Creates an Action to check if there is a UmpToken, and if it is valid.
   * It will continue to invoke the action body, with a [[UmpVerifiedRequest]] representing this status.
   *
-  * Use [[UmpAuthenticated]] Action if it should only proceed when there is a valid UmpToken.
+  * Use [[UmpAuthActionBuilder]] Action if it should only proceed when there is a valid UmpToken.
   */
 @Singleton
 class VerifySignInStatus @Inject()(
@@ -47,8 +47,8 @@ class VerifySignInStatus @Inject()(
 
     request.session.get(UmpToken.SESSION_KEY_NAME) match {
       case Some(token) =>
-        userManagementAuthConnector.isValid(UmpToken(token)).flatMap { isValid =>
-          block(UmpVerifiedRequest(request, cc.messagesApi, isSignedIn = isValid))
+        userManagementAuthConnector.getUser(UmpToken(token)).flatMap { optUser =>
+          block(UmpVerifiedRequest(request, cc.messagesApi, isSignedIn = optUser.isDefined))
         }
       case None =>
         block(UmpVerifiedRequest(request, cc.messagesApi, isSignedIn = false))

app/uk/gov/hmrc/cataloguefrontend/actions/VerifySignInStatus.scala

@@ -65,20 +65,20 @@ class UserManagementAuthConnector @Inject()(
     )
   }
 
-  def isValid(umpToken: UmpToken)(implicit headerCarrier: HeaderCarrier): Future[Boolean] = {
-    val responseReads: HttpReads[Boolean] = new HttpReads[Boolean] {
-      def read(method: String, url: String, response: HttpResponse): Boolean =
+  def getUser(umpToken: UmpToken)(implicit headerCarrier: HeaderCarrier): Future[Option[User]] = {
+    val responseReads = new HttpReads[Option[User]] {
+      def read(method: String, url: String, response: HttpResponse): Option[User] =
         response.status match {
-          case OK                       => true
-          case UNAUTHORIZED | FORBIDDEN => false
+          case OK                       => val groups = (response.json \ "groups").as[List[String]]
+                                           Some(User(groups))
+          case UNAUTHORIZED | FORBIDDEN => None
           case other                    => throw new BadGatewayException(s"Received $other from $method to $url")
         }
     }
 
     val headerCarrierWithToken = headerCarrier.withExtraHeaders("Token" -> umpToken.value)
     http.GET(s"$baseUrl/v1/login")(responseReads, headerCarrierWithToken, implicitly[ExecutionContext])
   }
-
 }
 
 @Singleton
@@ -112,4 +112,8 @@ object UserManagementAuthConnector {
   type UmpUnauthorized = UmpUnauthorized.type
   case object UmpUnauthorized
 
+  final case class User(
+    groups: List[String]
+  )
+
 }

app/uk/gov/hmrc/cataloguefrontend/connector/UserManagementAuthConnector.scala

@@ -33,4 +33,7 @@ class CatalogueErrorHandler @Inject()(val messagesApi: MessagesApi) extends Fron
   override def notFoundTemplate(implicit request: Request[_]): Html =
     error_404_template()
 
+  def forbiddenTemplate(implicit request: Request[_]): Html =
+    error_403_template()
+
 }

app/uk/gov/hmrc/cataloguefrontend/service/CatalogueErrorHandler.scala

@@ -32,10 +32,10 @@ class RouteRulesService @Inject()(
     )
 
   def serviceUrl(serviceName: String, environment: String = "production")(implicit hc: HeaderCarrier): Future[Option[EnvironmentRoute]] =
-    routeRulesConnector.serviceRoutes(serviceName).map(environmentRoutes => {
+    routeRulesConnector.serviceRoutes(serviceName).map(environmentRoutes =>
       environmentRoutes
         .find(environmentRoute => environmentRoute.environment == environment)
-    })
+    )
 }
 
 @Singleton