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.proposal
21 
22 import cats.implicits._
23 import cats.data.Validated
24 import cats.data.Validated.{Invalid, Valid}
25 import akka.http.scaladsl.model.StatusCodes
26 import akka.http.scaladsl.server._
27 import akka.http.scaladsl.unmarshalling.Unmarshaller._
28 import grizzled.slf4j.Logging
29 import io.circe.Codec
30 import io.circe.generic.semiauto.deriveCodec
31 import io.swagger.annotations._
32 import org.make.api.technical.directives.FutureDirectivesExtensions._
33 import org.make.api.idea.IdeaServiceComponent
34 import org.make.api.operation.OperationServiceComponent
35 import org.make.api.question.QuestionServiceComponent
36 import org.make.api.tag.TagServiceComponent
37 import org.make.api.technical.CsvReceptacle._
38 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
39 import org.make.api.technical.{
40   `X-Total-Count`,
41   ActorSystemComponent,
42   MakeAuthenticationDirectives,
43   ReadJournalComponent
44 }
45 import org.make.api.user.UserServiceComponent
46 import org.make.core._
47 import org.make.core.technical.{Multilingual, MultilingualUtils, Pagination}
48 import org.make.core.auth.UserRights
49 import org.make.core.idea.IdeaId
50 import org.make.core.operation.OperationId
51 import org.make.core.proposal._
52 import org.make.core.Validation._
53 import org.make.core.proposal.{Qualification => ProposalQualification, Vote => ProposalVote}
54 import org.make.core.proposal.indexed._
55 import org.make.core.question.{Question, QuestionId}
56 import org.make.core.reference.{Country, Language}
57 import org.make.core.tag.TagId
58 import org.make.core.user.Role.RoleAdmin
59 import org.make.core.user.{UserId, UserType}
60 import scalaoauth2.provider.AuthInfo
61 
62 import java.time.ZonedDateTime
63 import javax.ws.rs.Path
64 import scala.annotation.meta.field
65 import scala.concurrent.ExecutionContext.Implicits.global
66 import scala.concurrent.Future
67 
68 @Api(value = "ModerationProposal")
69 @Path("/moderation/proposals")
70 trait ModerationProposalApi extends Directives {
71 
72   @ApiOperation(
73     value = "get-moderation-proposal",
74     httpMethod = "GET",
75     code = HttpCodes.OK,
76     authorizations = Array(
77       new Authorization(
78         value = "MakeApi",
79         scopes = Array(
80           new AuthorizationScope(scope = "admin", description = "BO Admin"),
81           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
82         )
83       )
84     )
85   )
86   @ApiResponses(
87     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ModerationProposalResponse]))
88   )
89   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string")))
90   @Path(value = "/{proposalId}")
91   def getModerationProposal: Route
92 
93   @ApiOperation(
94     value = "legacy-moderation-search-proposals",
95     httpMethod = "GET",
96     code = HttpCodes.OK,
97     authorizations = Array(
98       new Authorization(
99         value = "MakeApi",
100         scopes = Array(
101           new AuthorizationScope(scope = "admin", description = "BO Admin"),
102           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
103         )
104       )
105     )
106   )
107   @ApiResponses(
108     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ProposalsSearchResult]))
109   )
110   @ApiImplicitParams(
111     value = Array(
112       new ApiImplicitParam(name = "proposalIds", paramType = "query", dataType = "string"),
113       new ApiImplicitParam(name = "createdBefore", paramType = "query", dataType = "dateTime"),
114       new ApiImplicitParam(name = "initialProposal", paramType = "query", dataType = "boolean"),
115       new ApiImplicitParam(name = "tagsIds", paramType = "query", dataType = "string"),
116       new ApiImplicitParam(name = "operationId", paramType = "query", dataType = "string"),
117       new ApiImplicitParam(name = "questionId", paramType = "query", dataType = "string"),
118       new ApiImplicitParam(name = "ideaId", paramType = "query", dataType = "string"),
119       new ApiImplicitParam(name = "content", paramType = "query", dataType = "string"),
120       new ApiImplicitParam(name = "source", paramType = "query", dataType = "string"),
121       new ApiImplicitParam(name = "location", paramType = "query", dataType = "string"),
122       new ApiImplicitParam(name = "question", paramType = "query", dataType = "string"),
123       new ApiImplicitParam(
124         name = "status",
125         paramType = "query",
126         dataType = "string",
127         allowableValues = ProposalStatus.swaggerAllowableValues,
128         allowMultiple = true
129       ),
130       new ApiImplicitParam(
131         name = "minVotesCount",
132         paramType = "query",
133         dataType = "int",
134         allowableValues = "range[0, infinity]"
135       ),
136       new ApiImplicitParam(name = "toEnrich", paramType = "query", dataType = "boolean"),
137       new ApiImplicitParam(name = "minScore", paramType = "query", dataType = "float"),
138       new ApiImplicitParam(name = "language", paramType = "query", dataType = "string"),
139       new ApiImplicitParam(name = "country", paramType = "query", dataType = "string"),
140       new ApiImplicitParam(
141         name = "limit",
142         paramType = "query",
143         dataType = "int",
144         allowableValues = "range[0, infinity]"
145       ),
146       new ApiImplicitParam(
147         name = "skip",
148         paramType = "query",
149         dataType = "int",
150         allowableValues = "range[0, infinity]"
151       ),
152       new ApiImplicitParam(
153         name = "sort",
154         paramType = "query",
155         dataType = "string",
156         example = "createdAt",
157         allowableValues = "content,slug,status,createdAt,updatedAt,trending,labels,country,language"
158       ),
159       new ApiImplicitParam(
160         name = "order",
161         paramType = "query",
162         dataType = "string",
163         allowableValues = Order.swaggerAllowableValues
164       ),
165       new ApiImplicitParam(
166         name = "userTypes",
167         paramType = "query",
168         dataType = "string",
169         allowableValues = UserType.swaggerAllowableValues,
170         allowMultiple = true
171       ),
172       new ApiImplicitParam(name = "keywords", paramType = "query", dataType = "string")
173     )
174   )
175   @Path(value = "/legacy")
176   def legacySearchAllProposals: Route
177 
178   @ApiOperation(
179     value = "moderation-search-proposals",
180     httpMethod = "GET",
181     code = HttpCodes.OK,
182     authorizations = Array(
183       new Authorization(
184         value = "MakeApi",
185         scopes = Array(
186           new AuthorizationScope(scope = "admin", description = "BO Admin"),
187           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
188         )
189       )
190     )
191   )
192   @ApiResponses(
193     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[ProposalListResponse]]))
194   )
195   @ApiImplicitParams(
196     value = Array(
197       new ApiImplicitParam(name = "id", paramType = "query", dataType = "string", allowMultiple = true),
198       new ApiImplicitParam(name = "questionId", paramType = "query", dataType = "string", allowMultiple = true),
199       new ApiImplicitParam(
200         name = "status",
201         paramType = "query",
202         dataType = "string",
203         allowableValues = ProposalStatus.swaggerAllowableValues,
204         allowMultiple = true
205       ),
206       new ApiImplicitParam(name = "content", paramType = "query", dataType = "string"),
207       new ApiImplicitParam(
208         name = "userType",
209         paramType = "query",
210         dataType = "string",
211         allowableValues = UserType.swaggerAllowableValues,
212         allowMultiple = true
213       ),
214       new ApiImplicitParam(name = "initialProposal", paramType = "query", dataType = "boolean"),
215       new ApiImplicitParam(name = "tagId", paramType = "query", dataType = "string", allowMultiple = true),
216       new ApiImplicitParam(
217         name = "submittedAsLanguages",
218         paramType = "query",
219         dataType = "string",
220         allowMultiple = true
221       ),
222       new ApiImplicitParam(
223         name = "_start",
224         paramType = "query",
225         dataType = "int",
226         allowableValues = "range[0, infinity]"
227       ),
228       new ApiImplicitParam(
229         name = "_end",
230         paramType = "query",
231         dataType = "int",
232         allowableValues = "range[0, infinity]"
233       ),
234       new ApiImplicitParam(
235         name = "_sort",
236         paramType = "query",
237         dataType = "string",
238         allowableValues = ProposalElasticsearchFieldName.swaggerAllowableValues
239       ),
240       new ApiImplicitParam(
241         name = "_order",
242         paramType = "query",
243         dataType = "string",
244         allowableValues = Order.swaggerAllowableValues
245       )
246     )
247   )
248   def searchAllProposals: Route
249 
250   @ApiOperation(
251     value = "update-proposal",
252     httpMethod = "PUT",
253     code = HttpCodes.OK,
254     authorizations = Array(
255       new Authorization(
256         value = "MakeApi",
257         scopes = Array(
258           new AuthorizationScope(scope = "admin", description = "BO Admin"),
259           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
260         )
261       )
262     )
263   )
264   @ApiImplicitParams(
265     value = Array(
266       new ApiImplicitParam(
267         value = "body",
268         paramType = "body",
269         dataType = "org.make.api.proposal.UpdateProposalRequest"
270       ),
271       new ApiImplicitParam(name = "proposalId", paramType = "path", required = true, dataType = "string")
272     )
273   )
274   @ApiResponses(
275     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ModerationProposalResponse]))
276   )
277   @Path(value = "/{proposalId}")
278   def updateProposal: Route
279 
280   @ApiOperation(
281     value = "validate-proposal",
282     httpMethod = "POST",
283     code = HttpCodes.OK,
284     authorizations = Array(
285       new Authorization(
286         value = "MakeApi",
287         scopes = Array(
288           new AuthorizationScope(scope = "admin", description = "BO Admin"),
289           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
290         )
291       )
292     )
293   )
294   @ApiImplicitParams(
295     value = Array(
296       new ApiImplicitParam(
297         value = "body",
298         paramType = "body",
299         dataType = "org.make.api.proposal.ValidateProposalRequest"
300       ),
301       new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string")
302     )
303   )
304   @ApiResponses(
305     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ModerationProposalResponse]))
306   )
307   @Path(value = "/{proposalId}/accept")
308   def acceptProposal: Route
309 
310   @ApiOperation(
311     value = "refuse-proposal",
312     httpMethod = "POST",
313     code = HttpCodes.OK,
314     authorizations = Array(
315       new Authorization(
316         value = "MakeApi",
317         scopes = Array(
318           new AuthorizationScope(scope = "admin", description = "BO Admin"),
319           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
320         )
321       )
322     )
323   )
324   @ApiImplicitParams(
325     value = Array(
326       new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string"),
327       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.proposal.RefuseProposalRequest")
328     )
329   )
330   @ApiResponses(
331     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ModerationProposalResponse]))
332   )
333   @Path(value = "/{proposalId}/refuse")
334   def refuseProposal: Route
335 
336   @ApiOperation(
337     value = "postpone-proposal",
338     httpMethod = "POST",
339     code = HttpCodes.OK,
340     authorizations = Array(
341       new Authorization(
342         value = "MakeApi",
343         scopes = Array(
344           new AuthorizationScope(scope = "admin", description = "BO Admin"),
345           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
346         )
347       )
348     )
349   )
350   @ApiResponses(
351     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ModerationProposalResponse]))
352   )
353   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string")))
354   @Path(value = "/{proposalId}/postpone")
355   def postponeProposal: Route
356 
357   @ApiOperation(
358     value = "lock-proposal",
359     httpMethod = "POST",
360     code = HttpCodes.NoContent,
361     authorizations = Array(
362       new Authorization(
363         value = "MakeApi",
364         scopes = Array(
365           new AuthorizationScope(scope = "admin", description = "BO Admin"),
366           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
367         )
368       )
369     )
370   )
371   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string")))
372   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
373   @Path(value = "/{proposalId}/lock")
374   def lock: Route
375 
376   @ApiOperation(
377     value = "lock-multiple-proposal",
378     httpMethod = "POST",
379     code = HttpCodes.NoContent,
380     authorizations = Array(
381       new Authorization(
382         value = "MakeApi",
383         scopes = Array(
384           new AuthorizationScope(scope = "admin", description = "BO Admin"),
385           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
386         )
387       )
388     )
389   )
390   @ApiImplicitParams(
391     value = Array(
392       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.proposal.LockProposalsRequest")
393     )
394   )
395   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
396   @Path(value = "/lock")
397   def lockMultiple: Route
398 
399   @ApiOperation(
400     value = "update-proposals-to-idea",
401     httpMethod = "POST",
402     code = HttpCodes.NoContent,
403     authorizations = Array(
404       new Authorization(
405         value = "MakeApi",
406         scopes = Array(new AuthorizationScope(scope = "moderator", description = "BO Moderator"))
407       )
408     )
409   )
410   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
411   @ApiImplicitParams(
412     value = Array(
413       new ApiImplicitParam(
414         name = "body",
415         paramType = "body",
416         dataType = "org.make.api.proposal.PatchProposalsIdeaRequest"
417       )
418     )
419   )
420   @Path(value = "/change-idea")
421   def changeProposalsIdea: Route
422 
423   @ApiOperation(
424     value = "next-author-to-moderate",
425     httpMethod = "POST",
426     code = HttpCodes.OK,
427     authorizations = Array(
428       new Authorization(
429         value = "MakeApi",
430         scopes = Array(new AuthorizationScope(scope = "moderator", description = "BO Moderator"))
431       )
432     )
433   )
434   @ApiResponses(
435     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ModerationAuthorResponse]))
436   )
437   @ApiImplicitParams(
438     value = Array(
439       new ApiImplicitParam(
440         name = "body",
441         paramType = "body",
442         dataType = "org.make.api.proposal.NextProposalToModerateRequest"
443       )
444     )
445   )
446   @Path(value = "/next-author-to-moderate")
447   def nextAuthorToModerate: Route
448 
449   @ApiOperation(
450     value = "next-proposal-to-moderate",
451     httpMethod = "POST",
452     code = HttpCodes.OK,
453     authorizations = Array(
454       new Authorization(
455         value = "MakeApi",
456         scopes = Array(new AuthorizationScope(scope = "moderator", description = "BO Moderator"))
457       )
458     )
459   )
460   @ApiResponses(
461     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ModerationProposalResponse]))
462   )
463   @ApiImplicitParams(
464     value = Array(
465       new ApiImplicitParam(
466         name = "body",
467         paramType = "body",
468         dataType = "org.make.api.proposal.NextProposalToModerateRequest"
469       )
470     )
471   )
472   @Path(value = "/next")
473   def nextProposalToModerate: Route
474 
475   @ApiOperation(
476     value = "get-tags-for-proposal",
477     httpMethod = "GET",
478     code = HttpCodes.OK,
479     authorizations = Array(
480       new Authorization(
481         value = "MakeApi",
482         scopes = Array(new AuthorizationScope(scope = "moderator", description = "BO Moderator"))
483       )
484     )
485   )
486   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string")))
487   @ApiResponses(
488     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[TagsForProposalResponse]))
489   )
490   @Path(value = "/{proposalId}/tags")
491   def getTagsForProposal: Route
492 
493   @ApiOperation(
494     value = "bulk-refuse-proposal",
495     httpMethod = "POST",
496     code = HttpCodes.OK,
497     authorizations = Array(
498       new Authorization(
499         value = "MakeApi",
500         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
501       )
502     )
503   )
504   @ApiImplicitParams(
505     value = Array(
506       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.proposal.BulkRefuseProposal")
507     )
508   )
509   @ApiResponses(
510     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[BulkActionResponse]))
511   )
512   @Path(value = "/refuse-initials-proposals")
513   def bulkRefuseInitialsProposals: Route
514 
515   @ApiOperation(
516     value = "bulk-tag-proposal",
517     httpMethod = "POST",
518     code = HttpCodes.OK,
519     authorizations = Array(
520       new Authorization(
521         value = "MakeApi",
522         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
523       )
524     )
525   )
526   @ApiImplicitParams(
527     value = Array(
528       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.proposal.BulkTagProposal")
529     )
530   )
531   @ApiResponses(
532     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[BulkActionResponse]))
533   )
534   @Path(value = "/tag")
535   def bulkTagProposal: Route
536 
537   @ApiOperation(
538     value = "bulk-delete-tag-proposal",
539     httpMethod = "DELETE",
540     code = HttpCodes.OK,
541     authorizations = Array(
542       new Authorization(
543         value = "MakeApi",
544         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
545       )
546     )
547   )
548   @ApiImplicitParams(
549     value = Array(
550       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.proposal.BulkDeleteTagProposal")
551     )
552   )
553   @ApiResponses(
554     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[BulkActionResponse]))
555   )
556   @Path(value = "/tag")
557   def bulkDeleteTagProposal: Route
558 
559   def routes: Route =
560     searchAllProposals ~
561       legacySearchAllProposals ~
562       updateProposal ~
563       acceptProposal ~
564       refuseProposal ~
565       postponeProposal ~
566       lock ~
567       lockMultiple ~
568       changeProposalsIdea ~
569       getModerationProposal ~
570       nextAuthorToModerate ~
571       nextProposalToModerate ~
572       getTagsForProposal ~
573       bulkTagProposal ~
574       bulkDeleteTagProposal ~
575       bulkRefuseInitialsProposals
576 }
577 
578 trait ModerationProposalApiComponent {
579   def moderationProposalApi: ModerationProposalApi
580 }
581 
582 trait DefaultModerationProposalApiComponent
583     extends ModerationProposalApiComponent
584     with MakeAuthenticationDirectives
585     with Logging
586     with ParameterExtractors {
587   this: ProposalServiceComponent
588     with MakeDirectivesDependencies
589     with UserServiceComponent
590     with IdeaServiceComponent
591     with QuestionServiceComponent
592     with OperationServiceComponent
593     with ProposalCoordinatorServiceComponent
594     with ReadJournalComponent
595     with ActorSystemComponent
596     with TagServiceComponent =>
597 
598   override lazy val moderationProposalApi: DefaultModerationProposalApi = new DefaultModerationProposalApi
599 
600   class DefaultModerationProposalApi extends ModerationProposalApi {
601 
602     val moderationProposalId: PathMatcher1[ProposalId] = Segment.map(id => ProposalId(id))
603 
604     override def getModerationProposal: Route = {
605       get {
606         path("moderation" / "proposals" / moderationProposalId) { proposalId =>
607           makeOperation("GetModerationProposal") { _ =>
608             makeOAuth2 { auth: AuthInfo[UserRights] =>
609               requireModerationRole(auth.user) {
610                 proposalService
611                   .getModerationProposalById(proposalId)
612                   .asDirectiveOrNotFound
613                   .apply(
614                     moderationProposalResponse =>
615                       requireRightsOnQuestion(auth.user, moderationProposalResponse.questionId) {
616                         complete(moderationProposalResponse)
617                       }
618                   )
619               }
620             }
621           }
622         }
623       }
624     }
625 
626     override def legacySearchAllProposals: Route = {
627       get {
628         path("moderation" / "proposals" / "legacy") {
629           makeOperation("SearchAll") { requestContext =>
630             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
631               requireModerationRole(userAuth.user) {
632                 parameters(
633                   "proposalIds".as[Seq[ProposalId]].?,
634                   "createdBefore".as[ZonedDateTime].?,
635                   "proposalType".csv[ProposalType],
636                   "tagsIds".as[Seq[TagId]].?,
637                   "operationId".as[OperationId].?,
638                   "questionId".as[Seq[QuestionId]].?,
639                   "ideaId".as[Seq[IdeaId]].?,
640                   "content".?,
641                   "source".?,
642                   "location".?,
643                   "question".?,
644                   "status".csv[ProposalStatus],
645                   "minVotesCount".as[Int].?,
646                   "toEnrich".as[Boolean].?,
647                   "minScore".as[Double].?,
648                   "language".as[Language].?,
649                   "country".as[Country].?,
650                   "userType".csv[UserType],
651                   "keywords".as[Seq[ProposalKeywordKey]].?,
652                   "userId".as[UserId].?
653                 ) {
654                   (
655                     proposalIds: Option[Seq[ProposalId]],
656                     createdBefore: Option[ZonedDateTime],
657                     proposalTypes: Option[Seq[ProposalType]],
658                     tagsIds: Option[Seq[TagId]],
659                     operationId: Option[OperationId],
660                     questionIds: Option[Seq[QuestionId]],
661                     ideaId: Option[Seq[IdeaId]],
662                     content: Option[String],
663                     source: Option[String],
664                     location: Option[String],
665                     question: Option[String],
666                     status: Option[Seq[ProposalStatus]],
667                     minVotesCount: Option[Int],
668                     toEnrich: Option[Boolean],
669                     minScore: Option[Double],
670                     language: Option[Language],
671                     country: Option[Country],
672                     userTypes: Option[Seq[UserType]],
673                     keywords: Option[Seq[ProposalKeywordKey]],
674                     userId: Option[UserId]
675                   ) =>
676                     parameters(
677                       "limit".as[Pagination.Limit].?,
678                       "skip".as[Pagination.Offset].?,
679                       "sort".?,
680                       "order".as[Order].?
681                     ) {
682                       (
683                         limit: Option[Pagination.Limit],
684                         offset: Option[Pagination.Offset],
685                         sort: Option[String],
686                         order: Option[Order]
687                       ) =>
688                         Validation.validate(Seq(country.map { countryValue =>
689                           Validation.validChoices(
690                             fieldName = "country",
691                             message = Some(
692                               s"Invalid country. Expected one of ${BusinessConfig.supportedCountries.map(_.countryCode)}"
693                             ),
694                             Seq(countryValue),
695                             BusinessConfig.supportedCountries.map(_.countryCode)
696                           )
697                         }, sort.map { sortValue =>
698                           val choices =
699                             Seq(
700                               "content",
701                               "slug",
702                               "status",
703                               "createdAt",
704                               "updatedAt",
705                               "trending",
706                               "labels",
707                               "country",
708                               "language"
709                             )
710                           Validation.validChoices(
711                             fieldName = "sort",
712                             message = Some(
713                               s"Invalid sort. Got $sortValue but expected one of: ${choices.mkString("\"", "\", \"", "\"")}"
714                             ),
715                             Seq(sortValue),
716                             choices
717                           )
718                         }).flatten: _*)
719 
720                         val resolvedQuestions: Option[Seq[QuestionId]] = {
721                           if (userAuth.user.roles.contains(RoleAdmin)) {
722                             questionIds
723                           } else {
724                             questionIds.map { questions =>
725                               questions.filter(id => userAuth.user.availableQuestions.contains(id))
726                             }.orElse(Some(userAuth.user.availableQuestions))
727                           }
728                         }
729 
730                         val contextFilterRequest: Option[ContextFilterRequest] =
731                           ContextFilterRequest.parse(operationId, source, location, question)
732 
733                         val exhaustiveSearchRequest: ExhaustiveSearchRequest = ExhaustiveSearchRequest(
734                           proposalIds = proposalIds,
735                           proposalTypes = proposalTypes,
736                           tagsIds = tagsIds,
737                           operationId = operationId,
738                           questionIds = resolvedQuestions,
739                           ideaIds = ideaId,
740                           content = content,
741                           context = contextFilterRequest,
742                           status = status,
743                           minVotesCount = minVotesCount,
744                           toEnrich = toEnrich,
745                           minScore = minScore,
746                           language = language,
747                           country = country,
748                           sort = sort,
749                           order = order,
750                           limit = limit,
751                           offset = offset,
752                           createdBefore = createdBefore,
753                           userTypes = userTypes,
754                           keywords = keywords,
755                           userId = userId
756                         )
757                         val query: SearchQuery = exhaustiveSearchRequest.toSearchQuery(requestContext)
758                         proposalService
759                           .searchInIndex(query = query, requestContext = requestContext)
760                           .asDirective
761                           .apply(complete(_))
762                     }
763                 }
764               }
765             }
766           }
767         }
768       }
769     }
770 
771     override def searchAllProposals: Route = get {
772       path("moderation" / "proposals") {
773         makeOperation("ModerationSearchAll") { requestContext =>
774           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
775             requireModerationRole(userAuth.user) {
776               parameters(
777                 "id".csv[ProposalId],
778                 "questionId".csv[QuestionId],
779                 "userId".as[UserId].?,
780                 "content".?,
781                 "status".csv[ProposalStatus],
782                 "userType".csv[UserType],
783                 "proposalType".csv[ProposalType],
784                 "tagId".csv[TagId],
785                 "submittedAsLanguages".csv[Language],
786                 "_start".as[Pagination.Offset].?,
787                 "_end".as[Pagination.End].?,
788                 "_sort".as[ProposalElasticsearchFieldName].?,
789                 "_order".as[Order].?
790               ) {
791                 (
792                   proposalIds: Option[Seq[ProposalId]],
793                   questionIds: Option[Seq[QuestionId]],
794                   userId: Option[UserId],
795                   content: Option[String],
796                   status: Option[Seq[ProposalStatus]],
797                   userTypes: Option[Seq[UserType]],
798                   proposalTypes: Option[Seq[ProposalType]],
799                   tagIds: Option[Seq[TagId]],
800                   submittedAsLanguages: Option[Seq[Language]],
801                   offset: Option[Pagination.Offset],
802                   end: Option[Pagination.End],
803                   sort: Option[ProposalElasticsearchFieldName],
804                   order: Option[Order]
805                 ) =>
806                   val resolvedQuestions: Option[Seq[QuestionId]] = {
807                     if (userAuth.user.roles.contains(RoleAdmin)) {
808                       questionIds
809                     } else {
810                       questionIds.map { questions =>
811                         questions.filter(id => userAuth.user.availableQuestions.contains(id))
812                       }.orElse(Some(userAuth.user.availableQuestions))
813                     }
814                   }
815 
816                   val exhaustiveSearchRequest = ExhaustiveSearchRequest(
817                     proposalIds = proposalIds,
818                     proposalTypes = proposalTypes,
819                     tagsIds = tagIds,
820                     questionIds = resolvedQuestions,
821                     content = content,
822                     status = status,
823                     sort = sort.map(_.field),
824                     order = order,
825                     limit = end.map(_.toLimit(offset.orZero)),
826                     offset = offset,
827                     userTypes = userTypes,
828                     userId = userId,
829                     submittedAsLanguages = submittedAsLanguages
830                   )
831                   proposalService
832                     .searchInIndex(exhaustiveSearchRequest.toSearchQuery(requestContext), requestContext)
833                     .asDirective
834                     .apply(
835                       proposals =>
836                         complete(
837                           (
838                             StatusCodes.OK,
839                             List(`X-Total-Count`(proposals.total.toString)),
840                             proposals.results.map(ProposalListResponse.apply)
841                           )
842                         )
843                     )
844               }
845             }
846           }
847         }
848       }
849     }
850 
851     private val maxProposalLength = BusinessConfig.defaultProposalMaxLength
852     private val maxProposalTranslationLength = BusinessConfig.defaultProposalTranslationMaxLength
853     private val minProposalLength = FrontConfiguration.defaultProposalMinLength
854 
855     override def updateProposal: Route = put {
856       path("moderation" / "proposals" / moderationProposalId) { proposalId =>
857         makeOperation("EditProposal") { requestContext =>
858           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
859             requireModerationRole(userAuth.user) {
860               decodeRequest {
861                 entity(as[UpdateProposalRequest]) { request =>
862                   retrieveQuestion(request.questionId, proposalId).asDirective { question =>
863                     requireRightsOnQuestion(userAuth.user, Some(question.questionId)) {
864                       proposalService.getModerationProposalById(proposalId).asDirectiveOrNotFound { proposal =>
865                         val newContent =
866                           request.newContent.fold(Validated.validNec[ValidationError, Unit](()))(
867                             content =>
868                               (
869                                 content.withMaxLength(maxProposalLength, "newContent"),
870                                 content.withMinLength(minProposalLength, "newContent"),
871                                 content.toSanitizedInput("newContent")
872                               ).tupled.void
873                           )
874                         val newContentTranslations =
875                           request.newContentTranslations.fold(Validated.validNec[ValidationError, Unit](()))(
876                             _.translations.foldMap(
877                               translations =>
878                                 (
879                                   translations.withMaxLength(maxProposalTranslationLength, "newContentTranslations"),
880                                   translations.withMinLength(minProposalLength, "newContentTranslations")
881                                 ).tupled.void
882                             )
883                           )
884                         val translations =
885                           request.newContentTranslations
886                             .orElse(proposal.contentTranslations)
887                             .getOrElse(Multilingual.empty)
888                             .addTranslation(
889                               proposal.submittedAsLanguage.getOrElse(question.defaultLanguage),
890                               request.newContent.getOrElse(proposal.content)
891                             )
892                         val validatedTranslations =
893                           MultilingualUtils
894                             .hasRequiredTranslations(question.languages.toList.toSet, List((translations, "contents")))
895                         (newContent, newContentTranslations, validatedTranslations).tupled match {
896                           case Invalid(errsNec) => failWith(ValidationFailedError(errsNec.toList))
897                           case Valid(_) =>
898                             proposalService
899                               .update(
900                                 proposalId = proposalId,
901                                 moderator = userAuth.user.userId,
902                                 requestContext = requestContext,
903                                 updatedAt = DateHelper.now(),
904                                 newContent = request.newContent,
905                                 newContentTranslations = request.newContentTranslations,
906                                 question = question,
907                                 tags = request.tags
908                               )
909                               .asDirectiveOrNotFound
910                               .apply(complete(_))
911                         }
912                       }
913                     }
914                   }
915                 }
916               }
917             }
918           }
919         }
920       }
921     }
922 
923     private def retrieveQuestion(maybeQuestionId: Option[QuestionId], proposalId: ProposalId): Future[Question] = {
924       maybeQuestionId match {
925         case Some(questionId) =>
926           questionService.getQuestion(questionId).flatMap {
927             case Some(question) => Future.successful(question)
928             case _ =>
929               Future.failed(
930                 ValidationFailedError(
931                   Seq(ValidationError("questionId", "not_found", Some(s"question '$questionId' not found")))
932                 )
933               )
934           }
935         case _ =>
936           proposalCoordinatorService.getProposal(proposalId).flatMap {
937             case Some(proposal) =>
938               proposal.questionId match {
939                 case Some(questionId) =>
940                   questionService.getQuestion(questionId).flatMap {
941                     case Some(question) => Future.successful(question)
942                     case _ =>
943                       Future.failed(
944                         new IllegalStateException(s"question '$questionId' not found for proposal '$proposalId'")
945                       )
946                   }
947                 case _ => Future.failed(new IllegalStateException(s"proposal '$proposalId' has no questionId"))
948               }
949             case _ =>
950               Future.failed(
951                 ValidationFailedError(
952                   Seq(ValidationError("questionId", "not_found", Some(s"proposal '$proposalId' not found")))
953                 )
954               )
955           }
956       }
957     }
958 
959     override def acceptProposal: Route = post {
960       path("moderation" / "proposals" / moderationProposalId / "accept") { proposalId =>
961         makeOperation("ValidateProposal") { requestContext =>
962           makeOAuth2 { auth: AuthInfo[UserRights] =>
963             requireModerationRole(auth.user) {
964               decodeRequest {
965                 entity(as[ValidateProposalRequest]) { request =>
966                   retrieveQuestion(request.questionId, proposalId).asDirective { question =>
967                     requireRightsOnQuestion(auth.user, Some(question.questionId)) {
968                       proposalService.getModerationProposalById(proposalId).asDirectiveOrNotFound { proposal =>
969                         val newContent =
970                           request.newContent.fold(Validated.validNec[ValidationError, Unit](()))(
971                             content =>
972                               (
973                                 content.withMaxLength(maxProposalLength, "Original content"),
974                                 content.withMinLength(minProposalLength, "Original content"),
975                                 content.toSanitizedInput("newContent")
976                               ).tupled.void
977                           )
978                         val newContentTranslations =
979                           request.newContentTranslations
980                             .fold(Validated.validNec[ValidationError, Unit](()))(_.toMap.toList.foldMap {
981                               case (language, translations) =>
982                                 (
983                                   translations
984                                     .withMaxLength(maxProposalTranslationLength, "Translations", Some(language)),
985                                   translations.withMinLength(minProposalLength, "Translations", Some(language))
986                                 ).tupled.void
987                             })
988                         val translations =
989                           request.newContentTranslations
990                             .orElse(proposal.contentTranslations)
991                             .getOrElse(Multilingual.empty)
992                             .addTranslation(
993                               proposal.submittedAsLanguage.getOrElse(question.defaultLanguage),
994                               request.newContent.getOrElse(proposal.content)
995                             )
996                         val validatedTranslations =
997                           MultilingualUtils
998                             .hasRequiredTranslations(
999                               question.languages.toList.toSet,
1000                               List((translations, "Translations"))
1001                             )
1002                         (newContent, newContentTranslations, validatedTranslations).tupled match {
1003                           case Invalid(errsNec) => failWith(ValidationFailedError(errsNec.toList))
1004                           case Valid(_) =>
1005                             proposalService
1006                               .validateProposal(
1007                                 proposalId = proposalId,
1008                                 moderator = auth.user.userId,
1009                                 requestContext = requestContext,
1010                                 question = question,
1011                                 newContent = request.newContent,
1012                                 newContentTranslations = request.newContentTranslations,
1013                                 sendNotificationEmail = request.sendNotificationEmail,
1014                                 tags = request.tags
1015                               )
1016                               .asDirectiveOrNotFound
1017                               .apply(complete(_))
1018                         }
1019                       }
1020                     }
1021                   }
1022                 }
1023               }
1024             }
1025           }
1026         }
1027       }
1028     }
1029 
1030     override def refuseProposal: Route = post {
1031       path("moderation" / "proposals" / moderationProposalId / "refuse") { proposalId =>
1032         makeOperation("RefuseProposal") { requestContext =>
1033           makeOAuth2 { auth: AuthInfo[UserRights] =>
1034             requireModerationRole(auth.user) {
1035               proposalCoordinatorService.getProposal(proposalId).asDirectiveOrNotFound { proposal =>
1036                 requireRightsOnQuestion(auth.user, proposal.questionId) {
1037                   decodeRequest {
1038                     entity(as[RefuseProposalRequest]) { refuseProposalRequest =>
1039                       proposalService
1040                         .refuseProposal(
1041                           proposalId = proposalId,
1042                           moderator = auth.user.userId,
1043                           requestContext = requestContext,
1044                           request = refuseProposalRequest
1045                         )
1046                         .asDirectiveOrNotFound
1047                         .apply(complete(_))
1048                     }
1049                   }
1050                 }
1051               }
1052             }
1053           }
1054         }
1055       }
1056     }
1057 
1058     override def postponeProposal: Route = post {
1059       path("moderation" / "proposals" / moderationProposalId / "postpone") { proposalId =>
1060         makeOperation("PostponeProposal") { requestContext =>
1061           makeOAuth2 { auth: AuthInfo[UserRights] =>
1062             requireModerationRole(auth.user) {
1063               proposalCoordinatorService.getProposal(proposalId).asDirectiveOrNotFound { proposal =>
1064                 requireRightsOnQuestion(auth.user, proposal.questionId) {
1065                   decodeRequest {
1066                     proposalService
1067                       .postponeProposal(
1068                         proposalId = proposalId,
1069                         moderator = auth.user.userId,
1070                         requestContext = requestContext
1071                       )
1072                       .asDirectiveOrNotFound
1073                       .apply(complete(_))
1074                   }
1075                 }
1076               }
1077             }
1078           }
1079         }
1080       }
1081     }
1082 
1083     override def lock: Route = post {
1084       path("moderation" / "proposals" / moderationProposalId / "lock") { proposalId =>
1085         makeOperation("LockProposal") { requestContext =>
1086           makeOAuth2 { auth: AuthInfo[UserRights] =>
1087             requireModerationRole(auth.user) {
1088               proposalCoordinatorService.getProposal(proposalId).asDirectiveOrNotFound { proposal =>
1089                 requireRightsOnQuestion(auth.user, proposal.questionId) {
1090                   userService.getUser(auth.user.userId).asDirectiveOrNotFound { moderator =>
1091                     proposalService
1092                       .lockProposal(
1093                         proposalId = proposalId,
1094                         moderatorId = moderator.userId,
1095                         moderatorFullName = moderator.fullName,
1096                         requestContext = requestContext
1097                       )
1098                       .asDirective { _ =>
1099                         complete(StatusCodes.NoContent)
1100                       }
1101                   }
1102                 }
1103               }
1104             }
1105           }
1106         }
1107       }
1108     }
1109 
1110     override def lockMultiple: Route = post {
1111       path("moderation" / "proposals" / "lock") {
1112         makeOperation("LockMultipleProposals") { requestContext =>
1113           makeOAuth2 { auth: AuthInfo[UserRights] =>
1114             requireModerationRole(auth.user) {
1115               decodeRequest {
1116                 entity(as[LockProposalsRequest]) { request =>
1117                   val query = SearchQuery(
1118                     filters = Some(
1119                       SearchFilters(
1120                         proposal = Some(ProposalSearchFilter(request.proposalIds.toSeq)),
1121                         status = Some(StatusSearchFilter(ProposalStatus.values))
1122                       )
1123                     ),
1124                     limit = Some(Pagination.Limit(request.proposalIds.size + 1))
1125                   )
1126                   proposalService.searchInIndex(query = query, requestContext = requestContext).asDirective {
1127                     proposals =>
1128                       val proposalIds = proposals.results.map(_.id)
1129                       val notFoundIds = request.proposalIds.diff(proposalIds.toSet)
1130                       Validation.validate(
1131                         Validation.validateField(
1132                           field = "proposalIds",
1133                           key = "invalid_value",
1134                           condition = notFoundIds.isEmpty,
1135                           message = s"Proposals not found: ${notFoundIds.mkString(", ")}"
1136                         )
1137                       )
1138                       requireRightsOnQuestion(auth.user, proposals.results.flatMap(_.question.map(_.questionId))) {
1139                         userService.getUser(auth.user.userId).asDirectiveOrNotFound { moderator =>
1140                           proposalService
1141                             .lockProposals(
1142                               proposalIds = proposalIds,
1143                               moderatorId = moderator.userId,
1144                               moderatorFullName = moderator.fullName,
1145                               requestContext = requestContext
1146                             )
1147                             .asDirective { _ =>
1148                               complete(StatusCodes.NoContent)
1149                             }
1150                         }
1151                       }
1152                   }
1153                 }
1154               }
1155             }
1156           }
1157         }
1158       }
1159     }
1160 
1161     override def changeProposalsIdea: Route = post {
1162       path("moderation" / "proposals" / "change-idea") {
1163         makeOperation("ChangeProposalsIdea") { _ =>
1164           makeOAuth2 { auth: AuthInfo[UserRights] =>
1165             requireAdminRole(auth.user) {
1166               decodeRequest {
1167                 entity(as[PatchProposalsIdeaRequest]) { changes =>
1168                   ideaService.fetchOne(changes.ideaId).asDirective { maybeIdea =>
1169                     Validation.validate(
1170                       Validation
1171                         .requirePresent(fieldValue = maybeIdea, fieldName = "ideaId", message = Some("Invalid idea id"))
1172                     )
1173                     changes.proposalIds.traverse(proposalService.getModerationProposalById).asDirective { proposals =>
1174                       val invalidProposalIdValues: Seq[String] =
1175                         changes.proposalIds.map(_.value).diff(proposals.flatten.map(_.proposalId.value))
1176                       val invalidProposalIdValuesString: String = invalidProposalIdValues.mkString(", ")
1177                       Validation.validate(
1178                         Validation.validateField(
1179                           field = "proposalIds",
1180                           "invalid_value",
1181                           message = s"Some proposal ids are invalid: $invalidProposalIdValuesString",
1182                           condition = invalidProposalIdValues.isEmpty
1183                         )
1184                       )
1185                       proposalService
1186                         .changeProposalsIdea(changes.proposalIds, moderatorId = auth.user.userId, changes.ideaId)
1187                         .asDirective { updatedProposals =>
1188                           val proposalIdsDiff: Seq[String] =
1189                             changes.proposalIds.map(_.value).diff(updatedProposals.map(_.proposalId.value))
1190                           if (proposalIdsDiff.nonEmpty) {
1191                             logger
1192                               .warn(
1193                                 s"Some proposals are not updated during change idea operation: ${proposalIdsDiff.mkString(", ")}"
1194                               )
1195                           }
1196                           complete(StatusCodes.NoContent)
1197                         }
1198                     }
1199                   }
1200                 }
1201               }
1202             }
1203           }
1204         }
1205       }
1206     }
1207 
1208     override def nextAuthorToModerate: Route = post {
1209       path("moderation" / "proposals" / "next-author-to-moderate") {
1210         makeOperation("NextAuthorToModerate") { context =>
1211           makeOAuth2 { auth =>
1212             requireModerationRole(auth.user) {
1213               decodeRequest {
1214                 entity(as[NextProposalToModerateRequest]) { request =>
1215                   request.questionId
1216                     .map(questionService.getQuestion)
1217                     .getOrElse(Future.successful(None))
1218                     .asDirectiveOrNotFound
1219                     .apply(
1220                       question =>
1221                         requireRightsOnQuestion(auth.user, Some(question.questionId)) {
1222                           userService
1223                             .getUser(auth.user.userId)
1224                             .asDirectiveOrNotFound
1225                             .flatMap(
1226                               moderator =>
1227                                 proposalService
1228                                   .searchAndLockAuthorToModerate(
1229                                     questionId = question.questionId,
1230                                     moderator = auth.user.userId,
1231                                     moderatorFullName = moderator.fullName,
1232                                     languages = request.languages,
1233                                     requestContext = context,
1234                                     toEnrich = request.toEnrich,
1235                                     minVotesCount = request.minVotesCount,
1236                                     minScore = request.minScore
1237                                   )
1238                                   .asDirectiveOrNotFound
1239                             )
1240                             .apply(complete(_))
1241                         }
1242                     )
1243                 }
1244               }
1245             }
1246           }
1247         }
1248       }
1249     }
1250 
1251     override def nextProposalToModerate: Route = post {
1252       path("moderation" / "proposals" / "next") {
1253         makeOperation("NextProposalToModerate") { context =>
1254           makeOAuth2 { user =>
1255             requireModerationRole(user.user) {
1256               decodeRequest {
1257                 entity(as[NextProposalToModerateRequest]) { request =>
1258                   request.questionId.map { questionId =>
1259                     questionService.getQuestion(questionId)
1260                   }.getOrElse(Future.successful(None)).asDirectiveOrNotFound { question =>
1261                     requireRightsOnQuestion(user.user, Some(question.questionId)) {
1262                       userService.getUser(user.user.userId).asDirectiveOrNotFound { moderator =>
1263                         proposalService
1264                           .searchAndLockProposalToModerate(
1265                             question.questionId,
1266                             moderator.userId,
1267                             moderator.fullName,
1268                             None,
1269                             context,
1270                             request.toEnrich,
1271                             request.minVotesCount,
1272                             request.minScore
1273                           )
1274                           .asDirectiveOrNotFound
1275                           .apply(complete(_))
1276                       }
1277                     }
1278                   }
1279                 }
1280               }
1281             }
1282           }
1283         }
1284       }
1285     }
1286 
1287     override def getTagsForProposal: Route = get {
1288       path("moderation" / "proposals" / moderationProposalId / "tags") { moderationProposalId =>
1289         makeOperation("GetTagsForProposal") { _ =>
1290           makeOAuth2 { user =>
1291             requireModerationRole(user.user) {
1292               proposalCoordinatorService.getProposal(moderationProposalId).asDirectiveOrNotFound { proposal =>
1293                 requireRightsOnQuestion(user.user, proposal.questionId) {
1294                   proposalService.getTagsForProposal(proposal).asDirective.apply(complete(_))
1295                 }
1296               }
1297             }
1298           }
1299         }
1300       }
1301     }
1302 
1303     override def bulkRefuseInitialsProposals: Route = post {
1304       path("moderation" / "proposals" / "refuse-initials-proposals") {
1305         makeOperation("BulkRefuseInitialsProposals") { requestContext =>
1306           makeOAuth2 { userAuth =>
1307             requireModerationRole(userAuth.user) {
1308               decodeRequest {
1309                 entity(as[BulkRefuseProposal]) { request =>
1310                   proposalService
1311                     .refuseAll(request.proposalIds, userAuth.user.userId, requestContext)
1312                     .asDirective
1313                     .apply(complete(_))
1314                 }
1315               }
1316             }
1317           }
1318         }
1319       }
1320     }
1321 
1322     override def bulkTagProposal: Route = post {
1323       path("moderation" / "proposals" / "tag") {
1324         makeOperation("BulkTagProposal") { requestContext =>
1325           makeOAuth2 { userAuth =>
1326             requireModerationRole(userAuth.user) {
1327               decodeRequest {
1328                 entity(as[BulkTagProposal]) { request =>
1329                   tagService.findByTagIds(request.tagIds).asDirective { foundTags =>
1330                     Validation.validate(request.tagIds.diff(foundTags.map(_.tagId)).map { tagId =>
1331                       Validation.validateField(
1332                         field = "tagId",
1333                         key = "invalid_value",
1334                         condition = false,
1335                         message = s"Tag $tagId does not exist."
1336                       )
1337                     }: _*)
1338                     proposalService
1339                       .addTagsToAll(request.proposalIds, request.tagIds, userAuth.user.userId, requestContext)
1340                       .asDirective
1341                       .apply(complete(_))
1342                   }
1343                 }
1344               }
1345             }
1346           }
1347         }
1348       }
1349     }
1350 
1351     override def bulkDeleteTagProposal: Route = delete {
1352       path("moderation" / "proposals" / "tag") {
1353         makeOperation("BulkDeleteTagProposal") { requestContext =>
1354           makeOAuth2 { userAuth =>
1355             requireModerationRole(userAuth.user) {
1356               decodeRequest {
1357                 entity(as[BulkDeleteTagProposal]) { request =>
1358                   tagService.getTag(request.tagId).asDirective { maybeTag =>
1359                     Validation.validate(
1360                       Validation.validateField(
1361                         field = "tagId",
1362                         key = "invalid_value",
1363                         condition = maybeTag.isDefined,
1364                         message = s"Tag ${request.tagId} does not exist."
1365                       )
1366                     )
1367                     proposalService
1368                       .deleteTagFromAll(request.proposalIds, request.tagId, userAuth.user.userId, requestContext)
1369                       .asDirective
1370                       .apply(complete(_))
1371                   }
1372                 }
1373               }
1374             }
1375           }
1376         }
1377       }
1378     }
1379   }
1380 }
1381 
1382 final case class ProposalListResponse(
1383   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
1384   id: ProposalId,
1385   author: ProposalListResponse.Author,
1386   content: String,
1387   contentTranslations: Multilingual[String],
1388   submittedAsLanguage: Option[Language],
1389   @(ApiModelProperty @field)(
1390     dataType = "string",
1391     required = true,
1392     allowableValues = ProposalStatus.swaggerAllowableValues
1393   )
1394   status: ProposalStatus,
1395   proposalType: ProposalType,
1396   refusalReason: Option[String],
1397   tags: Seq[IndexedTag] = Seq.empty,
1398   createdAt: ZonedDateTime,
1399   agreementRate: Double,
1400   context: ProposalListResponse.Context,
1401   votes: Seq[ProposalListResponse.Vote],
1402   votesCount: Int
1403 )
1404 
1405 object ProposalListResponse extends CirceFormatters {
1406 
1407   def apply(proposal: IndexedProposal): ProposalListResponse =
1408     ProposalListResponse(
1409       id = proposal.id,
1410       author = Author(proposal),
1411       content = proposal.contentGeneral,
1412       contentTranslations = proposal.content,
1413       submittedAsLanguage = proposal.submittedAsLanguage,
1414       status = proposal.status,
1415       proposalType = proposal.proposalType,
1416       refusalReason = proposal.refusalReason,
1417       tags = proposal.tags,
1418       createdAt = proposal.createdAt,
1419       agreementRate = proposal.agreementRate,
1420       context = Context(proposal.context),
1421       votes = proposal.votes.deprecatedVotesSeq.map(Vote.apply),
1422       votesCount = proposal.votesCount
1423     )
1424 
1425   final case class Author(
1426     @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
1427     id: UserId,
1428     @(ApiModelProperty @field)(dataType = "string", required = true, allowableValues = UserType.swaggerAllowableValues)
1429     userType: UserType,
1430     displayName: Option[String],
1431     @(ApiModelProperty @field)(dataType = "int", example = "42") age: Option[Int]
1432   )
1433 
1434   object Author {
1435     def apply(proposal: IndexedProposal): Author =
1436       Author(
1437         id = proposal.author.userId,
1438         userType = proposal.author.userType,
1439         displayName = proposal.author.displayName,
1440         age = proposal.author.age
1441       )
1442     implicit val codec: Codec[Author] = deriveCodec
1443   }
1444 
1445   final case class Context(
1446     source: Option[String],
1447     questionSlug: Option[String],
1448     @(ApiModelProperty @field)(dataType = "string", example = "FR") country: Option[Country],
1449     @(ApiModelProperty @field)(dataType = "string", example = "fr") questionLanguage: Option[Language],
1450     @(ApiModelProperty @field)(dataType = "string", example = "fr") proposalLanguage: Option[Language],
1451     @(ApiModelProperty @field)(dataType = "string", example = "fr") clientLanguage: Option[Language]
1452   )
1453 
1454   object Context {
1455     def apply(context: Option[IndexedContext]): Context =
1456       Context(
1457         source = context.flatMap(_.source),
1458         questionSlug = context.flatMap(_.questionSlug),
1459         country = context.flatMap(_.country),
1460         questionLanguage = context.flatMap(_.questionLanguage),
1461         proposalLanguage = context.flatMap(_.proposalLanguage),
1462         clientLanguage = context.flatMap(_.clientLanguage)
1463       )
1464     implicit val codec: Codec[Context] = deriveCodec
1465   }
1466 
1467   final case class Vote(
1468     @(ApiModelProperty @field)(dataType = "string", required = true, allowableValues = VoteKey.swaggerAllowableValues)
1469     key: VoteKey,
1470     count: Int,
1471     qualifications: Seq[Qualification]
1472   )
1473 
1474   object Vote {
1475     def apply(vote: ProposalVote): Vote =
1476       Vote(key = vote.key, count = vote.count, qualifications = vote.qualifications.map(Qualification.apply))
1477 
1478     implicit val codec: Codec[Vote] = deriveCodec
1479   }
1480 
1481   final case class Qualification(
1482     @(ApiModelProperty @field)(
1483       dataType = "string",
1484       required = true,
1485       allowableValues = QualificationKey.swaggerAllowableValues
1486     )
1487     key: QualificationKey,
1488     count: Int
1489   )
1490 
1491   object Qualification {
1492     def apply(qualification: ProposalQualification): Qualification =
1493       Qualification(key = qualification.key, count = qualification.count)
1494     implicit val codec: Codec[Qualification] = deriveCodec
1495   }
1496 
1497   implicit val codec: Codec[ProposalListResponse] = deriveCodec
1498 
1499 }