aboutsummaryrefslogtreecommitdiff
path: root/src/main/scala/xyz/driver/pdsuidomain/services/rest/RestTrialIssueService.scala
blob: b14d35b97907c4de6c351a18b9fc42f69c15d7b2 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
package xyz.driver.pdsuidomain.services.rest

import akka.http.scaladsl.marshalling.Marshal
import akka.http.scaladsl.model._
import akka.stream.Materializer
import spray.json.RootJsonReader
import xyz.driver.core.rest.{AuthorizedServiceRequestContext, ServiceTransport}
import xyz.driver.entities.users
import xyz.driver.pdsuicommon.db.{Pagination, SearchFilterExpr, Sorting}
import xyz.driver.pdsuicommon.domain.{LongId, StringId}
import xyz.driver.pdsuidomain.ListResponse
import xyz.driver.pdsuidomain.entities.{Trial, TrialIssue}
import xyz.driver.pdsuidomain.services.TrialIssueService

import scala.concurrent.ExecutionContext

class RestTrialIssueService(transport: ServiceTransport, baseUri: Uri)
                           (implicit
                            protected val materializer: Materializer,
                            protected val exec: ExecutionContext)
  extends TrialIssueService with RestHelper{

  import akka.http.scaladsl.marshallers.sprayjson.SprayJsonSupport._
  import xyz.driver.pdsuidomain.formats.json.listresponse._
  import xyz.driver.pdsuidomain.formats.json.trialissue._
  import xyz.driver.pdsuidomain.services.TrialIssueService._

  override def create(draft: TrialIssue)
                     (implicit requestContext: AuthorizedServiceRequestContext[users.AuthUserInfo]) = {
    val trialId = draft.trialId

    implicit val jsonReader: RootJsonReader[TrialIssue] = trialIssueReader(trialId)

    for {
      entity <- Marshal(draft).to[RequestEntity]
      request = HttpRequest(HttpMethods.POST, endpointUri(baseUri, s"/v1/trial/$trialId/issue")).withEntity(entity)
      response <- transport.sendRequestGetResponse(requestContext)(request)
      reply    <- apiResponse[TrialIssue](response)
    } yield {
      CreateReply.Created(reply)
    }
  }

  override def getListByTrialId(trialId: StringId[Trial],
                                filter: SearchFilterExpr,
                                sorting: Option[Sorting],
                                pagination: Option[Pagination])
                               (implicit requestContext: AuthorizedServiceRequestContext[users.AuthUserInfo]) = {
    implicit val jsonReader: RootJsonReader[TrialIssue] = trialIssueReader(trialId)

    val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/trial/$trialId/issue",
      filterQuery(filter) ++ sortingQuery(sorting) ++ paginationQuery(pagination))
    )
    for {
      response <- transport.sendRequestGetResponse(requestContext)(request)
      reply    <- apiResponse[ListResponse[TrialIssue]](response)
    } yield {
      GetListByTrialIdReply.EntityList(reply.items, reply.meta.itemsCount, reply.meta.lastUpdate)
    }
  }

  override def getById(trialId: StringId[Trial], id: LongId[TrialIssue])
                      (implicit requestContext: AuthorizedServiceRequestContext[users.AuthUserInfo]) = {
    implicit val jsonReader: RootJsonReader[TrialIssue] = trialIssueReader(trialId)

    val request = HttpRequest(HttpMethods.GET, endpointUri(baseUri, s"/v1/trial/$trialId/issue/$id"))
    for {
      response <- transport.sendRequestGetResponse(requestContext)(request)
      reply    <- apiResponse[TrialIssue](response)
    } yield {
      GetByIdReply.Entity(reply)
    }
  }

  override def update(orig: TrialIssue, draft: TrialIssue)
                     (implicit requestContext: AuthorizedServiceRequestContext[users.AuthUserInfo]) = {
    val trialId = draft.trialId
    val id = orig.id.id

    implicit val jsonReader: RootJsonReader[TrialIssue] = trialIssueReader(trialId)

    for {
      entity <- Marshal(draft).to[RequestEntity]
      request = HttpRequest(HttpMethods.PATCH, endpointUri(baseUri, s"/v1/trial/$trialId/issue/$id")).withEntity(entity)
      response <- transport.sendRequestGetResponse(requestContext)(request)
      reply    <- apiResponse[TrialIssue](response)
    } yield {
      UpdateReply.Updated(reply)
    }
  }

  override def delete(trialId: StringId[Trial], id: LongId[TrialIssue])
                     (implicit requestContext: AuthorizedServiceRequestContext[users.AuthUserInfo]) = {
    val request = HttpRequest(HttpMethods.DELETE, endpointUri(baseUri, s"/v1/trial/$trialId/issue/$id"))
    for {
      response <- transport.sendRequestGetResponse(requestContext)(request)
      _        <- apiResponse[HttpEntity](response)
    } yield {
      DeleteReply.Deleted
    }
  }

}