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