Puis-je faire une validation asynchrone du formulaire dans le cadre de jeu 2.x (Scala)?

j'ai eu du mal avec cela, aussi. Les applications réalistes vont généralement avoir une sorte de comptes d'utilisateur et d'authentification. Au lieu de bloquer le thread, une alternative serait de sortir les paramètres de la forme et de gérer l'appel d'authentification dans la méthode du controller elle-même, quelque chose comme ceci:

def authenticate = Action { implicit request =>
  Async {
    val (username, password) = loginForm.bindFromRequest.get
    User.authenticate(username, password).map { user =>
      user match {
        case Some(u: User) => Redirect(routes.Application.index).withSession("username" -> username)
        case None => Redirect(routes.Application.login).withNewSession.flashing("Login Failed" -> "Invalid username or password.")
      }
    }
  }
}

validation du formulaire signifie validation syntaxique des Champs, un par un. Si une demande ne réussit pas la validation, elle peut être marquée (p. ex. barre rouge avec message).

Authentification doit être placé dans le corps de l'action, qui peut être dans un bloc Async. Il devrait être après le bindFromRequest appel, donc il y a moi, après la validation, donc après chaque champ n'est pas vide, etc.

basé sur le résultat des appels asynchrones (ex. ReactiveMongo appels) le résultat de l'action peut être soit BadRequest, soit Ok.

les deux avec BadRequest et Ok peuvent rejouer le formulaire avec un message d'erreur si l'authentification échoue. Ces helpers ne spécifient que le code de statut HTTP de la réponse, indépendamment du corps de la réponse.

ce serait une solution élégante de faire L'authentification avec play.api.mvc.Security.Authenticated (ou écrivez un compositor d'action similaire et personnalisé), et utilisez des messages Flash scoped. Ainsi, l'utilisateur sera redirigé vers la page de connexion, si elle n'est pas authentifié, mais si elle soumet le formulaire de connexion avec de mauvaises références, le message d'erreur sera affiché en plus de la redirection.

veuillez jeter un oeil à L'exemple de ZenTasks de votre installation de jeu.

la même question était demande dans la Play liste de diffusion avec Johan Andrén la réponse:

Je déplacerais l'authentification actuelle hors de la validation du formulaire et le ferais dans votre action à la place et utiliserais la validation seulement pour la validation des champs requis, etc. Quelque chose comme ceci:

val loginForm = Form(
  tuple(
    "email" -> email,
    "password" -> text
  )
)

def authenticate = Action { implicit request =>
  loginForm.bindFromRequest.fold(
    formWithErrors => BadRequest(html.login(formWithErrors)),
    auth => Async {
      User.authenticate(auth._1, auth._2).map { maybeUser =>
        maybeUser.map(user => gotoLoginSucceeded(user.get.id))
        .getOrElse(... failed login page ...)
      }
    }
  )
}

j'ai vu sur le guardian's GH repo comment ils gèrent ce scénario de manière asynchrone tout en ayant toujours le support des helpers d'erreur de forme du jeu. À partir d'un rapide coup d'œil, semble qu'ils sont stocker les erreurs de forme dans un cookie crypté de manière à afficher ces erreurs à l'utilisateur la prochaine fois que l'utilisateur accède à la page de connexion.

Extrait à partir de: https://github.com/guardian/facia-tool/blob/9ec455804edbd104861117d477de9a0565776767/identity/app/controllers/ReauthenticationController.scala

def processForm = authenticatedActions.authActionWithUser.async { implicit request =>
  val idRequest = idRequestParser(request)
  val boundForm = formWithConstraints.bindFromRequest
  val verifiedReturnUrlAsOpt = returnUrlVerifier.getVerifiedReturnUrl(request)

  def onError(formWithErrors: Form[String]): Future[Result] = {
    logger.info("Invalid reauthentication form submission")
    Future.successful {
      redirectToSigninPage(formWithErrors, verifiedReturnUrlAsOpt)
    }
  }

  def onSuccess(password: String): Future[Result] = {
      logger.trace("reauthenticating with ID API")
      val persistent = request.user.auth match {
        case ScGuU(_, v) => v.isPersistent
        case _ => false
      }
      val auth = EmailPassword(request.user.primaryEmailAddress, password, idRequest.clientIp)
      val authResponse = api.authBrowser(auth, idRequest.trackingData, Some(persistent))

      signInService.getCookies(authResponse, persistent) map {
        case Left(errors) =>
          logger.error(errors.toString())
          logger.info(s"Reauthentication failed for user, ${errors.toString()}")
          val formWithErrors = errors.foldLeft(boundForm) { (formFold, error) =>
            val errorMessage =
              if ("Invalid email or password" == error.message) Messages("error.login")
              else error.description
            formFold.withError(error.context.getOrElse(""), errorMessage)
          }

          redirectToSigninPage(formWithErrors, verifiedReturnUrlAsOpt)

        case Right(responseCookies) =>
          logger.trace("Logging user in")
          SeeOther(verifiedReturnUrlAsOpt.getOrElse(returnUrlVerifier.defaultReturnUrl))
            .withCookies(responseCookies:_*)
      }
  }

  boundForm.fold[Future[Result]](onError, onSuccess)
}

def redirectToSigninPage(formWithErrors: Form[String], returnUrl: Option[String]): Result = {
  NoCache(SeeOther(routes.ReauthenticationController.renderForm(returnUrl).url).flashing(clearPassword(formWithErrors).toFlash))
}