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 cats.implicits._
23 import akka.http.scaladsl.model._
24 import akka.http.scaladsl.server._
25 import grizzled.slf4j.Logging
26 import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
27 import io.circe.{Decoder, Encoder}
28 import io.swagger.annotations._
29 import org.make.api.operation.OperationServiceComponent
30 import org.make.api.question.QuestionServiceComponent
31 import org.make.api.technical.CsvReceptacle._
32 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
33 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
34 import org.make.api.technical.directives.FutureDirectivesExtensions._
35 import org.make.api.user.DefaultPersistentUserServiceComponent.PersistentUser
36 import org.make.core.Validation._
37 import org.make.core._
38 import org.make.core.auth.UserRights
39 import org.make.core.question.QuestionId
40 import org.make.core.reference.{Country, Language}
41 import org.make.core.technical.Pagination
42 import org.make.core.technical.ValidatedUtils.ValidatedNecWithUtils
43 import org.make.core.user.Role.{RoleAdmin, RoleModerator, RoleSuperAdmin}
44 import org.make.core.user._
45 import scalaoauth2.provider.AuthInfo
46 
47 import javax.ws.rs.Path
48 import scala.annotation.meta.field
49 
50 @Api(value = "Admin Moderators")
51 @Path(value = "/admin/moderators")
52 trait AdminModeratorApi extends Directives {
53 
54   @ApiOperation(
55     value = "get-moderator",
56     httpMethod = "GET",
57     code = HttpCodes.OK,
58     authorizations = Array(
59       new Authorization(
60         value = "MakeApi",
61         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
62       )
63     )
64   )
65   @ApiResponses(
66     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ModeratorResponse]))
67   )
68   @ApiImplicitParams(
69     value = Array(
70       new ApiImplicitParam(
71         name = "moderatorId",
72         paramType = "path",
73         dataType = "string",
74         example = "11111111-2222-3333-4444-555555555555"
75       )
76     )
77   )
78   @Path(value = "/{moderatorId}")
79   def getModerator: Route
80 
81   @ApiOperation(
82     value = "get-moderators",
83     httpMethod = "GET",
84     code = HttpCodes.OK,
85     authorizations = Array(
86       new Authorization(
87         value = "MakeApi",
88         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
89       )
90     )
91   )
92   @ApiImplicitParams(
93     value = Array(
94       new ApiImplicitParam(
95         name = "_start",
96         paramType = "query",
97         dataType = "int",
98         allowableValues = "range[0, infinity]"
99       ),
100       new ApiImplicitParam(
101         name = "_end",
102         paramType = "query",
103         dataType = "int",
104         allowableValues = "range[0, infinity]"
105       ),
106       new ApiImplicitParam(
107         name = "_sort",
108         paramType = "query",
109         dataType = "string",
110         allowableValues = PersistentUser.swaggerAllowableValues
111       ),
112       new ApiImplicitParam(
113         name = "_order",
114         paramType = "query",
115         dataType = "string",
116         allowableValues = Order.swaggerAllowableValues
117       ),
118       new ApiImplicitParam(name = "id", paramType = "query", dataType = "string", allowMultiple = true),
119       new ApiImplicitParam(name = "email", paramType = "query", dataType = "string"),
120       new ApiImplicitParam(name = "firstName", paramType = "query", dataType = "string")
121     )
122   )
123   @ApiResponses(
124     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[ModeratorResponse]]))
125   )
126   @Path(value = "/")
127   def getModerators: Route
128 
129   @ApiOperation(
130     value = "create-moderator",
131     httpMethod = "POST",
132     code = HttpCodes.OK,
133     authorizations = Array(
134       new Authorization(
135         value = "MakeApi",
136         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
137       )
138     )
139   )
140   @ApiImplicitParams(
141     value = Array(
142       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.CreateModeratorRequest")
143     )
144   )
145   @ApiResponses(
146     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ModeratorResponse]))
147   )
148   @Path(value = "/")
149   def createModerator: Route
150 
151   @ApiOperation(
152     value = "update-moderator",
153     httpMethod = "PUT",
154     code = HttpCodes.OK,
155     authorizations = Array(
156       new Authorization(
157         value = "MakeApi",
158         scopes = Array(
159           new AuthorizationScope(scope = "admin", description = "BO Admin"),
160           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
161         )
162       )
163     )
164   )
165   @ApiImplicitParams(
166     value = Array(
167       new ApiImplicitParam(name = "moderatorId", paramType = "path", dataType = "string"),
168       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.user.UpdateModeratorRequest")
169     )
170   )
171   @ApiResponses(
172     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ModeratorResponse]))
173   )
174   @Path(value = "/{moderatorId}")
175   def updateModerator: Route
176 
177   def routes: Route =
178     getModerator ~ getModerators ~ createModerator ~ updateModerator
179 }
180 
181 trait AdminModeratorApiComponent {
182   def adminModeratorApi: AdminModeratorApi
183 }
184 
185 trait DefaultAdminModeratorApiComponent
186     extends AdminModeratorApiComponent
187     with MakeAuthenticationDirectives
188     with Logging
189     with ParameterExtractors {
190 
191   this: MakeDirectivesDependencies
192     with UserServiceComponent
193     with PersistentUserServiceComponent
194     with QuestionServiceComponent
195     with OperationServiceComponent =>
196 
197   override lazy val adminModeratorApi: AdminModeratorApi = new DefaultAdminModeratorApi
198 
199   class DefaultAdminModeratorApi extends AdminModeratorApi {
200 
201     val moderatorId: PathMatcher1[UserId] = Segment.map(UserId.apply)
202 
203     private def isModerator(user: User): Boolean = {
204       Set(RoleModerator, RoleAdmin, RoleSuperAdmin).intersect(user.roles.toSet).nonEmpty
205     }
206 
207     override def getModerator: Route = get {
208       path("admin" / "moderators" / moderatorId) { moderatorId =>
209         makeOperation("GetModerator") { _ =>
210           makeOAuth2 { auth: AuthInfo[UserRights] =>
211             requireAdminRole(auth.user) {
212               userService.getUser(moderatorId).asDirectiveOrNotFound { moderator =>
213                 if (!isModerator(moderator)) {
214                   complete(StatusCodes.NotFound)
215                 } else {
216                   complete(ModeratorResponse(moderator))
217                 }
218               }
219             }
220           }
221         }
222       }
223     }
224 
225     override def getModerators: Route = get {
226       path("admin" / "moderators") {
227         makeOperation("GetModerators") { _ =>
228           parameters(
229             "_start".as[Pagination.Offset].?,
230             "_end".as[Pagination.End].?,
231             "_sort".?,
232             "_order".as[Order].?,
233             "id".csv[UserId],
234             "email".?,
235             "firstName".?
236           ) {
237             (
238               offset: Option[Pagination.Offset],
239               end: Option[Pagination.End],
240               sort: Option[String],
241               order: Option[Order],
242               ids: Option[Seq[UserId]],
243               email: Option[String],
244               firstName: Option[String]
245             ) =>
246               makeOAuth2 { auth: AuthInfo[UserRights] =>
247                 requireAdminRole(auth.user) {
248                   (
249                     userService
250                       .adminCountUsers(
251                         ids = ids,
252                         email = email,
253                         firstName = firstName,
254                         lastName = None,
255                         role = Some(Role.RoleModerator),
256                         userType = None
257                       )
258                       .asDirective,
259                     userService
260                       .adminFindUsers(
261                         offset.orZero,
262                         end,
263                         sort,
264                         order,
265                         ids = ids,
266                         email = email,
267                         firstName = firstName,
268                         lastName = None,
269                         role = Some(Role.RoleModerator),
270                         userType = None
271                       )
272                       .asDirective
273                   ).tupled.apply({
274                     case (count, users) =>
275                       complete(
276                         (StatusCodes.OK, List(`X-Total-Count`(count.toString)), users.map(ModeratorResponse.apply))
277                       )
278                   })
279                 }
280               }
281           }
282         }
283       }
284     }
285 
286     override def createModerator: Route = post {
287       path("admin" / "moderators") {
288         makeOperation("CreateModerator") { requestContext =>
289           makeOAuth2 { auth: AuthInfo[UserRights] =>
290             requireAdminRole(auth.user) {
291               decodeRequest {
292                 entity(as[CreateModeratorRequest]) { request: CreateModeratorRequest =>
293                   userService
294                     .register(
295                       UserRegisterData(
296                         email = request.email,
297                         firstName = request.firstName,
298                         lastName = request.lastName,
299                         password = request.password,
300                         lastIp = None,
301                         country = request.country,
302                         language = request.language,
303                         crmCountry = request.country,
304                         crmLanguage = request.language,
305                         optIn = Some(false),
306                         optInPartner = Some(false),
307                         roles = request.roles
308                           .map(_.map(Role.apply))
309                           .getOrElse(Seq(Role.RoleModerator, Role.RoleCitizen)),
310                         availableQuestions = request.availableQuestions,
311                         privacyPolicyApprovalDate = Some(DateHelper.now())
312                       ),
313                       requestContext
314                     )
315                     .asDirective
316                     .apply { result =>
317                       complete(StatusCodes.Created -> ModeratorResponse(result))
318                     }
319                 }
320               }
321             }
322           }
323         }
324       }
325     }
326 
327     override def updateModerator: Route =
328       put {
329         path("admin" / "moderators" / moderatorId) { moderatorId =>
330           makeOperation("UpdateModerator") { requestContext =>
331             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
332               val isAdmin = Set(RoleAdmin, RoleSuperAdmin).intersect(userAuth.user.roles.toSet).nonEmpty
333               val isModerator = userAuth.user.roles.contains(RoleModerator)
334               authorize((isModerator && moderatorId == userAuth.user.userId) || isAdmin) {
335                 decodeRequest {
336                   entity(as[UpdateModeratorRequest]) { request: UpdateModeratorRequest =>
337                     userService.getUser(moderatorId).asDirectiveOrNotFound { user =>
338                       val roles =
339                         request.roles.map(_.map(Role.apply)).getOrElse(user.roles)
340                       authorize {
341                         roles != user.roles && isAdmin || roles == user.roles
342                       } {
343                         val lowerCasedEmail: String = request.email.getOrElse(user.email).toLowerCase()
344                         userService.getUserByEmail(lowerCasedEmail).asDirective { maybeUser =>
345                           maybeUser.foreach { userToCheck =>
346                             Validation.validate(
347                               Validation.validateField(
348                                 field = "email",
349                                 "already_registered",
350                                 condition = userToCheck.userId.value == user.userId.value,
351                                 message = s"Email $lowerCasedEmail already exists"
352                               )
353                             )
354                           }
355 
356                           userService
357                             .update(
358                               user.copy(
359                                 email = lowerCasedEmail,
360                                 firstName = request.firstName.orElse(user.firstName),
361                                 lastName = request.lastName.orElse(user.lastName),
362                                 country = request.country.getOrElse(user.country),
363                                 roles = roles,
364                                 availableQuestions = request.availableQuestions
365                               ),
366                               requestContext
367                             )
368                             .asDirective { user: User =>
369                               complete(StatusCodes.OK -> ModeratorResponse(user))
370                             }
371                         }
372                       }
373                     }
374                   }
375                 }
376               }
377             }
378           }
379         }
380       }
381   }
382 }
383 
384 final case class CreateModeratorRequest(
385   @(ApiModelProperty @field)(dataType = "string", example = "yopmail+test@make.org", required = true) email: String,
386   firstName: Option[String],
387   lastName: Option[String],
388   @(ApiModelProperty @field)(dataType = "list[string]", allowableValues = Role.swaggerAllowableValues) roles: Option[
389     Seq[String]
390   ],
391   password: Option[String],
392   @(ApiModelProperty @field)(dataType = "string", example = "FR", required = true) country: Country,
393   @(ApiModelProperty @field)(dataType = "string", example = "fr", required = true) language: Language,
394   @(ApiModelProperty @field)(dataType = "list[string]", required = true)
395   availableQuestions: Seq[QuestionId]
396 ) {
397 
398   email.toEmail.throwIfInvalid()
399 
400   Validation.validate(
401     mandatoryField("firstName", firstName),
402     validateOptionalUserInput("firstName", firstName, None),
403     validateOptionalUserInput("lastName", lastName, None),
404     mandatoryField("country", country),
405     validateField(
406       "password",
407       "invalid_password",
408       password.forall(_.length >= 8),
409       "Password must be at least 8 characters"
410     )
411   )
412 }
413 
414 object CreateModeratorRequest {
415   implicit val decoder: Decoder[CreateModeratorRequest] = deriveDecoder[CreateModeratorRequest]
416 }
417 
418 final case class UpdateModeratorRequest(
419   @(ApiModelProperty @field)(dataType = "string", example = "yopmail+test@make.org") email: Option[String],
420   firstName: Option[String],
421   lastName: Option[String],
422   @(ApiModelProperty @field)(dataType = "list[string]") roles: Option[Seq[String]],
423   @(ApiModelProperty @field)(dataType = "string", example = "FR") country: Option[Country],
424   @(ApiModelProperty @field)(
425     dataType = "list[string]",
426     example = "11111111-2222-3333-4444-555555555555",
427     required = true
428   )
429   availableQuestions: Seq[QuestionId]
430 ) {
431   private val maxCountryLength = 3
432 
433   Seq(
434     email.map(_.toSanitizedInput("email").void),
435     email.map(_.toEmail.void),
436     firstName.map(_.toNonEmpty("firstName").void),
437     firstName.map(_.toSanitizedInput("firstName").void),
438     lastName.map(_.toSanitizedInput("lastName").void),
439     country.map(_.value.withMaxLength(maxCountryLength, "country").void)
440   ).flatten.foreach(_.throwIfInvalid())
441 }
442 
443 object UpdateModeratorRequest {
444   implicit val decoder: Decoder[UpdateModeratorRequest] = deriveDecoder[UpdateModeratorRequest]
445 
446   def updateValue(oldValue: Option[String], newValue: Option[String]): Option[String] = {
447     newValue match {
448       case None     => oldValue
449       case Some("") => None
450       case value    => value
451     }
452   }
453 }
454 
455 final case class ModeratorResponse(
456   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true) id: UserId,
457   @(ApiModelProperty @field)(dataType = "string", example = "yopmail+test@make.org", required = true) email: String,
458   firstName: Option[String],
459   lastName: Option[String],
460   @(ApiModelProperty @field)(dataType = "list[string]", required = true, allowableValues = Role.swaggerAllowableValues) roles: Seq[
461     Role
462   ],
463   @(ApiModelProperty @field)(dataType = "string", example = "FR", required = true) country: Country,
464   @(ApiModelProperty @field)(dataType = "list[string]", required = true)
465   availableQuestions: Seq[QuestionId]
466 ) {
467   Validation.validate(
468     validateUserInput("email", email, None),
469     validateOptionalUserInput("firstName", firstName, None),
470     validateOptionalUserInput("lastName", lastName, None)
471   )
472 }
473 
474 object ModeratorResponse extends CirceFormatters {
475   implicit val encoder: Encoder[ModeratorResponse] = deriveEncoder[ModeratorResponse]
476   implicit val decoder: Decoder[ModeratorResponse] = deriveDecoder[ModeratorResponse]
477 
478   def apply(user: User): ModeratorResponse = ModeratorResponse(
479     id = user.userId,
480     email = user.email,
481     firstName = user.firstName,
482     lastName = user.lastName,
483     roles = user.roles,
484     country = user.country,
485     availableQuestions = user.availableQuestions
486   )
487 }