chore: rebase

knockoutwhistweb/app/controllers/HomeController.scala

@@ -1,89 +0,0 @@
-package controllers
-
-import com.google.inject.{Guice, Injector}
-import de.knockoutwhist.KnockOutWhist
-import de.knockoutwhist.components.Configuration
-import de.knockoutwhist.control.GameState.{InGame, Lobby, SelectTrump, TieBreak}
-import de.knockoutwhist.control.controllerBaseImpl.BaseGameLogic
-import di.KnockOutWebConfigurationModule
-import logic.PodManager
-import model.sessions.SimpleSession
-import play.api.mvc.*
-import play.api.*
-import play.twirl.api.Html
-
-import java.util.UUID
-import javax.inject.*
-
-
-/**
- * This controller creates an `Action` to handle HTTP requests to the
- * application's home page.
- */
-@Singleton
-class HomeController @Inject()(val controllerComponents: ControllerComponents) extends BaseController {
-
-  private var initial = false
-  private val injector: Injector = Guice.createInjector(KnockOutWebConfigurationModule())
-
-  /**
-   * Create an Action to render an HTML page.
-   *
-   * The configuration in the `routes` file means that this method
-   * will be called when the application receives a `GET` request with
-   * a path of `/`.
-   */
-  def index(): Action[AnyContent] = {
-    if (!initial) {
-      initial = true
-      KnockOutWhist.entry(injector.getInstance(classOf[Configuration]))
-    }
-    Action { implicit request =>
-      Redirect("/sessions")
-    }
-  }
-  def rules(): Action[AnyContent] = {
-    Action { implicit request =>
-      Ok(views.html.rules())
-    }
-  }
-  def sessions(): Action[AnyContent] = {
-    Action { implicit request =>
-      Ok(views.html.rules())
-    }
-  }
-
-  def ingame(id: String): Action[AnyContent] = {
-    val uuid: UUID = UUID.fromString(id)
-    Action { implicit request =>
-      NotFound(views.html.tui.apply(List(Html(s"<p>Session with id $id not found!</p>"))))
-    }
-//    if (PodGameManager.identify(uuid).isEmpty) {
-//      return Action { implicit request =>
-//        NotFound(views.html.tui.apply(List(Html(s"<p>Session with id $id not found!</p>"))))
-//      }
-//    } else {
-//      val session = PodGameManager.identify(uuid).get
-//      val player = session.asInstanceOf[SimpleSession].player
-//      val logic = BaseGameLogic(null)
-//      if (logic.getCurrentState == Lobby) {
-//
-//      } else if (logic.getCurrentState == InGame) {
-//        return Action { implicit request =>
-//          Ok(views.html.ingame.apply(player, logic))
-//        }
-//      } else if (logic.getCurrentState == SelectTrump) {
-//        return Action { implicit request =>
-//          Ok(views.html.selecttrump.apply(player, logic))
-//        }
-//      } else if (logic.getCurrentState == TieBreak) {
-//        return Action { implicit request =>
-//          Ok(views.html.tie.apply(player, logic))
-//        }
-//      }
-//    }
-//    Action { implicit request =>
-//      InternalServerError("Oops")
-//    }
-  }
-}

knockoutwhistweb/app/controllers/IngameController.scala

@@ -0,0 +1,75 @@
+package controllers
+
+import auth.{AuthAction, AuthenticatedRequest}
+import logic.user.{SessionManager, UserManager}
+import play.api.*
+import play.api.mvc.*
+
+import javax.inject.*
+
+
+/**
+ * This controller creates an `Action` to handle HTTP requests to the
+ * application's home page.
+ */
+@Singleton
+class IngameController @Inject()(
+                                val controllerComponents: ControllerComponents,
+                                val sessionManager: SessionManager,
+                                val userManager: UserManager,
+                                val authAction: AuthAction
+                              ) extends BaseController {
+
+  // Pass the request-handling function directly to authAction (no nested Action)
+  def mainMenu(): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
+    Ok("Main Menu for user: " + request.user.name)
+  }
+
+  def login(): Action[AnyContent] = {
+    Action { implicit request =>
+      val session = request.cookies.get("sessionId")
+      if (session.isDefined) {
+        val possibleUser = sessionManager.getUserBySession(session.get.value)
+        if (possibleUser.isDefined) {
+          Redirect("/mainmenu")
+        } else {
+          Ok(views.html.login())
+        }
+      } else {
+        Ok(views.html.login())
+      }
+    }
+  }
+
+  def login_Post(): Action[AnyContent] = {
+    Action { implicit request =>
+      val postData = request.body.asFormUrlEncoded
+      if (postData.isDefined) {
+        // Extract username and password from form data
+        val username = postData.get.get("username").flatMap(_.headOption).getOrElse("")
+        val password = postData.get.get("password").flatMap(_.headOption).getOrElse("")
+        val possibleUser = userManager.authenticate(username, password)
+        if (possibleUser.isDefined) {
+          Redirect("/mainmenu").withCookies(
+            Cookie("sessionId", sessionManager.createSession(possibleUser.get))
+          )
+        } else {
+          println("Failed login attempt for user: " + username)
+          Unauthorized("Invalid username or password")
+        }
+      } else {
+        BadRequest("Invalid form submission")
+      }
+    }
+  }
+
+  // Pass the request-handling function directly to authAction (no nested Action)
+  def logout(): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
+    val sessionCookie = request.cookies.get("sessionId")
+    if (sessionCookie.isDefined) {
+      sessionManager.invalidateSession(sessionCookie.get.value)
+    }
+    NoContent.discardingCookies(DiscardingCookie("sessionId"))
+  }
+
+}

knockoutwhistweb/app/controllers/MainMenuController.scala

@@ -0,0 +1,35 @@
+package controllers
+
+import auth.{AuthAction, AuthenticatedRequest}
+import play.api.*
+import play.api.mvc.*
+
+import javax.inject.*
+
+
+/**
+ * This controller creates an `Action` to handle HTTP requests to the
+ * application's home page.
+ */
+@Singleton
+class MainMenuController @Inject()(
+                                    val controllerComponents: ControllerComponents, 
+                                    val authAction: AuthAction
+                                  ) extends BaseController {
+
+  // Pass the request-handling function directly to authAction (no nested Action)
+  def mainMenu(): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
+    Ok("Main Menu for user: " + request.user.name)
+  }
+  
+  def index(): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
+    Redirect("/mainmenu")
+  }
+  
+  def rules(): Action[AnyContent] = {
+    Action { implicit request =>
+      Ok(views.html.rules())
+    }
+  }
+  
+}

knockoutwhistweb/app/controllers/UserController.scala

@@ -1,19 +1,10 @@
 package controllers
 
-import com.google.inject.{Guice, Injector}
-import de.knockoutwhist.KnockOutWhist
-import de.knockoutwhist.components.Configuration
-import de.knockoutwhist.control.GameState.{InGame, Lobby, SelectTrump, TieBreak}
-import de.knockoutwhist.control.controllerBaseImpl.BaseGameLogic
-import di.KnockOutWebConfigurationModule
-import logic.PodManager
+import auth.{AuthAction, AuthenticatedRequest}
 import logic.user.{SessionManager, UserManager}
-import model.sessions.SimpleSession
 import play.api.*
 import play.api.mvc.*
-import play.twirl.api.Html
 
-import java.util.UUID
 import javax.inject.*
 
 
@@ -22,25 +13,12 @@ import javax.inject.*
  * application's home page.
  */
 @Singleton
-class UserController @Inject()(val controllerComponents: ControllerComponents, val sessionManager: SessionManager, val userManager: UserManager) extends BaseController {
-
-  def mainMenu() : Action[AnyContent] = {
-    Action { implicit request =>
-      val session = request.cookies.get("sessionId")
-      if (session.isDefined) {
-        val possibleUser = sessionManager.getUserBySession(session.get.value)
-        if (possibleUser.isDefined) {
-          Ok("Main Menu for user: " + possibleUser.get.name)
-        } else
-        {
-          println("Invalid session, redirecting to login")
-          Redirect("/login")
-        }
-      } else {
-        Redirect("/login")
-      }
-    }
-  }
+class UserController @Inject()(
+                                val controllerComponents: ControllerComponents,
+                                val sessionManager: SessionManager,
+                                val userManager: UserManager,
+                                val authAction: AuthAction
+                              ) extends BaseController {
 
   def login(): Action[AnyContent] = {
     Action { implicit request =>
@@ -48,9 +26,8 @@ class UserController @Inject()(val controllerComponents: ControllerComponents, v
       if (session.isDefined) {
         val possibleUser = sessionManager.getUserBySession(session.get.value)
         if (possibleUser.isDefined) {
-          Redirect("/mainmenu")
-        } else
-        {
+          Redirect(routes.MainMenuController.mainMenu())
+        } else {
           Ok(views.html.login())
         }
       } else {
@@ -68,7 +45,7 @@ class UserController @Inject()(val controllerComponents: ControllerComponents, v
         val password = postData.get.get("password").flatMap(_.headOption).getOrElse("")
         val possibleUser = userManager.authenticate(username, password)
         if (possibleUser.isDefined) {
-          Redirect("/mainmenu").withCookies(
+          Redirect(routes.MainMenuController.mainMenu()).withCookies(
             Cookie("sessionId", sessionManager.createSession(possibleUser.get))
           )
         } else {
@@ -81,14 +58,13 @@ class UserController @Inject()(val controllerComponents: ControllerComponents, v
     }
   }
 
-  def logout(): Action[AnyContent] = {
-    Action { implicit request =>
-      val sessionCookie = request.cookies.get("sessionId")
-      if (sessionCookie.isDefined) {
-        sessionManager.invalidateSession(sessionCookie.get.value)
-      }
-      NoContent.discardingCookies(DiscardingCookie("sessionId"))
+  // Pass the request-handling function directly to authAction (no nested Action)
+  def logout(): Action[AnyContent] = authAction { implicit request: AuthenticatedRequest[AnyContent] =>
+    val sessionCookie = request.cookies.get("sessionId")
+    if (sessionCookie.isDefined) {
+      sessionManager.invalidateSession(sessionCookie.get.value)
     }
+    NoContent.discardingCookies(DiscardingCookie("sessionId"))
   }
 
 }