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 eu.timepit.refined.api.Refined
25 import eu.timepit.refined.string.Url
26 import grizzled.slf4j.Logging
27 import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
28 import io.circe.refined._
29 import io.circe.{Decoder, Encoder}
30 import io.swagger.annotations._
31 import scalaoauth2.provider.AuthInfo
32 import cats.implicits._
33 import org.make.api.operation.OperationServiceComponent
34 import org.make.api.proposal.ProposalServiceComponent
35 import org.make.api.question.QuestionServiceComponent
36 import org.make.api.technical.EventBusServiceComponent
37 import org.make.api.technical.CsvReceptacle._
38 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
39 import org.make.api.technical.directives.FutureDirectivesExtensions._
40 import org.make.api.technical.crm.SendMailPublisherServiceComponent
41 import org.make.api.technical.storage.{Content, StorageConfigurationComponent, StorageServiceComponent, UploadResponse}
42 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
43 import org.make.api.user.DefaultPersistentUserServiceComponent.PersistentUser
44 import org.make.core._
45 import org.make.core.Validation._
46 import org.make.core.auth.UserRights
47 import org.make.core.job.Job.JobId
48 import org.make.core.profile.Profile
49 import org.make.core.question.QuestionId
50 import org.make.core.reference.Country
51 import org.make.core.technical.Pagination
52 import org.make.core.technical.ValidatedUtils.ValidatedNecWithUtils
53 import org.make.core.user._
54 
55 import javax.ws.rs.Path
56 import scala.annotation.meta.field
57 import scala.concurrent.Future
58 import scala.util.{Failure, Success}
59 
60 @Api(value = "Admin Users")
61 @Path(value = "/admin/users")
62 trait AdminUserApi extends Directives {
63 
64   @ApiOperation(
65     value = "get-users",
66     httpMethod = "GET",
67     code = HttpCodes.OK,
68     authorizations = Array(
69       new Authorization(
70         value = "MakeApi",
71         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
72       )
73     )
74   )
75   @ApiImplicitParams(
76     value = Array(
77       new ApiImplicitParam(
78         name = "_start",
79         paramType = "query",
80         dataType = "int",
81         allowableValues = "range[0, infinity]"
82       ),
83       new ApiImplicitParam(
84         name = "_end",
85         paramType = "query",
86         dataType = "int",
87         allowableValues = "range[0, infinity]"
88       ),
89       new ApiImplicitParam(
90         name = "_sort",
91         paramType = "query",
92         dataType = "string",
93         allowableValues = PersistentUser.swaggerAllowableValues
94       ),
95       new ApiImplicitParam(
96         name = "_order",
97         paramType = "query",
98         dataType = "string",
99         allowableValues = Order.swaggerAllowableValues
100       ),
101       new ApiImplicitParam(name = "id", paramType = "query", dataType = "string", allowMultiple = true),
102       new ApiImplicitParam(name = "email", paramType = "query", dataType = "string"),
103       new ApiImplicitParam(
104         name = "role",
105         paramType = "query",
106         dataType = "string",
107         defaultValue = "ROLE_MODERATOR",
108         allowableValues = Role.swaggerAllowableValues
109       ),
110       new ApiImplicitParam(
111         name = "userType",
112         paramType = "query",
113         dataType = "string",
114         defaultValue = "USER",
115         allowableValues = UserType.swaggerAllowableValues
116       )
117     )
118   )
119   @ApiResponses(
120     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[AdminUserResponse]]))
121   )
122   @Path(value = "/")
123   def getUsers: Route
124 
125   @ApiOperation(
126     value = "update-user",
127     httpMethod = "PUT",
128     code = HttpCodes.OK,
129     authorizations = Array(
130       new Authorization(
131         value = "MakeApi",
132         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
133       )
134     )
135   )
136   @ApiImplicitParams(
137     value = Array(
138       new ApiImplicitParam(
139         name = "userId",
140         paramType = "path",
141         dataType = "string",
142         example = "11111111-2222-3333-4444-555555555555"
143       ),
144       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.AdminUpdateUserRequest")
145     )
146   )
147   @ApiResponses(
148     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[AdminUserResponse]))
149   )
150   @Path(value = "/{userId}")
151   def updateUser: Route
152 
153   @ApiOperation(
154     value = "get-user",
155     httpMethod = "GET",
156     code = HttpCodes.OK,
157     authorizations = Array(
158       new Authorization(
159         value = "MakeApi",
160         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
161       )
162     )
163   )
164   @ApiResponses(
165     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[AdminUserResponse]))
166   )
167   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string")))
168   @Path(value = "/{userId}")
169   def getUser: Route
170 
171   @ApiOperation(
172     value = "admin-anonymize-user",
173     httpMethod = "DELETE",
174     code = HttpCodes.OK,
175     authorizations = Array(
176       new Authorization(
177         value = "MakeApi",
178         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
179       )
180     )
181   )
182   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string")))
183   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok")))
184   @Path(value = "/{userId}")
185   def anonymizeUser: Route
186 
187   @ApiOperation(
188     value = "admin-anonymize-user-by-email",
189     httpMethod = "POST",
190     code = HttpCodes.OK,
191     authorizations = Array(
192       new Authorization(
193         value = "MakeApi",
194         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
195       )
196     )
197   )
198   @ApiImplicitParams(
199     value = Array(
200       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.AnonymizeUserRequest")
201     )
202   )
203   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok")))
204   @Path(value = "/anonymize")
205   def anonymizeUserByEmail: Route
206 
207   @ApiOperation(
208     value = "admin-upload-avatar",
209     httpMethod = "POST",
210     code = HttpCodes.OK,
211     consumes = "multipart/form-data",
212     authorizations = Array(
213       new Authorization(
214         value = "MakeApi",
215         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
216       )
217     )
218   )
219   @ApiImplicitParams(
220     value = Array(
221       new ApiImplicitParam(
222         name = "userType",
223         paramType = "path",
224         dataType = "string",
225         defaultValue = "USER",
226         allowableValues = UserType.swaggerAllowableValues
227       ),
228       new ApiImplicitParam(name = "data", paramType = "formData", dataType = "file")
229     )
230   )
231   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[UploadResponse])))
232   @Path(value = "/upload-avatar/{userType}")
233   def adminUploadAvatar: Route
234 
235   @ApiOperation(
236     value = "update-user-email",
237     httpMethod = "POST",
238     code = HttpCodes.NoContent,
239     authorizations = Array(
240       new Authorization(
241         value = "MakeApi",
242         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
243       )
244     )
245   )
246   @ApiImplicitParams(
247     value = Array(
248       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.AdminUpdateUserEmail")
249     )
250   )
251   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No content")))
252   @Path(value = "/update-user-email")
253   def updateUserEmail: Route
254 
255   @ApiOperation(
256     value = "update-user-roles",
257     httpMethod = "POST",
258     code = HttpCodes.NoContent,
259     authorizations = Array(
260       new Authorization(
261         value = "MakeApi",
262         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
263       )
264     )
265   )
266   @ApiImplicitParams(
267     value = Array(
268       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.UpdateUserRolesRequest")
269     )
270   )
271   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
272   @Path(value = "/update-user-roles")
273   def updateUserRoles: Route
274 
275   @ApiOperation(
276     value = "anonymize-users",
277     httpMethod = "DELETE",
278     code = HttpCodes.Accepted,
279     authorizations = Array(
280       new Authorization(
281         value = "MakeApi",
282         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
283       )
284     )
285   )
286   @ApiResponses(
287     value = Array(
288       new ApiResponse(code = HttpCodes.Accepted, message = "Accepted"),
289       new ApiResponse(code = HttpCodes.Conflict, message = "Conflict")
290     )
291   )
292   @Path(value = "/")
293   def anonymizeUsers: Route
294 
295   @ApiOperation(
296     value = "send-email-to-proposer",
297     httpMethod = "POST",
298     code = HttpCodes.NoContent,
299     authorizations = Array(
300       new Authorization(
301         value = "MakeApi",
302         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
303       )
304     )
305   )
306   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
307   @ApiImplicitParams(
308     value = Array(
309       new ApiImplicitParam(name = "body", paramType = "body", dataType = "org.make.api.user.SendProposerEmailRequest")
310     )
311   )
312   @Path(value = "/send-email-to-proposer")
313   def sendEmailToProposer: Route
314 
315   def routes: Route =
316     getUsers ~ getUser ~ updateUser ~ anonymizeUser ~ anonymizeUserByEmail ~ adminUploadAvatar ~ updateUserEmail ~ updateUserRoles ~ anonymizeUsers ~ sendEmailToProposer
317 
318 }
319 
320 trait AdminUserApiComponent {
321   def adminUserApi: AdminUserApi
322 }
323 
324 trait DefaultAdminUserApiComponent
325     extends AdminUserApiComponent
326     with MakeAuthenticationDirectives
327     with Logging
328     with ParameterExtractors {
329 
330   this: MakeDirectivesDependencies
331     with UserServiceComponent
332     with ProposalServiceComponent
333     with QuestionServiceComponent
334     with OperationServiceComponent
335     with EventBusServiceComponent
336     with PersistentUserServiceComponent
337     with SendMailPublisherServiceComponent
338     with StorageServiceComponent
339     with StorageConfigurationComponent =>
340 
341   override lazy val adminUserApi: AdminUserApi = new DefaultAdminUserApi
342 
343   class DefaultAdminUserApi extends AdminUserApi {
344 
345     val userId: PathMatcher1[UserId] = Segment.map(UserId.apply)
346 
347     override def getUsers: Route = get {
348       path("admin" / "users") {
349         makeOperation("AdminGetUsers") { _ =>
350           parameters(
351             "_start".as[Pagination.Offset].?,
352             "_end".as[Pagination.End].?,
353             "_sort".?,
354             "_order".as[Order].?,
355             "id".csv[UserId],
356             "email".?,
357             "role".as[String].?,
358             "userType".as[UserType].?
359           ) {
360             (
361               offset: Option[Pagination.Offset],
362               end: Option[Pagination.End],
363               sort: Option[String],
364               order: Option[Order],
365               ids: Option[Seq[UserId]],
366               email: Option[String],
367               maybeRole: Option[String],
368               userType: Option[UserType]
369             ) =>
370               makeOAuth2 { auth: AuthInfo[UserRights] =>
371                 requireSuperAdminRole(auth.user) {
372                   val role: Option[Role] = maybeRole.map(Role.apply)
373                   (
374                     userService
375                       .adminCountUsers(
376                         ids = ids,
377                         email = email,
378                         firstName = None,
379                         lastName = None,
380                         role = role,
381                         userType = userType
382                       )
383                       .asDirective,
384                     userService
385                       .adminFindUsers(
386                         offset.orZero,
387                         end,
388                         sort,
389                         order,
390                         ids = ids,
391                         email = email,
392                         firstName = None,
393                         lastName = None,
394                         role = role,
395                         userType = userType
396                       )
397                       .asDirective
398                   ).tupled.apply {
399                     case (count, users) =>
400                       complete(
401                         (StatusCodes.OK, List(`X-Total-Count`(count.toString)), users.map(AdminUserResponse.apply))
402                       )
403                   }
404                 }
405               }
406           }
407         }
408       }
409     }
410 
411     override def updateUser: Route =
412       put {
413         path("admin" / "users" / userId) { userId =>
414           makeOperation("AdminUpdateUser") { requestContext =>
415             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
416               requireSuperAdminRole(userAuth.user) {
417                 decodeRequest {
418                   entity(as[AdminUpdateUserRequest]) { request: AdminUpdateUserRequest =>
419                     userService.getUser(userId).asDirectiveOrNotFound { user =>
420                       val lowerCasedEmail: String = request.email.getOrElse(user.email).toLowerCase()
421                       userService.getUserByEmail(lowerCasedEmail).asDirective { maybeUser =>
422                         maybeUser.foreach { userToCheck =>
423                           Validation.validate(
424                             Validation.validateField(
425                               field = "email",
426                               "already_registered",
427                               condition = userToCheck.userId.value == user.userId.value,
428                               message = s"Email $lowerCasedEmail already exists"
429                             )
430                           )
431                         }
432                         val profile: Option[Profile] = user.profile
433                           .map(
434                             _.copy(
435                               website = request.website.map(_.value),
436                               politicalParty = request.politicalParty,
437                               optInNewsletter = request.optInNewsletter,
438                               avatarUrl = request.avatarUrl.map(_.value)
439                             )
440                           )
441                           .orElse(
442                             Profile.parseProfile(
443                               website = request.website.map(_.value),
444                               politicalParty = request.politicalParty,
445                               optInNewsletter = request.optInNewsletter,
446                               avatarUrl = request.avatarUrl.map(_.value)
447                             )
448                           )
449 
450                         onSuccess(
451                           userService.update(
452                             user.copy(
453                               email = lowerCasedEmail,
454                               firstName = request.firstName.orElse(user.firstName),
455                               lastName = request.lastName.orElse(user.lastName),
456                               country = request.country.getOrElse(user.country),
457                               organisationName = request.organisationName,
458                               userType = request.userType,
459                               roles = request.roles.map(_.map(Role.apply)).getOrElse(user.roles),
460                               availableQuestions = request.availableQuestions,
461                               profile = profile
462                             ),
463                             requestContext
464                           )
465                         ) { user: User =>
466                           complete(StatusCodes.OK -> AdminUserResponse(user))
467                         }
468                       }
469                     }
470                   }
471                 }
472               }
473 
474             }
475           }
476         }
477       }
478 
479     override def getUser: Route = get {
480       path("admin" / "users" / userId) { userId =>
481         makeOperation("GetUser") { _ =>
482           makeOAuth2 { auth: AuthInfo[UserRights] =>
483             requireSuperAdminRole(auth.user) {
484               userService.getUser(userId).asDirectiveOrNotFound { user =>
485                 complete(AdminUserResponse(user))
486               }
487             }
488           }
489         }
490       }
491     }
492 
493     override def anonymizeUser: Route = delete {
494       path("admin" / "users" / userId) { userId: UserId =>
495         makeOperation("adminDeleteUser") { requestContext =>
496           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
497             requireSuperAdminRole(userAuth.user) {
498               userService.getUser(userId).asDirectiveOrNotFound { user =>
499                 userService.anonymize(user, userAuth.user.userId, requestContext, Anonymization.Explicit).asDirective {
500                   _ =>
501                     oauth2DataHandler.removeTokenByUserId(userId).asDirective { _ =>
502                       complete(StatusCodes.OK)
503                     }
504                 }
505               }
506             }
507           }
508         }
509       }
510     }
511 
512     override def anonymizeUsers: Route = delete {
513       path("admin" / "users") {
514         makeOperation("adminDeleteUsers") { requestContext =>
515           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
516             requireSuperAdminRole(userAuth.user) {
517               userService.anonymizeInactiveUsers(userAuth.user.userId, requestContext).asDirective { acceptance =>
518                 if (acceptance.isAccepted)
519                   complete(StatusCodes.Accepted -> JobId.AnonymizeInactiveUsers)
520                 else
521                   complete(StatusCodes.Conflict -> JobId.AnonymizeInactiveUsers)
522               }
523             }
524           }
525         }
526       }
527     }
528 
529     override def anonymizeUserByEmail: Route = post {
530       path("admin" / "users" / "anonymize") {
531         makeOperation("anonymizeUserByEmail") { requestContext =>
532           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
533             requireSuperAdminRole(userAuth.user) {
534               decodeRequest {
535                 entity(as[AnonymizeUserRequest]) { request =>
536                   userService.getUserByEmail(request.email).asDirectiveOrNotFound { user =>
537                     userService
538                       .anonymize(user, userAuth.user.userId, requestContext, Anonymization.Explicit)
539                       .asDirective
540                       .apply { _ =>
541                         oauth2DataHandler.removeTokenByUserId(user.userId).asDirective { _ =>
542                           complete(StatusCodes.OK)
543                         }
544                       }
545                   }
546                 }
547               }
548             }
549           }
550         }
551       }
552     }
553 
554     override def adminUploadAvatar: Route = {
555       post {
556         path("admin" / "users" / "upload-avatar" / UserType) { userType =>
557           makeOperation("AdminUserUploadAvatar") { _ =>
558             makeOAuth2 { userAuth =>
559               requireAdminRole(userAuth.user) {
560                 def uploadFile(extension: String, contentType: String, fileContent: Content): Future[String] =
561                   storageService.uploadAdminUserAvatar(extension, contentType, fileContent, userType)
562 
563                 uploadImageAsync("data", uploadFile, sizeLimit = Some(storageConfiguration.maxFileSize)) {
564                   (path, file) =>
565                     file.delete()
566                     complete(UploadResponse(path))
567                 }
568               }
569             }
570           }
571         }
572       }
573     }
574 
575     override def updateUserEmail: Route = {
576       post {
577         path("admin" / "users" / "update-user-email") {
578           makeOperation("AdminUserUpdateEmail") { _ =>
579             makeOAuth2 { userAuth =>
580               requireSuperAdminRole(userAuth.user) {
581                 decodeRequest {
582                   entity(as[AdminUpdateUserEmail]) {
583                     case AdminUpdateUserEmail(oldEmail, newEmail) =>
584                       userService.getUserByEmail(oldEmail).asDirective {
585                         case Some(user) =>
586                           userService
587                             .adminUpdateUserEmail(user, newEmail)
588                             .asDirective
589                             .apply(_ => complete(StatusCodes.NoContent))
590                         case None =>
591                           complete(
592                             StatusCodes.BadRequest ->
593                               Seq(
594                                 ValidationError("oldEmail", "not_found", Some(s"No user found for email '$oldEmail'"))
595                               )
596                           )
597                       }
598                   }
599                 }
600               }
601             }
602           }
603         }
604       }
605     }
606 
607     override def updateUserRoles: Route = {
608       post {
609         path("admin" / "users" / "update-user-roles") {
610           makeOperation("UpdateUserRoles") { requestContext =>
611             makeOAuth2 { userAuth =>
612               requireSuperAdminRole(userAuth.user) {
613                 decodeRequest {
614                   entity(as[UpdateUserRolesRequest]) { request =>
615                     userService.getUserByEmail(request.email).asDirective {
616                       case None =>
617                         complete(
618                           StatusCodes.BadRequest ->
619                             Seq(
620                               ValidationError(
621                                 field = "email",
622                                 key = "not_found",
623                                 message = Some(s"The email ${request.email} was not found")
624                               )
625                             )
626                         )
627                       case Some(user) =>
628                         userService.update(user.copy(roles = request.roles), requestContext).asDirective { _ =>
629                           complete(StatusCodes.NoContent)
630                         }
631                     }
632                   }
633                 }
634               }
635             }
636           }
637         }
638       }
639     }
640 
641     private val MaximumEmailLength = 1000
642 
643     override def sendEmailToProposer: Route = {
644       post {
645         path("admin" / "users" / "send-email-to-proposer") {
646           makeOperation("SendProposerEmail") { requestContext =>
647             makeOAuth2 { userAuth =>
648               requireAdminRole(userAuth.user) {
649                 decodeRequest {
650                   entity(as[SendProposerEmailRequest]) { entity =>
651                     SanitizedHtml.fromString(entity.text, Some(MaximumEmailLength)) match {
652                       case Failure(_) =>
653                         complete(
654                           StatusCodes.BadRequest -> Seq(
655                             ValidationError(
656                               "text",
657                               "too_long",
658                               Some(s"The length of the email's body must not exceed $MaximumEmailLength characters")
659                             )
660                           )
661                         )
662                       case Success(sanitizedHtml) =>
663                         sendMailPublisherService
664                           .sendEmailToProposer(
665                             entity.proposalId,
666                             userAuth.user.userId,
667                             sanitizedHtml,
668                             entity.dryRun,
669                             requestContext
670                           )
671                           .asDirective
672                           .apply(_ => complete(StatusCodes.NoContent))
673                     }
674                   }
675                 }
676               }
677             }
678           }
679         }
680       }
681     }
682   }
683 }
684 
685 final case class AnonymizeUserRequest(email: String) {
686 
687   email.toEmail.throwIfInvalid()
688 }
689 
690 object AnonymizeUserRequest {
691   implicit val decoder: Decoder[AnonymizeUserRequest] = deriveDecoder[AnonymizeUserRequest]
692 }
693 
694 final case class AdminUserResponse(
695   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true) id: UserId,
696   @(ApiModelProperty @field)(dataType = "string", example = "yopmail+test@make.org", required = true)
697   email: String,
698   firstName: Option[String],
699   lastName: Option[String],
700   organisationName: Option[String],
701   @(ApiModelProperty @field)(dataType = "string", required = true, allowableValues = UserType.swaggerAllowableValues) userType: UserType,
702   @(ApiModelProperty @field)(dataType = "list[string]", required = true, allowableValues = Role.swaggerAllowableValues) roles: Seq[
703     Role
704   ],
705   @(ApiModelProperty @field)(dataType = "string", example = "FR", required = true) country: Country,
706   @(ApiModelProperty @field)(dataType = "list[string]", required = true)
707   availableQuestions: Seq[QuestionId],
708   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com")
709   website: Option[String],
710   politicalParty: Option[String],
711   @(ApiModelProperty @field)(dataType = "boolean") optInNewsletter: Option[Boolean],
712   avatarUrl: Option[String]
713 ) {
714   Validation.validate(validateUserInput("email", email, None))
715 }
716 
717 object AdminUserResponse extends CirceFormatters {
718   implicit val encoder: Encoder[AdminUserResponse] = deriveEncoder[AdminUserResponse]
719   implicit val decoder: Decoder[AdminUserResponse] = deriveDecoder[AdminUserResponse]
720 
721   def apply(user: User): AdminUserResponse = AdminUserResponse(
722     id = user.userId,
723     email = user.email,
724     firstName = user.firstName,
725     organisationName = user.organisationName,
726     userType = user.userType,
727     lastName = user.lastName,
728     roles = user.roles.map(role => CustomRole(role.value)),
729     country = user.country,
730     availableQuestions = user.availableQuestions,
731     politicalParty = user.profile.flatMap(_.politicalParty),
732     website = user.profile.flatMap(_.website),
733     optInNewsletter = user.profile.map(_.optInNewsletter),
734     avatarUrl = user.profile.flatMap(_.avatarUrl)
735   )
736 }
737 
738 final case class AdminUpdateUserRequest(
739   @(ApiModelProperty @field)(dataType = "string", example = "yopmail+test@make.org")
740   email: Option[String],
741   firstName: Option[String],
742   lastName: Option[String],
743   organisationName: Option[String],
744   @(ApiModelProperty @field)(dataType = "string", allowableValues = UserType.swaggerAllowableValues) userType: UserType,
745   roles: Option[Seq[String]],
746   @(ApiModelProperty @field)(dataType = "string", example = "FR") country: Option[Country],
747   @(ApiModelProperty @field)(
748     dataType = "list[string]",
749     example = "11111111-2222-3333-4444-555555555555",
750     required = true
751   )
752   availableQuestions: Seq[QuestionId],
753   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/website")
754   website: Option[String Refined Url],
755   politicalParty: Option[String],
756   optInNewsletter: Boolean,
757   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/avatar.png")
758   avatarUrl: Option[String Refined Url]
759 ) {
760   private val maxCountryLength = 3
761 
762   email.foreach(_.toEmail.throwIfInvalid())
763   country.foreach(_.value.withMaxLength(maxCountryLength, "country").throwIfInvalid())
764 }
765 
766 object AdminUpdateUserRequest {
767   implicit lazy val decoder: Decoder[AdminUpdateUserRequest] = deriveDecoder[AdminUpdateUserRequest]
768 }
769 
770 final case class AdminUpdateUserEmail(
771   @(ApiModelProperty @field)(dataType = "string", example = "yopmail+old@make.org", required = true) oldEmail: String,
772   @(ApiModelProperty @field)(dataType = "string", example = "yopmail+new@make.org", required = true) newEmail: String
773 ) {
774 
775   (oldEmail.toEmail, newEmail.toEmail).tupled.throwIfInvalid()
776 }
777 
778 object AdminUpdateUserEmail {
779   implicit val decoder: Decoder[AdminUpdateUserEmail] = deriveDecoder
780   implicit val encoder: Encoder[AdminUpdateUserEmail] = deriveEncoder
781 }
782 
783 final case class UpdateUserRolesRequest(
784   @(ApiModelProperty @field)(dataType = "string", example = "yopmail+test@make.org", required = true) email: String,
785   @(ApiModelProperty @field)(dataType = "list[string]", required = true, allowableValues = Role.swaggerAllowableValues) roles: Seq[
786     Role
787   ]
788 ) {
789 
790   email.toEmail.throwIfInvalid()
791 }
792 
793 object UpdateUserRolesRequest {
794   implicit lazy val decoder: Decoder[UpdateUserRolesRequest] = deriveDecoder[UpdateUserRolesRequest]
795   implicit lazy val encoder: Encoder[UpdateUserRolesRequest] = deriveEncoder[UpdateUserRolesRequest]
796 }