add ordering and rename query param to order_by for datasets (#33)

Author: realstraw

.scalafmt.conf

@@ -1,4 +1,4 @@
-version = 3.5.2
+version = 3.5.8
 
 runner.dialect = "scala213source3"
 

acdc-core/src/main/scala/com/salesforce/mce/acdc/db/DatasetQuery.scala

@@ -15,10 +15,16 @@ import slick.jdbc.PostgresProfile.api._
 
 object DatasetQuery {
 
-  object OrderColumn extends Enumeration {
+  sealed trait OrderBy
+  object OrderBy {
+    case object CreatedAt extends OrderBy
+    case object UpdatedAt extends OrderBy
+  }
 
-    val CreatedAt = Value("created_at")
-    val UpdatedAt = Value("updated_at")
+  sealed trait Order
+  object Order {
+    case object Asc extends Order
+    case object Desc extends Order
   }
 
   def now() = LocalDateTime.now()
@@ -70,18 +76,24 @@ object DatasetQuery {
 
   def filter(
     like: String,
-    order: OrderColumn.Value,
+    orderBy: OrderBy,
+    order: Order,
     limit: Int,
     offset: Int
   ): DBIO[Seq[DatasetTable.R]] = {
-    val ordering = order match {
-      case OrderColumn.CreatedAt => t: DatasetTable => t.createdAt
-      case OrderColumn.UpdatedAt => t: DatasetTable => t.updatedAt
-      case _ => throw new MatchError("unexpected order")
+    val sortByColumn = (orderBy, order) match {
+      case (OrderBy.CreatedAt, Order.Desc) =>
+        t: DatasetTable => t.createdAt.desc
+      case (OrderBy.CreatedAt, Order.Asc) =>
+        t: DatasetTable => t.createdAt.asc
+      case (OrderBy.UpdatedAt, Order.Desc) =>
+        t: DatasetTable => t.updatedAt.desc
+      case (OrderBy.UpdatedAt, Order.Asc) =>
+        t: DatasetTable => t.updatedAt.asc
     }
     DatasetTable()
       .filter(_.name.like(s"$like"))
-      .sortBy(ordering(_).desc)
+      .sortBy(sortByColumn)
       .drop(offset)
       .take(limit)
       .result

acdc-ws/app/controllers/DatasetController.scala

@@ -15,8 +15,7 @@ import scala.concurrent.Future
 import play.api.libs.json.{JsError, JsNull, JsValue, Json}
 import play.api.mvc._
 
-import com.salesforce.mce.acdc.db.DatasetQuery
-import com.salesforce.mce.acdc.db.DatasetTable
+import com.salesforce.mce.acdc.db.{DatasetQuery, DatasetTable}
 import models.CreateDatasetRequest
 import models.DatasetResponse
 import play.api.libs.json.JsString
@@ -90,47 +89,65 @@ class DatasetController @Inject() (
     case InvalidApiRequest(_) => Future.successful(Unauthorized(JsNull))
   }
 
-  def filter(like: String, order: Option[String], page: Option[Int], perPage: Option[Int]) =
-    authAction.async {
-      case ValidApiRequest(apiRole, _) =>
-        val validated = for {
-          vOrder <- DatasetController.validateOrder(order)
-          vPage <- DatasetController.validateOne(page.getOrElse(1), "page")
-          limit <- DatasetController.validateOne(perPage.getOrElse(50), "per_page")
-        } yield (vOrder, limit, (vPage - 1) * limit)
-
-        validated match {
-          case Right((o, limit, offset)) =>
-            db.async(DatasetQuery.filter(like, o, limit, offset))
-              .map(rs => Ok(Json.toJson(rs.map(toResponse))))
-          case Left(msg) =>
-            Future.successful(BadRequest(JsString(msg)))
-        }
-
-      case InvalidApiRequest(_) =>
-        Future.successful(Unauthorized(JsNull))
-    }
+  def filter(
+    like: String,
+    orderBy: Option[String],
+    order: Option[String],
+    page: Option[Int],
+    perPage: Option[Int]
+  ) = authAction.async {
+    case ValidApiRequest(apiRole, _) =>
+
+      val validated = for {
+        vOrderBy <- DatasetController.validateOrderBy(orderBy)
+        vOrder <- DatasetController.validateOrder(order)
+        vPage <- DatasetController.validateOne(page.getOrElse(1), "page")
+        limit <- DatasetController.validateOne(perPage.getOrElse(50), "per_page")
+      } yield (vOrderBy, vOrder, limit, (vPage - 1) * limit)
+
+      validated match {
+        case Right((by, ord, limit, offset)) =>
+          db.async(DatasetQuery.filter(like, by, ord, limit, offset))
+            .map(rs => Ok(Json.toJson(rs.map(toResponse))))
+        case Left(msg) =>
+          Future.successful(BadRequest(JsString(msg)))
+      }
+
+    case InvalidApiRequest(_) =>
+      Future.successful(Unauthorized(JsNull))
+  }
 
 }
 
 object DatasetController {
 
+  private def validateOrderBy(
+    orderBy: Option[String]
+  ): Either[String, DatasetQuery.OrderBy] = {
+    orderBy
+      .fold[Either[String, DatasetQuery.OrderBy]](
+        Right(DatasetQuery.OrderBy.CreatedAt)
+      ) {
+        case "created_at" => Right(DatasetQuery.OrderBy.CreatedAt)
+        case "updated_at" => Right(DatasetQuery.OrderBy.UpdatedAt)
+        case other => Left(s"Unknow order_by $other")
+      }
+  }
+
   private def validateOrder(
     order: Option[String]
-  ): Either[String, DatasetQuery.OrderColumn.Value] = {
+  ): Either[String, DatasetQuery.Order] = {
     order
-      .fold[Either[String, DatasetQuery.OrderColumn.Value]](
-        Right(DatasetQuery.OrderColumn.CreatedAt)
-      ) { o =>
-        try {
-          Right(DatasetQuery.OrderColumn.withName(o))
-        } catch {
-          case e: NoSuchElementException =>
-            Left(s"Unknow order $o")
-        }
+      .fold[Either[String, DatasetQuery.Order]](
+        Right(DatasetQuery.Order.Desc)
+      ) {
+        case "desc" => Right(DatasetQuery.Order.Desc)
+        case "asc" => Right(DatasetQuery.Order.Asc)
+        case other => Left(s"Unknow order $other")
       }
   }
 
+
   private def validateOne(num: Int, name: String): Either[String, Int] = {
     if (num < 1) Left(s"$name must be at least 1")
     else Right(num)

acdc-ws/app/routers/ApiRouter.scala

@@ -27,11 +27,12 @@ class ApiRouter @Inject() (
     case GET(
           p"/datasets" ?
           q"like=$like" &
+          q_o"order_by=$orderBy" &
           q_o"order=$order" &
           q_o"page=${int(page)}" &
           q_o"per_page=${int(perPage)}"
         ) =>
-      dataset.filter(like, order, page, perPage)
+      dataset.filter(like, orderBy, order, page, perPage)
     case DELETE(p"/dataset/$name") => dataset.delete(name)
 
     case POST(p"/instance") => instance.create()

build.sbt

@@ -35,7 +35,7 @@ lazy val core = (project in file("acdc-core")).
     libraryDependencies ++= Seq(
       "com.typesafe.slick" %% "slick" % slickVersion,
       "com.typesafe.slick" %% "slick-hikaricp" % slickVersion,
-      "org.postgresql" % "postgresql" % "42.3.+",
+      "org.postgresql" % "postgresql" % "42.4.+",
     )
   )
 

project/plugins.sbt

@@ -1,6 +1,6 @@
 addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "1.1.0")
 
-addSbtPlugin("com.typesafe.play" % "sbt-plugin" % "2.8.15")
+addSbtPlugin("com.typesafe.play" % "sbt-plugin" % "2.8.16")
 
 addSbtPlugin("com.eed3si9n" % "sbt-buildinfo" % "0.10.0")
 

version.sbt

@@ -1 +1 @@
- ThisBuild / version := "0.6.3"
+ ThisBuild / version := "0.7.0"