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