Migrate to Play 2.7.X

app/controllers/ApplicationController.scala

@@ -1,36 +1,40 @@
 package controllers
 
-import model.{User, UserForm}
+import javax.inject._
+import models.{User, UserForm}
+import play.api.Logging
 import play.api.mvc._
-import scala.concurrent.Future
-import service.UserService
+import services.UserService
+
 import scala.concurrent.ExecutionContext.Implicits.global
+import scala.concurrent.Future
 
-class ApplicationController extends Controller {
+@Singleton
+class ApplicationController @Inject()(cc: ControllerComponents, userService: UserService) extends AbstractController(cc) with Logging {
 
-  def index = Action.async { implicit request =>
-    UserService.listAllUsers map { users =>
+  def index() = Action.async { implicit request: Request[AnyContent] =>
+    userService.listAllUsers map { users =>
       Ok(views.html.index(UserForm.form, users))
     }
   }
 
-  def addUser() = Action.async { implicit request =>
+  def addUser() = Action.async { implicit request: Request[AnyContent] =>
     UserForm.form.bindFromRequest.fold(
       // if any error in submitted data
-      errorForm => Future.successful(Ok(views.html.index(errorForm, Seq.empty[User]))),
+      errorForm => {
+        logger.warn(s"Form submission with error: ${errorForm.errors}")
+        Future.successful(Ok(views.html.index(errorForm, Seq.empty[User])))
+      },
       data => {
         val newUser = User(0, data.firstName, data.lastName, data.mobile, data.email)
-        UserService.addUser(newUser).map(res =>
-          Redirect(routes.ApplicationController.index())
-        )
+        userService.addUser(newUser).map( _ => Redirect(routes.ApplicationController.index()))
       })
   }
 
-  def deleteUser(id: Long) = Action.async { implicit request =>
-    UserService.deleteUser(id) map { res =>
+  def deleteUser(id: Long) = Action.async { implicit request: Request[AnyContent] =>
+    userService.deleteUser(id) map { res =>
       Redirect(routes.ApplicationController.index())
     }
   }
 
 }
-

app/models/User.scala

@@ -1,13 +1,13 @@
-package model
+package models
 
-import play.api.Play
+import com.google.inject.Inject
 import play.api.data.Form
+import play.api.data.Forms.mapping
 import play.api.data.Forms._
-import play.api.db.slick.DatabaseConfigProvider
-import scala.concurrent.Future
-import slick.driver.JdbcProfile
-import slick.driver.MySQLDriver.api._
-import scala.concurrent.ExecutionContext.Implicits.global
+import play.api.db.slick.{DatabaseConfigProvider, HasDatabaseConfigProvider}
+import slick.jdbc.JdbcProfile
+
+import scala.concurrent.{ExecutionContext, Future}
 
 case class User(id: Long, firstName: String, lastName: String, mobile: Long, email: String)
 
@@ -25,6 +25,8 @@ object UserForm {
   )
 }
 
+import slick.jdbc.MySQLProfile.api._
+
 class UserTableDef(tag: Tag) extends Table[User](tag, "user") {
 
   def id = column[Long]("id", O.PrimaryKey,O.AutoInc)
@@ -37,9 +39,7 @@ class UserTableDef(tag: Tag) extends Table[User](tag, "user") {
     (id, firstName, lastName, mobile, email) <>(User.tupled, User.unapply)
 }
 
-object Users {
-
-  val dbConfig = DatabaseConfigProvider.get[JdbcProfile](Play.current)
+class Users @Inject() (protected val dbConfigProvider: DatabaseConfigProvider)(implicit executionContext: ExecutionContext) extends HasDatabaseConfigProvider[JdbcProfile] {
 
   val users = TableQuery[UserTableDef]
 
@@ -58,7 +58,7 @@ object Users {
   }
 
   def listAll: Future[Seq[User]] = {
-    dbConfig.db.run(users.result)
+   dbConfig.db.run(users.result)
   }
 
 }

app/services/UserService.scala

@@ -1,23 +1,25 @@
-package service
+package services
+
+import com.google.inject.Inject
+import models.{User, Users}
 
-import model.{User, Users}
 import scala.concurrent.Future
 
-object UserService {
+class UserService @Inject() (users: Users) {
 
   def addUser(user: User): Future[String] = {
-    Users.add(user)
+    users.add(user)
   }
 
   def deleteUser(id: Long): Future[Int] = {
-    Users.delete(id)
+    users.delete(id)
   }
 
   def getUser(id: Long): Future[Option[User]] = {
-    Users.get(id)
+    users.get(id)
   }
 
   def listAllUsers: Future[Seq[User]] = {
-    Users.listAll
+    users.listAll
   }
 }