src/main/scala/xyz/driver/pdsuidomain/services/ExtractedDataService.scala


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

package xyz.driver.pdsuidomain.services

import xyz.driver.core.rest.AuthorizedServiceRequestContext
import xyz.driver.entities.users.AuthUserInfo
import xyz.driver.pdsuicommon.db.{Pagination, SearchFilterExpr, Sorting}
import xyz.driver.pdsuicommon.domain.{LongId, UuidId}
import xyz.driver.pdsuicommon.error.DomainError
import xyz.driver.pdsuicommon.logging._
import xyz.driver.pdsuidomain.entities._
import xyz.driver.pdsuidomain.entities.export.patient.ExportPatientWithLabels

import scala.concurrent.Future

object ExtractedDataService {

  trait DefaultNotFoundError {
    def userMessage: String = "Extracted data hasn't been found"
  }

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

  final case class RichExtractedData(extractedData: ExtractedData, labels: List[ExtractedDataLabel])

  object RichExtractedData {
    implicit def toPhiString(x: RichExtractedData): PhiString = {
      import x._
      phi"RichExtractedData(extractedData=$extractedData, labels=$labels)"
    }
  }

  sealed trait GetByIdReply
  object GetByIdReply {
    type Error = GetByIdReply with DomainError
    final case class Entity(x: RichExtractedData) extends GetByIdReply

    case object AuthorizationError
        extends GetByIdReply with DomainError.AuthorizationError with DefaultAccessDeniedError

    case object NotFoundError extends GetByIdReply with DefaultNotFoundError with DomainError.NotFoundError

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

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

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

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

    final case class Entity(x: ExportPatientWithLabels) extends GetPatientLabelsReply

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

  sealed trait CreateReply
  object CreateReply {
    type Error = CreateReply with DomainError
    final case class Created(x: RichExtractedData) extends CreateReply

    case object AuthorizationError
        extends CreateReply with DomainError.AuthorizationError with DefaultAccessDeniedError

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

  sealed trait UpdateReply
  object UpdateReply {
    type Error = UpdateReply with DomainError
    final case class Updated(updated: RichExtractedData) extends UpdateReply

    case object AuthorizationError
        extends UpdateReply with DefaultAccessDeniedError with DomainError.AuthorizationError

    case object NotFoundError extends UpdateReply with DefaultNotFoundError with DomainError.NotFoundError

    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 DefaultAccessDeniedError with DomainError.AuthorizationError

    case object NotFoundError extends DeleteReply with DefaultNotFoundError with DomainError.NotFoundError

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

trait ExtractedDataService {

  import ExtractedDataService._

  def getById(id: LongId[ExtractedData])(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[GetByIdReply]

  def getPatientLabels(id: UuidId[Patient])(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[GetPatientLabelsReply]

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

  def create(draftRichExtractedData: RichExtractedData)(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[CreateReply]

  def update(origRichExtractedData: RichExtractedData, draftRichExtractedData: RichExtractedData)(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[UpdateReply]

  def delete(id: LongId[ExtractedData])(
          implicit requestContext: AuthorizedServiceRequestContext[AuthUserInfo]): Future[DeleteReply]
}