Refactor reply mapping

9 files changed, 69 insertions, 173 deletions

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 e7cd2db..0bbbb72 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestArmService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestArmService.scala
@@ -1,8 +1,8 @@
 package xyz.driver.pdsuidomain.services.rest
 
-import akka.http.scaladsl.marshalling.Marshal
 import scala.concurrent.{ExecutionContext, Future}
 
+import akka.http.scaladsl.marshalling.Marshal
 import akka.http.scaladsl.model._
 import akka.stream.ActorMaterializer
 import xyz.driver.core.rest._
@@ -18,31 +18,21 @@ class RestArmService(transport: ServiceTransport, baseUri: Uri)(implicit protect
                                                                 protected val exec: ExecutionContext)
     extends ArmService with RestHelper {
 
-  import xyz.driver.pdsuidomain.services.ArmService._
   import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
-
-  // GET               /v1/arm                    xyz.driver.server.controllers.ArmController.getList
-  // GET               /v1/arm/:id                xyz.driver.server.controllers.ArmController.getById(id: Long)
-  // POST              /v1/arm                    xyz.driver.server.controllers.ArmController.create
-  // PATCH             /v1/arm/:id                xyz.driver.server.controllers.ArmController.update(id: Long)
-  // DELETE            /v1/arm/:id                xyz.driver.server.controllers.ArmController.delete(id: Long)
+  import xyz.driver.pdsuidomain.services.ArmService._
 
   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/arm", filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination)))
-
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ListResponse[ApiArm], GetListReply](response) { api =>
-                GetListReply.EntityList(api.items.map(_.toDomain), api.meta.itemsCount)
-              }
+      reply    <- apiResponse[ListResponse[ApiArm]](response)
     } yield {
-      reply
+      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount)
     }
   }
 
@@ -50,11 +40,9 @@ 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, GetByIdReply](response) { api =>
-                GetByIdReply.Entity(api.toDomain)
-              }
+      reply    <- apiResponse[ApiArm](response)
     } yield {
-      reply
+      GetByIdReply.Entity(reply.toDomain)
     }
   }
 
@@ -63,11 +51,9 @@ class RestArmService(transport: ServiceTransport, baseUri: Uri)(implicit protect
       entity <- Marshal(ApiArm.fromDomain(draftArm)).to[RequestEntity]
       request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, "/v1/arm")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ApiArm, CreateReply](response) { api =>
-                CreateReply.Created(api.toDomain)
-              }
+      reply    <- apiResponse[ApiArm](response)
     } yield {
-      reply
+      CreateReply.Created(reply.toDomain)
     }
   }
 
@@ -76,11 +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, UpdateReply](response) { api =>
-                UpdateReply.Updated(api.toDomain)
-              }
+      reply    <- apiResponse[ApiArm](response)
     } yield {
-      reply
+      UpdateReply.Updated(reply.toDomain)
     }
   }
 
@@ -88,11 +72,9 @@ class RestArmService(transport: ServiceTransport, baseUri: Uri)(implicit protect
     val request = HttpRequest(HttpMethods.DELETE, endpointUri(baseUri, s"/v1/arm/$id"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ApiArm, DeleteReply](response) { _ =>
-                DeleteReply.Deleted
-              }
+      reply    <- apiResponse[ApiArm](response)
     } yield {
-      reply
+      DeleteReply.Deleted
     }
   }
 
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 f2cc9a8..2ec4db0 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestCriterionService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestCriterionService.scala
@@ -22,23 +22,15 @@ class RestCriterionService(transport: ServiceTransport, baseUri: Uri)(
   import xyz.driver.pdsuidomain.formats.json.criterion.ApiCriterion
   import xyz.driver.pdsuidomain.services.CriterionService._
 
-  // GET               /v1/criterion              xyz.driver.server.controllers.CriterionController.getList
-  // GET               /v1/criterion/:id          xyz.driver.server.controllers.CriterionController.getById(id: Long)
-  // PATCH             /v1/criterion/:id          xyz.driver.server.controllers.CriterionController.update(id: Long)
-  // POST              /v1/criterion              xyz.driver.server.controllers.CriterionController.create
-  // DELETE            /v1/criterion/:id          xyz.driver.server.controllers.CriterionController.delete(id: Long)
-
   def create(draftRichCriterion: RichCriterion)(
           implicit requestContext: AuthenticatedRequestContext): Future[CreateReply] = {
     for {
       entity <- Marshal(ApiCriterion.fromDomain(draftRichCriterion)).to[RequestEntity]
       request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, "/v1/criterion")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ApiCriterion, CreateReply](response) { api =>
-                CreateReply.Created(api.toDomain)
-              }
+      reply    <- apiResponse[ApiCriterion](response)
     } yield {
-      reply
+      CreateReply.Created(reply.toDomain)
     }
   }
 
@@ -46,11 +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, GetByIdReply](response) { api =>
-                GetByIdReply.Entity(api.toDomain)
-              }
+      reply    <- apiResponse[ApiCriterion](response)
     } yield {
-      reply
+      GetByIdReply.Entity(reply.toDomain)
     }
   }
 
@@ -58,23 +48,15 @@ class RestCriterionService(transport: ServiceTransport, baseUri: Uri)(
              sorting: Option[Sorting] = None,
              pagination: Option[Pagination] = None)(
           implicit requestContext: AuthenticatedRequestContext): Future[GetListReply] = {
-
     val request = HttpRequest(HttpMethods.GET,
                               endpointUri(baseUri,
                                           s"/v1/criterion",
                                           filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination)))
-
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ListResponse[ApiCriterion], GetListReply](response) { api =>
-                GetListReply.EntityList(
-                  api.items.map(_.toDomain),
-                  api.meta.itemsCount,
-                  api.meta.lastUpdate
-                )
-              }
+      reply    <- apiResponse[ListResponse[ApiCriterion]](response)
     } yield {
-      reply
+      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount, reply.meta.lastUpdate)
     }
   }
 
@@ -85,11 +67,9 @@ class RestCriterionService(transport: ServiceTransport, baseUri: Uri)(
       entity <- Marshal(ApiCriterion.fromDomain(draftRichCriterion)).to[RequestEntity]
       request = HttpRequest(HttpMethods.PATCH, endpointUri(baseUri, s"/v1/criterion/$id")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ApiCriterion, UpdateReply](response) { api =>
-                UpdateReply.Updated(api.toDomain)
-              }
+      reply    <- apiResponse[ApiCriterion](response)
     } yield {
-      reply
+      UpdateReply.Updated(reply.toDomain)
     }
   }
 
@@ -97,11 +77,9 @@ class RestCriterionService(transport: ServiceTransport, baseUri: Uri)(
     val request = HttpRequest(HttpMethods.DELETE, endpointUri(baseUri, s"/v1/criterion/$id"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ApiCriterion, DeleteReply](response) { _ =>
-                DeleteReply.Deleted
-              }
+      reply    <- apiResponse[ApiCriterion](response)
     } yield {
-      reply
+      DeleteReply.Deleted
     }
   }
 
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 bd9580a..3113b21 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHelper.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHelper.scala
@@ -15,7 +15,6 @@ import xyz.driver.pdsuicommon.db.{
   Sorting,
   SortingOrder
 }
-import xyz.driver.pdsuicommon.serialization.PlayJsonSupport
 import xyz.driver.pdsuicommon.error._
 
 trait RestHelper {
@@ -92,11 +91,11 @@ trait RestHelper {
     * is not explicitly handled, it will be encoded as a failure in the returned future.
     * @param unmarshaller An unmarshaller that converts a successful response to an api reply.
     */
-  def apiResponse[ApiReply, DomainReply](response: HttpResponse)(successMapper: ApiReply => DomainReply)(
-          implicit unmarshaller: Unmarshaller[ResponseEntity, ApiReply]): Future[DomainReply] = {
+  def apiResponse[ApiReply](response: HttpResponse)(
+          implicit unmarshaller: Unmarshaller[ResponseEntity, ApiReply]): Future[ApiReply] = {
 
     def extractErrorMessage(response: HttpResponse): Future[String] = {
-      import PlayJsonSupport._
+      import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
       Unmarshal(response.entity)
         .to[ErrorsResponse.ResponseError]
         .transform(
@@ -106,8 +105,7 @@ trait RestHelper {
     }
 
     if (response.status.isSuccess) {
-      val reply = Unmarshal(response.entity).to[ApiReply]
-      reply.map(successMapper)
+      Unmarshal(response.entity).to[ApiReply]
     } else {
       extractErrorMessage(response).flatMap { message =>
         Future.failed(response.status match {
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 085c347..37b28ae 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHypothesisService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestHypothesisService.scala
@@ -19,20 +19,14 @@ class RestHypothesisService(transport: ServiceTransport, baseUri: Uri)(
   import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
   import xyz.driver.pdsuidomain.services.HypothesisService._
 
-  // GET               /v1/hypothesis             xyz.driver.server.controllers.HypothesisController.getList
-
   def getAll(sorting: Option[Sorting] = None)(
           implicit requestContext: AuthenticatedRequestContext): Future[GetListReply] = {
-
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, "/v1/hypothesis", sortingQuery(sorting)))
-
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ListResponse[ApiHypothesis], GetListReply](response) { api =>
-                GetListReply.EntityList(api.items.map(_.toDomain), api.meta.itemsCount)
-              }
+      reply    <- apiResponse[ListResponse[ApiHypothesis]](response)
     } yield {
-      reply
+      GetListReply.EntityList(reply.items.map(_.toDomain), 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 9b5c51c..19509a3 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestInterventionService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestInterventionService.scala
@@ -1,8 +1,8 @@
 package xyz.driver.pdsuidomain.services.rest
 
-import akka.http.scaladsl.marshalling.Marshal
 import scala.concurrent.{ExecutionContext, Future}
 
+import akka.http.scaladsl.marshalling.Marshal
 import akka.http.scaladsl.model._
 import akka.stream.ActorMaterializer
 import xyz.driver.core.rest._
@@ -19,59 +19,45 @@ class RestInterventionService(transport: ServiceTransport, baseUri: Uri)(
         protected val exec: ExecutionContext)
     extends InterventionService with RestHelper {
 
-  import xyz.driver.pdsuidomain.services.InterventionService._
   import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
-
-  // GET   /v1/intervention     xyz.driver.server.controllers.InterventionController.getList
-  // GET   /v1/intervention/:id xyz.driver.server.controllers.InterventionController.getById(id: Long)
-  // PATCH /v1/intervention/:id xyz.driver.server.controllers.InterventionController.update(id: Long)
+  import xyz.driver.pdsuidomain.services.InterventionService._
 
   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/intervention",
                                           filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination)))
-
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ListResponse[ApiIntervention], GetListReply](response) { api =>
-                GetListReply.EntityList(api.items.map(_.toDomain), api.meta.itemsCount)
-              }
+      reply    <- apiResponse[ListResponse[ApiIntervention]](response)
     } yield {
-      reply
+      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount)
     }
   }
 
   def getById(id: LongId[Intervention])(implicit requestContext: AuthenticatedRequestContext): Future[GetByIdReply] = {
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/intervention/$id"))
-
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ApiIntervention, GetByIdReply](response) { api =>
-                GetByIdReply.Entity(api.toDomain)
-              }
+      reply    <- apiResponse[ApiIntervention](response)
     } yield {
-      reply
+      GetByIdReply.Entity(reply.toDomain)
     }
   }
 
   def update(origIntervention: InterventionWithArms, draftIntervention: InterventionWithArms)(
           implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply] = {
     val id = origIntervention.intervention.id
-
     for {
       entity <- Marshal(ApiIntervention.fromDomain(draftIntervention)).to[RequestEntity]
       request = HttpRequest(HttpMethods.PATCH, endpointUri(baseUri, s"/v1/intervention/$id")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ApiIntervention, UpdateReply](response) { api =>
-                UpdateReply.Updated(api.toDomain)
-              }
+      reply    <- apiResponse[ApiIntervention](response)
     } yield {
-      reply
+      UpdateReply.Updated(reply.toDomain)
     }
   }
 
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 8a4694c..fad2841 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestInterventionTypeService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestInterventionTypeService.scala
@@ -21,16 +21,15 @@ class RestInterventionTypeService(transport: ServiceTransport, baseUri: Uri)(
 
   def getAll(sorting: Option[Sorting] = None)(
           implicit requestContext: AuthenticatedRequestContext): Future[GetListReply] = {
-
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, "/v1/intervention-type", sortingQuery(sorting)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ListResponse[ApiInterventionType], GetListReply](response) { list =>
-                val domain = list.items.map(_.toDomain)
-                GetListReply.EntityList(domain.toList, list.meta.itemsCount)
-              }
+      reply    <- apiResponse[ListResponse[ApiInterventionType]](response)
     } yield {
-      reply
+      {
+        val domain = reply.items.map(_.toDomain)
+        GetListReply.EntityList(domain.toList, reply.meta.itemsCount)
+      }
     }
   }
 
diff --git a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestMessageService.scala b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestMessageService.scala
index e0e0813..17ded0a 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestMessageService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestMessageService.scala
@@ -1,8 +1,8 @@
 package xyz.driver.pdsuidomain.services.rest
 
-import akka.http.scaladsl.marshalling.Marshal
 import scala.concurrent.{ExecutionContext, Future}
 
+import akka.http.scaladsl.marshalling.Marshal
 import akka.http.scaladsl.model._
 import akka.stream.ActorMaterializer
 import xyz.driver.core.rest._
@@ -22,53 +22,43 @@ class RestMessageService(transport: ServiceTransport, baseUri: Uri)(
   import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
   import xyz.driver.pdsuidomain.services.MessageService._
 
-  // GET    /v1/message     xyz.driver.server.controllers.MessageController.getList
-  // POST   /v1/message     xyz.driver.server.controllers.MessageController.create
-  // PATCH  /v1/message/:id xyz.driver.server.controllers.MessageController.update(id: Long)
-  // DELETE /v1/message/:id xyz.driver.server.controllers.MessageController.delete(id: Long)
-
   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, CreateReply](response) { api =>
-                CreateReply.Created(api.toDomain)
-              }
+      reply    <- apiResponse[ApiMessage](response)
     } yield {
-      reply
+      CreateReply.Created(reply.toDomain)
     }
   }
 
   def getById(messageId: LongId[Message])(implicit requestContext: AuthenticatedRequestContext): Future[GetByIdReply] = {
-    import SearchFilterExpr._
-    import SearchFilterBinaryOperation._
+    import xyz.driver.pdsuicommon.db.SearchFilterBinaryOperation._
+    import xyz.driver.pdsuicommon.db.SearchFilterExpr._
     val filter = Atom.Binary("id", Eq, messageId)
-    getAll(filter).map {
+    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], GetListReply](response) { api =>
-                GetListReply.EntityList(api.items.map(_.toDomain), api.meta.itemsCount, api.meta.lastUpdate)
-              }
+      reply    <- apiResponse[ListResponse[ApiMessage]](response)
     } yield {
-      reply
+      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount, reply.meta.lastUpdate)
     }
   }
 
@@ -79,24 +69,19 @@ class RestMessageService(transport: ServiceTransport, baseUri: Uri)(
       id      = origMessage.id.id
       request = HttpRequest(HttpMethods.PATCH, endpointUri(baseUri, s"/v1/message/$id")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ApiMessage, UpdateReply](response) { api =>
-                UpdateReply.Updated(api.toDomain)
-              }
+      reply    <- apiResponse[ApiMessage](response)
     } yield {
-      reply
+      UpdateReply.Updated(reply.toDomain)
     }
   }
 
   def delete(messageId: LongId[Message])(implicit requestContext: AuthenticatedRequestContext): Future[DeleteReply] = {
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/message/${messageId.id}"))
-
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ApiMessage, DeleteReply](response) { _ =>
-                DeleteReply.Deleted
-              }
+      reply    <- apiResponse[ApiMessage](response)
     } yield {
-      reply
+      DeleteReply.Deleted
     }
   }
 
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 1945b0a..4fba287 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestStudyDesignService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestStudyDesignService.scala
@@ -19,18 +19,14 @@ class RestStudyDesignService(transport: ServiceTransport, baseUri: Uri)(
   import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
   import xyz.driver.pdsuidomain.services.StudyDesignService._
 
-  // GET               /v1/study-design           xyz.driver.server.controllers.StudyDesignController.getList
-
   def getAll(sorting: Option[Sorting] = None)(
           implicit requestContext: AuthenticatedRequestContext): Future[GetListReply] = {
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, "/v1/study-design", sortingQuery(sorting)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ListResponse[ApiStudyDesign], GetListReply](response) { api =>
-                GetListReply.EntityList(api.items.map(_.toDomain), api.meta.itemsCount)
-              }
+      reply    <- apiResponse[ListResponse[ApiStudyDesign]](response)
     } yield {
-      reply
+      GetListReply.EntityList(reply.items.map(_.toDomain), 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 db7f79e..9265280 100644
--- a/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala
+++ b/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialService.scala
@@ -1,9 +1,9 @@
 package xyz.driver.pdsuidomain.services.rest
 
-import akka.http.scaladsl.marshalling.Marshal
 import scala.NotImplementedError
 import scala.concurrent.{ExecutionContext, Future}
 
+import akka.http.scaladsl.marshalling.Marshal
 import akka.http.scaladsl.model._
 import akka.stream.ActorMaterializer
 import xyz.driver.core.rest._
@@ -11,9 +11,9 @@ 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.trial.ApiTrial
 import xyz.driver.pdsuidomain.services.TrialService
-import xyz.driver.pdsuidomain.formats.json.ListResponse
 
 class RestTrialService(transport: ServiceTransport, baseUri: Uri)(
         implicit protected val materializer: ActorMaterializer,
@@ -23,50 +23,32 @@ class RestTrialService(transport: ServiceTransport, baseUri: Uri)(
   import xyz.driver.pdsuicommon.serialization.PlayJsonSupport._
   import xyz.driver.pdsuidomain.services.TrialService._
 
-  // GET               /v1/trial                  xyz.driver.server.controllers.TrialController.getList
-  // GET               /v1/trial/:id              xyz.driver.server.controllers.TrialController.getById(id: String)
-  // GET               /v1/trial/:id/source       xyz.driver.server.controllers.TrialController.getSource(id: String)
-  // PATCH             /v1/trial/:id              xyz.driver.server.controllers.TrialController.update(id: String)
-  // POST              /v1/trial/:id/start        xyz.driver.server.controllers.TrialController.start(id: String)
-  // POST              /v1/trial/:id/submit       xyz.driver.server.controllers.TrialController.submit(id: String)
-  // POST              /v1/trial/:id/restart      xyz.driver.server.controllers.TrialController.restart(id: String)
-  // POST              /v1/trial/:id/flag         xyz.driver.server.controllers.TrialController.flag(id: String)
-  // POST              /v1/trial/:id/resolve      xyz.driver.server.controllers.TrialController.resolve(id: String)
-  // POST              /v1/trial/:id/archive      xyz.driver.server.controllers.TrialController.archive(id: String)
-  // POST              /v1/trial/:id/unassign     xyz.driver.server.controllers.TrialController.unassign(id: String)
-
   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, GetByIdReply](response) { api =>
-                GetByIdReply.Entity(api.toDomain)
-              }
+      reply    <- apiResponse[ApiTrial](response)
     } yield {
-      reply
+      GetByIdReply.Entity(reply.toDomain)
     }
   }
 
   def getPdfSource(trialId: StringId[Trial])(
-          implicit requestContext: AuthenticatedRequestContext): Future[GetPdfSourceReply] = Future.failed(
-    new NotImplementedError("Streaming PDF over network is not supported.")
-  )
+          implicit requestContext: AuthenticatedRequestContext): Future[GetPdfSourceReply] =
+    Future.failed(new NotImplementedError("Streaming PDF over network is not supported."))
 
   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/trial", filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination)))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ListResponse[ApiTrial], GetListReply](response) { api =>
-                GetListReply.EntityList(api.items.map(_.toDomain), api.meta.itemsCount, api.meta.lastUpdate)
-              }
+      reply    <- apiResponse[ListResponse[ApiTrial]](response)
     } yield {
-      reply
+      GetListReply.EntityList(reply.items.map(_.toDomain), reply.meta.itemsCount, reply.meta.lastUpdate)
     }
   }
 
@@ -77,11 +59,9 @@ class RestTrialService(transport: ServiceTransport, baseUri: Uri)(
       entity <- Marshal(ApiTrial.fromDomain(draftTrial)).to[RequestEntity]
       request = HttpRequest(HttpMethods.PATCH, endpointUri(baseUri, s"/v1/trial/$id")).withEntity(entity)
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ApiTrial, UpdateReply](response) { api =>
-                UpdateReply.Updated(api.toDomain)
-              }
+      reply    <- apiResponse[ApiTrial](response)
     } yield {
-      reply
+      UpdateReply.Updated(reply.toDomain)
     }
   }
 
@@ -91,11 +71,9 @@ class RestTrialService(transport: ServiceTransport, baseUri: Uri)(
     val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/trial/$id/$action"))
     for {
       response <- transport.sendRequestGetResponse(requestContext)(request)
-      reply <- apiResponse[ApiTrial, UpdateReply](response) { api =>
-                UpdateReply.Updated(api.toDomain)
-              }
+      reply    <- apiResponse[ApiTrial](response)
     } yield {
-      reply
+      UpdateReply.Updated(reply.toDomain)
     }
   }