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.tag
21 
22 import cats.implicits._
23 import akka.http.scaladsl.model.StatusCodes
24 import akka.http.scaladsl.server._
25 import io.circe.Decoder
26 import io.circe.generic.semiauto.deriveDecoder
27 import io.swagger.annotations._
28 import org.make.api.operation.{
29   OperationOfQuestionServiceComponent,
30   OperationServiceComponent,
31   SearchOperationsOfQuestions
32 }
33 
34 import javax.ws.rs.Path
35 import org.make.api.technical.directives.FutureDirectivesExtensions._
36 import org.make.api.question.QuestionServiceComponent
37 import org.make.api.tag.DefaultPersistentTagServiceComponent.PersistentTag
38 import org.make.api.technical.CsvReceptacle.RepeatedCsvFlatteningParamOps
39 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
40 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
41 import org.make.core.auth.UserRights
42 import org.make.core.operation.OperationOfQuestion
43 import org.make.core.question.QuestionId
44 import org.make.core.tag.{TagDisplay, TagId, TagTypeId}
45 import org.make.core.{tag, HttpCodes, Order, ParameterExtractors, Validation}
46 import org.make.core.Validation.OptionWithParsers
47 import org.make.core.technical.ValidatedUtils.ValidatedNecWithUtils
48 import scalaoauth2.provider.AuthInfo
49 
50 import scala.annotation.meta.field
51 import scala.concurrent.ExecutionContext.Implicits.global
52 import scala.concurrent.Future
53 import org.make.core.technical.Pagination._
54 
55 import java.time.ZonedDateTime
56 import org.make.core.technical.Pagination
57 import org.make.core.question.Question
58 
59 @Api(value = "Moderation Tags")
60 @Path(value = "/moderation/tags")
61 trait ModerationTagApi extends Directives {
62 
63   @Path(value = "/{tagId}")
64   @ApiOperation(
65     value = "get-tag",
66     httpMethod = "GET",
67     code = HttpCodes.OK,
68     authorizations = Array(
69       new Authorization(
70         value = "MakeApi",
71         scopes = Array(
72           new AuthorizationScope(scope = "admin", description = "BO Admin"),
73           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
74         )
75       )
76     )
77   )
78   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[TagResponse])))
79   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "tagId", paramType = "path", dataType = "string")))
80   def moderationGetTag: Route
81 
82   @ApiOperation(
83     value = "create-tag",
84     httpMethod = "POST",
85     code = HttpCodes.OK,
86     authorizations = Array(
87       new Authorization(
88         value = "MakeApi",
89         scopes = Array(
90           new AuthorizationScope(scope = "admin", description = "BO Admin"),
91           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
92         )
93       )
94     )
95   )
96   @ApiImplicitParams(
97     value =
98       Array(new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.tag.CreateTagRequest"))
99   )
100   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[TagResponse])))
101   @Path(value = "/")
102   def moderationCreateTag: Route
103 
104   @ApiOperation(
105     value = "list-tags",
106     httpMethod = "GET",
107     code = HttpCodes.OK,
108     authorizations = Array(
109       new Authorization(
110         value = "MakeApi",
111         scopes = Array(
112           new AuthorizationScope(scope = "admin", description = "BO Admin"),
113           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
114         )
115       )
116     )
117   )
118   @ApiImplicitParams(
119     value = Array(
120       new ApiImplicitParam(
121         name = "_start",
122         paramType = "query",
123         dataType = "int",
124         allowableValues = "range[0, infinity]"
125       ),
126       new ApiImplicitParam(
127         name = "_end",
128         paramType = "query",
129         dataType = "int",
130         allowableValues = "range[0, infinity]"
131       ),
132       new ApiImplicitParam(
133         name = "_sort",
134         paramType = "query",
135         dataType = "string",
136         allowableValues = PersistentTag.swaggerAllowableValues
137       ),
138       new ApiImplicitParam(
139         name = "_order",
140         paramType = "query",
141         dataType = "string",
142         allowableValues = Order.swaggerAllowableValues
143       ),
144       new ApiImplicitParam(name = "label", paramType = "query", dataType = "string"),
145       new ApiImplicitParam(name = "tagTypeId", paramType = "query", dataType = "string"),
146       new ApiImplicitParam(name = "questionId", paramType = "query", dataType = "string")
147     )
148   )
149   @ApiResponses(
150     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[TagResponse]]))
151   )
152   @Path(value = "/")
153   def moderationlistTags: Route
154 
155   @ApiOperation(
156     value = "update-tag",
157     httpMethod = "PUT",
158     code = HttpCodes.OK,
159     authorizations = Array(
160       new Authorization(
161         value = "MakeApi",
162         scopes = Array(
163           new AuthorizationScope(scope = "admin", description = "BO Admin"),
164           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
165         )
166       )
167     )
168   )
169   @ApiImplicitParams(
170     value = Array(
171       new ApiImplicitParam(name = "tagId", paramType = "path", dataType = "string"),
172       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.tag.UpdateTagRequest")
173     )
174   )
175   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[tag.Tag])))
176   @Path(value = "/{tagId}")
177   def moderationUpdateTag: Route
178 
179   def routes: Route = moderationGetTag ~ moderationCreateTag ~ moderationlistTags ~ moderationUpdateTag
180 }
181 
182 trait ModerationTagApiComponent {
183   def moderationTagApi: ModerationTagApi
184 }
185 
186 trait DefaultModerationTagApiComponent
187     extends ModerationTagApiComponent
188     with MakeAuthenticationDirectives
189     with ParameterExtractors {
190   this: MakeDirectivesDependencies
191     with TagServiceComponent
192     with QuestionServiceComponent
193     with OperationServiceComponent
194     with OperationOfQuestionServiceComponent =>
195 
196   override lazy val moderationTagApi: ModerationTagApi = new DefaultModerationTagApi
197 
198   class DefaultModerationTagApi extends ModerationTagApi {
199 
200     val moderationTagId: PathMatcher1[TagId] = Segment.map(id => TagId(id))
201 
202     override def moderationGetTag: Route = {
203       get {
204         path("moderation" / "tags" / moderationTagId) { tagId =>
205           makeOperation("ModerationGetTag") { _ =>
206             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
207               requireModerationRole(userAuth.user) {
208                 tagService.getTag(tagId).asDirectiveOrNotFound { tag =>
209                   complete(TagResponse(tag))
210                 }
211               }
212             }
213           }
214         }
215       }
216     }
217 
218     override def moderationCreateTag: Route = post {
219       path("moderation" / "tags") {
220         makeOperation("ModerationRegisterTag") { _ =>
221           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
222             requireAdminRole(userAuth.user) {
223               decodeRequest {
224                 entity(as[CreateTagRequest]) { request: CreateTagRequest =>
225                   (
226                     tagService.findByLabel(request.label, like = false).asDirective,
227                     request.questionId
228                       .fold(Future.successful(Option.empty[Question]))(questionService.getQuestion(_))
229                       .asDirectiveOrNotFound
230                   ).tupled.flatMap({
231                     case (tagList, question) =>
232                       val duplicateLabel = tagList.find { tag =>
233                         tag.questionId.isDefined && tag.questionId == request.questionId
234                       }
235                       Validation.validate(
236                         Validation.requireNotPresent(
237                           fieldName = "label",
238                           fieldValue = duplicateLabel,
239                           message = Some("Tag label already exist in this context. Duplicates are not allowed")
240                         ),
241                         Validation.validateUserInput("label", request.label, None)
242                       )
243                       onSuccess(
244                         tagService.createTag(
245                           label = request.label,
246                           tagTypeId = request.tagTypeId,
247                           question = question,
248                           display = request.display.getOrElse(TagDisplay.Inherit),
249                           weight = request.weight.getOrElse(0f)
250                         )
251                       )
252                   })(tag => complete(StatusCodes.Created -> TagResponse(tag)))
253                 }
254               }
255             }
256           }
257         }
258       }
259     }
260 
261     override def moderationlistTags: Route = {
262       get {
263         path("moderation" / "tags") {
264           makeOperation("ModerationSearchTag") { _ =>
265             parameters(
266               "_start".as[Pagination.Offset].?,
267               "_end".as[End].?,
268               "_sort".?,
269               "_order".as[Order].?,
270               "tagId".csv[TagId],
271               "label".?,
272               "tagTypeId".as[TagTypeId].?,
273               "questionId".as[QuestionId].?,
274               "questionEndAfter".as[ZonedDateTime].?
275             ) {
276               (
277                 offset: Option[Pagination.Offset],
278                 end: Option[Pagination.End],
279                 sort: Option[String],
280                 order: Option[Order],
281                 tagIds: Option[Seq[TagId]],
282                 maybeLabel: Option[String],
283                 maybeTagTypeId: Option[TagTypeId],
284                 maybeQuestionId: Option[QuestionId],
285                 questionEndAfter: Option[ZonedDateTime]
286               ) =>
287                 makeOAuth2 { userAuth: AuthInfo[UserRights] =>
288                   requireModerationRole(userAuth.user) {
289                     val futureQuestions =
290                       (maybeQuestionId, questionEndAfter) match {
291                         case (None, None) => Future.successful(Option.empty[Seq[OperationOfQuestion]])
292                         case _ =>
293                           operationOfQuestionService
294                             .find(
295                               offset = Pagination.Offset.zero,
296                               end = None,
297                               sort = None,
298                               order = None,
299                               SearchOperationsOfQuestions(
300                                 questionIds = maybeQuestionId.map(Seq(_)),
301                                 endAfter = questionEndAfter
302                               )
303                             )
304                             .map(Option(_))
305                       }
306                     futureQuestions.asDirective
307                       .flatMap(questions => {
308                         val filter = TagFilter(
309                           tagIds = tagIds,
310                           label = maybeLabel,
311                           tagTypeId = maybeTagTypeId,
312                           questionIds = questions.map(_.map(_.questionId))
313                         )
314                         (
315                           tagService.count(filter).asDirective,
316                           tagService
317                             .find(offset = offset.orZero, end = end, sort = sort, order = order, tagFilter = filter)
318                             .asDirective
319                         ).mapN(
320                           (count, filteredTags) =>
321                             (StatusCodes.OK, List(`X-Total-Count`(count.toString)), filteredTags.map(TagResponse.apply))
322                         )
323                       })
324                       .apply(complete(_))
325                   }
326                 }
327             }
328           }
329         }
330       }
331     }
332 
333     override def moderationUpdateTag: Route = put {
334       path("moderation" / "tags" / moderationTagId) { tagId =>
335         makeOperation("ModerationUpdateTag") { requestContext =>
336           makeOAuth2 { auth: AuthInfo[UserRights] =>
337             requireAdminRole(auth.user) {
338               decodeRequest {
339                 entity(as[UpdateTagRequest]) { request: UpdateTagRequest =>
340                   (
341                     tagService
342                       .findByLabel(request.label, like = false)
343                       .asDirective,
344                     request.questionId
345                       .map(questionId => questionService.getQuestion(questionId))
346                       .getOrElse(Future.successful(None))
347                       .asDirectiveOrNotFound
348                   ).mapN({
349                       case (tagList, question) =>
350                         val duplicateLabel = tagList.find { tag =>
351                           tag.tagId != tagId && tag.questionId.isDefined && tag.questionId == request.questionId
352                         }
353                         Validation.validate(
354                           Validation.requireNotPresent(
355                             fieldName = "label",
356                             fieldValue = duplicateLabel,
357                             message = Some("Tag label already exist in this context. Duplicates are not allowed")
358                           )
359                         )
360                         tagService
361                           .updateTag(
362                             tagId = tagId,
363                             label = request.label,
364                             display = request.display,
365                             tagTypeId = request.tagTypeId,
366                             weight = request.weight,
367                             question = question,
368                             requestContext = requestContext
369                           )
370                           .asDirectiveOrNotFound
371                     })
372                     .flatten
373                     .apply(tag => complete(TagResponse(tag)))
374                 }
375               }
376             }
377           }
378         }
379       }
380     }
381   }
382 }
383 
384 final case class CreateTagRequest(
385   label: String,
386   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
387   tagTypeId: TagTypeId,
388   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
389   questionId: Option[QuestionId],
390   @(ApiModelProperty @field)(dataType = "string", allowableValues = TagDisplay.swaggerAllowableValues)
391   display: Option[TagDisplay],
392   @(ApiModelProperty @field)(dataType = "float") weight: Option[Float]
393 ) {
394 
395   questionId.getValidated("question", None, Some("question should not be empty")).throwIfInvalid()
396 }
397 
398 object CreateTagRequest {
399   implicit val decoder: Decoder[CreateTagRequest] = deriveDecoder[CreateTagRequest]
400 }
401 
402 final case class UpdateTagRequest(
403   label: String,
404   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
405   tagTypeId: TagTypeId,
406   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
407   questionId: Option[QuestionId],
408   @(ApiModelProperty @field)(dataType = "string", allowableValues = TagDisplay.swaggerAllowableValues)
409   display: TagDisplay,
410   weight: Float
411 ) {
412 
413   questionId.getValidated("question", None, Some("question should not be empty")).throwIfInvalid()
414 }
415 
416 object UpdateTagRequest {
417   implicit val decoder: Decoder[UpdateTagRequest] = deriveDecoder[UpdateTagRequest]
418 }