Merge pull request #245 from hmrc/VER-4608

VER-4608 - removal of deprecated GA events

accessibility/PersonalDetailsPageSpec.scala → accessibility/AllySpec.scala

@@ -30,7 +30,6 @@ import uk.gov.hmrc.config.{AppConfig, DwpMessagesApiProvider}
 import uk.gov.hmrc.personaldetailsvalidation.connectors.IdentityVerificationConnector
 import uk.gov.hmrc.personaldetailsvalidation.generators.ValuesGenerators
 import uk.gov.hmrc.personaldetailsvalidation.model.CompletionUrl
-import uk.gov.hmrc.personaldetailsvalidation.monitoring.EventDispatcher
 import uk.gov.hmrc.personaldetailsvalidation.monitoring.dataStreamAudit.DataStreamAuditService
 import uk.gov.hmrc.personaldetailsvalidation.views.html.pages._
 import uk.gov.hmrc.personaldetailsvalidation.views.html.template.{do_you_have_your_nino, enter_your_details, what_is_your_nino, what_is_your_postcode}
@@ -65,7 +64,7 @@ class AllySpec extends UnitSpec with GuiceOneAppPerSuite with AccessibilityMatch
 
     "return the enter your details page" in new Setup {
 
-      val result: Future[Result] = controller.enterYourDetails(url, false, failureUrl)(fakeRequest)
+      val result: Future[Result] = controller.enterYourDetails(url, withError = false, failureUrl)(fakeRequest)
       status(result) shouldBe Status.OK
       contentAsString(result) should passAccessibilityChecks
     }
@@ -75,13 +74,12 @@ class AllySpec extends UnitSpec with GuiceOneAppPerSuite with AccessibilityMatch
 
     lazy val appConfig: AppConfig = app.injector.instanceOf[AppConfig]
 
-    implicit val mockDwpMessagesApi = app.injector.instanceOf[DwpMessagesApiProvider]
-    implicit val authConnector = app.injector.instanceOf[AuthConnector]
-    implicit val executionContext = app.injector.instanceOf[ExecutionContext]
+    implicit val mockDwpMessagesApi: DwpMessagesApiProvider = app.injector.instanceOf[DwpMessagesApiProvider]
+    implicit val authConnector: AuthConnector = app.injector.instanceOf[AuthConnector]
+    implicit val executionContext: ExecutionContext = app.injector.instanceOf[ExecutionContext]
 
     private val personalDetailsSubmission: PersonalDetailsSubmission = app.injector.instanceOf[PersonalDetailsSubmission]
     private val dataStreamAuditService: DataStreamAuditService = app.injector.instanceOf[DataStreamAuditService]
-    private val eventDispatcher: EventDispatcher = app.injector.instanceOf[EventDispatcher]
     private val controllerComponents: DefaultMessagesControllerComponents = app.injector.instanceOf[DefaultMessagesControllerComponents]
     private val enter_your_details: enter_your_details = app.injector.instanceOf[enter_your_details]
     private val do_you_have_your_nino: do_you_have_your_nino = app.injector.instanceOf[do_you_have_your_nino]
@@ -100,7 +98,6 @@ class AllySpec extends UnitSpec with GuiceOneAppPerSuite with AccessibilityMatch
         personalDetailsSubmission,
         appConfig,
         dataStreamAuditService,
-        eventDispatcher,
         controllerComponents,
         what_is_your_postcode,
         what_is_your_nino,

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

@@ -35,11 +35,6 @@ class AppConfig @Inject()(val configuration: Configuration, servicesConfig: Serv
   //Lockout
   lazy val retryLimit: Int = configuration.getOptional[Int]("retry.limit").getOrElse(5)
 
-  //GA related configs
-  lazy val platformAnalyticsUrl: String = servicesConfig.baseUrl("platform-analytics")
-  def analyticsToken: String = configuration.getOptional[String]("google-analytics.token").getOrElse("")
-  lazy val originDimension: Int = configuration.get[Int]("google-analytics.origin-dimension")
-
   //logout related configs
   lazy val logoutPage: String = servicesConfig.getConfString("logoutPage", "https://www.access.service.gov.uk/logout")
   lazy val basGatewayUrl: String = servicesConfig.getConfString("auth.bas-gateway.url", throw new RuntimeException("Bas gateway url required"))

app/uk/gov/hmrc/personaldetailsvalidation/endpoints/PersonalDetailsCollectionController.scala

@@ -43,7 +43,6 @@ import scala.concurrent.{ExecutionContext, Future}
 class PersonalDetailsCollectionController @Inject()(personalDetailsSubmission: PersonalDetailsSubmission,
                                                     appConfig: AppConfig,
                                                     dataStreamAuditService: DataStreamAuditService,
-                                                    val eventDispatcher: EventDispatcher,
                                                     val controllerComponents: MessagesControllerComponents,
                                                     what_is_your_postcode: what_is_your_postcode,
                                                     what_is_your_nino: what_is_your_nino,
@@ -90,7 +89,6 @@ class PersonalDetailsCollectionController @Inject()(personalDetailsSubmission: P
     }
 
   def enterYourDetails(completionUrl: CompletionUrl, withError: Boolean = false, failureUrl: Option[CompletionUrl], maybeRetryGuidanceText: Option[String] = None): Action[AnyContent] = Action.async { implicit request =>
-    maybeRetryGuidanceText foreach (retryGuidanceText => eventDispatcher.dispatchEvent(PdvRetry(retryGuidanceText)))
     viewConfig.isLoggedIn.map { isLoggedIn: Boolean =>
       if (withError) {
         Ok(enter_your_details(initialForm.withGlobalError("personal-details.validation.failed"), completionUrl, loggedInUser = isLoggedIn, failureUrl))
@@ -237,13 +235,11 @@ class PersonalDetailsCollectionController @Inject()(personalDetailsSubmission: P
               val isSA = origin == "bta-sa" || origin == "pta-sa" || origin == "ssttp-sa"
               val pdvFailedAttempt = PdvFailedAttempt(attempt, appConfig.retryLimit, personalDetails.journeyVersion, maybeCredId, origin)
               dataStreamAuditService.audit(pdvFailedAttempt)
-              eventDispatcher.dispatchEvent(pdvFailedAttempt.copy(attempts = attemptsRemaining))
               if (isSA) Redirect(routes.PersonalDetailsCollectionController.incorrectDetailsForSa(completionUrl, attemptsRemaining, failureUrl)).withSession(cleanedSession)
               else Redirect(routes.PersonalDetailsCollectionController.incorrectDetails(completionUrl, attemptsRemaining, failureUrl)).withSession(cleanedSession)
             } else {
               val pdvLockedOut = PdvLockedOut(personalDetails.journeyVersion, maybeCredId, origin)
               dataStreamAuditService.audit(pdvLockedOut)
-              eventDispatcher.dispatchEvent(pdvLockedOut)
               if (failureUrl.isDefined) {
                 Redirect(failureUrl.get.value).withSession(cleanedSession)
               } else {
@@ -260,7 +256,6 @@ class PersonalDetailsCollectionController @Inject()(personalDetailsSubmission: P
   }.recover {
     case _: Exception =>
       if (appConfig.enabledCircuitBreaker) {
-        eventDispatcher.dispatchEvent(PDVServiceUnavailable())
         Redirect(routes.PersonalDetailsCollectionController.serviceTemporarilyUnavailable())
       }
       else {
@@ -275,7 +270,6 @@ class PersonalDetailsCollectionController @Inject()(personalDetailsSubmission: P
     * redirect user to the completionUrl with a timeout status
     */
   def redirectAfterTimeout(completionUrl: CompletionUrl, failureUrl: Option[CompletionUrl]): Action[AnyContent] = Action.async { implicit request =>
-    eventDispatcher.dispatchEvent(TimedOut())
     ivConnector.updateJourney(completionUrl.value, "Timeout")
     val redirectUrl: String = if (failureUrl.isDefined) {failureUrl.get.value} else {completionUrl.value}
     Future.successful(Redirect(redirectUrl, Map("userTimeout" -> Seq(""))))
@@ -294,13 +288,11 @@ class PersonalDetailsCollectionController @Inject()(personalDetailsSubmission: P
     * Endpoint which just has the side-effect of extending the Play session to avoid (the 15 min) timeout
     *
     * */
-  def keepAlive: Action[AnyContent] = Action.async { implicit request =>
-    eventDispatcher.dispatchEvent(TimeoutContinue())
+  def keepAlive: Action[AnyContent] = Action.async {
     Future.successful(Ok("OK"))
   }
 
   def weCannotCheckYourIdentity(): Action[AnyContent] = Action.async { implicit request =>
-    eventDispatcher.dispatchEvent(UnderNinoAge())
     Future.successful(Ok(weCannotCheckYourIdentityPage()))
   }
 

app/uk/gov/hmrc/personaldetailsvalidation/endpoints/PersonalDetailsSubmission.scala

@@ -36,9 +36,7 @@ class PersonalDetailsSubmission @Inject()(personalDetailsValidationConnector: Pe
                            (implicit request: Request[_],
                             headerCarrier: HeaderCarrier): Future[PersonalDetailsValidation] = {
     val origin = request.session.get("origin").getOrElse("Unknown-Origin")
-    val gaClientId: Option[String] = request.cookies.get("_ga").map(_.value)
-    val hc: HeaderCarrier = headerCarrier.copy(otherHeaders = Seq("_ga" -> gaClientId.getOrElse("")))
-    personalDetailsValidationConnector.submitValidationRequest(personalDetails, origin, hc)
+    personalDetailsValidationConnector.submitValidationRequest(personalDetails, origin, headerCarrier)
   }
 
   private val UUIDRegex = """[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89aAbB][a-f0-9]{3}-[a-f0-9]{12}"""

app/uk/gov/hmrc/personaldetailsvalidation/endpoints/PersonalDetailsValidationStartController.scala

@@ -18,20 +18,16 @@ package uk.gov.hmrc.personaldetailsvalidation.endpoints
 
 import play.api.mvc.{Action, AnyContent, MessagesControllerComponents}
 import uk.gov.hmrc.personaldetailsvalidation.model.CompletionUrl
-import uk.gov.hmrc.personaldetailsvalidation.monitoring.{BeginPDV, EventDispatcher}
 import uk.gov.hmrc.play.bootstrap.frontend.controller.FrontendController
 
 import javax.inject.{Inject, Singleton}
-import scala.concurrent.ExecutionContext
 
 @Singleton
 class PersonalDetailsValidationStartController @Inject()(journeyStart: JourneyStart,
-                                                         eventDispatcher: EventDispatcher,
-                                                         mcc: MessagesControllerComponents)(implicit ec: ExecutionContext)
+                                                         mcc: MessagesControllerComponents)
   extends FrontendController(mcc) {
 
   def start(completionUrl: CompletionUrl, origin: Option[String], failureUrl: Option[CompletionUrl]): Action[AnyContent] = Action.async { implicit request =>
-    eventDispatcher.dispatchEvent(BeginPDV())
     journeyStart.findRedirect(completionUrl, origin, failureUrl)
   }
 }

app/uk/gov/hmrc/personaldetailsvalidation/endpoints/SignOutController.scala

@@ -18,20 +18,17 @@ package uk.gov.hmrc.personaldetailsvalidation.endpoints
 
 import play.api.mvc.{Action, AnyContent, MessagesControllerComponents}
 import uk.gov.hmrc.config.AppConfig
-import uk.gov.hmrc.personaldetailsvalidation.monitoring.{EventDispatcher, SignedOut}
 import uk.gov.hmrc.play.bootstrap.frontend.controller.FrontendController
 
 import javax.inject.{Inject, Singleton}
-import scala.concurrent.{ExecutionContext, Future}
+import scala.concurrent.Future
 
 @Singleton
-class SignOutController @Inject()(cc: MessagesControllerComponents, eventDispatcher: EventDispatcher)
-                                 (implicit appConfig: AppConfig, executionContext: ExecutionContext)
+class SignOutController @Inject()(cc: MessagesControllerComponents)
+                                 (implicit appConfig: AppConfig)
   extends FrontendController(cc) {
 
-  def signOut(): Action[AnyContent] = Action.async { implicit request =>
-
-    eventDispatcher.dispatchEvent(SignedOut())
+  def signOut(): Action[AnyContent] = Action.async {
 
     val ggRedirectParms = Map(
       "continue" -> Seq(s"${appConfig.logoutCallback}"),