src/main/scala/xyz/driver/pdsuidomain/services/UserService.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
127

package xyz.driver.pdsuidomain.services

import xyz.driver.pdsuicommon.auth.{AnonymousRequestContext, AuthenticatedRequestContext}
import xyz.driver.pdsuicommon.db.{Pagination, SearchFilterExpr, Sorting}
import xyz.driver.pdsuicommon.domain.{Email, LongId, User}
import xyz.driver.pdsuicommon.error.DomainError

import scala.concurrent.Future

object UserService {

  trait DefaultCredentialsError {
    def userMessage: String = "Incorrect email/password. Try again."
  }

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

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

  sealed trait ActivateExecutorReply
  object ActivateExecutorReply {
    type Error = ActivateExecutorReply with DomainError
    case class Entity(x: User) extends ActivateExecutorReply
    case object NotFoundError extends ActivateExecutorReply with DomainError.NotFoundError {
      val userMessage = "Info about you is not found on the server"
    }
  }

  sealed trait GetByIdReply
  object GetByIdReply {
    type Error = GetByIdReply with DomainError
    case class Entity(x: User) extends GetByIdReply
    case object AuthorizationError
        extends GetByIdReply with DomainError.AuthorizationError with DefaultAccessDeniedError
    case object NotFoundError                   extends GetByIdReply with DomainError.NotFoundError with DefaultNotFoundError
    case class CommonError(userMessage: String) extends GetByIdReply with DomainError
  }

  sealed trait GetByEmailReply
  object GetByEmailReply {
    case class Entity(x: User) extends GetByEmailReply
    case object NotFoundError extends GetByEmailReply with DefaultNotFoundError with DomainError.NotFoundError {
      override def userMessage: String = "Incorrect email. Try again."
    }
  }

  sealed trait GetByCredentialsReply
  object GetByCredentialsReply {
    case class Entity(x: User) extends GetByCredentialsReply
    case object AuthenticationError
        extends GetByCredentialsReply with DefaultCredentialsError with DomainError.AuthenticationError
    case object NotFoundError extends GetByCredentialsReply with DomainError.NotFoundError with DefaultNotFoundError
  }

  sealed trait GetListReply
  object GetListReply {
    case class EntityList(xs: Seq[User], totalFound: Int) extends GetListReply
    case object AuthorizationError                        extends GetListReply with DomainError.AuthorizationError with DefaultNotFoundError
  }

  sealed trait CreateReply
  object CreateReply {
    type Error = CreateReply with DomainError
    case class Created(x: User)    extends CreateReply
    case object AuthorizationError extends CreateReply with DefaultNotFoundError with DomainError.AuthorizationError
    case class UserAlreadyExistsError(email: Email) extends CreateReply with DomainError {
      val userMessage = s"The user with this email already exists."
    }
    case class CommonError(userMessage: String) extends CreateReply with DomainError
  }

  sealed trait UpdateReply
  object UpdateReply {
    type Error = UpdateReply with DomainError
    case class Updated(updated: User) extends UpdateReply
    case object AuthorizationError
        extends UpdateReply with DefaultAccessDeniedError with DomainError.AuthorizationError
    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 class AuthorizationError(user: User)
        extends DeleteReply with DefaultAccessDeniedError with DomainError.AuthorizationError
    case object AssignedToRecordAndDocumentError extends DeleteReply with DomainError {
      val userMessage = "User is can not be deleted because he has record and document in work"
    }
    case object NotFoundError                   extends DeleteReply with DefaultNotFoundError with DomainError.NotFoundError
    case class CommonError(userMessage: String) extends DeleteReply with DomainError
  }
}

trait UserService {

  import UserService._

  /**
    * Utility method for getting request executor.
    */
  def activateExecutor(executorId: LongId[User])(
          implicit requestContext: AnonymousRequestContext): Future[ActivateExecutorReply]

  def getById(userId: LongId[User])(implicit requestContext: AuthenticatedRequestContext): Future[GetByIdReply]

  def getByEmail(email: Email)(implicit requestContext: AnonymousRequestContext): Future[GetByEmailReply]

  def getByCredentials(email: Email, password: String)(
          implicit requestContext: AnonymousRequestContext): Future[GetByCredentialsReply]

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

  def create(draftUser: User)(implicit requestContext: AuthenticatedRequestContext): Future[CreateReply]

  def update(origUser: User, draftUser: User)(
          implicit requestContext: AuthenticatedRequestContext): Future[UpdateReply]

  def delete(userId: LongId[User])(implicit requestContext: AuthenticatedRequestContext): Future[DeleteReply]
}