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.question
21 
22 import cats.implicits._
23 import akka.http.scaladsl.model.{MediaTypes, StatusCodes}
24 import akka.http.scaladsl.server._
25 import akka.http.scaladsl.unmarshalling.Unmarshal
26 import akka.http.scaladsl.unmarshalling.Unmarshaller._
27 import akka.stream.Materializer
28 import akka.stream.alpakka.csv.scaladsl.{CsvParsing, CsvToMap}
29 import akka.stream.scaladsl.{Sink, Source}
30 import cats.data.Validated.Valid
31 import cats.data.ValidatedNec
32 import eu.timepit.refined.api.Refined
33 import eu.timepit.refined.boolean.And
34 import eu.timepit.refined.collection.{MaxSize, MinSize}
35 import grizzled.slf4j.Logging
36 import io.circe.Decoder
37 import io.circe.generic.semiauto.deriveDecoder
38 import io.circe.refined._
39 import io.swagger.annotations._
40 
41 import javax.ws.rs.Path
42 import org.make.api.operation.{OperationOfQuestionServiceComponent, OperationServiceComponent}
43 import org.make.api.proposal.{
44   ExhaustiveSearchRequest,
45   ProposalIdResponse,
46   ProposalSearchEngineComponent,
47   ProposalServiceComponent,
48   RefuseProposalRequest
49 }
50 import org.make.api.question.DefaultPersistentQuestionServiceComponent.PersistentQuestion
51 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
52 import org.make.api.technical.Traverses.RichTraverse
53 import org.make.api.technical.directives.FutureDirectivesExtensions._
54 import org.make.api.technical.storage.{Content, FileType, StorageServiceComponent, UploadResponse}
55 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
56 import org.make.api.user.UserServiceComponent
57 import org.make.core._
58 import org.make.core.Validation._
59 import org.make.core.technical.{Multilingual, MultilingualUtils, Pagination}
60 import org.make.core.technical.ValidatedUtils.ValidatedNecWithUtils
61 import org.make.core.auth.UserRights
62 import org.make.core.operation.OperationId
63 import org.make.core.proposal.{
64   ContentSearchFilter,
65   ProposalType,
66   ProposalTypesSearchFilter,
67   QuestionSearchFilter,
68   SearchFilters,
69   SearchQuery,
70   UserSearchFilter
71 }
72 import org.make.core.question.{Question, QuestionId}
73 import org.make.core.reference.{Country, Language}
74 import org.make.core.tag.TagId
75 import org.make.core.user.Role.RoleAdmin
76 import scalaoauth2.provider.AuthInfo
77 
78 import scala.annotation.meta.field
79 import scala.collection.mutable
80 import scala.concurrent.ExecutionContext.Implicits.global
81 import scala.concurrent.Future
82 
83 @Api(value = "Moderation questions")
84 @Path(value = "/moderation/questions")
85 trait ModerationQuestionApi extends Directives {
86 
87   @ApiOperation(
88     value = "moderation-list-questions",
89     httpMethod = "GET",
90     code = HttpCodes.OK,
91     authorizations = Array(
92       new Authorization(
93         value = "MakeApi",
94         scopes = Array(
95           new AuthorizationScope(scope = "admin", description = "BO Admin"),
96           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
97         )
98       )
99     )
100   )
101   @ApiImplicitParams(
102     value = Array(
103       new ApiImplicitParam(
104         name = "_start",
105         paramType = "query",
106         dataType = "int",
107         allowableValues = "range[0, infinity]"
108       ),
109       new ApiImplicitParam(
110         name = "_end",
111         paramType = "query",
112         dataType = "int",
113         allowableValues = "range[0, infinity]"
114       ),
115       new ApiImplicitParam(
116         name = "_sort",
117         paramType = "query",
118         dataType = "string",
119         allowableValues = PersistentQuestion.swaggerAllowableValues
120       ),
121       new ApiImplicitParam(
122         name = "_order",
123         paramType = "query",
124         dataType = "string",
125         allowableValues = Order.swaggerAllowableValues
126       ),
127       new ApiImplicitParam(name = "slug", paramType = "query", dataType = "string"),
128       new ApiImplicitParam(name = "operationId", paramType = "query", dataType = "string"),
129       new ApiImplicitParam(name = "country", paramType = "query", dataType = "string"),
130       new ApiImplicitParam(name = "language", paramType = "query", dataType = "string")
131     )
132   )
133   @ApiResponses(
134     value =
135       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[ModerationQuestionResponse]]))
136   )
137   @Path(value = "/")
138   def listQuestions: Route
139 
140   @ApiOperation(
141     value = "moderation-create-initial-proposal",
142     httpMethod = "POST",
143     code = HttpCodes.OK,
144     authorizations = Array(
145       new Authorization(
146         value = "MakeApi",
147         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
148       )
149     )
150   )
151   @ApiImplicitParams(
152     value = Array(
153       new ApiImplicitParam(
154         name = "body",
155         paramType = "body",
156         dataType = "org.make.api.question.CreateInitialProposalRequest"
157       ),
158       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string")
159     )
160   )
161   @ApiResponses(
162     value = Array(new ApiResponse(code = HttpCodes.Created, message = "Ok", response = classOf[ProposalIdResponse]))
163   )
164   @Path(value = "/{questionId}/initial-proposals")
165   def addInitialProposal: Route
166 
167   @ApiOperation(
168     value = "moderation-refuse-initial-proposal",
169     httpMethod = "POST",
170     code = HttpCodes.NoContent,
171     authorizations = Array(
172       new Authorization(
173         value = "MakeApi",
174         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
175       )
176     )
177   )
178   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string")))
179   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
180   @Path(value = "/{questionId}/initial-proposals/refuse")
181   def refuseInitialProposals: Route
182 
183   @ApiOperation(
184     value = "moderation-inject-proposal",
185     httpMethod = "POST",
186     consumes = "multipart/form-data",
187     code = HttpCodes.NoContent,
188     authorizations = Array(
189       new Authorization(
190         value = "MakeApi",
191         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
192       )
193     )
194   )
195   @ApiImplicitParams(
196     value = Array(
197       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
198       new ApiImplicitParam(name = "proposals", paramType = "formData", dataType = "file", required = true),
199       new ApiImplicitParam(
200         name = "body",
201         paramType = "formData",
202         dataType = "org.make.api.question.InjectProposalsRequest"
203       )
204     )
205   )
206   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.Accepted, message = "Accepted")))
207   @Path(value = "/{questionId}/inject-proposals")
208   def injectProposals: Route
209 
210   @ApiOperation(
211     value = "moderation-get-question",
212     httpMethod = "GET",
213     code = HttpCodes.OK,
214     authorizations = Array(
215       new Authorization(
216         value = "MakeApi",
217         scopes = Array(
218           new AuthorizationScope(scope = "admin", description = "BO Admin"),
219           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
220         )
221       )
222     )
223   )
224   @ApiResponses(
225     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ModerationQuestionResponse]))
226   )
227   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string")))
228   @Path(value = "/{questionId}")
229   def getQuestion: Route
230 
231   @ApiOperation(
232     value = "moderation-upload-operation-consultation-image",
233     httpMethod = "POST",
234     code = HttpCodes.OK,
235     consumes = "multipart/form-data",
236     authorizations = Array(
237       new Authorization(
238         value = "MakeApi",
239         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
240       )
241     )
242   )
243   @ApiImplicitParams(
244     value = Array(
245       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
246       new ApiImplicitParam(name = "data", paramType = "formData", dataType = "file", required = true)
247     )
248   )
249   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[UploadResponse])))
250   @Path(value = "/{questionId}/image")
251   def uploadQuestionImage: Route
252 
253   @ApiOperation(
254     value = "moderation-upload-consultation-report",
255     httpMethod = "POST",
256     code = HttpCodes.OK,
257     consumes = "multipart/form-data",
258     authorizations = Array(
259       new Authorization(
260         value = "MakeApi",
261         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
262       )
263     )
264   )
265   @ApiImplicitParams(
266     value = Array(
267       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
268       new ApiImplicitParam(name = "data", paramType = "formData", dataType = "file", required = true)
269     )
270   )
271   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[UploadResponse])))
272   @Path(value = "/{questionId}/report")
273   def uploadReport: Route
274 
275   def routes: Route =
276     listQuestions ~ getQuestion ~ addInitialProposal ~ refuseInitialProposals ~ uploadQuestionImage ~ uploadReport ~ injectProposals
277 
278 }
279 
280 trait ModerationQuestionComponent {
281   def moderationQuestionApi: ModerationQuestionApi
282 }
283 
284 trait DefaultModerationQuestionComponent
285     extends ModerationQuestionComponent
286     with MakeAuthenticationDirectives
287     with Logging
288     with ParameterExtractors {
289 
290   this: MakeDirectivesDependencies
291     with QuestionServiceComponent
292     with ProposalServiceComponent
293     with ProposalSearchEngineComponent
294     with StorageServiceComponent
295     with OperationOfQuestionServiceComponent
296     with OperationServiceComponent
297     with UserServiceComponent =>
298 
299   override lazy val moderationQuestionApi: ModerationQuestionApi = new DefaultModerationQuestionApi
300 
301   class DefaultModerationQuestionApi extends ModerationQuestionApi {
302 
303     import Validation.AnyWithParsers
304 
305     lazy val questionId: PathMatcher1[QuestionId] = Segment.map(QuestionId.apply)
306 
307     @SuppressWarnings(Array("org.wartremover.warts.Throw"))
308     override def addInitialProposal: Route = post {
309       path("moderation" / "questions" / questionId / "initial-proposals") { questionId =>
310         makeOperation("ModerationAddInitialProposalToQuestion") { requestContext =>
311           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
312             requireAdminRole(userAuth.user) {
313               decodeRequest {
314                 entity(as[CreateInitialProposalRequest]) { request =>
315                   questionService.getQuestion(questionId).asDirectiveOrNotFound { question =>
316                     val contents =
317                       List(
318                         (
319                           request.contentTranslations
320                             .map(_.mapTranslations(_.value))
321                             .getOrElse(Multilingual.empty)
322                             .addTranslation(request.submittedAsLanguage, request.content.value),
323                           "contents"
324                         )
325                       )
326                     elasticsearchProposalAPI
327                       .countProposals(
328                         SearchQuery(filters = SearchFilters(
329                           question = QuestionSearchFilter(Seq(questionId)).some,
330                           proposalTypes = ProposalTypesSearchFilter(Seq(ProposalType.ProposalTypeInitial)).some
331                         ).some
332                         )
333                       )
334                       .asDirective { initialProposalsCount =>
335                         (
336                           // NOTE: cannot rewrite as MultilingualUtils.genDecoder since the required languages aren't located in the same data structure
337                           MultilingualUtils
338                             .hasRequiredTranslations(question.languages.toList.toSet, contents)
339                             .toValidationEither,
340                           request.country
341                             .toOneOf(question.countries.toList, "country")
342                             .toValidationEither,
343                           initialProposalsCount
344                             .max("proposals", 20, Some("Too many initial proposals"))
345                             .toValidationEither
346                         ).mapN {
347                           case (_, country, _) =>
348                             proposalService
349                               .createInitialProposal(
350                                 request.content.value,
351                                 request.contentTranslations.map(_.mapTranslations(_.value)),
352                                 question,
353                                 country.value,
354                                 request.submittedAsLanguage,
355                                 false,
356                                 request.tags,
357                                 request.author,
358                                 userAuth.user.userId,
359                                 requestContext
360                               )
361                         }.fold(failWith, _.asDirective { proposalId =>
362                           complete(StatusCodes.Created -> ProposalIdResponse(proposalId))
363                         })
364                       }
365                   }
366                 }
367               }
368             }
369           }
370         }
371       }
372     }
373 
374     override def refuseInitialProposals: Route = post {
375       path("moderation" / "questions" / questionId / "initial-proposals" / "refuse") { questionId =>
376         makeOperation("ModerationRefuseInitialProposals") { requestContext =>
377           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
378             requireAdminRole(userAuth.user) {
379               val query = ExhaustiveSearchRequest(
380                 questionIds = Some(Seq(questionId)),
381                 proposalTypes = Some(Seq(ProposalType.ProposalTypeInitial))
382               ).toSearchQuery(requestContext)
383               proposalService.searchInIndex(query = query, requestContext = requestContext).asDirective { proposals =>
384                 Future
385                   .traverse(proposals.results.map(_.id)) { proposalId =>
386                     proposalService
387                       .refuseProposal(
388                         proposalId,
389                         userAuth.user.userId,
390                         requestContext,
391                         RefuseProposalRequest(sendNotificationEmail = false, refusalReason = Some("Other"))
392                       )
393                   }
394                   .asDirective { _ =>
395                     complete(StatusCodes.NoContent)
396                   }
397               }
398             }
399           }
400         }
401       }
402     }
403 
404     private case class UserData(firstName: String, age: Option[String])
405 
406     private def getDuplicateLanguageWarning(
407       translations: Option[Multilingual[String]],
408       contentOriginalLanguage: String,
409       lineNumber: Int
410     ): Option[String] = {
411       translations.flatMap { t =>
412         Option.when(t.providedLanguages.contains(Language(contentOriginalLanguage)))(
413           s"Warning: duplicate language $contentOriginalLanguage on line $lineNumber, proposal from the content column was chosen"
414         )
415       }
416     }
417 
418     private def getTranslations(line: Map[String, String]): Option[Map[String, String]] = {
419       val notLanguagesHeaders = Seq("content", "contentOriginalLanguage", "firstName", "age", "externalUserId")
420       line.filterNot {
421         case (key, value) => notLanguagesHeaders.contains(key) || value.isEmpty
422       } match {
423         case t if t.isEmpty => None
424         case t              => Some(t)
425       }
426     }
427 
428     @SuppressWarnings(Array("org.wartremover.warts.MutableDataStructures"))
429     private def validateLine(
430       line: Map[String, String],
431       userData: mutable.Map[String, UserData],
432       questionLanguages: List[Language],
433       lineNumber: Int
434     ): ValidatedNec[
435       ValidationError,
436       (
437         StringWithMaxLength,
438         StringWithMinLength,
439         NonEmptyString,
440         Option[Multilingual[String]],
441         NonEmptyString,
442         Option[Int],
443         NonEmptyString,
444         Unit
445       )
446     ] = {
447       val maxProposalLength = BusinessConfig.defaultProposalMaxLength
448       val minProposalLength = FrontConfiguration.defaultProposalMinLength
449       val translations: Option[Multilingual[String]] = getTranslations(line).map(t => Multilingual.fromMap(t))
450       (
451         line
452           .getOrElse("content", "")
453           .withMaxLength(
454             maxProposalLength,
455             "content",
456             None,
457             Some(s"content should be less than $maxProposalLength characters on line $lineNumber")
458           ),
459         line
460           .getOrElse("content", "")
461           .withMinLength(
462             minProposalLength,
463             "content",
464             None,
465             Some(s"content should be more than $minProposalLength characters on line $lineNumber")
466           ),
467         line.getNonEmptyString(
468           "contentOriginalLanguage",
469           Some(s"contentOriginalLanguage is required on line $lineNumber")
470         ),
471         MultilingualUtils
472           .hasRequiredTranslationsFromCsv(
473             questionLanguages.toSet,
474             translations,
475             line.get("contentOriginalLanguage").map(Language(_)),
476             lineNumber
477           ),
478         line.getNonEmptyString("firstName", Some(s"firstName is required on line $lineNumber")),
479         line
480           .get("age")
481           .traverse(_.toValidAge(Some(s"age should be over than $minLegalAgeForExternalProposal on line $lineNumber"))),
482         line.getNonEmptyString("externalUserId", Some(s"externalUserId is required on line $lineNumber")),
483         line.get("externalUserId") match {
484           case None => ().validNec
485           case Some(id) =>
486             userData.get(id) match {
487               case Some(UserData(firstName, _)) if !line.get("firstName").contains(firstName) =>
488                 ValidationError(
489                   "firstName",
490                   "unexpected_value",
491                   Some(s"users with the same externalUserId should have the same firstName on line $lineNumber")
492                 ).invalidNec
493               case Some(UserData(_, age)) if line.get("age") != age =>
494                 ValidationError(
495                   "age",
496                   "unexpected_value",
497                   Some(s"users with the same externalUserId should have the same age on line $lineNumber")
498                 ).invalidNec
499               case _ =>
500                 userData += (id -> UserData(line.getOrElse("firstName", ""), line.get("age")))
501                 ().validNec
502             }
503         }
504       ).tupled
505     }
506 
507     @SuppressWarnings(Array("org.wartremover.warts.MutableDataStructures"))
508     override def injectProposals: Route = post {
509       path("moderation" / "questions" / questionId / "inject-proposals") { questionId =>
510         makeOperation("ModerationInjectProposals") { requestContext =>
511           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
512             requireAdminRole(userAuth.user) {
513               questionService.getQuestion(questionId).asDirectiveOrNotFound { question =>
514                 extractRequestContext { ctx =>
515                   implicit val materializer: Materializer = ctx.materializer
516                   formField("body") { body =>
517                     Unmarshal(body).to[InjectProposalsRequest].asDirective { request =>
518                       fileUpload("proposals") {
519                         case (fileInfo, byteSource) =>
520                           Validation.validate(
521                             validateField(
522                               fileInfo.fieldName,
523                               "invalid_format",
524                               fileInfo.contentType.mediaType == MediaTypes.`text/csv`,
525                               "File must be a csv"
526                             )
527                           )
528                           byteSource
529                             .recoverWithRetries(
530                               attempts = 1, {
531                                 case e: Exception =>
532                                   logger.error(s"Failed to parse CSV file: ${e.getMessage}")
533                                   Source.failed(new IllegalArgumentException("Invalid CSV format"))
534                               }
535                             )
536                             .via(CsvParsing.lineScanner())
537                             .via(CsvToMap.toMapAsStrings())
538                             .runWith(Sink.seq)
539                             .asDirective { lines =>
540                               val userData = mutable.Map.empty[String, UserData]
541                               lines.zipWithIndex.toList.sequentialTraverse {
542                                 case (line, index) =>
543                                   val lineNumber = index + 2
544                                   val trimLine = line.map {
545                                     case (key, value) => (key.trim, value.trim)
546                                   }
547                                   val validation =
548                                     validateLine(trimLine, userData, question.languages.toList, lineNumber)
549                                   validation match {
550                                     case Valid(
551                                         (content, _, originalLanguage, translations, firstName, age, externalUserId, _)
552                                         ) =>
553                                       val warning =
554                                         getDuplicateLanguageWarning(translations, originalLanguage.value, lineNumber)
555                                       for {
556                                         user <- userService
557                                           .getUserByEmail(
558                                             s"${question.questionId.value}-${externalUserId.value}@example.com"
559                                           )
560                                         count <- user.fold(Future.successful(0L))(
561                                           u =>
562                                             elasticsearchProposalAPI
563                                               .countProposals(
564                                                 SearchQuery(filters = SearchFilters(
565                                                   content = ContentSearchFilter(content.value).some,
566                                                   question = QuestionSearchFilter(Seq(questionId)).some,
567                                                   users = UserSearchFilter(Seq(u.userId)).some
568                                                 ).some
569                                                 )
570                                               )
571                                         )
572                                         result <- count match {
573                                           case 0L =>
574                                             proposalService
575                                               .createExternalProposal(
576                                                 content.value,
577                                                 contentTranslations = translations,
578                                                 question = question,
579                                                 country = question.countries.head,
580                                                 submittedAsLanguage = Language(originalLanguage.value),
581                                                 isAnonymous = request.anonymous,
582                                                 externalUserId = externalUserId.value,
583                                                 author = AuthorRequest(
584                                                   firstName = firstName.value,
585                                                   age = age,
586                                                   lastName = None,
587                                                   postalCode = None,
588                                                   profession = None
589                                                 ),
590                                                 moderator = userAuth.user.userId,
591                                                 moderatorRequestContext = requestContext,
592                                                 lineNumber = lineNumber
593                                               )
594                                               .as((validation, warning))
595                                           case _ => Future.successful((validation, None))
596                                         }
597                                       } yield result
598                                     case _ => Future.successful((validation, None))
599                                   }
600                               }.asDirective { res =>
601                                 val (validations, warnings) = res.unzip
602                                 validations.sequence.throwIfInvalid()
603                                 complete(StatusCodes.Accepted -> warnings.flatten)
604                               }
605                             }
606                       }
607                     }
608                   }
609                 }
610               }
611             }
612           }
613         }
614       }
615     }
616 
617     override def listQuestions: Route = get {
618       path("moderation" / "questions") {
619         makeOperation("ModerationSearchQuestion") { _ =>
620           parameters(
621             "slug".?,
622             "operationId".as[OperationId].?,
623             "country".as[Country].?,
624             "language".as[Language].?,
625             "_start".as[Pagination.Offset].?,
626             "_end".as[Pagination.End].?,
627             "_sort".?,
628             "_order".as[Order].?
629           ) { (maybeSlug, operationId, country, language, offset, end, sort, order) =>
630             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
631               requireModerationRole(userAuth.user) {
632                 val questionIds: Option[Seq[QuestionId]] = if (userAuth.user.roles.contains(RoleAdmin)) {
633                   None
634                 } else {
635                   Some(userAuth.user.availableQuestions)
636                 }
637                 val request: SearchQuestionRequest = SearchQuestionRequest(
638                   maybeQuestionIds = questionIds,
639                   maybeOperationIds = operationId.map(op => Seq(op)),
640                   country = country,
641                   language = language,
642                   maybeSlug = maybeSlug,
643                   offset = offset,
644                   end = end,
645                   sort = sort,
646                   order = order
647                 )
648                 val searchResults: Future[(Int, Seq[Question])] =
649                   questionService.countQuestion(request).flatMap { count =>
650                     questionService.searchQuestion(request).map(results => count -> results)
651                   }
652 
653                 onSuccess(searchResults) {
654                   case (count, results) =>
655                     complete(
656                       (
657                         StatusCodes.OK,
658                         Seq(`X-Total-Count`(count.toString)),
659                         results.map(ModerationQuestionResponse.apply)
660                       )
661                     )
662                 }
663               }
664             }
665           }
666         }
667       }
668     }
669 
670     override def getQuestion: Route = get {
671       path("moderation" / "questions" / questionId) { questionId =>
672         makeOperation("ModerationGetQuestion") { _ =>
673           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
674             requireModerationRole(userAuth.user) {
675               questionService.getQuestion(questionId).asDirectiveOrNotFound { question =>
676                 complete(ModerationQuestionResponse(question))
677               }
678             }
679           }
680         }
681       }
682     }
683 
684     override def uploadQuestionImage: Route = {
685       post {
686         path("moderation" / "questions" / questionId / "image") { questionId =>
687           makeOperation("uploadQuestionConsultationImage") { _ =>
688             makeOAuth2 { user =>
689               requireAdminRole(user.user) {
690                 operationOfQuestionService.findByQuestionId(questionId).asDirectiveOrNotFound { operationOfQuestion =>
691                   operationService.findOneSimple(operationOfQuestion.operationId).asDirectiveOrNotFound { operation =>
692                     def uploadFile(extension: String, contentType: String, fileContent: Content): Future[String] = {
693                       storageService
694                         .uploadImage(
695                           FileType.Operation,
696                           s"${operation.slug}/${idGenerator.nextId()}$extension",
697                           contentType,
698                           fileContent
699                         )
700                     }
701                     uploadImageAsync("data", uploadFile, sizeLimit = None) { (path, file) =>
702                       file.delete()
703                       complete(UploadResponse(path))
704                     }
705                   }
706                 }
707               }
708             }
709           }
710         }
711       }
712     }
713 
714     override def uploadReport: Route = {
715       post {
716         path("moderation" / "questions" / questionId / "report") { questionId =>
717           makeOperation("uploadConsultationReport") { _ =>
718             makeOAuth2 { user =>
719               requireAdminRole(user.user) {
720                 operationOfQuestionService.findByQuestionId(questionId).asDirectiveOrNotFound { operationOfQuestion =>
721                   operationService.findOneSimple(operationOfQuestion.operationId).asDirectiveOrNotFound { operation =>
722                     def uploadFile(name: String, contentType: String, fileContent: Content): Future[String] = {
723                       storageService
724                         .uploadReport(
725                           FileType.Report,
726                           s"${operation.slug}_${idGenerator.nextId()}_$name",
727                           contentType,
728                           fileContent
729                         )
730                     }
731                     uploadPDFAsync("data", uploadFile) { (path, file) =>
732                       file.delete()
733                       complete(UploadResponse(path))
734                     }
735                   }
736                 }
737               }
738             }
739           }
740         }
741       }
742     }
743   }
744 }
745 
746 final case class CreateInitialProposalRequest(
747   content: String Refined (
748     MinSize[FrontConfiguration.defaultProposalMinLength]
749       And MaxSize[BusinessConfig.defaultProposalMaxLength]
750       And ValidHtml
751   ),
752   contentTranslations: Option[Multilingual[
753     String Refined (
754       MinSize[FrontConfiguration.defaultProposalMinLength]
755         And MaxSize[BusinessConfig.defaultProposalTranslationMaxLength]
756         And ValidHtml
757     )
758   ]],
759   @(ApiModelProperty @field)(dataType = "string", example = "FR", required = true)
760   country: Country,
761   @(ApiModelProperty @field)(dataType = "string", example = "fr", required = true)
762   submittedAsLanguage: Language,
763   author: AuthorRequest,
764   @(ApiModelProperty @field)(dataType = "list[string]", required = true) tags: Seq[TagId]
765 )
766 
767 object CreateInitialProposalRequest {
768   implicit val decoder: Decoder[CreateInitialProposalRequest] = deriveDecoder[CreateInitialProposalRequest]
769 }
770 
771 final case class InjectProposalsRequest(anonymous: Boolean)
772 
773 object InjectProposalsRequest {
774   implicit val decoder: Decoder[InjectProposalsRequest] = deriveDecoder[InjectProposalsRequest]
775 }