aboutsummaryrefslogtreecommitdiff
path: root/src/main/scala/xyz/driver/pdsuidomain/services/TrialService.scala
blob: 9ae1c1097db6c759d90ab4485c2659fa8eba61c1 (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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
package xyz.driver.pdsuidomain.services

import java.time.LocalDateTime

import akka.NotUsed
import akka.stream.scaladsl.Source
import akka.util.ByteString
import xyz.driver.core.rest.AuthorizedServiceRequestContext
import xyz.driver.entities.patient.CancerType
import xyz.driver.entities.users.AuthUserInfo
import xyz.driver.pdsuicommon.db._
import xyz.driver.pdsuicommon.domain.StringId
import xyz.driver.pdsuicommon.error.DomainError
import xyz.driver.pdsuicommon.logging._
import xyz.driver.pdsuidomain.entities.{Trial, TrialCreationRequest}
import xyz.driver.pdsuidomain.entities.export.trial.ExportTrialWithLabels

import scala.concurrent.Future

object TrialService {

  trait DefaultNotFoundError {
    def userMessage: String = "Trial not found"
  }

  trait DefaultAccessDeniedError {
    def userMessage: String = "Access denied"
  }

  sealed trait GetListReply
  object GetListReply {
    final case class EntityList(xs: Seq[Trial], totalFound: Int, lastUpdate: Option[LocalDateTime])
        extends GetListReply

    case object AuthorizationError
        extends GetListReply with DomainError.AuthorizationError with DefaultAccessDeniedError
  }

  sealed trait GetByIdReply
  object GetByIdReply {
    final case class Entity(x: Trial) extends GetByIdReply

    type Error = GetByIdReply with DomainError

    case object NotFoundError extends GetByIdReply with DefaultNotFoundError with DomainError.NotFoundError

    case object AuthorizationError
        extends GetByIdReply with DomainError.AuthorizationError with DefaultAccessDeniedError

    final case class CommonError(userMessage: String)(
            implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo])
        extends GetByIdReply with DomainError

    implicit def toPhiString(reply: GetByIdReply): PhiString = reply match {
      case x: DomainError => phi"GetByIdReply.Error($x)"
      case Entity(x)      => phi"GetByIdReply.Entity($x)"
    }
  }

  sealed trait GetTrialWithLabelsReply
  object GetTrialWithLabelsReply {
    type Error = GetTrialWithLabelsReply with DomainError

    final case class Entity(x: ExportTrialWithLabels) extends GetTrialWithLabelsReply

    case object NotFoundError extends GetTrialWithLabelsReply with DomainError.NotFoundError {
      def userMessage: String = "Trial not found"
    }

    case object AuthorizationError
        extends GetTrialWithLabelsReply with DomainError.AuthorizationError with DefaultAccessDeniedError
  }

  sealed trait GetTrialsWithLabelsReply
  object GetTrialsWithLabelsReply {
    type Error = GetTrialsWithLabelsReply with DomainError

    final case class EntityList(xs: Seq[ExportTrialWithLabels]) extends GetTrialsWithLabelsReply

    case object NotFoundError extends GetTrialsWithLabelsReply with DomainError.NotFoundError {
      def userMessage: String = "Trials for disease are not found"
    }

    case object AuthorizationError
        extends GetTrialsWithLabelsReply with DomainError.AuthorizationError with DefaultAccessDeniedError
  }

  sealed trait UpdateReply
  object UpdateReply {
    type Error = UpdateReply with DomainError

    final case class Updated(updated: Trial) extends UpdateReply

    case object NotFoundError extends UpdateReply with DefaultNotFoundError with DomainError.NotFoundError

    case object AuthorizationError
        extends UpdateReply with DefaultAccessDeniedError with DomainError.AuthorizationError

    final case class CommonError(userMessage: String) extends UpdateReply with DomainError

    implicit def toPhiString(reply: UpdateReply): PhiString = reply match {
      case Updated(x) => phi"Updated($x)"
      case x: Error   => DomainError.toPhiString(x)
    }
  }
}

trait TrialService {

  import TrialService._

  def getById(id: StringId[Trial])(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[GetByIdReply]

  def getTrialWithLabels(trialId: StringId[Trial], cancerType: CancerType)(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[GetTrialWithLabelsReply]

  def getTrialsWithLabels(cancerType: CancerType)(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[GetTrialsWithLabelsReply]

  def getPdfSource(trialId: StringId[Trial])(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[Source[ByteString, NotUsed]]

  def getHtmlSource(trialId: StringId[Trial])(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[Source[ByteString, NotUsed]]

  def getAll(filter: SearchFilterExpr = SearchFilterExpr.Empty,
             sorting: Option[Sorting] = None,
             pagination: Option[Pagination] = None)(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[GetListReply]

  def update(origTrial: Trial, draftTrial: Trial)(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply]

  def start(origTrial: Trial)(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply]

  def submit(origTrial: Trial)(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply]

  def restart(origTrial: Trial)(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply]

  def flag(origTrial: Trial)(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply]

  def resolve(origTrial: Trial)(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply]

  def archive(origTrial: Trial, comment: Option[String])(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply]

  def unassign(origTrial: Trial)(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply]

  def addTrial(trial: TrialCreationRequest)(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[Trial]
}