Adding domain entitiesv0.1.0

5 files changed, 360 insertions, 0 deletions

diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/CategoryService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/CategoryService.scala
new file mode 100644
index 0000000..31ccff7
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/CategoryService.scala
@@ -0,0 +1,28 @@
+package xyz.driver.pdsuidomain.services
+
+import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
+import xyz.driver.pdsuicommon.db.Sorting
+import xyz.driver.pdsuicommon.error.DomainError
+import xyz.driver.pdsuicommon.logging._
+import xyz.driver.pdsuidomain.entities.CategoryWithLabels
+
+import scala.concurrent.Future
+
+object CategoryService {
+  sealed trait GetListReply
+  object GetListReply {
+    case class EntityList(xs: Seq[CategoryWithLabels], totalFound: Int) extends GetListReply
+
+    case object AuthorizationError
+      extends GetListReply with DomainError.AuthorizationError {
+      def userMessage: String = "Access denied"
+    }
+  }
+}
+
+trait CategoryService extends PhiLogging {
+
+  import CategoryService._
+
+  def getAll(sorting: Option[Sorting] = None)(implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/ExportService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/ExportService.scala
new file mode 100644
index 0000000..eaffb2a
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/ExportService.scala
@@ -0,0 +1,60 @@
+package xyz.driver.pdsuidomain.services
+
+import java.time.LocalDateTime
+
+import xyz.driver.pdsuicommon.auth.AnonymousRequestContext
+import xyz.driver.pdsuicommon.db.SearchFilterExpr
+import xyz.driver.pdsuicommon.domain.{StringId, UuidId}
+import xyz.driver.pdsuicommon.error.DomainError
+import xyz.driver.pdsuicommon.logging._
+import xyz.driver.pdsuidomain.entities.{Patient, Trial}
+import xyz.driver.pdsuidomain.entities.export.patient.ExportPatientWithLabels
+import xyz.driver.pdsuidomain.entities.export.trial.{ExportTrial, ExportTrialWithLabels}
+
+import scala.concurrent.Future
+
+object ExportService {
+
+  sealed trait GetPatientReply
+  object GetPatientReply {
+    type Error = GetPatientReply with DomainError
+
+    case class Entity(x: ExportPatientWithLabels) extends GetPatientReply
+
+    case object NotFoundError extends GetPatientReply with DomainError.NotFoundError {
+      def userMessage: String = "Patient not found"
+    }
+  }
+
+  sealed trait GetTrialListReply
+  object GetTrialListReply {
+    case class EntityList(xs: Seq[ExportTrial], totalFound: Int, lastUpdate: Option[LocalDateTime])
+      extends GetTrialListReply
+  }
+
+  sealed trait GetTrialReply
+  object GetTrialReply {
+    type Error = GetTrialReply with DomainError
+
+    case class Entity(x: ExportTrialWithLabels) extends GetTrialReply
+
+    case object NotFoundError extends GetTrialReply with DomainError.NotFoundError {
+      def userMessage: String = "Trial not found"
+    }
+  }
+}
+
+trait ExportService extends PhiLogging {
+
+  import ExportService._
+
+  def getPatient(id: UuidId[Patient])
+                (implicit requestContext: AnonymousRequestContext): Future[GetPatientReply]
+
+  def getTrialList(filter: SearchFilterExpr = SearchFilterExpr.Empty)
+                  (implicit requestContext: AnonymousRequestContext): Future[GetTrialListReply]
+
+  def getTrial(trialId: StringId[Trial], condition: String)
+              (implicit requestContext: AnonymousRequestContext): Future[GetTrialReply]
+
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/LabelService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/LabelService.scala
new file mode 100644
index 0000000..25291f1
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/LabelService.scala
@@ -0,0 +1,29 @@
+package xyz.driver.pdsuidomain.services
+
+import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
+import xyz.driver.pdsuicommon.db.Sorting
+import xyz.driver.pdsuicommon.error.DomainError
+import xyz.driver.pdsuicommon.logging.PhiLogging
+import xyz.driver.pdsuidomain.entities.Label
+
+import scala.concurrent.Future
+
+object LabelService {
+
+  sealed trait GetListReply
+  object GetListReply {
+    case class EntityList(xs: Seq[Label], totalFound: Int) extends GetListReply
+
+    case object AuthorizationError
+      extends GetListReply with DomainError.AuthorizationError {
+      def userMessage: String = "Access denied"
+    }
+  }
+}
+
+trait LabelService extends PhiLogging {
+  import LabelService._
+
+  def getAll(sorting: Option[Sorting] = None)
+            (implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/MessageService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/MessageService.scala
new file mode 100644
index 0000000..56140ce
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/MessageService.scala
@@ -0,0 +1,100 @@
+package xyz.driver.pdsuidomain.services
+
+import java.time.LocalDateTime
+
+import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
+import xyz.driver.pdsuicommon.db.{Pagination, SearchFilterExpr, Sorting}
+import xyz.driver.pdsuicommon.domain.LongId
+import xyz.driver.pdsuicommon.error.DomainError
+import xyz.driver.pdsuicommon.logging._
+import xyz.driver.pdsuidomain.entities.Message
+
+import scala.concurrent.Future
+
+object MessageService {
+
+  trait DefaultNotFoundError {
+    def userMessage: String = "Message not found"
+  }
+
+  trait DefaultAccessDeniedError {
+    def userMessage: String = "Access denied"
+  }
+
+  sealed trait CreateReply
+  object CreateReply {
+    type Error = CreateReply with DomainError
+    case class Created(x: Message)
+      extends CreateReply
+    case object AuthorizationError
+      extends CreateReply with DomainError.AuthorizationError with DefaultAccessDeniedError
+    case class CommonError(userMessage: String)
+      extends CreateReply with DomainError
+  }
+
+  sealed trait GetByIdReply
+  object GetByIdReply {
+    type Error = GetByIdReply with DomainError
+    case class Entity(x: Message)
+      extends GetByIdReply
+    case object NotFoundError
+      extends GetByIdReply with DomainError.NotFoundError with DefaultNotFoundError
+    case class CommonError(userMessage: String)
+      extends GetByIdReply with DomainError
+    case object AuthorizationError
+      extends GetByIdReply with DomainError.AuthorizationError with DefaultAccessDeniedError
+  }
+
+  sealed trait GetListReply
+  object GetListReply {
+    type Error = GetListReply with DomainError
+    case class EntityList(xs: Seq[Message], totalFound: Int, lastUpdate: Option[LocalDateTime])
+      extends GetListReply
+    case object AuthorizationError
+      extends GetListReply with DomainError.AuthorizationError with DefaultAccessDeniedError
+  }
+
+  sealed trait UpdateReply
+  object UpdateReply {
+    type Error = UpdateReply with DomainError
+    case class Updated(updated: Message)
+      extends UpdateReply
+    case object AuthorizationError
+      extends UpdateReply with DomainError.AuthorizationError with DefaultAccessDeniedError
+    case class CommonError(userMessage: String)
+      extends UpdateReply with DomainError
+  }
+
+  sealed trait DeleteReply
+  object DeleteReply {
+    type Error = DeleteReply with DomainError
+    case object Deleted extends DeleteReply
+    case object AuthorizationError
+      extends DeleteReply with DomainError.AuthorizationError with DefaultAccessDeniedError
+    case object NotFoundError
+      extends DeleteReply with DomainError.NotFoundError with DefaultNotFoundError
+    case class CommonError(userMessage: String)
+      extends DeleteReply with DomainError
+  }
+
+}
+
+trait MessageService extends PhiLogging {
+
+  import MessageService._
+
+  def create(draftMessage: Message)(implicit requestContext: AuthenticatedRequestContext): Future[CreateReply]
+
+  def getById(messageId: LongId[Message])(implicit requestContext: AuthenticatedRequestContext): Future[GetByIdReply]
+
+  def getAll(filter: SearchFilterExpr = SearchFilterExpr.Empty,
+             sorting: Option[Sorting] = None,
+             pagination: Option[Pagination] = None)
+            (implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
+
+  def update(origMessage: Message, draftMessage: Message)
+            (implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply]
+
+  def delete(messageId: LongId[Message])
+            (implicit requestContext: AuthenticatedRequestContext): Future[DeleteReply]
+}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/UserService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/UserService.scala
new file mode 100644
index 0000000..350720e
--- /dev/null
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/UserService.scala
@@ -0,0 +1,143 @@
+package xyz.driver.pdsuidomain.services
+
+import xyz.driver.pdsuicommon.auth.{AnonymousRequestContext, AuthenticatedRequestContext}
+import xyz.driver.pdsuicommon.db.{Pagination, SearchFilterExpr, Sorting}
+import xyz.driver.pdsuicommon.domain.{Email, LongId, User}
+import xyz.driver.pdsuicommon.error.DomainError
+import xyz.driver.pdsuicommon.logging._
+
+import scala.concurrent.Future
+
+object UserService {
+
+  trait DefaultCredentialsError {
+    def userMessage: String = "Incorrect email/password. Try again."
+  }
+
+  trait DefaultAccessDeniedError {
+    def userMessage: String = "Access denied"
+  }
+
+  trait DefaultNotFoundError {
+    def userMessage: String = "User not found"
+  }
+
+  sealed trait ActivateExecutorReply
+  object ActivateExecutorReply {
+    type Error = ActivateExecutorReply with DomainError
+    case class Entity(x: User) extends ActivateExecutorReply
+    case object NotFoundError
+      extends ActivateExecutorReply with DomainError.NotFoundError {
+      val userMessage = "Info about you is not found on the server"
+    }
+  }
+
+  sealed trait GetByIdReply
+  object GetByIdReply {
+    type Error = GetByIdReply with DomainError
+    case class Entity(x: User) extends GetByIdReply
+    case object AuthorizationError
+      extends GetByIdReply with DomainError.AuthorizationError with DefaultAccessDeniedError
+    case object NotFoundError
+      extends GetByIdReply with DomainError.NotFoundError with DefaultNotFoundError
+    case class CommonError(userMessage: String)
+      extends GetByIdReply with DomainError
+  }
+
+  sealed trait GetByEmailReply
+  object GetByEmailReply {
+    case class Entity(x: User) extends GetByEmailReply
+    case object NotFoundError
+      extends GetByEmailReply with DefaultNotFoundError with DomainError.NotFoundError {
+      override def userMessage: String = "Incorrect email. Try again."
+    }
+  }
+
+  sealed trait GetByCredentialsReply
+  object GetByCredentialsReply {
+    case class Entity(x: User) extends GetByCredentialsReply
+    case object AuthenticationError
+      extends GetByCredentialsReply with DefaultCredentialsError with DomainError.AuthenticationError
+    case object NotFoundError
+      extends GetByCredentialsReply with DomainError.NotFoundError with DefaultNotFoundError
+  }
+
+  sealed trait GetListReply
+  object GetListReply {
+    case class EntityList(xs: Seq[User], totalFound: Int) extends GetListReply
+    case object AuthorizationError
+      extends GetListReply with DomainError.AuthorizationError with DefaultNotFoundError
+  }
+
+  sealed trait CreateReply
+  object CreateReply {
+    type Error = CreateReply with DomainError
+    case class Created(x: User) extends CreateReply
+    case object AuthorizationError
+      extends CreateReply with DefaultNotFoundError with DomainError.AuthorizationError
+    case class UserAlreadyExistsError(email: Email)
+      extends CreateReply with DomainError {
+      val userMessage = s"The user with this email already exists."
+    }
+    case class CommonError(userMessage: String)
+      extends CreateReply with DomainError
+  }
+
+  sealed trait UpdateReply
+  object UpdateReply {
+    type Error = UpdateReply with DomainError
+    case class Updated(updated: User) extends UpdateReply
+    case object AuthorizationError
+      extends UpdateReply with DefaultAccessDeniedError with DomainError.AuthorizationError
+    case class CommonError(userMessage: String)
+      extends UpdateReply with DomainError
+  }
+
+  sealed trait DeleteReply
+  object DeleteReply {
+    type Error = DeleteReply with DomainError
+    case object Deleted extends DeleteReply
+    case class AuthorizationError(user: User)
+      extends DeleteReply with DefaultAccessDeniedError with DomainError.AuthorizationError
+    case object AssignedToRecordAndDocumentError
+      extends DeleteReply with DomainError {
+      val userMessage = "User is can not be deleted because he has record and document in work"
+    }
+    case object NotFoundError
+      extends DeleteReply with DefaultNotFoundError with DomainError.NotFoundError
+    case class CommonError(userMessage: String)
+      extends DeleteReply with DomainError
+  }
+
+}
+
+trait UserService extends PhiLogging {
+
+  import UserService._
+
+  /**
+    * Utility method for getting request executor.
+    */
+  def activateExecutor(executorId: LongId[User])
+                      (implicit requestContext: AnonymousRequestContext): Future[ActivateExecutorReply]
+
+  def getById(userId: LongId[User])(implicit requestContext: AuthenticatedRequestContext): Future[GetByIdReply]
+
+  def getByEmail(email: Email)
+                (implicit requestContext: AnonymousRequestContext): Future[GetByEmailReply]
+
+  def getByCredentials(email: Email, password: String)
+                      (implicit requestContext: AnonymousRequestContext): Future[GetByCredentialsReply]
+
+  def getAll(filter: SearchFilterExpr = SearchFilterExpr.Empty,
+             sorting: Option[Sorting] = None,
+             pagination: Option[Pagination] = None)
+            (implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
+
+  def create(draftUser: User)(implicit requestContext: AuthenticatedRequestContext): Future[CreateReply]
+
+  def update(origUser: User, draftUser: User)
+            (implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply]
+
+  def delete(userId: LongId[User])(implicit requestContext: AuthenticatedRequestContext): Future[DeleteReply]
+}