feat/BE: import project API (#40)

NhatNguyen1502 · web-flow · commit 900c6e9533e0 · 2025-10-31T13:36:47.000+07:00
diff --git a/backend/app/controllers/ProjectController.scala b/backend/app/controllers/ProjectController.scala
@@ -1,17 +1,25 @@
 package controllers
 
-import dto.request.project.CreateProjectRequest
+import dto.request.project.{CreateProjectRequest, ImportProjectData}
 import dto.response.ApiResponse
 import play.api.i18n.I18nSupport.RequestWithMessagesApi
 import play.api.i18n.Messages
-import play.api.libs.json.{JsValue, Json}
-import play.api.mvc.{Action, AnyContent, MessagesAbstractController, MessagesControllerComponents}
+import play.api.libs.Files.TemporaryFile
+import play.api.libs.json.{JsResultException, JsValue, Json}
+import play.api.mvc.{
+  Action,
+  AnyContent,
+  MessagesAbstractController,
+  MessagesControllerComponents,
+  MultipartFormData
+}
+import scoverage.Platform.Source
 import services.ProjectService
 import utils.WritesExtras.unitWrites
 import validations.ValidationHandler
 
 import javax.inject.Inject
-import scala.concurrent.ExecutionContext
+import scala.concurrent.{ExecutionContext, Future}
 
 class ProjectController @Inject()(
   cc: MessagesControllerComponents,
@@ -109,7 +117,7 @@ class ProjectController @Inject()(
       }
     }
 
-    /** GET /projects/:projectId */
+  /** GET /projects/:projectId */
   def getProjectById(projectId: Int): Action[AnyContent] =
     authenticatedActionWithUser.async { request =>
       val userId = request.userToken.userId
@@ -141,4 +149,48 @@ class ProjectController @Inject()(
         Ok(Json.toJson(apiResponse))
       }
     }
+
+  def uploadJsonFile(
+    workspaceId: Int
+  ): Action[MultipartFormData[TemporaryFile]] =
+    authenticatedActionWithUser.async(parse.multipartFormData) { request =>
+      val userId = request.userToken.userId
+
+      request.body.file("file") match {
+        case Some(uploadedFile) =>
+          val filePath = uploadedFile.ref.path.toFile
+
+          try {
+            val fileSource = Source.fromFile(filePath)("UTF-8")
+            val fileContent = try fileSource.getLines().mkString("\n")
+            finally fileSource.close()
+            val json = Json.parse(fileContent)
+
+            val data = json.as[ImportProjectData]
+
+            projectService
+              .importProject(data, userId, workspaceId)
+              .map { res =>
+                val apiResponse =
+                  ApiResponse.success("Project imported successfully", res)
+                Ok(Json.toJson(apiResponse))
+              }
+
+          } catch {
+            case _: JsResultException =>
+              Future.successful(
+                BadRequest(Json.obj("message" -> "JSON parse failed"))
+              )
+            case _: Throwable =>
+              Future.successful(
+                BadRequest(Json.obj("message" -> "Invalid JSON format"))
+              )
+          }
+
+        case None =>
+          Future.successful(
+            BadRequest(Json.obj("message" -> "No file uploaded"))
+          )
+      }
+    }
 }
diff --git a/backend/app/dto/request/project/ImportProjectData.scala b/backend/app/dto/request/project/ImportProjectData.scala
@@ -0,0 +1,15 @@
+package dto.request.project
+
+import models.entities.{Column, Project, Task, UserProject, UserTask}
+import play.api.libs.json.{Json, OFormat}
+
+case class ImportProjectData(
+                       project: Project,
+                       columns: Seq[Column],
+                       tasks: Seq[Task],
+                       userTasks: Seq[UserTask],
+                       userProjects: Seq[UserProject]
+                     )
+object ImportProjectData {
+  implicit val format: OFormat[ImportProjectData] = Json.format[ImportProjectData]
+}
diff --git a/backend/app/models/entities/Project.scala b/backend/app/models/entities/Project.scala
@@ -1,30 +1,33 @@
 package models.entities
 
 import models.Enums.ColumnStatus.ColumnStatus
-import models.Enums.{ColumnStatus, ProjectStatus, ProjectVisibility}
 import models.Enums.ProjectStatus.ProjectStatus
 import models.Enums.ProjectVisibility.ProjectVisibility
+import models.Enums.{ColumnStatus, ProjectStatus, ProjectVisibility}
+import play.api.libs.json.{Json, OFormat}
 
-import java.time.{Instant, LocalDateTime}
-
-case class Project(
-                    id: Option[Int] = None,
-                    name: String,
-                    workspaceId: Int,
-                    status: ProjectStatus = ProjectStatus.active,
-                    visibility: ProjectVisibility = ProjectVisibility.Workspace,
-                    createdBy: Option[Int] = None,
-                    updatedBy: Option[Int] = None,
-                    createdAt: Instant = Instant.now(),
-                    updatedAt: Instant = Instant.now()
-                  )
+import java.time.Instant
 
-case class Column(
-                   id: Option[Int] = None,
-                   projectId: Int,
+case class Project(id: Option[Int] = None,
                    name: String,
-                   position: Int,
+                   workspaceId: Int,
+                   status: ProjectStatus = ProjectStatus.active,
+                   visibility: ProjectVisibility = ProjectVisibility.Workspace,
+                   createdBy: Option[Int] = None,
+                   updatedBy: Option[Int] = None,
                    createdAt: Instant = Instant.now(),
-                   updatedAt: Instant = Instant.now(),
-                   status: ColumnStatus = ColumnStatus.active
-                 )
+                   updatedAt: Instant = Instant.now())
+object Project {
+  implicit val projectFormat: OFormat[Project] = Json.format[Project]
+}
+
+case class Column(id: Option[Int] = None,
+                  projectId: Int,
+                  name: String,
+                  position: Int,
+                  createdAt: Instant = Instant.now(),
+                  updatedAt: Instant = Instant.now(),
+                  status: ColumnStatus = ColumnStatus.active)
+object Column {
+  implicit val columnFormat: OFormat[Column] = Json.format[Column]
+}
diff --git a/backend/app/models/entities/Task.scala b/backend/app/models/entities/Task.scala
@@ -3,70 +3,65 @@ package models.entities
 import models.Enums.TaskPriority.TaskPriority
 import models.Enums.TaskStatus
 import models.Enums.TaskStatus.TaskStatus
+import play.api.libs.json.{Json, OFormat}
 
 import java.time.{Instant, LocalDateTime}
 
-case class Task(
-                 id: Option[Int] = None,
-                 columnId: Int,
-                 name: String,
-                 description: Option[String] = None,
-                 startDate: Option[Instant] = None,
-                 endDate: Option[Instant] = None,
-                 priority: Option[TaskPriority] = None,
-                 position: Int,
-                 createdBy: Option[Int] = None,
-                 updatedBy: Option[Int] = None,
-                 createdAt: Instant = Instant.now(),
-                 updatedAt: Instant = Instant.now(),
-                 status: TaskStatus = TaskStatus.active,
-                 isCompleted: Boolean = false
-               )
+case class Task(id: Option[Int] = None,
+                columnId: Int,
+                name: String,
+                description: Option[String] = None,
+                startDate: Option[Instant] = None,
+                endDate: Option[Instant] = None,
+                priority: Option[TaskPriority] = None,
+                position: Int,
+                createdBy: Option[Int] = None,
+                updatedBy: Option[Int] = None,
+                createdAt: Instant = Instant.now(),
+                updatedAt: Instant = Instant.now(),
+                status: TaskStatus = TaskStatus.active,
+                isCompleted: Boolean = false)
 
-case class UserTask(
-                     id: Option[Int] = None,
-                     taskId: Int,
-                     assignedTo: Int,
-                     assignedBy: Option[Int] = None,
-                     assignedAt: Instant = Instant.now()
-                   )
+object Task {
+  implicit val projectFormat: OFormat[Task] = Json.format[Task]
+}
 
-case class Checklist(
-                      id: Option[Int] = None,
-                      taskId: Option[Int] = None,
-                      name: Option[String] = None,
-                      createdAt: Option[LocalDateTime] = None,
-                      updatedAt: Option[LocalDateTime] = None
-                    )
+case class UserTask(id: Option[Int] = None,
+                    taskId: Int,
+                    assignedTo: Int,
+                    assignedBy: Option[Int] = None,
+                    assignedAt: Instant = Instant.now())
 
-case class ChecklistItem(
-                          id: Option[Int] = None,
-                          checklistId: Option[Int] = None,
-                          content: Option[String] = None,
-                          isCompleted: Boolean = false,
-                          createdAt: Option[LocalDateTime] = None,
-                          updatedAt: Option[LocalDateTime] = None
-                        )
+object UserTask {
+  implicit val userTaskFormat: OFormat[UserTask] = Json.format[UserTask]
+}
 
-case class TaskComment(
-                        id: Option[Int] = None,
-                        taskId: Option[Int] = None,
-                        userId: Option[Int] = None,
-                        content: Option[String] = None,
-                        createdAt: Option[LocalDateTime] = None,
-                        updatedAt: Option[LocalDateTime] = None
-                      )
+case class Checklist(id: Option[Int] = None,
+                     taskId: Option[Int] = None,
+                     name: Option[String] = None,
+                     createdAt: Option[LocalDateTime] = None,
+                     updatedAt: Option[LocalDateTime] = None)
 
-case class Tag(
-                id: Option[Int] = None,
-                projectId: Option[Int] = None,
-                name: Option[String] = None,
-                color: Option[String] = None,
-                createdAt: Option[LocalDateTime] = None
-              )
+case class ChecklistItem(id: Option[Int] = None,
+                         checklistId: Option[Int] = None,
+                         content: Option[String] = None,
+                         isCompleted: Boolean = false,
+                         createdAt: Option[LocalDateTime] = None,
+                         updatedAt: Option[LocalDateTime] = None)
 
-case class TaskTag(
-                    id: Option[Int] = None,
-                    taskId: Option[Int] = None,
-                    tagId: Option[Int] = None
-                  )
+case class TaskComment(id: Option[Int] = None,
+                       taskId: Option[Int] = None,
+                       userId: Option[Int] = None,
+                       content: Option[String] = None,
+                       createdAt: Option[LocalDateTime] = None,
+                       updatedAt: Option[LocalDateTime] = None)
+
+case class Tag(id: Option[Int] = None,
+               projectId: Option[Int] = None,
+               name: Option[String] = None,
+               color: Option[String] = None,
+               createdAt: Option[LocalDateTime] = None)
+
+case class TaskTag(id: Option[Int] = None,
+                   taskId: Option[Int] = None,
+                   tagId: Option[Int] = None)
diff --git a/backend/app/models/entities/User.scala b/backend/app/models/entities/User.scala
@@ -2,6 +2,7 @@ package models.entities
 
 import models.Enums.UserProjectRole
 import models.Enums.UserProjectRole.UserProjectRole
+import play.api.libs.json.{Json, OFormat}
 
 import java.time.{Instant, LocalDateTime}
 
@@ -18,9 +19,18 @@ case class User(
     updatedAt: LocalDateTime = LocalDateTime.now()
 )
 
+object User {
+  implicit val userFormat: OFormat[User] = Json.format[User]
+}
+
 case class UserProject(id: Option[Int] = None,
                        userId: Int,
                        projectId: Int,
                        role: UserProjectRole = UserProjectRole.member,
                        invitedBy: Option[Int] = None,
-                       joinedAt: Instant = Instant.now())
+                       joinedAt: Instant = Instant.now())
+
+object UserProject {
+  implicit val userProjectFormat: OFormat[UserProject] = Json.format[UserProject]
+
+}
diff --git a/backend/app/repositories/ColumnRepository.scala b/backend/app/repositories/ColumnRepository.scala
@@ -130,4 +130,8 @@ class ColumnRepository @Inject()(
     db.run((columns returning columns) ++= cols).map(_.toSeq)
   }
 
+  def importColumnBatch(cols: Seq[Column]): DBIO[Seq[Int]] = {
+    (columns returning columns.map(_.id)) ++= cols
+  }
+
 }
diff --git a/backend/app/repositories/ProjectRepository.scala b/backend/app/repositories/ProjectRepository.scala
@@ -74,6 +74,21 @@ class ProjectRepository @Inject()(
     } yield projectId
   }
 
+  def importProjectWithOwner(project: Project, ownerId: Int): DBIO[Int] = {
+    for {
+      projectId <- (projects returning projects.map(_.id)) += project
+
+      _ <- DBIO.seq(
+        userProjects += UserProject(
+          userId = ownerId,
+          projectId = projectId,
+          role = UserProjectRole.owner,
+          joinedAt = Instant.now()
+        )
+      )
+    } yield projectId
+  }
+
   def findNonDeletedByWorkspace(
     workspaceId: Int
   ): DBIO[Seq[ProjectSummariesResponse]] = {
@@ -160,6 +175,13 @@ class ProjectRepository @Inject()(
     db.run(action)
   }
 
+  def importUserBatchIntoProject(
+                                  entries: Seq[UserProject]
+                                ): DBIO[Seq[Int]] = {
+    val insertQuery = userProjects returning userProjects.map(_.id)
+    insertQuery ++= entries
+  }
+
   def getProjectsByUser(userId: Int): DBIO[Seq[Project]] = {
     val q = for {
       up <- userProjects
diff --git a/backend/app/repositories/TaskRepository.scala b/backend/app/repositories/TaskRepository.scala
@@ -247,6 +247,14 @@ class TaskRepository@Inject()(
     db.run(insertQuery).map(_ => ())
   }
 
+  def importTaskBatch(tasksChunk: Seq[Task]): DBIO[Seq[Int]] = {
+    ((tasks returning tasks.map(_.id)) ++= tasksChunk).map(_.toSeq)
+  }
+
+  def importUserBatchIntoTask(entries: Seq[UserTask]): DBIO[Seq[Int]]= {
+    (userTasks returning userTasks.map(_.id) ++= entries).map(_.toSeq)
+  }
+
   def search(
               projectIds: Option[Seq[Int]] = None,
               keyword: Option[String] = None,
diff --git a/backend/app/services/ProjectService.scala b/backend/app/services/ProjectService.scala
diff --git a/backend/conf/routes b/backend/conf/routes

Original file line number	Diff line number	Diff line change
`@@ -130,4 +130,8 @@ class ColumnRepository @Inject()(`
`130`	`130`	`db.run((columns returning columns) ++= cols).map(_.toSeq)`
`131`	`131`	`}`
`132`	`132`
	`133`	`+ def importColumnBatch(cols: Seq[Column]): DBIO[Seq[Int]] = {`
	`134`	`+ (columns returning columns.map(_.id)) ++= cols`
	`135`	`+ }`
	`136`	`+`
`133`	`137`	`}`