Merge pull request #58 from nashtech-garage/feat/upload-file-on-task

feat upload file on task

Author: nguyenvanhadncntt

backend/app/controllers/MediaController.scala

@@ -0,0 +1,51 @@
+package controllers
+
+import play.api.mvc._
+import services.MediaService
+
+import javax.inject.Inject
+import scala.concurrent.{ExecutionContext, Future}
+
+class MediaController @Inject()(
+  cc: ControllerComponents,
+  mediaService: MediaService,
+  authenticatedActionWithUser: AuthenticatedActionWithUser
+)(implicit ec: ExecutionContext) extends AbstractController(cc) {
+
+  def upload(taskId: Int) = authenticatedActionWithUser.async(parse.multipartFormData) { request =>
+    val userId = request.userToken.userId
+    request.body.file("file") match {
+      case Some(filePart) =>
+        mediaService.uploadMedia(userId, taskId, filePart).map(m => Ok(s"""{"id": ${m.id.get}}"""))
+
+      case None =>
+        Future.successful(BadRequest("File missing"))
+    }
+  }
+
+  def get(id: Int) = Action.async {
+    mediaService.getMedia(id).map {
+      case Some(media) => Ok(play.api.libs.json.Json.toJson(media))
+      case None        => NotFound
+    }
+  }
+
+  def delete(id: Int) = Action.async {
+    mediaService.deleteMedia(id).map {
+      case true  => NoContent
+      case false => NotFound
+    }
+  }
+
+  def update(id: Int) = Action(parse.multipartFormData).async { request =>
+    request.body.file("file") match {
+      case Some(file) =>
+        mediaService.updateMedia(id, file).map {
+          case Some(updatedMedia) => Ok(play.api.libs.json.Json.toJson(updatedMedia))
+          case None               => NotFound
+        }
+      case None =>
+        Future.successful(BadRequest("File missing"))
+    }
+  }
+}

backend/app/dto/response/project/ProjectDetailResponse.scala

@@ -24,7 +24,7 @@ object ProjectDetailResponse {
              status: ProjectStatus,
              columns: Seq[Column],
              members: Seq[UserInProjectResponse],
-             rankedTasks: Seq[(Int, String, Int, Int, java.time.Instant, Int, Int)],
+             rankedTasks: Seq[(Int, String, Int, Int, java.time.Instant, Int, Int, String)],
              allUserTasks: Seq[UserTask]
            ): ProjectDetailResponse = {
     val memberIdsByTask = allUserTasks
@@ -34,8 +34,8 @@ object ProjectDetailResponse {
       .toMap
 
     val allTasks = rankedTasks.map {
-      case (taskId, taskName, pos, colId, updatedAt, _, totalTasksInColumn) =>
-        (taskId, taskName, pos, colId, updatedAt, totalTasksInColumn)
+      case (taskId, taskName, pos, colId, updatedAt, _, totalTasksInColumn, mediaPreviewPath) =>
+        (taskId, taskName, pos, colId, updatedAt, totalTasksInColumn, mediaPreviewPath)
     }
 
     val totalTasksByColumn =
@@ -44,14 +44,15 @@ object ProjectDetailResponse {
     val tasksByColumn =
       allTasks.groupBy(_._4).view.mapValues { tasks =>
         tasks.map {
-          case (taskId, taskName, pos, colId, updatedAt, _) =>
+          case (taskId, taskName, pos, colId, updatedAt, _, mediaPreviewPath) =>
             TaskSummaryResponse(
               taskId,
               taskName,
               pos,
               colId,
               memberIdsByTask.getOrElse(taskId, Seq.empty),
-              updatedAt
+              updatedAt,
+              Some(mediaPreviewPath)
             )
         }
       }.toMap

backend/app/dto/response/task/TaskDetailResponse.scala

@@ -1,5 +1,6 @@
 package dto.response.task
 
+import models.entities.Media
 import play.api.libs.json.{Format, Json}
 
 import java.time.Instant
@@ -16,7 +17,8 @@ case class TaskDetailResponse(id: Int,
                               isCompleted: Boolean,
                               createdAt: Instant,
                               updatedAt: Instant,
-                              assignedMembers: Seq[AssignedMemberResponse] = Seq.empty
+                              assignedMembers: Seq[AssignedMemberResponse] = Seq.empty,
+                              media: Seq[Media] = Seq.empty
                              )
 
 object TaskDetailResponse {

backend/app/dto/response/task/TaskSummaryResponse.scala

@@ -9,7 +9,8 @@ case class TaskSummaryResponse(id: Int,
                                position: Int,
                                columnId: Int,
                                memberIds: Seq[Int],
-                               updatedAt: Instant)
+                               updatedAt: Instant,
+                               mediaPreviewPath: Option[String] = None)
 
 object TaskSummaryResponse {
   implicit val taskSummaryFmt: OFormat[TaskSummaryResponse] =

backend/app/mappers/TaskMapper.scala

@@ -1,11 +1,11 @@
 package mappers
 
 import dto.response.task.{AssignedMemberResponse, TaskDetailResponse}
-import models.entities.Task
+import models.entities.{Media, Task}
 
 object TaskMapper {
 
-  def toDetailResponse(entity: Task): TaskDetailResponse = {
+  def toDetailResponse(entity: Task, media: Seq[Media] = Seq.empty): TaskDetailResponse = {
     TaskDetailResponse(
       id = entity.id.getOrElse(0),
       name = entity.name,
@@ -18,10 +18,11 @@ object TaskMapper {
       columnId = entity.columnId,
       isCompleted = entity.isCompleted,
       createdAt = entity.createdAt,
-      updatedAt = entity.updatedAt
+      updatedAt = entity.updatedAt,
+      media = media
     )
   }
-  def toDetailWithAssignMembersResponse(entity: Task,assignedMembers: Seq[AssignedMemberResponse]): TaskDetailResponse = {
+  def toDetailWithAssignMembersResponse(entity: Task, assignedMembers: Seq[AssignedMemberResponse], media: Seq[Media] = Seq.empty): TaskDetailResponse = {
     TaskDetailResponse(
       id = entity.id.getOrElse(0),
       name = entity.name,
@@ -35,7 +36,8 @@ object TaskMapper {
       isCompleted = entity.isCompleted,
       createdAt = entity.createdAt,
       updatedAt = entity.updatedAt,
-      assignedMembers = assignedMembers
+      assignedMembers = assignedMembers,
+      media = media
     )
   }
 

backend/app/models/entities/Task.scala

@@ -65,3 +65,17 @@ case class Tag(id: Option[Int] = None,
 case class TaskTag(id: Option[Int] = None,
                    taskId: Option[Int] = None,
                    tagId: Option[Int] = None)
+
+case class Media(id: Option[Int] = None,
+                 userId: Int,
+                 taskId: Int,
+                 filePath: String,
+                 fileName: String,
+                 fileType: String,
+                 fileSize: Long,
+                 createdAt: Instant = Instant.now(),
+                 updatedAt: Instant = Instant.now())
+
+object Media {
+  implicit val mediaFormat: OFormat[Media] = Json.format[Media]
+}

backend/app/models/tables/MediaTable.scala

@@ -0,0 +1,26 @@
+package models.tables
+
+import slick.lifted.Tag
+import models.entities.Media
+import db.MyPostgresProfile.api._
+
+import java.time.Instant
+
+class MediaTable(tag: Tag) extends Table[Media](tag, "media") {
+
+  def id = column[Int]("id", O.PrimaryKey, O.AutoInc)
+  def userId = column[Int]("user_id")
+  def taskId = column[Int]("task_id")
+  def filePath = column[String]("file_path")
+  def fileName = column[String]("file_name")
+  def fileType = column[String]("file_type")
+  def fileSize = column[Long]("file_size")
+  def createdAt = column[Instant]("created_at")
+  def updatedAt = column[Instant]("updated_at")
+
+  def * = (id.?, userId, taskId, filePath, fileName, fileType, fileSize, createdAt, updatedAt) <> ((Media.apply _).tupled, Media.unapply)
+
+  // Foreign keys
+  def user = foreignKey("media_user_fk", userId, TableQuery[UserTable])(_.id, onDelete = ForeignKeyAction.Cascade)
+  def task = foreignKey("media_task_fk", taskId, TableQuery[TaskTable])(_.id, onDelete = ForeignKeyAction.Cascade)
+}

backend/app/models/tables/TableRegistry.scala

@@ -20,11 +20,12 @@ object TableRegistry {
   lazy val activityLogs = TableQuery[ActivityLogTable]
   lazy val userTasks = TableQuery[UserTaskTable]
   lazy val userProfiles = TableQuery[UserProfileTable]
+  lazy val medias = TableQuery[MediaTable]
 
   // All tables for schema creation/evolution
   val allTables = Seq(
     roles, users, workspaces, userWorkspaces, projects, columns,
     tasks, checklists, checklistItems, taskComments, tags, taskTags,
-    notifications, activityLogs
+    notifications, activityLogs, userTasks, userProfiles, medias
   )
 }

backend/app/modules/CloudinaryModule.scala

@@ -0,0 +1,30 @@
+package modules
+
+import com.cloudinary.Cloudinary
+import play.api.{Configuration, Environment}
+import play.api.inject._
+
+import javax.inject.{Inject, Provider}
+import scala.jdk.CollectionConverters._
+
+class CloudinaryModule extends Module {
+  override def bindings(environment: Environment, config: Configuration) = {
+    Seq(
+      bind[Cloudinary].toProvider[CloudinaryProvider].eagerly()
+    )
+  }
+}
+
+class CloudinaryProvider @Inject()(config: Configuration) extends Provider[Cloudinary] {
+  override def get(): Cloudinary = {
+    val cloudName = config.get[String]("cloudinary.cloud-name")
+    val apiKey    = config.get[String]("cloudinary.api-key")
+    val apiSecret = config.get[String]("cloudinary.api-secret")
+
+    new Cloudinary(Map(
+      "cloud_name" -> cloudName,
+      "api_key"    -> apiKey,
+      "api_secret" -> apiSecret
+    ).asJava)
+  }
+}

backend/app/repositories/MediaRepository.scala

@@ -0,0 +1,33 @@
+package repositories
+
+import javax.inject._
+import db.MyPostgresProfile.api._
+import models.entities.Media
+import models.tables.MediaTable
+import play.api.db.slick.{DatabaseConfigProvider, HasDatabaseConfigProvider}
+import slick.jdbc.JdbcProfile
+
+import scala.concurrent.{ExecutionContext, Future}
+
+class MediaRepository @Inject()(
+                                 protected val dbConfigProvider: DatabaseConfigProvider
+                               )(implicit ec: ExecutionContext) extends HasDatabaseConfigProvider[JdbcProfile]  {
+  private val mediaTable  = TableQuery[MediaTable]
+
+  def insert(media: Media): Future[Media] =
+    db.run((mediaTable returning mediaTable.map(_.id)
+      into ((data, id) => data.copy(id = Some(id))
+    ) += media))
+
+  def findById(id: Int): Future[Option[Media]] =
+    db.run(mediaTable.filter(_.id === id).result.headOption)
+
+  def delete(id: Int): Future[Int] =
+    db.run(mediaTable.filter(_.id === id).delete)
+
+  def update(media: Media): Future[Int] =
+    db.run(mediaTable.filter(_.id === media.id).update(media))
+
+  def findByTaskId(taskId: Int): Future[Seq[Media]] =
+    db.run(mediaTable.filter(_.taskId === taskId).result)
+}