1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2018 Make.org
4  *
5  * This program is free software: you can redistribute it and/or modify
6  *  it under the terms of the GNU Affero General Public License as
7  *  published by the Free Software Foundation, either version 3 of the
8  *  License, or (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU Affero General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Affero General Public License
16  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
17  *
18  */
19 
20 package org.make.api.user
21 
22 import akka.http.scaladsl.model._
23 import akka.http.scaladsl.server._
24 import cats.syntax.traverse._
25 import grizzled.slf4j.Logging
26 import io.swagger.annotations._
27 import org.make.api.operation.OperationServiceComponent
28 import org.make.api.proposal.{ProposalServiceComponent, ProposalsResultResponse, ProposalsResultSeededResponse}
29 import org.make.api.question.QuestionServiceComponent
30 import org.make.api.technical.CsvReceptacle._
31 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
32 import org.make.api.technical._
33 import org.make.api.technical.directives.ClientDirectives
34 import org.make.api.technical.directives.FutureDirectivesExtensions._
35 import org.make.api.technical.storage._
36 import org.make.api.user.UserExceptions.EmailAlreadyRegisteredException
37 import org.make.api.user.social.SocialServiceComponent
38 import org.make.api.user.validation.UserRegistrationValidatorComponent
39 import org.make.api.userhistory._
40 import org.make.core._
41 import org.make.core.auth.UserRights
42 import org.make.core.common.indexed.Sort
43 import org.make.core.profile.Profile
44 import org.make.core.proposal._
45 import org.make.core.proposal.indexed.ProposalElasticsearchFieldName
46 import org.make.core.question.Question
47 import org.make.core.reference.{Country, Language}
48 import org.make.core.technical.Pagination
49 import org.make.core.user.Role.RoleAdmin
50 import org.make.core.user._
51 import scalaoauth2.provider.AuthInfo
52 
53 import java.time.ZonedDateTime
54 import javax.ws.rs.Path
55 import scala.concurrent.ExecutionContext.Implicits.global
56 import scala.concurrent.Future
57 
58 @Api(value = "User")
59 @Path(value = "/user")
60 trait UserApi extends Directives {
61 
62   @Path(value = "/{userId}/profile")
63   @ApiOperation(
64     value = "get-user-profile",
65     httpMethod = "GET",
66     authorizations = Array(
67       new Authorization(
68         value = "MakeApi",
69         scopes = Array(
70           new AuthorizationScope(scope = "user", description = "application user"),
71           new AuthorizationScope(scope = "admin", description = "BO Admin")
72         )
73       )
74     )
75   )
76   @ApiResponses(
77     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[UserProfileResponse]))
78   )
79   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string")))
80   def getUserProfile: Route
81 
82   @Path(value = "/me")
83   @ApiOperation(
84     value = "get-me",
85     httpMethod = "GET",
86     authorizations = Array(
87       new Authorization(
88         value = "MakeApi",
89         scopes = Array(
90           new AuthorizationScope(scope = "user", description = "application user"),
91           new AuthorizationScope(scope = "admin", description = "BO Admin")
92         )
93       )
94     )
95   )
96   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[UserResponse])))
97   def getMe: Route
98 
99   @Path(value = "/current")
100   @ApiOperation(
101     value = "current-user",
102     httpMethod = "GET",
103     authorizations = Array(
104       new Authorization(
105         value = "MakeApi",
106         scopes = Array(
107           new AuthorizationScope(scope = "user", description = "application user"),
108           new AuthorizationScope(scope = "admin", description = "BO Admin")
109         )
110       )
111     )
112   )
113   @ApiResponses(
114     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[CurrentUserResponse]))
115   )
116   def currentUser: Route
117 
118   @Path(value = "/login/social")
119   @ApiOperation(value = "social-login", httpMethod = "POST", code = HttpCodes.OK)
120   @ApiImplicitParams(
121     value =
122       Array(new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.SocialLoginRequest"))
123   )
124   @ApiResponses(
125     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[SocialLoginResponse]))
126   )
127   def socialLogin: Route
128 
129   @Path(value = "/{userId}/votes")
130   @ApiOperation(value = "voted-proposals", httpMethod = "GET")
131   @ApiImplicitParams(
132     value = Array(
133       new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string"),
134       new ApiImplicitParam(
135         name = "votes",
136         paramType = "query",
137         dataType = "string",
138         allowableValues = VoteKey.swaggerAllowableValues,
139         allowMultiple = true
140       ),
141       new ApiImplicitParam(
142         name = "qualifications",
143         paramType = "query",
144         dataType = "string",
145         allowableValues = QualificationKey.swaggerAllowableValues,
146         allowMultiple = true
147       ),
148       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string", example = "fr"),
149       new ApiImplicitParam(
150         name = "sort",
151         paramType = "query",
152         dataType = "string",
153         allowableValues = ProposalElasticsearchFieldName.swaggerAllowableValues
154       ),
155       new ApiImplicitParam(
156         name = "order",
157         paramType = "query",
158         dataType = "string",
159         allowableValues = Order.swaggerAllowableValues
160       ),
161       new ApiImplicitParam(
162         name = "limit",
163         paramType = "query",
164         dataType = "int",
165         allowableValues = "range[0, infinity]"
166       ),
167       new ApiImplicitParam(name = "skip", paramType = "query", dataType = "int", allowableValues = "range[0, infinity]")
168     )
169   )
170   @ApiResponses(
171     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ProposalsResultResponse]))
172   )
173   def getVotedProposalsByUser: Route
174 
175   @ApiOperation(value = "register-user", httpMethod = "POST", code = HttpCodes.Created)
176   @ApiImplicitParams(
177     value = Array(
178       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.RegisterUserRequest")
179     )
180   )
181   @ApiResponses(
182     value = Array(new ApiResponse(code = HttpCodes.Created, message = "Created", response = classOf[UserResponse]))
183   )
184   def register: Route
185 
186   @ApiOperation(value = "verifiy-user-email", httpMethod = "POST", code = HttpCodes.NoContent)
187   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No content")))
188   @Path(value = "/{userId}/validate/:verificationToken")
189   @ApiImplicitParams(
190     value = Array(
191       new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string"),
192       new ApiImplicitParam(name = "verificationToken", paramType = "path", dataType = "string")
193     )
194   )
195   def validateAccountRoute: Route
196 
197   @ApiOperation(value = "reset-password-request-token", httpMethod = "POST", code = HttpCodes.NoContent)
198   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No content")))
199   @Path(value = "/reset-password/request-reset")
200   @ApiImplicitParams(
201     value = Array(
202       new ApiImplicitParam(name = "body", paramType = "body", dataType = "org.make.api.user.ResetPasswordRequest")
203     )
204   )
205   def resetPasswordRequestRoute: Route
206 
207   @ApiOperation(value = "reset-password-token-check", httpMethod = "POST", code = HttpCodes.NoContent)
208   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No content")))
209   @Path(value = "/reset-password/check-validity/:userId/:resetToken")
210   @ApiImplicitParams(
211     value = Array(
212       new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string"),
213       new ApiImplicitParam(name = "resetToken", paramType = "path", dataType = "string")
214     )
215   )
216   def resetPasswordCheckRoute: Route
217 
218   @ApiOperation(value = "reset-password", httpMethod = "POST", code = HttpCodes.NoContent)
219   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No content")))
220   @Path(value = "/reset-password/change-password/:userId")
221   @ApiImplicitParams(
222     value = Array(
223       new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string"),
224       new ApiImplicitParam(name = "body", paramType = "body", dataType = "org.make.api.user.ResetPassword")
225     )
226   )
227   def resetPasswordRoute: Route
228 
229   @Path(value = "/{userId}/proposals")
230   @ApiOperation(
231     value = "user-proposals",
232     httpMethod = "GET",
233     authorizations = Array(
234       new Authorization(
235         value = "MakeApi",
236         scopes = Array(
237           new AuthorizationScope(scope = "user", description = "application user"),
238           new AuthorizationScope(scope = "admin", description = "BO Admin")
239         )
240       )
241     )
242   )
243   @ApiImplicitParams(
244     value = Array(
245       new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string"),
246       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string", example = "fr"),
247       new ApiImplicitParam(
248         name = "sort",
249         paramType = "query",
250         dataType = "string",
251         allowableValues = ProposalElasticsearchFieldName.swaggerAllowableValues
252       ),
253       new ApiImplicitParam(
254         name = "order",
255         paramType = "query",
256         dataType = "string",
257         allowableValues = Order.swaggerAllowableValues
258       ),
259       new ApiImplicitParam(
260         name = "limit",
261         paramType = "query",
262         dataType = "int",
263         allowableValues = "range[0, infinity]"
264       ),
265       new ApiImplicitParam(name = "skip", paramType = "query", dataType = "int", allowableValues = "range[0, infinity]")
266     )
267   )
268   @ApiResponses(
269     value =
270       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ProposalsResultSeededResponse]))
271   )
272   def getProposalsByUser: Route
273 
274   @ApiOperation(
275     value = "user-update",
276     httpMethod = "PATCH",
277     authorizations = Array(
278       new Authorization(
279         value = "MakeApi",
280         scopes = Array(new AuthorizationScope(scope = "user", description = "application user"))
281       )
282     )
283   )
284   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[UserResponse])))
285   @ApiImplicitParams(
286     value =
287       Array(new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.UpdateUserRequest"))
288   )
289   @Path(value = "/")
290   def patchCurrentUser: Route
291 
292   @ApiOperation(
293     value = "change-password",
294     httpMethod = "POST",
295     authorizations = Array(
296       new Authorization(
297         value = "MakeApi",
298         scopes = Array(new AuthorizationScope(scope = "user", description = "application user"))
299       )
300     )
301   )
302   @ApiImplicitParams(
303     value = Array(
304       new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string"),
305       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.ChangePasswordRequest")
306     )
307   )
308   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok")))
309   @Path(value = "{userId}/change-password")
310   def changePassword: Route
311 
312   @ApiOperation(
313     value = "delete-user",
314     httpMethod = "POST",
315     authorizations = Array(
316       new Authorization(
317         value = "MakeApi",
318         scopes = Array(new AuthorizationScope(scope = "user", description = "application user"))
319       )
320     )
321   )
322   @ApiImplicitParams(
323     value = Array(
324       new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string"),
325       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.DeleteUserRequest")
326     )
327   )
328   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok")))
329   @Path(value = "{userId}/delete")
330   def deleteUser: Route
331 
332   @ApiOperation(
333     value = "follow-user",
334     httpMethod = "POST",
335     authorizations = Array(
336       new Authorization(
337         value = "MakeApi",
338         scopes = Array(new AuthorizationScope(scope = "user", description = "application user"))
339       )
340     )
341   )
342   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok")))
343   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string")))
344   @Path(value = "/{userId}/follow")
345   def followUser: Route
346 
347   @ApiOperation(
348     value = "unfollow-user",
349     httpMethod = "POST",
350     authorizations = Array(
351       new Authorization(
352         value = "MakeApi",
353         scopes = Array(new AuthorizationScope(scope = "user", description = "application user"))
354       )
355     )
356   )
357   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok")))
358   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string")))
359   @Path(value = "/{userId}/unfollow")
360   def unfollowUser: Route
361 
362   @ApiOperation(value = "reconnect-info", httpMethod = "POST")
363   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ReconnectInfo])))
364   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string")))
365   @Path(value = "/{userId}/reconnect")
366   def reconnectInfo: Route
367 
368   @ApiOperation(value = "resend-validation-email", httpMethod = "POST", code = HttpCodes.NoContent)
369   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
370   @ApiImplicitParams(
371     value = Array(
372       new ApiImplicitParam(
373         name = "body",
374         paramType = "body",
375         dataType = "org.make.api.user.ResendValidationEmailRequest"
376       )
377     )
378   )
379   @Path(value = "/validation-email")
380   def resendValidationEmail: Route
381 
382   @ApiOperation(
383     value = "upload-avatar",
384     httpMethod = "POST",
385     code = HttpCodes.OK,
386     consumes = "multipart/form-data",
387     authorizations = Array(
388       new Authorization(
389         value = "MakeApi",
390         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
391       )
392     )
393   )
394   @ApiImplicitParams(
395     value = Array(
396       new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string"),
397       new ApiImplicitParam(name = "data", paramType = "formData", dataType = "file")
398     )
399   )
400   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[UploadResponse])))
401   @Path(value = "/{userId}/upload-avatar")
402   def uploadAvatar: Route
403 
404   @ApiOperation(
405     value = "update-user-profile",
406     httpMethod = "PUT",
407     authorizations = Array(
408       new Authorization(
409         value = "MakeApi",
410         scopes = Array(new AuthorizationScope(scope = "user", description = "application user"))
411       )
412     )
413   )
414   @ApiResponses(
415     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[UserProfileResponse]))
416   )
417   @ApiImplicitParams(
418     value = Array(
419       new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string"),
420       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.UserProfileRequest")
421     )
422   )
423   @Path(value = "/{userId}/profile")
424   def modifyUserProfile: Route
425 
426   @Path(value = "/privacy-policy")
427   @ApiOperation(value = "get-privacy-policy-approval-date", httpMethod = "POST")
428   @ApiImplicitParams(
429     value = Array(
430       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.PrivacyPolicyRequest")
431     )
432   )
433   @ApiResponses(
434     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[UserPrivacyPolicyResponse]))
435   )
436   def getPrivacyPolicy: Route
437 
438   @Path(value = "/social/privacy-policy")
439   @ApiOperation(value = "get-social-privacy-policy-approval-date", httpMethod = "POST")
440   @ApiImplicitParams(
441     value = Array(
442       new ApiImplicitParam(
443         value = "body",
444         paramType = "body",
445         dataType = "org.make.api.user.SocialPrivacyPolicyRequest"
446       )
447     )
448   )
449   @ApiResponses(
450     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[UserPrivacyPolicyResponse]))
451   )
452   def getSocialPrivacyPolicy: Route
453 
454   @Path(value = "/check-registration")
455   @ApiOperation(value = "check-registration", httpMethod = "POST")
456   @ApiImplicitParams(
457     value = Array(
458       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.CheckRegistrationRequest")
459     )
460   )
461   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
462   def checkRegistration: Route
463 
464   def routes: Route =
465     getMe ~
466       currentUser ~
467       register ~
468       socialLogin ~
469       resetPasswordRequestRoute ~
470       resetPasswordCheckRoute ~
471       resetPasswordRoute ~
472       validateAccountRoute ~
473       getVotedProposalsByUser ~
474       getProposalsByUser ~
475       patchCurrentUser ~
476       changePassword ~
477       deleteUser ~
478       followUser ~
479       unfollowUser ~
480       reconnectInfo ~
481       resendValidationEmail ~
482       uploadAvatar ~
483       getUserProfile ~
484       modifyUserProfile ~
485       getPrivacyPolicy ~
486       getSocialPrivacyPolicy ~
487       checkRegistration
488 
489   val userId: PathMatcher1[UserId] =
490     Segment.map(id => UserId(id))
491 }
492 
493 trait UserApiComponent {
494   def userApi: UserApi
495 }
496 
497 trait DefaultUserApiComponent
498     extends UserApiComponent
499     with MakeAuthenticationDirectives
500     with Logging
501     with ParameterExtractors {
502 
503   this: MakeDirectivesDependencies
504     with UserServiceComponent
505     with SocialServiceComponent
506     with ProposalServiceComponent
507     with QuestionServiceComponent
508     with OperationServiceComponent
509     with EventBusServiceComponent
510     with PersistentUserServiceComponent
511     with UserHistoryCoordinatorServiceComponent
512     with ReadJournalComponent
513     with ActorSystemComponent
514     with StorageServiceComponent
515     with StorageConfigurationComponent
516     with UserRegistrationValidatorComponent
517     with ClientDirectives =>
518 
519   override lazy val userApi: UserApi = new DefaultUserApi
520 
521   class DefaultUserApi extends UserApi {
522 
523     override def getUserProfile: Route = {
524       get {
525         path("user" / userId / "profile") { userId =>
526           makeOperation("GetUserProfile") { _ =>
527             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
528               authorize(userId == userAuth.user.userId) {
529                 userService.getUser(userId).asDirectiveOrNotFound { user =>
530                   complete(
531                     UserProfileResponse(
532                       email = user.email,
533                       firstName = user.firstName,
534                       lastName = user.lastName,
535                       dateOfBirth = user.profile.flatMap(_.dateOfBirth),
536                       avatarUrl = user.profile.flatMap(_.avatarUrl),
537                       profession = user.profile.flatMap(_.profession),
538                       description = user.profile.flatMap(_.description),
539                       postalCode = user.profile.flatMap(_.postalCode),
540                       optInNewsletter = user.profile.forall(_.optInNewsletter),
541                       website = user.profile.flatMap(_.website),
542                       crmCountry = user.profile.map(_.crmCountry),
543                       crmLanguage = user.profile.map(_.crmLanguage)
544                     )
545                   )
546                 }
547               }
548             }
549           }
550         }
551       }
552     }
553 
554     override def getMe: Route = {
555       get {
556         path("user" / "me") {
557           makeOperation("GetMe") { _ =>
558             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
559               userService.getUser(userAuth.user.userId).asDirectiveOrNotFound { user =>
560                 userService.getFollowedUsers(user.userId).asDirective { followedUsers =>
561                   complete(UserResponse(user, followedUsers))
562                 }
563               }
564             }
565           }
566         }
567       }
568     }
569 
570     override def currentUser: Route = {
571       get {
572         path("user" / "current") {
573           makeOperation("GetCurrentUser") { _ =>
574             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
575               userService.getUser(userAuth.user.userId).asDirectiveOrNotFound { user =>
576                 complete(
577                   CurrentUserResponse(
578                     userId = user.userId,
579                     email = user.email,
580                     displayName = user.displayName,
581                     userType = user.userType,
582                     roles = user.roles,
583                     hasPassword = user.hashedPassword.isDefined,
584                     enabled = user.enabled,
585                     emailVerified = user.emailVerified,
586                     country = user.country,
587                     avatarUrl = user.profile.flatMap(_.avatarUrl),
588                     privacyPolicyApprovalDate = user.privacyPolicyApprovalDate,
589                     crmCountry = user.profile.map(_.crmCountry),
590                     crmLanguage = user.profile.map(_.crmLanguage),
591                     availableEvents = user.availableEvents
592                   )
593                 )
594               }
595             }
596           }
597         }
598       }
599     }
600 
601     override def socialLogin: Route = post {
602       path("user" / "login" / "social") {
603         makeOperation("SocialLogin", EndpointType.CoreOnly) { requestContext =>
604           decodeRequest {
605             entity(as[SocialLoginRequest]) { request: SocialLoginRequest =>
606               extractClientOrDefault { client =>
607                 val language: Language =
608                   request.language.orElse(requestContext.languageContext.language).getOrElse(Language("fr"))
609 
610                 val futureMaybeQuestion: Future[Option[Question]] =
611                   request.questionId.orElse(requestContext.questionContext.questionId) match {
612                     case Some(questionId) => questionService.getQuestion(questionId)
613                     case _                => Future.successful(None)
614                   }
615                 val privacyPolicyApprovalDate: Option[ZonedDateTime] = request.approvePrivacyPolicy match {
616                   case Some(true) => Some(DateHelper.now())
617                   case _          => None
618                 }
619 
620                 futureMaybeQuestion.asDirective { maybeQuestion =>
621                   onSuccess(
622                     socialService
623                       .login(
624                         request.provider,
625                         request.token,
626                         request.country,
627                         language,
628                         request.crmCountry.getOrElse(Country("FR")),
629                         request.crmLanguage.getOrElse(Language("fr")),
630                         maybeQuestion.map(_.questionId),
631                         requestContext,
632                         client.clientId,
633                         privacyPolicyApprovalDate,
634                         request.optIn,
635                         maybeQuestion.flatMap(_.operationId),
636                         request.redirectUri
637                       )
638                       .flatMap {
639                         case (userId, social) =>
640                           sessionHistoryCoordinatorService
641                             .convertSession(requestContext.sessionId, userId, requestContext)
642                             .map(_ => (userId, social))
643                       }
644                   ) {
645                     case (userId, social) =>
646                       setMakeSecure(requestContext.applicationName, social.toTokenResponse, userId) {
647                         complete(StatusCodes.Created -> social)
648                       }
649                   }
650                 }
651               }
652             }
653           }
654         }
655       }
656     }
657 
658     /**
659       *
660       * proposals from themes will not be retrieve since themes are not displayed on front
661       */
662     override def getVotedProposalsByUser: Route = get {
663       path("user" / userId / "votes") { userId: UserId =>
664         makeOperation("UserVotedProposals") { requestContext =>
665           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
666             parameters(
667               "votes".csv[VoteKey],
668               "qualifications".csv[QualificationKey],
669               "preferredLanguage".as[Language].?,
670               "sort".?,
671               "order".as[Order].?,
672               "limit".as[Pagination.Limit].?,
673               "skip".as[Pagination.Offset].?
674             ) {
675               (
676                 votes: Option[Seq[VoteKey]],
677                 qualifications: Option[Seq[QualificationKey]],
678                 preferredLanguage: Option[Language],
679                 sort: Option[String],
680                 order: Option[Order],
681                 limit: Option[Pagination.Limit],
682                 offset: Option[Pagination.Offset]
683               ) =>
684                 if (userAuth.user.userId != userId) {
685                   complete(StatusCodes.Forbidden)
686                 } else {
687                   val defaultSort = Some("createdAt")
688                   val defaultOrder = Some(Order.desc)
689                   proposalService
690                     .searchProposalsVotedByUser(
691                       userId = userId,
692                       filterVotes = votes,
693                       filterQualifications = qualifications,
694                       preferredLanguage = preferredLanguage,
695                       sort = Some(
696                         Sort(field = sort.orElse(defaultSort), mode = order.orElse(defaultOrder).map(_.sortOrder))
697                       ),
698                       limit = limit,
699                       offset = offset,
700                       requestContext = requestContext
701                     )
702                     .asDirective
703                     .apply(complete(_))
704                 }
705             }
706           }
707         }
708       }
709     }
710 
711     override def register: Route = post {
712       path("user") {
713         makeOperation("RegisterUser", EndpointType.Public) { requestContext =>
714           decodeRequest {
715             entity(as[RegisterUserRequest]) { request: RegisterUserRequest =>
716               Validation.validate(userRegistrationValidator.requirements(request): _*)
717               val language: Language =
718                 request.language.orElse(requestContext.languageContext.language).getOrElse(Language("fr"))
719 
720               val futureMaybeQuestion: Future[Option[Question]] = request.questionId match {
721                 case Some(questionId) => questionService.getQuestion(questionId)
722                 case _                => Future.successful(None)
723               }
724 
725               futureMaybeQuestion.asDirective { maybeQuestion =>
726                 val privacyPolicyApprovalDate = request.approvePrivacyPolicy match {
727                   case Some(true) => Some(DateHelper.now())
728                   case _          => None
729                 }
730                 onSuccess(
731                   userService
732                     .register(
733                       UserRegisterData(
734                         email = request.email.value.toLowerCase,
735                         firstName = request.firstName.map(_.value),
736                         lastName = request.lastName.map(_.value),
737                         password = Some(request.password.value),
738                         lastIp = requestContext.ipAddress,
739                         dateOfBirth = Some(request.dateOfBirth.birthDate),
740                         profession = request.profession.map(_.value),
741                         postalCode = request.postalCode.map(_.value),
742                         country = request.country,
743                         language = language,
744                         crmCountry = request.crmCountry.getOrElse(Country("FR")),
745                         crmLanguage = request.crmLanguage.getOrElse(Language("fr")),
746                         gender = request.gender,
747                         socioProfessionalCategory = request.socioProfessionalCategory,
748                         questionId = maybeQuestion.map(_.questionId),
749                         optIn = request.optIn,
750                         optInPartner = request.optInPartner,
751                         politicalParty = request.politicalParty,
752                         website = request.website.map(_.value),
753                         legalMinorConsent = request.legalMinorConsent,
754                         legalAdvisorApproval = request.legalAdvisorApproval,
755                         privacyPolicyApprovalDate = privacyPolicyApprovalDate
756                       ),
757                       requestContext
758                     )
759                     .flatMap { user =>
760                       sessionHistoryCoordinatorService
761                         .convertSession(requestContext.sessionId, user.userId, requestContext)
762                         .map(_ => user)
763                     }
764                 ) { result =>
765                   complete(StatusCodes.Created -> UserResponse(result))
766                 }
767               }
768             }
769           }
770         }
771       }
772     }
773 
774     override def validateAccountRoute: Route = {
775       post {
776         path("user" / userId / "validate" / Segment) { (userId: UserId, verificationToken: String) =>
777           makeOperation("UserValidation", EndpointType.Public) { requestContext =>
778             persistentUserService
779               .findUserByUserIdAndVerificationToken(userId, verificationToken)
780               .asDirectiveOrNotFound { user =>
781                 if (user.verificationTokenExpiresAt.forall(_.isBefore(DateHelper.now()))) {
782                   complete(StatusCodes.BadRequest)
783                 } else {
784                   onSuccess(
785                     userService
786                       .validateEmail(user = user, verificationToken = verificationToken)
787                       .map { token =>
788                         eventBusService.publish(
789                           UserValidatedAccountEvent(
790                             userId = userId,
791                             country = user.country,
792                             requestContext = requestContext,
793                             eventDate = DateHelper.now(),
794                             eventId = Some(idGenerator.nextEventId())
795                           )
796                         )
797                         token
798                       }
799                   ) { token =>
800                     setMakeSecure(requestContext.applicationName, token, userId) {
801                       complete(StatusCodes.NoContent)
802                     }
803                   }
804                 }
805               }
806           }
807         }
808       }
809     }
810 
811     override def resetPasswordRequestRoute: Route = {
812       post {
813         path("user" / "reset-password" / "request-reset") {
814           makeOperation("ResetPasswordRequest", EndpointType.Public) { requestContext =>
815             optionalMakeOAuth2 { userAuth: Option[AuthInfo[UserRights]] =>
816               decodeRequest(entity(as[ResetPasswordRequest]) { request =>
817                 persistentUserService.findByEmail(request.email.value.toLowerCase).asDirectiveOrNotFound { user =>
818                   onSuccess(userService.requestPasswordReset(user.userId).map { result =>
819                     eventBusService.publish(
820                       ResetPasswordEvent(
821                         userId = user.userId,
822                         connectedUserId = userAuth.map(_.user.userId),
823                         country = user.country,
824                         requestContext = requestContext,
825                         eventDate = DateHelper.now(),
826                         eventId = Some(idGenerator.nextEventId())
827                       )
828                     )
829                     result
830                   }) { _ =>
831                     complete(StatusCodes.NoContent)
832                   }
833                 }
834               })
835             }
836           }
837         }
838       }
839     }
840 
841     override def resetPasswordCheckRoute: Route = {
842       post {
843         path("user" / "reset-password" / "check-validity" / userId / Segment) { (userId: UserId, resetToken: String) =>
844           makeOperation("ResetPasswordCheck", EndpointType.Public) { _ =>
845             persistentUserService.findUserByUserIdAndResetToken(userId, resetToken).asDirectiveOrNotFound { user =>
846               if (user.resetTokenExpiresAt.exists(_.isAfter(DateHelper.now()))) {
847                 complete(StatusCodes.NoContent)
848               } else {
849                 complete(StatusCodes.BadRequest)
850               }
851             }
852           }
853         }
854       }
855     }
856 
857     override def resetPasswordRoute: Route = {
858       post {
859         path("user" / "reset-password" / "change-password" / userId) { userId =>
860           makeOperation("ResetPassword", EndpointType.Public) { _ =>
861             decodeRequest {
862               entity(as[ResetPassword]) { request: ResetPassword =>
863                 persistentUserService
864                   .findUserByUserIdAndResetToken(userId, request.resetToken.value)
865                   .asDirectiveOrNotFound { user =>
866                     if (user.resetTokenExpiresAt.forall(_.isBefore(DateHelper.now()))) {
867                       complete(StatusCodes.BadRequest)
868                     } else {
869                       onSuccess(
870                         userService
871                           .updatePassword(
872                             userId = userId,
873                             resetToken = Some(request.resetToken.value),
874                             password = request.password.value
875                           )
876                       ) { _ =>
877                         complete(StatusCodes.NoContent)
878                       }
879                     }
880                   }
881               }
882             }
883           }
884         }
885       }
886     }
887 
888     /**
889       *
890       * proposals from themes will not be retrieve since themes are not displayed on front
891       */
892     override def getProposalsByUser: Route = get {
893       path("user" / userId / "proposals") { userId: UserId =>
894         makeOperation("UserProposals") { requestContext =>
895           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
896             parameters(
897               "preferredLanguage".as[Language].?,
898               "sort".?,
899               "order".as[Order].?,
900               "limit".as[Pagination.Limit].?,
901               "skip".as[Pagination.Offset].?
902             ) {
903               (
904                 preferredLanguage: Option[Language],
905                 sort: Option[String],
906                 order: Option[Order],
907                 limit: Option[Pagination.Limit],
908                 offset: Option[Pagination.Offset]
909               ) =>
910                 val connectedUserId: UserId = userAuth.user.userId
911                 if (connectedUserId != userId) {
912                   complete(StatusCodes.Forbidden)
913                 } else {
914                   val defaultSort = Some("createdAt")
915                   val defaultOrder = Some(Order.desc)
916                   proposalService
917                     .searchForUser(
918                       userId = Some(userId),
919                       query = SearchQuery(
920                         filters = Some(
921                           SearchFilters(
922                             users = Some(UserSearchFilter(userIds = Seq(userId))),
923                             status =
924                               Some(StatusSearchFilter(ProposalStatus.values.filter(_ != ProposalStatus.Archived)))
925                           )
926                         ),
927                         sort = Some(
928                           Sort(field = sort.orElse(defaultSort), mode = order.orElse(defaultOrder).map(_.sortOrder))
929                         ),
930                         limit = limit,
931                         offset = offset
932                       ),
933                       requestContext = requestContext,
934                       preferredLanguage = preferredLanguage,
935                       questionDefaultLanguage = None
936                     )
937                     .asDirective
938                     .apply(complete(_))
939                 }
940             }
941           }
942         }
943       }
944     }
945 
946     override def patchCurrentUser: Route =
947       patch {
948         path("user") {
949           makeOperation("PatchCurrentUser") { requestContext =>
950             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
951               decodeRequest {
952                 entity(as[UpdateUserRequest]) { request: UpdateUserRequest =>
953                   userService.getUser(userAuth.user.userId).asDirectiveOrNotFound { user =>
954                     val optInNewsletterHasChanged: Boolean = (request.optInNewsletter, user.profile) match {
955                       case (Some(value), Some(profileValue)) => value != profileValue.optInNewsletter
956                       case (Some(_), None)                   => true
957                       case _                                 => false
958                     }
959 
960                     val profile = user.profile.orElse(Profile.parseProfile())
961 
962                     val updatedProfile = profile.map(
963                       _.copy(
964                         dateOfBirth = request.dateOfBirth.map(_.birthDate).orElse(user.profile.flatMap(_.dateOfBirth)),
965                         profession = request.profession.orElse(user.profile.flatMap(_.profession)),
966                         postalCode = request.postalCode.map(_.value).orElse(user.profile.flatMap(_.postalCode)),
967                         phoneNumber = request.phoneNumber.map(_.value).orElse(user.profile.flatMap(_.phoneNumber)),
968                         description = request.description.map(_.value).orElse(user.profile.flatMap(_.description)),
969                         optInNewsletter = request.optInNewsletter.getOrElse(user.profile.exists(_.optInNewsletter)),
970                         gender = request.gender.orElse(user.profile.flatMap(_.gender)),
971                         genderName = request.genderName.orElse(user.profile.flatMap(_.genderName)),
972                         crmCountry = request.crmCountry.orElse(user.profile.map(_.crmCountry)).getOrElse(Country("FR")),
973                         crmLanguage =
974                           request.crmLanguage.orElse(user.profile.map(_.crmLanguage)).getOrElse(Language("fr")),
975                         socioProfessionalCategory =
976                           request.socioProfessionalCategory.orElse(user.profile.flatMap(_.socioProfessionalCategory)),
977                         politicalParty = request.politicalParty.orElse(user.profile.flatMap(_.politicalParty)),
978                         website = request.website.map(_.value).orElse(user.profile.flatMap(_.website))
979                       )
980                     )
981 
982                     onSuccess(
983                       userService.update(
984                         user.copy(
985                           firstName = request.firstName.map(_.value).orElse(user.firstName),
986                           lastName = request.lastName.orElse(user.lastName),
987                           organisationName = request.organisationName.map(_.value).orElse(user.organisationName),
988                           country = request.crmCountry.getOrElse(user.country),
989                           profile = updatedProfile
990                         ),
991                         requestContext
992                       )
993                     ) { user: User =>
994                       if (optInNewsletterHasChanged && user.userType == UserType.UserTypeUser) {
995                         eventBusService.publish(
996                           UserUpdatedOptInNewsletterEvent(
997                             connectedUserId = Some(userAuth.user.userId),
998                             userId = user.userId,
999                             requestContext = requestContext,
1000                             eventDate = DateHelper.now(),
1001                             country = user.country,
1002                             optInNewsletter = user.profile.exists(_.optInNewsletter),
1003                             eventId = Some(idGenerator.nextEventId())
1004                           )
1005                         )
1006                       }
1007                       if (user.userType == UserType.UserTypeOrganisation) {
1008                         eventBusService.publish(
1009                           OrganisationUpdatedEvent(
1010                             connectedUserId = Some(user.userId),
1011                             userId = user.userId,
1012                             requestContext = requestContext,
1013                             country = user.country,
1014                             eventDate = DateHelper.now(),
1015                             eventId = Some(idGenerator.nextEventId())
1016                           )
1017                         )
1018                       }
1019                       userService.getFollowedUsers(user.userId).asDirective { followedUsers =>
1020                         complete(StatusCodes.OK -> UserResponse(user, followedUsers))
1021                       }
1022                     }
1023                   }
1024                 }
1025               }
1026             }
1027           }
1028         }
1029       }
1030 
1031     override def changePassword: Route = post {
1032       path("user" / userId / "change-password") { userId: UserId =>
1033         makeOperation("ChangePassword") { _ =>
1034           decodeRequest {
1035             entity(as[ChangePasswordRequest]) { request: ChangePasswordRequest =>
1036               makeOAuth2 { userAuth: AuthInfo[UserRights] =>
1037                 val connectedUserId: UserId = userAuth.user.userId
1038                 if (connectedUserId != userId) {
1039                   complete(StatusCodes.Forbidden)
1040                 } else {
1041                   userService.getUserByUserIdAndPassword(userId, request.actualPassword).asDirective {
1042                     case Some(_) =>
1043                       userService.updatePassword(userId, None, request.newPassword.value).asDirective { _ =>
1044                         complete(StatusCodes.OK)
1045                       }
1046                     case None =>
1047                       complete(
1048                         StatusCodes.BadRequest -> Seq(
1049                           ValidationError("password", "invalid_password", Some("Wrong password"))
1050                         )
1051                       )
1052                   }
1053                 }
1054               }
1055             }
1056           }
1057         }
1058       }
1059     }
1060 
1061     override def deleteUser: Route = post {
1062       path("user" / userId / "delete") { userId: UserId =>
1063         makeOperation("deleteUser") { requestContext =>
1064           decodeRequest {
1065             entity(as[DeleteUserRequest]) { request: DeleteUserRequest =>
1066               makeOAuth2 { userAuth: AuthInfo[UserRights] =>
1067                 if (userAuth.user.userId != userId) {
1068                   complete(StatusCodes.Forbidden)
1069                 } else {
1070                   userService.getUserByUserIdAndPassword(userId, request.password).asDirective {
1071                     case Some(user) =>
1072                       userService
1073                         .anonymize(user, userAuth.user.userId, requestContext, Anonymization.Explicit)
1074                         .asDirective { _ =>
1075                           oauth2DataHandler.removeTokenByUserId(userId).asDirective { _ =>
1076                             addCookies(requestContext.applicationName, logoutCookies()) { complete(StatusCodes.OK) }
1077                           }
1078                         }
1079                     case None =>
1080                       complete(
1081                         StatusCodes.BadRequest -> Seq(
1082                           ValidationError("password", "invalid_password", Some("Wrong password"))
1083                         )
1084                       )
1085                   }
1086                 }
1087               }
1088             }
1089           }
1090         }
1091       }
1092     }
1093 
1094     override def followUser: Route =
1095       post {
1096         path("user" / userId / "follow") { userId =>
1097           makeOperation("FollowUser") { requestContext =>
1098             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
1099               userService.getUser(userId).asDirectiveOrNotFound { user =>
1100                 if (!user.publicProfile) {
1101                   complete(StatusCodes.Forbidden)
1102                 } else {
1103                   userService.getFollowedUsers(userAuth.user.userId).asDirective { followedUsers =>
1104                     if (followedUsers.contains(userId)) {
1105                       complete(StatusCodes.BadRequest)
1106                     } else {
1107                       onSuccess(userService.followUser(userId, userAuth.user.userId, requestContext)) { _ =>
1108                         complete(StatusCodes.OK)
1109                       }
1110                     }
1111                   }
1112                 }
1113               }
1114             }
1115           }
1116         }
1117       }
1118 
1119     override def unfollowUser: Route =
1120       post {
1121         path("user" / userId / "unfollow") { userId =>
1122           makeOperation("FollowUser") { requestContext =>
1123             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
1124               userService.getUser(userId).asDirectiveOrNotFound { _ =>
1125                 userService.getFollowedUsers(userAuth.user.userId).asDirective { followedUsers =>
1126                   if (!followedUsers.contains(userId)) {
1127                     complete(
1128                       StatusCodes.BadRequest -> Seq(
1129                         ValidationError("userId", "invalid_state", Some("User already unfollowed"))
1130                       )
1131                     )
1132                   } else {
1133                     onSuccess(userService.unfollowUser(userId, userAuth.user.userId, requestContext)) { _ =>
1134                       complete(StatusCodes.OK)
1135                     }
1136                   }
1137                 }
1138               }
1139             }
1140           }
1141         }
1142       }
1143 
1144     override def reconnectInfo: Route = {
1145       post {
1146         path("user" / userId / "reconnect") { userId =>
1147           makeOperation("ReconnectInfo") { _ =>
1148             userService.reconnectInfo(userId).asDirectiveOrNotFound { reconnectInfo =>
1149               complete(StatusCodes.OK -> reconnectInfo)
1150             }
1151           }
1152         }
1153       }
1154     }
1155 
1156     override def resendValidationEmail: Route = {
1157       post {
1158         path("user" / "validation-email") {
1159           makeOperation("ResendValidationEmail") { requestContext =>
1160             decodeRequest {
1161               entity(as[ResendValidationEmailRequest]) { entity =>
1162                 userService.getUserByEmail(entity.email).asDirective { maybeUser =>
1163                   maybeUser.foreach { user =>
1164                     eventBusService.publish(
1165                       ResendValidationEmailEvent(
1166                         connectedUserId = None,
1167                         eventDate = DateHelper.now(),
1168                         userId = user.userId,
1169                         country = user.country,
1170                         requestContext = requestContext,
1171                         eventId = Some(idGenerator.nextEventId())
1172                       )
1173                     )
1174                   }
1175                   complete(StatusCodes.NoContent)
1176                 }
1177               }
1178             }
1179           }
1180         }
1181       }
1182     }
1183 
1184     override def uploadAvatar: Route = {
1185       post {
1186         path("user" / userId / "upload-avatar") { userId =>
1187           makeOperation("UserUploadAvatar") { requestContext =>
1188             makeOAuth2 { user =>
1189               authorize(user.user.userId == userId || user.user.roles.contains(RoleAdmin)) {
1190                 def uploadFile(extension: String, contentType: String, fileContent: Content): Future[String] =
1191                   storageService.uploadUserAvatar(extension, contentType, fileContent)
1192                 uploadImageAsync("data", uploadFile, sizeLimit = Some(storageConfiguration.maxFileSize)) {
1193                   (path, file) =>
1194                     file.delete()
1195                     userService.getUser(userId).asDirectiveOrNotFound { user =>
1196                       val modifiedProfile = user.profile match {
1197                         case Some(profile) => Some(profile.copy(avatarUrl = Some(path)))
1198                         case None          => Profile.parseProfile(avatarUrl = Some(path))
1199                       }
1200 
1201                       onSuccess(userService.update(user.copy(profile = modifiedProfile), requestContext)) { _ =>
1202                         complete(UploadResponse(path))
1203                       }
1204                     }
1205                 }
1206               }
1207             }
1208           }
1209         }
1210       }
1211     }
1212 
1213     override def modifyUserProfile: Route = {
1214       put {
1215         path("user" / userId / "profile") { userId =>
1216           makeOperation("modifyUserProfile") { requestContext =>
1217             makeOAuth2 { user =>
1218               authorize(user.user.userId == userId) {
1219                 decodeRequest {
1220                   entity(as[UserProfileRequest]) { entity =>
1221                     Validation.validate(userRegistrationValidator.requirements(entity): _*)
1222                     userService.getUser(userId).asDirectiveOrNotFound { user =>
1223                       val modifiedProfile = user.profile
1224                         .orElse(Profile.parseProfile())
1225                         .map(
1226                           _.copy(
1227                             dateOfBirth = Some(entity.dateOfBirth.birthDate),
1228                             avatarUrl = entity.avatarUrl.map(_.value),
1229                             profession = entity.profession.map(_.value),
1230                             description = entity.description.map(_.value),
1231                             postalCode = entity.postalCode.map(_.value),
1232                             crmCountry = entity.crmCountry.getOrElse(Country("FR")),
1233                             crmLanguage = entity.crmLanguage.getOrElse(Language("fr")),
1234                             optInNewsletter = entity.optInNewsletter,
1235                             website = entity.website.map(_.value)
1236                           )
1237                         )
1238 
1239                       val modifiedUser =
1240                         user.copy(
1241                           profile = modifiedProfile,
1242                           firstName = Some(entity.firstName.value),
1243                           lastName = entity.lastName.map(_.value)
1244                         )
1245 
1246                       userService.update(modifiedUser, requestContext).asDirective { result =>
1247                         complete(
1248                           UserProfileResponse(
1249                             email = result.email,
1250                             firstName = result.firstName,
1251                             lastName = result.lastName,
1252                             dateOfBirth = result.profile.flatMap(_.dateOfBirth),
1253                             avatarUrl = result.profile.flatMap(_.avatarUrl),
1254                             profession = result.profile.flatMap(_.profession),
1255                             description = result.profile.flatMap(_.description),
1256                             postalCode = result.profile.flatMap(_.postalCode),
1257                             optInNewsletter = result.profile.forall(_.optInNewsletter),
1258                             website = result.profile.flatMap(_.website),
1259                             crmCountry = result.profile.map(_.crmCountry),
1260                             crmLanguage = result.profile.map(_.crmLanguage)
1261                           )
1262                         )
1263                       }
1264                     }
1265                   }
1266                 }
1267               }
1268             }
1269           }
1270         }
1271       }
1272     }
1273 
1274     override def getPrivacyPolicy: Route = {
1275       post {
1276         path("user" / "privacy-policy") {
1277           makeOperation("GetPrivacyPolicy") { _ =>
1278             decodeRequest {
1279               entity(as[PrivacyPolicyRequest]) { request =>
1280                 userService.getUserByEmailAndPassword(request.email, request.password).asDirective {
1281                   case None =>
1282                     complete(
1283                       StatusCodes.BadRequest -> Seq(
1284                         ValidationError("email", "invalid", Some("email or password is invalid."))
1285                       )
1286                     )
1287                   case Some(user) => complete(UserPrivacyPolicyResponse(user.privacyPolicyApprovalDate))
1288                 }
1289               }
1290             }
1291           }
1292         }
1293       }
1294     }
1295 
1296     override def getSocialPrivacyPolicy: Route = {
1297       post {
1298         path("user" / "social" / "privacy-policy") {
1299           makeOperation("GetSocialPrivacyPolicy") { _ =>
1300             decodeRequest {
1301               entity(as[SocialPrivacyPolicyRequest]) { request =>
1302                 (for {
1303                   maybeQuestion <- request.questionId.flatTraverse(questionService.getQuestion)
1304                   maybeUser <- socialService
1305                     .getUserByProviderAndToken(
1306                       request.provider,
1307                       request.token,
1308                       maybeQuestion.flatMap(_.operationId),
1309                       request.redirectUri
1310                     )
1311                 } yield maybeUser).asDirective { maybeUser =>
1312                   complete(UserPrivacyPolicyResponse(maybeUser.flatMap(_.privacyPolicyApprovalDate)))
1313                 }
1314               }
1315             }
1316           }
1317         }
1318       }
1319     }
1320 
1321     override def checkRegistration: Route = {
1322       post {
1323         path("user" / "check-registration") {
1324           makeOperation("CheckRegistration") { _ =>
1325             decodeRequest {
1326               entity(as[CheckRegistrationRequest]) { request =>
1327                 userService.getUserByEmail(request.email.value).asDirective {
1328                   case None    => complete(StatusCodes.NoContent)
1329                   case Some(_) => failWith(EmailAlreadyRegisteredException(request.email.value))
1330                 }
1331               }
1332             }
1333           }
1334         }
1335       }
1336     }
1337   }
1338 }