[Sprint 8][BE] Create table user_setting and add crud for table

Author: nashtech-longlevanquoc1

backend/app/controllers/UserProfileController.scala

@@ -0,0 +1,53 @@
+package controllers
+
+import javax.inject.{Inject, Singleton}
+import play.api.mvc._
+import play.api.libs.json._
+import services.UserProfileService
+import models.entities.UserProfile
+
+import scala.concurrent.{ExecutionContext, Future}
+
+@Singleton
+class UserProfileController @Inject()(
+  val controllerComponents: ControllerComponents,
+  userProfileService: UserProfileService,
+  authenticatedAction: AuthenticatedActionWithUser
+)(implicit ec: ExecutionContext) extends BaseController {
+
+  implicit val userProfileWrites: OWrites[UserProfile] = Json.writes[UserProfile]
+
+  // Request DTO for partial updates
+  private case class UpdateUserProfileRequest(userLanguage: Option[String], themeMode: Option[String])
+  private object UpdateUserProfileRequest {
+    implicit val reads: Reads[UpdateUserProfileRequest] = Json.reads[UpdateUserProfileRequest]
+  }
+
+  def getUserProfile: Action[AnyContent] = authenticatedAction.async { request =>
+    userProfileService.getUserProfile(request.userToken.userId).map {
+      case Some(profile) => Ok(Json.toJson(profile))
+      case None => NotFound
+    }
+  }
+
+  def updateProfile: Action[JsValue] = authenticatedAction.async(parse.json) { request =>
+    request.body.validate[UpdateUserProfileRequest].fold(
+      errors => Future.successful(BadRequest(JsError.toJson(errors))),
+      dto => {
+        userProfileService.getUserProfile(request.userToken.userId).flatMap {
+          case None => Future.successful(NotFound)
+          case Some(existing) =>
+            val updated = existing.copy(
+              userLanguage = dto.userLanguage.getOrElse(existing.userLanguage),
+              themeMode = dto.themeMode.getOrElse(existing.themeMode),
+              updatedAt = java.time.LocalDateTime.now()
+            )
+            userProfileService.updateProfile(updated).map {
+              case Some(profile) => Ok(Json.toJson(profile))
+              case None => InternalServerError(Json.obj("error" -> "Failed to update profile"))
+            }
+        }
+      }
+    )
+  }
+}

backend/app/exception/AppException.scala

@@ -2,6 +2,8 @@ package exception
 
 import play.api.http.Status
 
-case class AppException(message: String, statusCode: Int = Status.BAD_REQUEST) extends RuntimeException {
-
-}
+/**
+ * Base application exception with an associated HTTP status code.
+ * Specific exceptions extend this so handlers can map them to proper HTTP responses.
+ */
+sealed abstract class AppException(message: String, val statusCode: Int = Status.BAD_REQUEST) extends RuntimeException(message)

backend/app/exception/BadRequestException.scala

@@ -0,0 +1,6 @@
+package exception
+
+import play.api.http.Status
+
+case class BadRequestException(message: String = "Bad Request", statusCode: Int = Status.BAD_REQUEST)
+  extends RuntimeException(message)

backend/app/exception/InternalException.scala

@@ -0,0 +1,6 @@
+package exception
+
+import play.api.http.Status
+
+case class InternalErrorException(message: String = "Internal Server Error", statusCode: Int = Status.INTERNAL_SERVER_ERROR)
+  extends RuntimeException(message)

backend/app/exception/NotFoundException.scala

@@ -0,0 +1,6 @@
+package exception
+
+import play.api.http.Status
+
+case class NotFoundException(message: String = "Not Found", statusCode: Int = Status.NOT_FOUND)
+  extends RuntimeException(message)

backend/app/exception/ResourceInactiveException.scala

@@ -0,0 +1,6 @@
+package exception
+
+import play.api.http.Status
+
+case class ResourceInactiveException(message: String = "Resource Inactive", statusCode: Int = Status.CONFLICT)
+  extends RuntimeException(message)

backend/app/models/entities/UserProfile.scala

@@ -0,0 +1,19 @@
+package models.entities
+
+import java.time.LocalDateTime
+
+case class UserProfile(
+  id: Int,
+  userId: Int,
+  userLanguage: String,
+  themeMode: String,
+  createdAt: LocalDateTime = LocalDateTime.now(),
+  updatedAt: LocalDateTime = LocalDateTime.now(),
+  createdBy: Option[Int] = None,
+  updatedBy: Option[Int] = None,
+)
+
+object UserProfile {
+  def apply(id: Int, userId: Int, userLanguage: String, themeMode: String, createdAt: LocalDateTime, updatedAt: LocalDateTime): UserProfile =
+    UserProfile(id, userId, userLanguage, themeMode, createdAt, updatedAt, None, None)
+}

backend/app/models/tables/UserProfileTable.scala

@@ -0,0 +1,43 @@
+package models.tables
+
+import models.entities.UserProfile
+import play.api.db.slick.HasDatabaseConfig
+import slick.jdbc.PostgresProfile
+import java.time.LocalDateTime
+
+trait UserProfileTable { self: HasDatabaseConfig[PostgresProfile] =>
+  import profile.api._
+
+  class UserProfileTable(tag: Tag) extends Table[UserProfile](tag, "user_profiles") {
+    def id = column[Int]("id", O.PrimaryKey, O.AutoInc)
+    def userId = column[Int]("user_id")
+    def userLanguage = column[String]("user_language")
+    def themeMode = column[String]("theme_mode")
+    def createdAt = column[LocalDateTime]("created_at")
+    def updatedAt = column[LocalDateTime]("updated_at")
+
+    def * = (
+      id,
+      userId,
+      userLanguage,
+      themeMode,
+      createdAt,
+      updatedAt
+    ) <> (
+      { case (id, userId, userLanguage, themeMode, createdAt, updatedAt) =>
+          UserProfile(id, userId, userLanguage, themeMode, createdAt, updatedAt)
+      },
+      (up: UserProfile) => Some((up.id, up.userId, up.userLanguage, up.themeMode, up.createdAt, up.updatedAt))
+    )
+
+    private def userFk = foreignKey(
+      "user_profile_user_fk",
+      userId,
+      TableQuery[UserTable]
+    )(_.id, onDelete = ForeignKeyAction.Cascade)
+
+    private def userIdIdx = index("user_profile_user_id_idx", userId, unique = true)
+  }
+
+  lazy val userProfiles = TableQuery[UserProfileTable]
+}

backend/app/repositories/UserProfileRepository.scala

@@ -0,0 +1,41 @@
+package repositories
+
+import javax.inject.{Inject, Singleton}
+import models.entities.UserProfile
+import models.tables.UserProfileTable
+import play.api.db.slick.{DatabaseConfigProvider, HasDatabaseConfig}
+import slick.jdbc.PostgresProfile
+import scala.concurrent.{ExecutionContext, Future}
+
+@Singleton
+class UserProfileRepository @Inject()(
+  protected val dbConfigProvider: DatabaseConfigProvider
+)(implicit ec: ExecutionContext) extends HasDatabaseConfig[PostgresProfile] with UserProfileTable {
+
+  import profile.api._
+  
+  def create(userProfile: UserProfile): Future[UserProfile] = {
+    val query = userProfiles returning userProfiles.map(_.id) into ((profile, id) => profile.copy(id = id))
+    db.run(query += userProfile)
+  }
+
+  def update(userProfile: UserProfile): Future[Int] = {
+    val query = userProfiles.filter(_.id === userProfile.id).update(userProfile)
+    db.run(query)
+  }
+
+  def findByUserId(userId: Int): Future[Option[UserProfile]] = {
+    val query = userProfiles.filter(_.userId === userId)
+    db.run(query.result.headOption)
+  }
+
+  def findById(id: Int): Future[Option[UserProfile]] = {
+    val query = userProfiles.filter(_.id === id)
+    db.run(query.result.headOption)
+  }
+
+  def delete(id: Int): Future[Int] = {
+    val query = userProfiles.filter(_.id === id).delete
+    db.run(query)
+  }
+}

backend/app/services/UserProfileService.scala

@@ -0,0 +1,27 @@
+package services
+
+import javax.inject.{Inject, Singleton}
+import models.entities.UserProfile
+import repositories.UserProfileRepository
+import scala.concurrent.{ExecutionContext, Future}
+
+@Singleton
+class UserProfileService @Inject()(
+  userProfileRepository: UserProfileRepository
+)(implicit ec: ExecutionContext) {
+
+  def createProfile(newProfile: UserProfile): Future[UserProfile] = {
+    userProfileRepository.create(newProfile)
+  }
+
+  def updateProfile(userProfile: UserProfile): Future[Option[UserProfile]] = {
+    userProfileRepository.update(userProfile).flatMap {
+      case 0 => Future.successful(None)
+      case _ => userProfileRepository.findById(userProfile.id)
+    }
+  }
+
+  def getUserProfile(userId: Int): Future[Option[UserProfile]] = {
+    userProfileRepository.findByUserId(userId)
+  }
+}