Created SlickQueryBuilder

1 files changed, 103 insertions, 0 deletions

diff --git a/src/main/scala/xyz/driver/pdsuicommon/db/SlickPostgresQueryBuilder.scala b/src/main/scala/xyz/driver/pdsuicommon/db/SlickPostgresQueryBuilder.scala
new file mode 100644
index 0000000..66434f0
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuicommon/db/SlickPostgresQueryBuilder.scala
@@ -0,0 +1,103 @@
+package xyz.driver.pdsuicommon.db
+
+import java.time.{LocalDateTime, ZoneOffset}
+
+import slick.driver.JdbcProfile
+import slick.jdbc.GetResult
+import xyz.driver.core.database.SlickDal
+
+import scala.collection.breakOut
+import scala.concurrent.ExecutionContext
+
+object SlickPostgresQueryBuilder {
+
+  import xyz.driver.pdsuicommon.db.SlickQueryBuilder._
+
+  def apply[T](tableName: String,
+               lastUpdateFieldName: Option[String],
+               nullableFields: Set[String],
+               links: Set[SlickTableLink],
+               runner: Runner[T],
+               countRunner: CountRunner)(implicit sqlContext: SlickDal,
+                                         profile: JdbcProfile,
+                                         getResult: GetResult[T],
+                                         ec: ExecutionContext): SlickPostgresQueryBuilder[T] = {
+    val parameters = SlickPostgresQueryBuilderParameters(
+      tableData = TableData(tableName, lastUpdateFieldName, nullableFields),
+      links = links.map(x => x.foreignTableName -> x)(breakOut)
+    )
+    new SlickPostgresQueryBuilder[T](parameters)(runner, countRunner)
+  }
+
+  def apply[T](tableName: String,
+               lastUpdateFieldName: Option[String],
+               nullableFields: Set[String],
+               links: Set[SlickTableLink])(implicit sqlContext: SlickDal,
+                                           profile: JdbcProfile,
+                                           getResult: GetResult[T],
+                                           ec: ExecutionContext): SlickPostgresQueryBuilder[T] = {
+    apply(tableName, SlickQueryBuilderParameters.AllFields, lastUpdateFieldName, nullableFields, links)
+  }
+
+  def apply[T](tableName: String,
+               fields: Set[String],
+               lastUpdateFieldName: Option[String],
+               nullableFields: Set[String],
+               links: Set[SlickTableLink])(implicit sqlContext: SlickDal,
+                                           profile: JdbcProfile,
+                                           getResult: GetResult[T],
+                                           ec: ExecutionContext): SlickPostgresQueryBuilder[T] = {
+
+    val runner: Runner[T] = { parameters =>
+      val sql = parameters.toSql(countQuery = false, fields = fields).as[T]
+      sqlContext.execute(sql)
+    }
+
+    val countRunner: CountRunner = { parameters =>
+      implicit val getCountResult: GetResult[(Int, Option[LocalDateTime])] = GetResult({ r =>
+        val count = r.rs.getInt(1)
+        val lastUpdate = if (parameters.tableData.lastUpdateFieldName.isDefined) {
+          Option(r.rs.getTimestamp(2)).map(timestampToLocalDateTime)
+        } else None
+        (count, lastUpdate)
+      })
+      val sql = parameters.toSql(countQuery = true).as[(Int, Option[LocalDateTime])]
+      sqlContext.execute(sql).map(_.head)
+    }
+
+    apply[T](
+      tableName = tableName,
+      lastUpdateFieldName = lastUpdateFieldName,
+      nullableFields = nullableFields,
+      links = links,
+      runner = runner,
+      countRunner = countRunner
+    )
+  }
+
+  def timestampToLocalDateTime(timestamp: java.sql.Timestamp): LocalDateTime = {
+    LocalDateTime.ofInstant(timestamp.toInstant, ZoneOffset.UTC)
+  }
+}
+
+class SlickPostgresQueryBuilder[T](parameters: SlickPostgresQueryBuilderParameters)(
+        implicit runner: SlickQueryBuilder.Runner[T],
+        countRunner: SlickQueryBuilder.CountRunner)
+    extends SlickQueryBuilder[T](parameters) {
+
+  def withFilter(newFilter: SearchFilterExpr): SlickQueryBuilder[T] = {
+    new SlickPostgresQueryBuilder[T](parameters.copy(filter = newFilter))
+  }
+
+  def withSorting(newSorting: Sorting): SlickQueryBuilder[T] = {
+    new SlickPostgresQueryBuilder[T](parameters.copy(sorting = newSorting))
+  }
+
+  def withPagination(newPagination: Pagination): SlickQueryBuilder[T] = {
+    new SlickPostgresQueryBuilder[T](parameters.copy(pagination = Some(newPagination)))
+  }
+
+  def resetPagination: SlickQueryBuilder[T] = {
+    new SlickPostgresQueryBuilder[T](parameters.copy(pagination = None))
+  }
+}