Common code for synchronizers

1 files changed, 70 insertions, 0 deletions

diff --git a/src/main/scala/xyz/driver/pdsuicommon/synchronization/db/SlickDbAction.scala b/src/main/scala/xyz/driver/pdsuicommon/synchronization/db/SlickDbAction.scala
new file mode 100644
index 0000000..57cc3d4
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuicommon/synchronization/db/SlickDbAction.scala
@@ -0,0 +1,70 @@
+package xyz.driver.pdsuicommon.synchronization.db
+
+import slick.dbio.DBIO
+import xyz.driver.pdsuicommon.logging._
+import xyz.driver.pdsuicommon.synchronization.utils.{FakeIdGen, FakeIdMap}
+
+import scala.concurrent.ExecutionContext
+import scalaz.Monad
+
+trait SlickDbAction[+T] {
+  def entity: T
+}
+
+object SlickDbAction {
+
+  final case class Create[T](entity: T) extends SlickDbAction[T]
+  final case class Update[T](entity: T) extends SlickDbAction[T]
+  final case class Delete[T](entity: T) extends SlickDbAction[T]
+
+  // Use it only inside of a transaction!
+  def unsafeRun[T](actions: List[SlickDbAction[T]], dataSource: SlickDataSource[T])(
+          implicit core: FakeIdGen[T],
+          executionContext: ExecutionContext,
+          dbioMonad: Monad[DBIO]): DBIO[FakeIdMap[T]] = {
+    unsafeRun(DBIO.successful(FakeIdMap.empty))(actions, dataSource)
+  }
+
+  // Use it only inside of a transaction!
+  def unsafeRun[T](initial: DBIO[FakeIdMap[T]])(actions: List[SlickDbAction[T]], dataSource: SlickDataSource[T])(
+          implicit core: FakeIdGen[T],
+          executionContext: ExecutionContext,
+          dbioMonad: Monad[DBIO]): DBIO[FakeIdMap[T]] = {
+    // TODO Squash Updates and Delete to one operation, when bugs in repositories will be fixed
+    actions.foldLeft(initial) {
+      case (previousActions, Create(x)) =>
+        for {
+          r      <- previousActions
+          newArm <- dataSource.create(x)
+        } yield {
+          r + (core(newArm) -> newArm)
+        }
+
+      case (previousActions, Update(x)) =>
+        for {
+          r          <- previousActions
+          updatedArm <- dataSource.update(x).getOrElse(x)
+        } yield {
+          r - core(updatedArm) + (core(updatedArm) -> updatedArm)
+        }
+
+      case (previousActions, Delete(_)) if dataSource.isDictionary =>
+        previousActions // We don't delete entities from dictionaries
+
+      case (previousActions, Delete(x)) =>
+        for {
+          r <- previousActions
+          _ <- dataSource.delete(x).run
+        } yield {
+          r - core(x)
+        }
+    }
+  }
+
+  implicit def toPhiString[T](input: SlickDbAction[T])(implicit inner: T => PhiString): PhiString = input match {
+    case Create(x) => phi"Create($x)"
+    case Update(x) => phi"Update($x)"
+    case Delete(x) => phi"Delete($x)"
+  }
+
+}