Assuming we'll be generalizing the base monad at some point, perhaps something like this would allow both:
trait BaseMonadicActions[F[_]] {
implicit def optionToStepOps[A](option: Option[A]): StepTOps[F, A, Unit] = ???
...
}
trait ScalazMonadicActions[F[_]] {
implicit def disjunctionToStepOps[A, B](disjunction: A \/ B): StepTOps[F, B, A] = ???
...
}
trait MonadicActions extends BaseMonadicActions[Future] // backward compatibility
object io.kanaka.play.future extends BaseMonadicActions[Future]
object io.kanaka.play.compat.scalaz.future extends ScalazMonadicActions[Future]
class ControllerViaTraits() extends Controller with BaseMonadicActions[Future] with ScalazMonadicActions[Future] {
...
}
class ControllerViaImports() extends Controller {
import io.kanaka.play.future._
import io.kanaka.play.compat.scalaz.future._
...
}
Any initial thoughts here? I can flesh this out into a PR (without the base monad generalization initially) if you want to see more.
I'm a little more busy than usual right now, and it will be difficult to think more deeply about this during the next days
The layout you propose looks cleaner, I was thinking about something similar (without the carrier monad parametrization)
A thing that's worth keeping at mind is that at the end, even with another carrier monad, we need to end up with a
Future[Either[Result, Result]] (that we "merge" to finally get a suitable Future[Result])
- upgraded to play 2.5.3
- removed the
MonadicActionstrait
- moved everything under
io.kanaka.monadic.dsl(users only have to importio.kanaka.monadic.dsl._to get the goodies)
- got rid of the
ExecutionContextinStep, it is now passed via an implicit parameter everywhere (meaning that users must have an implicitExecutionContextin scope for the DSL to work)
I think we're ready for a first release candidate (I'm not yet settled on the idea of generalizing the base monad), we need to update the README though
2.0 has been merged into master
Hi! I have a case where I am retrieving an optional user (to see whether there exists already a user with the email adress that tries to sign up). And the happy path would be the case when there is None returned (then signup process goes on). Otherwise I want to return and tell the user that his email is already signed up. For me, the library seems not to be designed for such a use case. But maybe you can tell me some smart way to do it? Here is the code I want to transform:
def submit = silhouette.UnsecuredAction.async { implicit request: Request[AnyContent] =>
SignUpForm.form.bindFromRequest.fold(
form => Future.successful(BadRequest(views.html.signUp(form))),
data => {
val result = Redirect(routes.SignUpController.view()).flashing("info" -> Messages("sign.up.email.sent", data.email))
val loginInfo = LoginInfo(CredentialsProvider.ID, data.email)
userService.retrieve(loginInfo).flatMap {
case Some(user) =>
val url = routes.SignInController.view().absoluteURL()
mailerClient.send(Email(
subject = Messages("email.already.signed.up.subject"),
from = Messages("email.from"),
to = Seq(data.email),
bodyText = Some(views.txt.emails.alreadySignedUp(user, url).body),
bodyHtml = Some(views.html.emails.alreadySignedUp(user, url).body)
))
Future.successful(result)
case None =>
val authInfo = passwordHasherRegistry.current.hash(data.password)
val user = User(
userID = UUID.randomUUID(),
loginInfo = loginInfo,
firstName = Some(data.firstName),
lastName = Some(data.lastName),
fullName = Some(data.firstName + " " + data.lastName),
email = Some(data.email),
avatarURL = None,
activated = false
)
for {
avatar <- avatarService.retrieveURL(data.email)
user <- userService.save(user.copy(avatarURL = avatar))
authInfo <- authInfoRepository.add(loginInfo, authInfo)
authToken <- authTokenService.create(user.userID)
} yield {
val url = routes.ActivateAccountController.activate(authToken.id).absoluteURL()
mailerClient.send(Email(
subject = Messages("email.sign.up.subject"),
from = Messages("email.from"),
to = Seq(data.email),
bodyText = Some(views.txt.emails.signUp(user, url).body),
bodyHtml = Some(views.html.emails.signUp(user, url).body)
))
silhouette.env.eventBus.publish(SignUpEvent(user, request))
result
}
}
}(from here)
You're right, what you want isn't achievable out of the box, but you can map your
Future[Option] to a Future[Either[UserAlreadyDefined, Unit]]