Updated external user service to return email. The email is a new identifier.

app/controllers/AuthController.scala

@@ -2,13 +2,13 @@ package controllers
 
 import javax.inject.Inject
 
-import _root_.services.CredentialsVerificationService
+import _root_.services.{UserService, CredentialsVerificationService}
 import com.mohiva.play.silhouette.api._
 import com.mohiva.play.silhouette.api.util.Clock
 import com.mohiva.play.silhouette.impl.authenticators.CookieAuthenticator
 import models.User
 import play.api.data.Form
-import play.api.data.Forms._
+import play.api.data.Forms.{email =>_, _}
 import play.api.i18n.{Messages, MessagesApi}
 import play.api.libs.concurrent.Execution.Implicits._
 
@@ -20,7 +20,8 @@ class AuthController @Inject() (
   val messagesApi: MessagesApi,
   val env: Environment[User, CookieAuthenticator],
   clock: Clock,
-  credentialsVerificationService: CredentialsVerificationService
+  credentialsVerificationService: CredentialsVerificationService,
+  userService: UserService
 ) extends AuthenticatedController {
 
   val signInForm = Form(mapping(
@@ -41,16 +42,19 @@ class AuthController @Inject() (
       formWithErrors => Future.successful(BadRequest(views.html.auth.signIn(formWithErrors/*, socialProviderRegistry*/))),
       loginRequest => {
         credentialsVerificationService.verifyCredentials(loginRequest.username, loginRequest.password).flatMap{
-          case true =>
+          case Right(email) =>
-            val loginInfo: LoginInfo = LoginInfo(providerID = "credentials-verification", providerKey = loginRequest.username)
+            val loginInfo: LoginInfo = LoginInfo(providerID = "credentials-verification", providerKey = email)
-            val user: User = User(username = loginRequest.username)
+            for{
-            env.authenticatorService.create(loginInfo) flatMap { authenticator =>
+              userOption <- userService.retrieve(loginInfo)
-              env.eventBus.publish(LoginEvent(user, request, implicitly[Messages]))
+              user = userOption.getOrElse(???)
-              env.authenticatorService.init(authenticator).flatMap(cookie =>
+              authenticator <- env.authenticatorService.create(loginInfo)
+              _ = env.eventBus.publish(LoginEvent(user, request, implicitly[Messages]))
+              res <- env.authenticatorService.init(authenticator).flatMap(cookie =>
                 env.authenticatorService.embed(cookie.copy(secure = request.secure), Redirect(routes.Application.index(Map())))
               )
-            }
+            } yield res
-          case false => Future.successful(Redirect(routes.AuthController.signIn()).flashing("error" -> Messages("invalid.credentials")))
+          case Left(errorMessage) =>
+            Future.successful(Redirect(routes.AuthController.signIn()).flashing("error" -> Messages("invalid.credentials")))
         }
       }
     )

app/models/User.scala

@@ -1,5 +1,7 @@
 package models
 
-import com.mohiva.play.silhouette.api.Identity
+import com.mohiva.play.silhouette.api.{LoginInfo, Identity}
 
-case class User(username: String) extends Identity
+case class User(username: String) extends Identity{
+  def loginInfo = LoginInfo(providerID = "credentials-verification", providerKey = username)
+}

app/services/AllowAllCredentialsVerificationService.scala

@@ -8,6 +8,6 @@ class AllowAllCredentialsVerificationService(app: play.api.Application) extends
     sys.error("allow-all can be used in dev mode only")
   }
 
-  override def verifyCredentials(username: String, password: String): Future[Boolean] = Future.successful(true)
+  override def verifyCredentials(username: String, password: String): Future[Either[String, String]] = Future.successful(Right(username))
 
 }

app/services/CredentialsVerificationService.scala

@@ -3,5 +3,5 @@ package services
 import scala.concurrent.Future
 
 trait CredentialsVerificationService {
-  def verifyCredentials(username: String, password: String): Future[Boolean]
+  def verifyCredentials(username: String, password: String): Future[Either[String, String]]
 }

app/services/ExternalCredentialsVerificationService.scala

@@ -5,12 +5,18 @@ import play.api.libs.ws.{WS, WSClient}
 
 import scala.concurrent.{Future, ExecutionContext}
 
+case class LoginResponse(error: Option[String], email: Option[String])
+
 class ExternalCredentialsVerificationService(url: String)(implicit executionContext: ExecutionContext, wSClient: WSClient) extends CredentialsVerificationService{
-  override def verifyCredentials(username: String, password: String): Future[Boolean] = {
+
+  private implicit val loginResponseFormat = Json.format[LoginResponse]
+
+  override def verifyCredentials(username: String, password: String): Future[Either[String, String]] = {
     WS.clientUrl(url).post(Json.toJson(Map("username" -> username, "password" -> password))).map{ response =>
-      response.body match {
+      val loginResponse = loginResponseFormat.reads(response.json).get
-        case "OK" => true
+      loginResponse.error match {
-        case "bad" => false
+        case Some(err) => Left(err)
+        case None => Right(loginResponse.email.get)
       }
     }
   }