From 54b15dae509212f6661dc1f1bc4ca248cb487443 Mon Sep 17 00:00:00 2001
From: Kseniya Tomskikh <ktomskih@datamonsters.co>
Date: Fri, 20 Oct 2017 16:25:04 +0700
Subject: PDSUI-2336 Deleted api classes of play format, userhistory and
 message services

---
 .../pdsuidomain/services/MessageService.scala      | 88 ----------------------
 .../pdsuidomain/services/UserHistoryService.scala  | 30 --------
 .../pdsuidomain/services/rest/RestArmService.scala | 26 +++----
 .../services/rest/RestCriterionService.scala       | 28 +++----
 .../services/rest/RestDocumentService.scala        | 32 ++++----
 .../services/rest/RestDocumentTypeService.scala    | 13 ++--
 .../rest/RestEligibilityVerificationService.scala  |  2 +-
 .../services/rest/RestExtractedDataService.scala   | 28 +++----
 .../pdsuidomain/services/rest/RestHelper.scala     |  3 +-
 .../services/rest/RestHypothesisService.scala      | 13 ++--
 .../services/rest/RestInterventionService.scala    | 27 +++----
 .../rest/RestInterventionTypeService.scala         | 13 ++--
 .../services/rest/RestMedicalRecordService.scala   | 33 ++++----
 .../services/rest/RestMessageService.scala         | 87 ---------------------
 .../services/rest/RestPatientService.scala         | 20 ++---
 .../services/rest/RestProviderTypeService.scala    | 13 ++--
 .../services/rest/RestStudyDesignService.scala     | 13 ++--
 .../services/rest/RestTrialService.scala           | 28 +++----
 18 files changed, 151 insertions(+), 346 deletions(-)
 delete mode 100644 src/main/scala/xyz/driver/pdsuidomain/services/MessageService.scala
 delete mode 100644 src/main/scala/xyz/driver/pdsuidomain/services/UserHistoryService.scala
 delete mode 100644 src/main/scala/xyz/driver/pdsuidomain/services/rest/RestMessageService.scala

(limited to 'src/main/scala/xyz/driver/pdsuidomain/services')

diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/MessageService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/MessageService.scala
deleted file mode 100644
index 6718f26..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/services/MessageService.scala
+++ /dev/null
@@ -1,88 +0,0 @@
-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.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
-    final case class Created(x: Message) extends CreateReply
-    case object AuthorizationError
-        extends CreateReply with DomainError.AuthorizationError with DefaultAccessDeniedError
-    final case class CommonError(userMessage: String) extends CreateReply with DomainError
-  }
-
-  sealed trait GetByIdReply
-  object GetByIdReply {
-    type Error = GetByIdReply with DomainError
-    final case class Entity(x: Message)               extends GetByIdReply
-    case object NotFoundError                         extends GetByIdReply with DomainError.NotFoundError with DefaultNotFoundError
-    final 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
-    final 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
-    final case class Updated(updated: Message) extends UpdateReply
-    case object AuthorizationError
-        extends UpdateReply with DomainError.AuthorizationError with DefaultAccessDeniedError
-    final 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
-    final case class CommonError(userMessage: String) extends DeleteReply with DomainError
-  }
-}
-
-trait MessageService {
-
-  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/UserHistoryService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/UserHistoryService.scala
deleted file mode 100644
index a29e041..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/services/UserHistoryService.scala
+++ /dev/null
@@ -1,30 +0,0 @@
-package xyz.driver.pdsuidomain.services
-
-import xyz.driver.pdsuicommon.auth.AuthenticatedRequestContext
-import xyz.driver.pdsuicommon.db.{Pagination, SearchFilterExpr, Sorting}
-import xyz.driver.pdsuicommon.error.DomainError
-import xyz.driver.pdsuidomain.entities.UserHistory
-
-import scala.concurrent.Future
-
-object UserHistoryService {
-
-  sealed trait GetListReply
-  object GetListReply {
-    final case class EntityList(xs: Seq[UserHistory], totalFound: Int) extends GetListReply
-
-    case object AuthorizationError extends GetListReply with DomainError.AuthorizationError {
-      def userMessage: String = "Access denied"
-    }
-  }
-}
-
-trait UserHistoryService {
-
-  import UserHistoryService._
-
-  def getAll(filter: SearchFilterExpr = SearchFilterExpr.Empty,
-             sorting: Option[Sorting] = None,
-             pagination: Option[Pagination] = None)(
-          implicit requestContext: AuthenticatedRequestContext): Future[GetListReply]
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestArmService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestArmService.scala
index 2b4e858..e5eb18f 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestArmService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestArmService.scala
@@ -1,7 +1,6 @@
 package xyz.driver.pdsuidomain.services.rest
 
 import scala.concurrent.{ExecutionContext, Future}
-
 import akka.http.scaladsl.marshalling.Marshal
 import akka.http.scaladsl.model._
 import akka.stream.Materializer
@@ -9,16 +8,17 @@ import xyz.driver.core.rest.{Pagination => _, _}
 import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain._
+import xyz.driver.pdsuidomain.ListResponse
 import xyz.driver.pdsuidomain.entities._
-import xyz.driver.pdsuidomain.formats.json.ListResponse
-import xyz.driver.pdsuidomain.formats.json.arm.ApiArm
 import xyz.driver.pdsuidomain.services.ArmService
 
 class RestArmService(transport: ServiceTransport, baseUri: Uri)(implicit protected val materializer: Materializer,
                                                                 protected val exec: ExecutionContext)
     extends ArmService with RestHelper {
 
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.listresponse._
+  import xyz.driver.pdsuidomain.formats.json.arm._
   import xyz.driver.pdsuidomain.services.ArmService._
 
   def getAll(filter: SearchFilterExpr = SearchFilterExpr.Empty,
@@ -30,9 +30,9 @@ class RestArmService(transport: ServiceTransport, baseUri: Uri)(implicit protect
       endpointUri(baseUri, "/v1/arm", filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiArm]](response)
+      reply    <- apiResponse[ListResponse[Arm]](response)
     } yield {
-      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount)
+      GetListReply.EntityList(reply.items, reply.meta.itemsCount)
     }
   }
 
@@ -40,20 +40,20 @@ class RestArmService(transport: ServiceTransport, baseUri: Uri)(implicit protect
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/arm/$armId"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiArm](response)
+      reply    <- apiResponse[Arm](response)
     } yield {
-      GetByIdReply.Entity(reply.toDomain)
+      GetByIdReply.Entity(reply)
     }
   }
 
   def create(draftArm: Arm)(implicit requestContext: AuthenticatedRequestContext): Future[CreateReply] = {
     for {
-      entity <- Marshal(ApiArm.fromDomain(draftArm)).to[RequestEntity]
+      entity <- Marshal(draftArm).to[RequestEntity]
       request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, "/v1/arm")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiArm](response)
+      reply    <- apiResponse[Arm](response)
     } yield {
-      CreateReply.Created(reply.toDomain)
+      CreateReply.Created(reply)
     }
   }
 
@@ -62,9 +62,9 @@ class RestArmService(transport: ServiceTransport, baseUri: Uri)(implicit protect
     val request = HttpRequest(HttpMethods.PATCH, endpointUri(baseUri, s"/v1/arm/$id"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiArm](response)
+      reply    <- apiResponse[Arm](response)
     } yield {
-      UpdateReply.Updated(reply.toDomain)
+      UpdateReply.Updated(reply)
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestCriterionService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestCriterionService.scala
index f0f4de8..6e2da61 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestCriterionService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestCriterionService.scala
@@ -1,7 +1,6 @@
 package xyz.driver.pdsuidomain.services.rest
 
 import scala.concurrent.{ExecutionContext, Future}
-
 import akka.http.scaladsl.marshalling.Marshal
 import akka.http.scaladsl.model._
 import akka.stream.Materializer
@@ -9,8 +8,8 @@ import xyz.driver.core.rest.{Pagination => _, _}
 import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain._
+import xyz.driver.pdsuidomain.ListResponse
 import xyz.driver.pdsuidomain.entities._
-import xyz.driver.pdsuidomain.formats.json.ListResponse
 import xyz.driver.pdsuidomain.services.CriterionService
 
 class RestCriterionService(transport: ServiceTransport, baseUri: Uri)(
@@ -18,19 +17,20 @@ class RestCriterionService(transport: ServiceTransport, baseUri: Uri)(
         protected val exec: ExecutionContext)
     extends CriterionService with RestHelper {
 
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
-  import xyz.driver.pdsuidomain.formats.json.criterion.ApiCriterion
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.listresponse._
+  import xyz.driver.pdsuidomain.formats.json.criterion._
   import xyz.driver.pdsuidomain.services.CriterionService._
 
   def create(draftRichCriterion: RichCriterion)(
           implicit requestContext: AuthenticatedRequestContext): Future[CreateReply] = {
     for {
-      entity <- Marshal(ApiCriterion.fromDomain(draftRichCriterion)).to[RequestEntity]
+      entity <- Marshal(draftRichCriterion).to[RequestEntity]
       request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, "/v1/criterion")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiCriterion](response)
+      reply    <- apiResponse[RichCriterion](response)
     } yield {
-      CreateReply.Created(reply.toDomain)
+      CreateReply.Created(reply)
     }
   }
 
@@ -38,9 +38,9 @@ class RestCriterionService(transport: ServiceTransport, baseUri: Uri)(
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/criterion/$id"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiCriterion](response)
+      reply    <- apiResponse[RichCriterion](response)
     } yield {
-      GetByIdReply.Entity(reply.toDomain)
+      GetByIdReply.Entity(reply)
     }
   }
 
@@ -54,9 +54,9 @@ class RestCriterionService(transport: ServiceTransport, baseUri: Uri)(
                                           filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiCriterion]](response)
+      reply    <- apiResponse[ListResponse[RichCriterion]](response)
     } yield {
-      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount, reply.meta.lastUpdate)
+      GetListReply.EntityList(reply.items, reply.meta.itemsCount, reply.meta.lastUpdate)
     }
   }
 
@@ -64,12 +64,12 @@ class RestCriterionService(transport: ServiceTransport, baseUri: Uri)(
           implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply] = {
     val id = origRichCriterion.criterion.id
     for {
-      entity <- Marshal(ApiCriterion.fromDomain(draftRichCriterion)).to[RequestEntity]
+      entity <- Marshal(draftRichCriterion).to[RequestEntity]
       request = HttpRequest(HttpMethods.PATCH, endpointUri(baseUri, s"/v1/criterion/$id")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiCriterion](response)
+      reply    <- apiResponse[RichCriterion](response)
     } yield {
-      UpdateReply.Updated(reply.toDomain)
+      UpdateReply.Updated(reply)
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestDocumentService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestDocumentService.scala
index 68fdde1..dcd7721 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestDocumentService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestDocumentService.scala
@@ -1,7 +1,6 @@
 package xyz.driver.pdsuidomain.services.rest
 
 import scala.concurrent.{ExecutionContext, Future}
-
 import akka.http.scaladsl.marshalling.Marshal
 import akka.http.scaladsl.model._
 import akka.stream.Materializer
@@ -9,25 +8,26 @@ import xyz.driver.core.rest.{Pagination => _, _}
 import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain._
+import xyz.driver.pdsuidomain.ListResponse
 import xyz.driver.pdsuidomain.entities._
-import xyz.driver.pdsuidomain.formats.json.ListResponse
-import xyz.driver.pdsuidomain.formats.json.document.ApiDocument
 import xyz.driver.pdsuidomain.services.DocumentService
 
 class RestDocumentService(transport: ServiceTransport, baseUri: Uri)(implicit protected val materializer: Materializer,
                                                                      protected val exec: ExecutionContext)
     extends DocumentService with RestHelper {
 
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.listresponse._
+  import xyz.driver.pdsuidomain.formats.json.document._
   import xyz.driver.pdsuidomain.services.DocumentService._
 
   def getById(id: LongId[Document])(implicit requestContext: AuthenticatedRequestContext): Future[GetByIdReply] = {
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/document/$id"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiDocument](response)
+      reply    <- apiResponse[Document](response)
     } yield {
-      GetByIdReply.Entity(reply.toDomain)
+      GetByIdReply.Entity(reply)
     }
   }
 
@@ -42,32 +42,32 @@ class RestDocumentService(transport: ServiceTransport, baseUri: Uri)(implicit pr
                                           filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiDocument]](response)
+      reply    <- apiResponse[ListResponse[Document]](response)
     } yield {
-      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount, reply.meta.lastUpdate)
+      GetListReply.EntityList(reply.items, reply.meta.itemsCount, reply.meta.lastUpdate)
     }
   }
 
   def create(draftDocument: Document)(implicit requestContext: AuthenticatedRequestContext): Future[CreateReply] = {
     for {
-      entity <- Marshal(ApiDocument.fromDomain(draftDocument)).to[RequestEntity]
+      entity <- Marshal(draftDocument).to[RequestEntity]
       request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, "/v1/document")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiDocument](response)
+      reply    <- apiResponse[Document](response)
     } yield {
-      CreateReply.Created(reply.toDomain)
+      CreateReply.Created(reply)
     }
   }
 
   def update(orig: Document, draft: Document)(
           implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply] = {
     for {
-      entity <- Marshal(ApiDocument.fromDomain(draft)).to[RequestEntity]
+      entity <- Marshal(draft).to[RequestEntity]
       request = HttpRequest(HttpMethods.PATCH, endpointUri(baseUri, s"/v1/document/${orig.id}")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiDocument](response)
+      reply    <- apiResponse[Document](response)
     } yield {
-      UpdateReply.Updated(reply.toDomain)
+      UpdateReply.Updated(reply)
     }
   }
 
@@ -87,9 +87,9 @@ class RestDocumentService(transport: ServiceTransport, baseUri: Uri)(implicit pr
     val request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, s"/v1/document/$id/$action"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiDocument](response)
+      reply    <- apiResponse[Document](response)
     } yield {
-      UpdateReply.Updated(reply.toDomain)
+      UpdateReply.Updated(reply)
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestDocumentTypeService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestDocumentTypeService.scala
index caa0042..6ddc022 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestDocumentTypeService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestDocumentTypeService.scala
@@ -1,22 +1,23 @@
 package xyz.driver.pdsuidomain.services.rest
 
 import scala.concurrent.{ExecutionContext, Future}
-
 import akka.http.scaladsl.model._
 import akka.stream.Materializer
 import xyz.driver.core.rest.{Pagination => _, _}
 import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
-import xyz.driver.pdsuidomain.formats.json.ListResponse
+import xyz.driver.pdsuidomain.ListResponse
+import xyz.driver.pdsuidomain.entities.DocumentType
 import xyz.driver.pdsuidomain.services.DocumentTypeService
-import xyz.driver.pdsuidomain.formats.json.document.ApiDocumentType
 
 class RestDocumentTypeService(transport: ServiceTransport, baseUri: Uri)(
         implicit protected val materializer: Materializer,
         protected val exec: ExecutionContext)
     extends DocumentTypeService with RestHelper {
 
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.listresponse._
+  import xyz.driver.pdsuidomain.formats.json.document.documentTypeFormat
   import xyz.driver.pdsuidomain.services.DocumentTypeService._
 
   def getAll(sorting: Option[Sorting] = None)(
@@ -24,9 +25,9 @@ class RestDocumentTypeService(transport: ServiceTransport, baseUri: Uri)(
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, "/v1/document-type", sortingQuery(sorting)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiDocumentType]](response)
+      reply    <- apiResponse[ListResponse[DocumentType]](response)
     } yield {
-      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount)
+      GetListReply.EntityList(reply.items, reply.meta.itemsCount)
     }
   }
 }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestEligibilityVerificationService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestEligibilityVerificationService.scala
index 93ee2ab..e057c55 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestEligibilityVerificationService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestEligibilityVerificationService.scala
@@ -24,7 +24,7 @@ class RestEligibilityVerificationService(transport: ServiceTransport, baseUri: U
 
   import DefaultJsonProtocol._
   import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
-  import xyz.driver.pdsuidomain.formats.json.sprayformats.eligibility._
+  import xyz.driver.pdsuidomain.formats.json.eligibility._
 
   override def getMatchedPatients()(
           implicit ctx: AuthorizedServiceRequestContext[AuthUserInfo]): ListT[Future, eligibility.MatchedPatient] = {
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestExtractedDataService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestExtractedDataService.scala
index a65e1f4..8c07968 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestExtractedDataService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestExtractedDataService.scala
@@ -10,27 +10,27 @@ import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain._
 import xyz.driver.pdsuidomain.entities._
 import xyz.driver.pdsuidomain.entities.export.patient.ExportPatientWithLabels
-import xyz.driver.pdsuidomain.formats.json.ListResponse
-import xyz.driver.pdsuidomain.formats.json.extracteddata.ApiExtractedData
 import xyz.driver.pdsuidomain.services.ExtractedDataService
 import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
-import xyz.driver.pdsuidomain.formats.json.sprayformats.export._
+import xyz.driver.pdsuidomain.ListResponse
+import xyz.driver.pdsuidomain.formats.json.export._
 
 class RestExtractedDataService(transport: ServiceTransport, baseUri: Uri)(
         implicit protected val materializer: Materializer,
         protected val exec: ExecutionContext)
     extends ExtractedDataService with RestHelper {
 
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.listresponse._
+  import xyz.driver.pdsuidomain.formats.json.extracteddata._
   import xyz.driver.pdsuidomain.services.ExtractedDataService._
 
   def getById(id: LongId[ExtractedData])(implicit requestContext: AuthenticatedRequestContext): Future[GetByIdReply] = {
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/extracted-data/$id"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiExtractedData](response)
+      reply    <- apiResponse[RichExtractedData](response)
     } yield {
-      GetByIdReply.Entity(reply.toDomain)
+      GetByIdReply.Entity(reply)
     }
   }
 
@@ -44,33 +44,33 @@ class RestExtractedDataService(transport: ServiceTransport, baseUri: Uri)(
                                           filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiExtractedData]](response)
+      reply    <- apiResponse[ListResponse[RichExtractedData]](response)
     } yield {
-      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount)
+      GetListReply.EntityList(reply.items, reply.meta.itemsCount)
     }
   }
 
   def create(draftRichExtractedData: RichExtractedData)(
           implicit requestContext: AuthenticatedRequestContext): Future[CreateReply] = {
     for {
-      entity <- Marshal(ApiExtractedData.fromDomain(draftRichExtractedData)).to[RequestEntity]
+      entity <- Marshal(draftRichExtractedData).to[RequestEntity]
       request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, "/v1/extracted-data")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiExtractedData](response)
+      reply    <- apiResponse[RichExtractedData](response)
     } yield {
-      CreateReply.Created(reply.toDomain)
+      CreateReply.Created(reply)
     }
   }
   def update(origRichExtractedData: RichExtractedData, draftRichExtractedData: RichExtractedData)(
           implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply] = {
     val id = origRichExtractedData.extractedData.id
     for {
-      entity <- Marshal(ApiExtractedData.fromDomain(draftRichExtractedData)).to[RequestEntity]
+      entity <- Marshal(draftRichExtractedData).to[RequestEntity]
       request = HttpRequest(HttpMethods.PATCH, endpointUri(baseUri, s"/v1/extracted-data/$id")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiExtractedData](response)
+      reply    <- apiResponse[RichExtractedData](response)
     } yield {
-      UpdateReply.Updated(reply.toDomain)
+      UpdateReply.Updated(reply)
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHelper.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHelper.scala
index 0ff29ef..bf42f40 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHelper.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHelper.scala
@@ -17,6 +17,8 @@ import xyz.driver.pdsuicommon.db.{
 import xyz.driver.pdsuicommon.error._
 
 trait RestHelper {
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import ErrorsResponse._
 
   implicit protected val materializer: Materializer
   implicit protected val exec: ExecutionContext
@@ -89,7 +91,6 @@ trait RestHelper {
           implicit unmarshaller: Unmarshaller[ResponseEntity, ApiReply]): Future[ApiReply] = {
 
     def extractErrorMessage(response: HttpResponse): Future[String] = {
-      import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
       Unmarshal(response.entity)
         .to[ErrorsResponse]
         .transform(
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHypothesisService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHypothesisService.scala
index 1b8c943..a352053 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHypothesisService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHypothesisService.scala
@@ -1,14 +1,13 @@
 package xyz.driver.pdsuidomain.services.rest
 
 import scala.concurrent.{ExecutionContext, Future}
-
 import akka.http.scaladsl.model._
 import akka.stream.Materializer
 import xyz.driver.core.rest._
 import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
-import xyz.driver.pdsuidomain.formats.json.ListResponse
-import xyz.driver.pdsuidomain.formats.json.hypothesis.ApiHypothesis
+import xyz.driver.pdsuidomain.ListResponse
+import xyz.driver.pdsuidomain.entities.Hypothesis
 import xyz.driver.pdsuidomain.services.HypothesisService
 
 class RestHypothesisService(transport: ServiceTransport, baseUri: Uri)(
@@ -16,7 +15,9 @@ class RestHypothesisService(transport: ServiceTransport, baseUri: Uri)(
         protected val exec: ExecutionContext)
     extends HypothesisService with RestHelper {
 
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.listresponse._
+  import xyz.driver.pdsuidomain.formats.json.hypothesis._
   import xyz.driver.pdsuidomain.services.HypothesisService._
 
   def getAll(sorting: Option[Sorting] = None)(
@@ -24,9 +25,9 @@ class RestHypothesisService(transport: ServiceTransport, baseUri: Uri)(
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, "/v1/hypothesis", sortingQuery(sorting)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiHypothesis]](response)
+      reply    <- apiResponse[ListResponse[Hypothesis]](response)
     } yield {
-      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount)
+      GetListReply.EntityList(reply.items, reply.meta.itemsCount)
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestInterventionService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestInterventionService.scala
index 025a48a..93036be 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestInterventionService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestInterventionService.scala
@@ -8,9 +8,8 @@ import xyz.driver.core.rest.{Pagination => _, _}
 import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain._
+import xyz.driver.pdsuidomain.ListResponse
 import xyz.driver.pdsuidomain.entities._
-import xyz.driver.pdsuidomain.formats.json.ListResponse
-import xyz.driver.pdsuidomain.formats.json.intervention.ApiIntervention
 import xyz.driver.pdsuidomain.services.InterventionService
 
 class RestInterventionService(transport: ServiceTransport, baseUri: Uri)(
@@ -18,7 +17,9 @@ class RestInterventionService(transport: ServiceTransport, baseUri: Uri)(
         protected val exec: ExecutionContext)
     extends InterventionService with RestHelper {
 
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.listresponse._
+  import xyz.driver.pdsuidomain.formats.json.intervention._
   import xyz.driver.pdsuidomain.services.InterventionService._
 
   def getAll(filter: SearchFilterExpr = SearchFilterExpr.Empty,
@@ -31,9 +32,9 @@ class RestInterventionService(transport: ServiceTransport, baseUri: Uri)(
                                           filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiIntervention]](response)
+      reply    <- apiResponse[ListResponse[InterventionWithArms]](response)
     } yield {
-      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount)
+      GetListReply.EntityList(reply.items, reply.meta.itemsCount)
     }
   }
 
@@ -41,9 +42,9 @@ class RestInterventionService(transport: ServiceTransport, baseUri: Uri)(
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/intervention/$id"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiIntervention](response)
+      reply    <- apiResponse[InterventionWithArms](response)
     } yield {
-      GetByIdReply.Entity(reply.toDomain)
+      GetByIdReply.Entity(reply)
     }
   }
 
@@ -51,24 +52,24 @@ class RestInterventionService(transport: ServiceTransport, baseUri: Uri)(
           implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply] = {
     val id = origIntervention.intervention.id
     for {
-      entity <- Marshal(ApiIntervention.fromDomain(draftIntervention)).to[RequestEntity]
+      entity <- Marshal(draftIntervention).to[RequestEntity]
       request = HttpRequest(HttpMethods.PATCH, endpointUri(baseUri, s"/v1/intervention/$id")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiIntervention](response)
+      reply    <- apiResponse[InterventionWithArms](response)
     } yield {
-      UpdateReply.Updated(reply.toDomain)
+      UpdateReply.Updated(reply)
     }
   }
 
   def create(draftIntervention: InterventionWithArms)(
           implicit requestContext: AuthenticatedRequestContext): Future[CreateReply] = {
     for {
-      entity <- Marshal(ApiIntervention.fromDomain(draftIntervention)).to[RequestEntity]
+      entity <- Marshal(draftIntervention).to[RequestEntity]
       request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, "/v1/intervention")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiIntervention](response)
+      reply    <- apiResponse[InterventionWithArms](response)
     } yield {
-      CreateReply.Created(reply.toDomain)
+      CreateReply.Created(reply)
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestInterventionTypeService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestInterventionTypeService.scala
index ce7ac10..004d6c4 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestInterventionTypeService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestInterventionTypeService.scala
@@ -1,13 +1,13 @@
 package xyz.driver.pdsuidomain.services.rest
 
 import scala.concurrent.{ExecutionContext, Future}
-
 import akka.http.scaladsl.model._
 import akka.stream.Materializer
 import xyz.driver.core.rest._
 import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
-import xyz.driver.pdsuidomain.formats.json.intervention.ApiInterventionType
+import xyz.driver.pdsuidomain.ListResponse
+import xyz.driver.pdsuidomain.entities.InterventionType
 import xyz.driver.pdsuidomain.services.InterventionTypeService
 
 class RestInterventionTypeService(transport: ServiceTransport, baseUri: Uri)(
@@ -15,8 +15,9 @@ class RestInterventionTypeService(transport: ServiceTransport, baseUri: Uri)(
         protected val exec: ExecutionContext)
     extends InterventionTypeService with RestHelper {
 
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
-  import xyz.driver.pdsuidomain.formats.json.ListResponse
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.listresponse._
+  import xyz.driver.pdsuidomain.formats.json.intervention.interventionTypeFormat
   import xyz.driver.pdsuidomain.services.InterventionTypeService._
 
   def getAll(sorting: Option[Sorting] = None)(
@@ -24,10 +25,10 @@ class RestInterventionTypeService(transport: ServiceTransport, baseUri: Uri)(
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, "/v1/intervention-type", sortingQuery(sorting)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiInterventionType]](response)
+      reply    <- apiResponse[ListResponse[InterventionType]](response)
     } yield {
       {
-        val domain = reply.items.flatMap(_.toDomain)
+        val domain = reply.items
         GetListReply.EntityList(domain.toList, reply.meta.itemsCount)
       }
     }
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestMedicalRecordService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestMedicalRecordService.scala
index f2b0f2d..0627521 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestMedicalRecordService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestMedicalRecordService.scala
@@ -3,8 +3,8 @@ package xyz.driver.pdsuidomain.services.rest
 import akka.NotUsed
 import akka.stream.scaladsl.Source
 import akka.util.ByteString
-import scala.concurrent.{ExecutionContext, Future}
 
+import scala.concurrent.{ExecutionContext, Future}
 import akka.http.scaladsl.marshalling.Marshal
 import akka.http.scaladsl.model._
 import akka.stream.Materializer
@@ -12,9 +12,8 @@ import xyz.driver.core.rest.{Pagination => _, _}
 import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain._
+import xyz.driver.pdsuidomain.ListResponse
 import xyz.driver.pdsuidomain.entities._
-import xyz.driver.pdsuidomain.formats.json.ListResponse
-import xyz.driver.pdsuidomain.formats.json.record.ApiRecord
 import xyz.driver.pdsuidomain.services.MedicalRecordService
 
 class RestMedicalRecordService(transport: ServiceTransport, baseUri: Uri)(
@@ -22,7 +21,9 @@ class RestMedicalRecordService(transport: ServiceTransport, baseUri: Uri)(
         protected val exec: ExecutionContext)
     extends MedicalRecordService with RestHelper {
 
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.listresponse._
+  import xyz.driver.pdsuidomain.formats.json.record._
   import xyz.driver.pdsuidomain.services.MedicalRecordService._
 
   def getById(recordId: LongId[MedicalRecord])(
@@ -30,9 +31,9 @@ class RestMedicalRecordService(transport: ServiceTransport, baseUri: Uri)(
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/record/$recordId"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiRecord](response)
+      reply    <- apiResponse[MedicalRecord](response)
     } yield {
-      GetByIdReply.Entity(reply.toDomain)
+      GetByIdReply.Entity(reply)
     }
   }
 
@@ -59,20 +60,20 @@ class RestMedicalRecordService(transport: ServiceTransport, baseUri: Uri)(
       endpointUri(baseUri, "/v1/record", filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiRecord]](response)
+      reply    <- apiResponse[ListResponse[MedicalRecord]](response)
     } yield {
-      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount, reply.meta.lastUpdate)
+      GetListReply.EntityList(reply.items, reply.meta.itemsCount, reply.meta.lastUpdate)
     }
   }
 
   def create(draftRecord: MedicalRecord)(implicit requestContext: AnonymousRequestContext): Future[CreateReply] = {
     for {
-      entity <- Marshal(ApiRecord.fromDomain(draftRecord)).to[RequestEntity]
+      entity <- Marshal(draftRecord).to[RequestEntity]
       request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, "/v1/record")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiRecord](response)
+      reply    <- apiResponse[MedicalRecord](response)
     } yield {
-      CreateReply.Created(reply.toDomain)
+      CreateReply.Created(reply)
     }
   }
 
@@ -80,12 +81,12 @@ class RestMedicalRecordService(transport: ServiceTransport, baseUri: Uri)(
           implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply] = {
     val id = origRecord.id.toString
     for {
-      entity <- Marshal(ApiRecord.fromDomain(draftRecord)).to[RequestEntity]
+      entity <- Marshal(draftRecord).to[RequestEntity]
       request = HttpRequest(HttpMethods.PATCH, endpointUri(baseUri, s"/v1/record/$id")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiRecord](response)
+      reply    <- apiResponse[MedicalRecord](response)
     } yield {
-      UpdateReply.Updated(reply.toDomain)
+      UpdateReply.Updated(reply)
     }
   }
 
@@ -95,9 +96,9 @@ class RestMedicalRecordService(transport: ServiceTransport, baseUri: Uri)(
     val request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, s"/v1/record/$id/$action"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiRecord](response)
+      reply    <- apiResponse[MedicalRecord](response)
     } yield {
-      UpdateReply.Updated(reply.toDomain)
+      UpdateReply.Updated(reply)
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestMessageService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestMessageService.scala
deleted file mode 100644
index e133825..0000000
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestMessageService.scala
+++ /dev/null
@@ -1,87 +0,0 @@
-package xyz.driver.pdsuidomain.services.rest
-
-import scala.concurrent.{ExecutionContext, Future}
-
-import akka.http.scaladsl.marshalling.Marshal
-import akka.http.scaladsl.model._
-import akka.stream.Materializer
-import xyz.driver.core.rest.{Pagination => _, _}
-import xyz.driver.pdsuicommon.auth._
-import xyz.driver.pdsuicommon.db._
-import xyz.driver.pdsuicommon.domain._
-import xyz.driver.pdsuidomain.entities._
-import xyz.driver.pdsuidomain.formats.json.ListResponse
-import xyz.driver.pdsuidomain.formats.json.message.ApiMessage
-import xyz.driver.pdsuidomain.services.MessageService
-
-class RestMessageService(transport: ServiceTransport, baseUri: Uri)(implicit protected val materializer: Materializer,
-                                                                    protected val exec: ExecutionContext)
-    extends MessageService with RestHelper {
-
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
-  import xyz.driver.pdsuidomain.services.MessageService._
-
-  def create(draftMessage: Message)(implicit requestContext: AuthenticatedRequestContext): Future[CreateReply] = {
-    for {
-      entity <- Marshal(ApiMessage.fromDomain(draftMessage)).to[RequestEntity]
-      request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, "/v1/message")).withEntity(entity)
-      response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiMessage](response)
-    } yield {
-      CreateReply.Created(reply.toDomain)
-    }
-  }
-
-  def getById(messageId: LongId[Message])(implicit requestContext: AuthenticatedRequestContext): Future[GetByIdReply] = {
-    import xyz.driver.pdsuicommon.db.SearchFilterBinaryOperation._
-    import xyz.driver.pdsuicommon.db.SearchFilterExpr._
-    val filter = Atom.Binary("id", Eq, messageId)
-    getAll(filter).map({
-      case GetListReply.EntityList(messages, _, _) if messages.isEmpty =>
-        GetByIdReply.NotFoundError
-      case GetListReply.EntityList(messages, _, _) =>
-        GetByIdReply.Entity(messages.head)
-      case GetListReply.AuthorizationError =>
-        GetByIdReply.AuthorizationError
-    })
-  }
-
-  def getAll(filter: SearchFilterExpr = SearchFilterExpr.Empty,
-             sorting: Option[Sorting] = None,
-             pagination: Option[Pagination] = None)(
-          implicit requestContext: AuthenticatedRequestContext): Future[GetListReply] = {
-    val request = HttpRequest(
-      HttpMethods.GET,
-      endpointUri(baseUri, "/v1/message", filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination)))
-    for {
-      response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiMessage]](response)
-    } yield {
-      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount, reply.meta.lastUpdate)
-    }
-  }
-
-  def update(origMessage: Message, draftMessage: Message)(
-          implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply] = {
-    for {
-      entity <- Marshal(ApiMessage.fromDomain(draftMessage)).to[RequestEntity]
-      id      = origMessage.id.id
-      request = HttpRequest(HttpMethods.PATCH, endpointUri(baseUri, s"/v1/message/$id")).withEntity(entity)
-      response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiMessage](response)
-    } yield {
-      UpdateReply.Updated(reply.toDomain)
-    }
-  }
-
-  def delete(messageId: LongId[Message])(implicit requestContext: AuthenticatedRequestContext): Future[DeleteReply] = {
-    val request = HttpRequest(HttpMethods.DELETE, endpointUri(baseUri, s"/v1/message/${messageId.id}"))
-    for {
-      response <- transport.sendRequestGetResponse(requestContext)(request)
-      _        <- apiResponse[HttpEntity](response)
-    } yield {
-      DeleteReply.Deleted
-    }
-  }
-
-}
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestPatientService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestPatientService.scala
index b9cbec8..af3c782 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestPatientService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestPatientService.scala
@@ -8,25 +8,27 @@ import xyz.driver.core.rest.{Pagination => _, _}
 import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain._
+import xyz.driver.pdsuidomain.ListResponse
 import xyz.driver.pdsuidomain.entities._
-import xyz.driver.pdsuidomain.formats.json.ListResponse
-import xyz.driver.pdsuidomain.formats.json.patient.ApiPatient
 import xyz.driver.pdsuidomain.services.PatientService
 
 class RestPatientService(transport: ServiceTransport, baseUri: Uri)(implicit protected val materializer: Materializer,
                                                                     protected val exec: ExecutionContext)
     extends PatientService with RestHelper {
 
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.listresponse._
+  import xyz.driver.pdsuidomain.formats.json.patient._
+
   import xyz.driver.pdsuidomain.services.PatientService._
 
   def getById(id: UuidId[Patient])(implicit requestContext: AuthenticatedRequestContext): Future[GetByIdReply] = {
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/patient/$id"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiPatient](response)
+      reply    <- apiResponse[Patient](response)
     } yield {
-      GetByIdReply.Entity(reply.toDomain)
+      GetByIdReply.Entity(reply)
     }
   }
 
@@ -39,9 +41,9 @@ class RestPatientService(transport: ServiceTransport, baseUri: Uri)(implicit pro
       endpointUri(baseUri, "/v1/patient", filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiPatient]](response)
+      reply    <- apiResponse[ListResponse[Patient]](response)
     } yield {
-      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount, reply.meta.lastUpdate)
+      GetListReply.EntityList(reply.items, reply.meta.itemsCount, reply.meta.lastUpdate)
     }
   }
 
@@ -51,9 +53,9 @@ class RestPatientService(transport: ServiceTransport, baseUri: Uri)(implicit pro
     val request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, s"/v1/patient/$id/$action"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiPatient](response)
+      reply    <- apiResponse[Patient](response)
     } yield {
-      UpdateReply.Updated(reply.toDomain)
+      UpdateReply.Updated(reply)
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestProviderTypeService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestProviderTypeService.scala
index f82ec40..f038c95 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestProviderTypeService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestProviderTypeService.scala
@@ -1,22 +1,23 @@
 package xyz.driver.pdsuidomain.services.rest
 
 import scala.concurrent.{ExecutionContext, Future}
-
 import akka.http.scaladsl.model._
 import akka.stream.Materializer
 import xyz.driver.core.rest.{Pagination => _, _}
 import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
-import xyz.driver.pdsuidomain.formats.json.ListResponse
+import xyz.driver.pdsuidomain.ListResponse
+import xyz.driver.pdsuidomain.entities.ProviderType
 import xyz.driver.pdsuidomain.services.ProviderTypeService
-import xyz.driver.pdsuidomain.formats.json.document.ApiProviderType
 
 class RestProviderTypeService(transport: ServiceTransport, baseUri: Uri)(
         implicit protected val materializer: Materializer,
         protected val exec: ExecutionContext)
     extends ProviderTypeService with RestHelper {
 
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.listresponse._
+  import xyz.driver.pdsuidomain.formats.json.record.providerTypeFormat
   import xyz.driver.pdsuidomain.services.ProviderTypeService._
 
   def getAll(sorting: Option[Sorting] = None)(
@@ -24,9 +25,9 @@ class RestProviderTypeService(transport: ServiceTransport, baseUri: Uri)(
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, "/v1/provider-type", sortingQuery(sorting)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiProviderType]](response)
+      reply    <- apiResponse[ListResponse[ProviderType]](response)
     } yield {
-      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount)
+      GetListReply.EntityList(reply.items, reply.meta.itemsCount)
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestStudyDesignService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestStudyDesignService.scala
index b1684eb..d3f0eb7 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestStudyDesignService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestStudyDesignService.scala
@@ -1,14 +1,13 @@
 package xyz.driver.pdsuidomain.services.rest
 
 import scala.concurrent.{ExecutionContext, Future}
-
 import akka.http.scaladsl.model._
 import akka.stream.Materializer
 import xyz.driver.core.rest._
 import xyz.driver.pdsuicommon.auth._
 import xyz.driver.pdsuicommon.db._
-import xyz.driver.pdsuidomain.formats.json.ListResponse
-import xyz.driver.pdsuidomain.formats.json.studydesign.ApiStudyDesign
+import xyz.driver.pdsuidomain.ListResponse
+import xyz.driver.pdsuidomain.entities.StudyDesign
 import xyz.driver.pdsuidomain.services.StudyDesignService
 
 class RestStudyDesignService(transport: ServiceTransport, baseUri: Uri)(
@@ -16,7 +15,9 @@ class RestStudyDesignService(transport: ServiceTransport, baseUri: Uri)(
         protected val exec: ExecutionContext)
     extends StudyDesignService with RestHelper {
 
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.listresponse._
+  import xyz.driver.pdsuidomain.formats.json.studydesign._
   import xyz.driver.pdsuidomain.services.StudyDesignService._
 
   def getAll(sorting: Option[Sorting] = None)(
@@ -24,9 +25,9 @@ class RestStudyDesignService(transport: ServiceTransport, baseUri: Uri)(
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, "/v1/study-design", sortingQuery(sorting)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiStudyDesign]](response)
+      reply    <- apiResponse[ListResponse[StudyDesign]](response)
     } yield {
-      GetListReply.EntityList(reply.items.flatMap(_.toDomain), reply.meta.itemsCount)
+      GetListReply.EntityList(reply.items, reply.meta.itemsCount)
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala
index ea719e1..04b45fb 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala
@@ -13,28 +13,28 @@ import xyz.driver.pdsuicommon.db._
 import xyz.driver.pdsuicommon.domain._
 import xyz.driver.pdsuidomain.entities._
 import xyz.driver.pdsuidomain.entities.export.trial.ExportTrialWithLabels
-import xyz.driver.pdsuidomain.formats.json.ListResponse
-import xyz.driver.pdsuidomain.formats.json.trial.ApiTrial
 import xyz.driver.pdsuidomain.services.TrialService
 import spray.json.DefaultJsonProtocol._
-import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
 import xyz.driver.entities.patient.CancerType
-import xyz.driver.pdsuidomain.formats.json.sprayformats.export._
+import xyz.driver.pdsuidomain.ListResponse
+import xyz.driver.pdsuidomain.formats.json.export._
 
 class RestTrialService(transport: ServiceTransport, baseUri: Uri)(implicit protected val materializer: Materializer,
                                                                   protected val exec: ExecutionContext)
     extends TrialService with RestHelper {
 
-  import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
+  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
+  import xyz.driver.pdsuidomain.formats.json.listresponse._
+  import xyz.driver.pdsuidomain.formats.json.trial._
   import xyz.driver.pdsuidomain.services.TrialService._
 
   def getById(id: StringId[Trial])(implicit requestContext: AuthenticatedRequestContext): Future[GetByIdReply] = {
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/trial/$id"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiTrial](response)
+      reply    <- apiResponse[Trial](response)
     } yield {
-      GetByIdReply.Entity(reply.toDomain)
+      GetByIdReply.Entity(reply)
     }
   }
 
@@ -80,9 +80,9 @@ class RestTrialService(transport: ServiceTransport, baseUri: Uri)(implicit prote
       endpointUri(baseUri, "/v1/trial", filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ListResponse[ApiTrial]](response)
+      reply    <- apiResponse[ListResponse[Trial]](response)
     } yield {
-      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount, reply.meta.lastUpdate)
+      GetListReply.EntityList(reply.items, reply.meta.itemsCount, reply.meta.lastUpdate)
     }
   }
 
@@ -90,12 +90,12 @@ class RestTrialService(transport: ServiceTransport, baseUri: Uri)(implicit prote
           implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply] = {
     val id = origTrial.id.id
     for {
-      entity <- Marshal(ApiTrial.fromDomain(draftTrial)).to[RequestEntity]
+      entity <- Marshal(draftTrial).to[RequestEntity]
       request = HttpRequest(HttpMethods.PATCH, endpointUri(baseUri, s"/v1/trial/$id")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiTrial](response)
+      reply    <- apiResponse[Trial](response)
     } yield {
-      UpdateReply.Updated(reply.toDomain)
+      UpdateReply.Updated(reply)
     }
   }
 
@@ -105,9 +105,9 @@ class RestTrialService(transport: ServiceTransport, baseUri: Uri)(implicit prote
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/trial/$id/$action"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply    <- apiResponse[ApiTrial](response)
+      reply    <- apiResponse[Trial](response)
     } yield {
-      UpdateReply.Updated(reply.toDomain)
+      UpdateReply.Updated(reply)
     }
   }
 
-- 
cgit v1.2.3