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 akka.http.scaladsl.model._
23 import akka.http.scaladsl.server._
24 import akka.http.scaladsl.unmarshalling.Unmarshaller.CsvSeq
25 import cats.data.Validated.{Invalid, Valid}
26 import cats.implicits._
27 import grizzled.slf4j.Logging
28 import io.swagger.annotations._
29 import org.make.api.operation.OperationServiceComponent
30 import org.make.api.question.QuestionServiceComponent
31 import org.make.api.sequence.SequenceConfigurationComponent
32 import org.make.api.technical.CsvReceptacle._
33 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
34 import org.make.api.technical.directives.FutureDirectivesExtensions._
35 import org.make.api.technical.{EventBusServiceComponent, MakeAuthenticationDirectives}
36 import org.make.api.user.UserServiceComponent
37 import org.make.core.Validation._
38 import org.make.core.auth.UserRights
39 import org.make.core.idea.IdeaId
40 import org.make.core.operation.{OperationId, OperationKind, SortAlgorithm}
41 import org.make.core.proposal._
42 import org.make.core.proposal.indexed.ProposalElasticsearchFieldName
43 import org.make.core.question.{Question, QuestionId}
44 import org.make.core.reference.{Country, Language}
45 import org.make.core.tag.TagId
46 import org.make.core.technical.Pagination
47 import org.make.core.user.UserType
48 import org.make.core._
49 import scalaoauth2.provider.AuthInfo
50 
51 import javax.ws.rs.Path
52 import scala.concurrent.ExecutionContext.Implicits.global
53 import scala.concurrent.Future
54 
55 @Api(value = "Proposal")
56 @Path(value = "/")
57 trait ProposalApi extends Directives {
58 
59   @ApiOperation(value = "get-proposal", httpMethod = "GET", code = HttpCodes.OK)
60   @ApiResponses(
61     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ProposalResponse]))
62   )
63   @ApiImplicitParams(
64     value = Array(
65       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
66       new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string"),
67       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string", example = "fr")
68     )
69   )
70   @Path(value = "/questions/{questionId}/proposals/{proposalId}")
71   def getProposal: Route
72 
73   @ApiOperation(value = "search-proposals", httpMethod = "GET", code = HttpCodes.OK)
74   @ApiResponses(
75     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ProposalsResultResponse]))
76   )
77   @ApiImplicitParams(
78     value = Array(
79       new ApiImplicitParam(name = "proposalIds", paramType = "query", dataType = "string"),
80       new ApiImplicitParam(name = "questionId", paramType = "query", dataType = "string"),
81       new ApiImplicitParam(name = "tagsIds", paramType = "query", dataType = "string"),
82       new ApiImplicitParam(name = "operationId", paramType = "query", dataType = "string"),
83       new ApiImplicitParam(name = "content", paramType = "query", dataType = "string"),
84       new ApiImplicitParam(name = "slug", paramType = "query", dataType = "string"),
85       new ApiImplicitParam(name = "seed", paramType = "query", dataType = "int"),
86       new ApiImplicitParam(name = "source", paramType = "query", dataType = "string"),
87       new ApiImplicitParam(name = "context", paramType = "query", dataType = "string"),
88       new ApiImplicitParam(name = "location", paramType = "query", dataType = "string"),
89       new ApiImplicitParam(name = "question", paramType = "query", dataType = "string"),
90       new ApiImplicitParam(name = "language", paramType = "query", dataType = "string"),
91       new ApiImplicitParam(name = "country", paramType = "query", dataType = "string"),
92       new ApiImplicitParam(
93         name = "sort",
94         paramType = "query",
95         dataType = "string",
96         allowableValues = ProposalElasticsearchFieldName.swaggerAllowableValues
97       ),
98       new ApiImplicitParam(
99         name = "order",
100         paramType = "query",
101         dataType = "string",
102         allowableValues = Order.swaggerAllowableValues
103       ),
104       new ApiImplicitParam(
105         name = "limit",
106         paramType = "query",
107         dataType = "int",
108         allowableValues = "range[0, infinity]"
109       ),
110       new ApiImplicitParam(
111         name = "skip",
112         paramType = "query",
113         dataType = "int",
114         allowableValues = "range[0, infinity]"
115       ),
116       new ApiImplicitParam(name = "isRandom", paramType = "query", dataType = "boolean"),
117       new ApiImplicitParam(
118         name = "sortAlgorithm",
119         paramType = "query",
120         dataType = "string",
121         allowableValues = SortAlgorithm.swaggerAllowableValues
122       ),
123       new ApiImplicitParam(
124         name = "operationKinds",
125         paramType = "query",
126         dataType = "string",
127         allowableValues = OperationKind.swaggerAllowableValues,
128         allowMultiple = true
129       ),
130       new ApiImplicitParam(
131         name = "userType",
132         paramType = "query",
133         dataType = "string",
134         allowableValues = UserType.swaggerAllowableValues
135       ),
136       new ApiImplicitParam(name = "ideaIds", paramType = "query", dataType = "string"),
137       new ApiImplicitParam(name = "keywords", paramType = "query", dataType = "string"),
138       new ApiImplicitParam(name = "isNotVoted", paramType = "query", dataType = "boolean")
139     )
140   )
141   @Path(value = "/proposals")
142   def search: Route
143 
144   @ApiOperation(
145     value = "propose-proposal",
146     httpMethod = "POST",
147     code = HttpCodes.OK,
148     authorizations = Array(
149       new Authorization(
150         value = "MakeApi",
151         scopes = Array(
152           new AuthorizationScope(scope = "user", description = "application user"),
153           new AuthorizationScope(scope = "admin", description = "BO Admin")
154         )
155       )
156     )
157   )
158   @ApiImplicitParams(
159     value = Array(
160       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
161       new ApiImplicitParam(
162         value = "body",
163         paramType = "body",
164         dataType = "org.make.api.proposal.ProposeProposalRequest"
165       )
166     )
167   )
168   @ApiResponses(
169     value = Array(new ApiResponse(code = HttpCodes.Created, message = "Ok", response = classOf[ProposalIdResponse]))
170   )
171   @Path(value = "/questions/{questionId}/proposals")
172   def postProposal: Route
173 
174   @ApiOperation(value = "vote-proposal", httpMethod = "POST", code = HttpCodes.OK)
175   @ApiImplicitParams(
176     value = Array(
177       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
178       new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string"),
179       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.proposal.VoteProposalRequest")
180     )
181   )
182   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[VoteResponse])))
183   @Path(value = "/questions/{questionId}/proposals/{proposalId}/vote")
184   def vote: Route
185 
186   @ApiOperation(value = "unvote-proposal", httpMethod = "POST", code = HttpCodes.OK)
187   @ApiImplicitParams(
188     value = Array(
189       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
190       new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string"),
191       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.proposal.VoteProposalRequest")
192     )
193   )
194   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[VoteResponse])))
195   @Path(value = "/questions/{questionId}/proposals/{proposalId}/unvote")
196   def unvote: Route
197 
198   @ApiOperation(value = "qualification-vote", httpMethod = "POST", code = HttpCodes.OK)
199   @ApiImplicitParams(
200     value = Array(
201       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
202       new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string"),
203       new ApiImplicitParam(
204         value = "body",
205         paramType = "body",
206         dataType = "org.make.api.proposal.QualificationProposalRequest"
207       )
208     )
209   )
210   @ApiResponses(
211     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[QualificationResponse]))
212   )
213   @Path(value = "/questions/{questionId}/proposals/{proposalId}/qualification")
214   def qualification: Route
215 
216   @ApiOperation(value = "unqualification-vote", httpMethod = "POST", code = HttpCodes.OK)
217   @ApiImplicitParams(
218     value = Array(
219       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
220       new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string"),
221       new ApiImplicitParam(
222         value = "body",
223         paramType = "body",
224         dataType = "org.make.api.proposal.QualificationProposalRequest"
225       )
226     )
227   )
228   @ApiResponses(
229     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[QualificationResponse]))
230   )
231   @Path(value = "/questions/{questionId}/proposals/{proposalId}/unqualification")
232   def unqualification: Route
233 
234   @ApiOperation(value = "report-proposal", httpMethod = "POST", code = HttpCodes.OK)
235   @ApiImplicitParams(
236     value = Array(
237       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
238       new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string"),
239       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.proposal.ReportProposalRequest")
240     )
241   )
242   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "Ok")))
243   @Path(value = "/questions/{questionId}/proposals/{proposalId}/report")
244   def reportProposal: Route
245 
246   def routes: Route =
247     postProposal ~
248       getProposal ~
249       search ~
250       vote ~
251       unvote ~
252       qualification ~
253       unqualification ~
254       reportProposal
255 
256 }
257 
258 trait ProposalApiComponent {
259   def proposalApi: ProposalApi
260 }
261 
262 trait DefaultProposalApiComponent
263     extends ProposalApiComponent
264     with MakeAuthenticationDirectives
265     with Logging
266     with ParameterExtractors {
267 
268   this: MakeDirectivesDependencies
269     with EventBusServiceComponent
270     with ProposalServiceComponent
271     with UserServiceComponent
272     with OperationServiceComponent
273     with SequenceConfigurationComponent
274     with QuestionServiceComponent =>
275 
276   override lazy val proposalApi: DefaultProposalApi = new DefaultProposalApi
277 
278   class DefaultProposalApi extends ProposalApi {
279     val questionId: PathMatcher1[QuestionId] = Segment.map(id => QuestionId(id))
280     val proposalId: PathMatcher1[ProposalId] = Segment.map(id => ProposalId(id))
281 
282     def getProposal: Route = {
283       get {
284         path("questions" / questionId / "proposals" / proposalId) { (questionId, proposalId) =>
285           makeOperation("GetProposal") { requestContext =>
286             optionalOidcAuth(questionId) { _ =>
287               parameters("preferredLanguage".as[Language].?) {
288                 (
289                   preferredLanguage: Option[Language]
290                 ) =>
291                   proposalService
292                     .getProposalById(proposalId, requestContext)
293                     .asDirectiveOrNotFound
294                     .flatMap(
295                       proposal =>
296                         (
297                           proposal.question
298                             .fold(Future.successful(Option.empty[Question]))(
299                               question => questionService.getQuestion(question.questionId)
300                             )
301                             .asDirectiveOrNotFound,
302                           proposal.question
303                             .fold(Future.successful(Option.empty[Int]))(
304                               question =>
305                                 sequenceConfigurationService
306                                   .getSequenceConfigurationByQuestionId(question.questionId)
307                                   .map(config => Some(config.newProposalsVoteThreshold))
308                             )
309                             .asDirectiveOrBadRequest(
310                               ValidationError(
311                                 "questionId",
312                                 "not_found",
313                                 Some(s"Question not found for proposal $proposalId.")
314                               )
315                             ),
316                           sessionHistoryCoordinatorService
317                             .retrieveVoteAndQualifications(requestContext.sessionId, Seq(proposalId))
318                             .asDirective
319                         ).mapN((question, newProposalsVoteThreshold, votes) => {
320                           val proposalKey =
321                             proposalService.generateProposalKeyHash(
322                               proposalId,
323                               requestContext.sessionId,
324                               requestContext.location,
325                               securityConfiguration.secureVoteSalt
326                             )
327                           ProposalResponse(
328                             proposal,
329                             requestContext.userId.contains(proposal.author.userId),
330                             votes.get(proposalId),
331                             proposalKey,
332                             newProposalsVoteThreshold,
333                             preferredLanguage,
334                             Some(question.defaultLanguage)
335                           )
336                         })
337                     )
338                     .apply(complete(_))
339               }
340             }
341           }
342         }
343       }
344     }
345 
346     def search: Route = {
347       get {
348         path("proposals") {
349           makeOperation("Search") { requestContext =>
350             optionalMakeOAuth2 { userAuth: Option[AuthInfo[UserRights]] =>
351               parameters(
352                 "proposalIds".as[Seq[ProposalId]].?,
353                 "questionId".as[Seq[QuestionId]].?,
354                 "tagsIds".as[Seq[TagId]].?,
355                 "operationId".as[OperationId].?,
356                 "content".?,
357                 "slug".?,
358                 "source".?,
359                 "location".?,
360                 "question".?,
361                 "language".as[Language].?,
362                 "country".as[Country].?,
363                 "operationKinds".csv[OperationKind],
364                 "userType".as[Seq[UserType]].?,
365                 "ideaIds".as[Seq[IdeaId]].?,
366                 "keywords".as[Seq[ProposalKeywordKey]].?,
367                 "isNotVoted".as[Boolean].?
368               ) {
369                 (
370                   proposalIds: Option[Seq[ProposalId]],
371                   questionIds: Option[Seq[QuestionId]],
372                   tagsIds: Option[Seq[TagId]],
373                   operationId: Option[OperationId],
374                   content: Option[String],
375                   slug: Option[String],
376                   source: Option[String],
377                   location: Option[String],
378                   question: Option[String],
379                   language: Option[Language],
380                   country: Option[Country],
381                   operationKinds: Option[Seq[OperationKind]],
382                   userType: Option[Seq[UserType]],
383                   ideaIds: Option[Seq[IdeaId]],
384                   keywords: Option[Seq[ProposalKeywordKey]],
385                   isNotVoted: Option[Boolean]
386                 ) =>
387                   parameters(
388                     "sort".as[ProposalElasticsearchFieldName].?,
389                     "order".as[Order].?,
390                     "limit".as[Pagination.Limit].?,
391                     "skip".as[Pagination.Offset].?,
392                     "sortAlgorithm".as[AlgorithmSelector].?,
393                     "seed".as[Int].?,
394                     "preferredLanguage".as[Language].?
395                   ) {
396                     (
397                       sort: Option[ProposalElasticsearchFieldName],
398                       order: Option[Order],
399                       limit: Option[Pagination.Limit],
400                       offset: Option[Pagination.Offset],
401                       sortAlgorithm: Option[AlgorithmSelector],
402                       seed: Option[Int],
403                       preferredLanguage: Option[Language]
404                     ) =>
405                       Validation.validate(country.map { countryValue =>
406                         Validation.validChoices(
407                           fieldName = "country",
408                           message = Some(
409                             s"Invalid country. Expected one of ${BusinessConfig.supportedCountries.map(_.countryCode)}"
410                           ),
411                           Seq(countryValue),
412                           BusinessConfig.supportedCountries.map(_.countryCode)
413                         )
414                       }.toList: _*)
415 
416                       val futureExcludedProposalIds = isNotVoted match {
417                         case Some(true) =>
418                           sessionHistoryCoordinatorService
419                             .retrieveVotedProposals(requestContext.sessionId)
420                             .map {
421                               case Seq() => None
422                               case voted => Some(voted)
423                             }
424                         case _ => Future.successful(None)
425                       }
426                       val maybeQuestionId = questionIds match {
427                         case Some(Seq(questionId)) => Some(questionId)
428                         case _                     => None
429                       }
430                       (
431                         maybeQuestionId.flatTraverse(questionService.getQuestion(_)).asDirective,
432                         futureExcludedProposalIds.asDirective
433                       ).tupled.flatMap {
434                         case (maybeQuestion, excludedProposalIds) =>
435                           val contextFilterRequest: Option[ContextFilterRequest] =
436                             ContextFilterRequest.parse(operationId, source, location, question)
437                           val searchRequest: SearchRequest = SearchRequest(
438                             proposalIds = proposalIds,
439                             questionIds = questionIds,
440                             tagsIds = tagsIds,
441                             operationId = operationId,
442                             content = content,
443                             slug = slug,
444                             seed = seed,
445                             context = contextFilterRequest,
446                             language = language,
447                             country = country,
448                             sort = sort.map(_.field),
449                             order = order,
450                             limit = limit,
451                             offset = offset,
452                             sortAlgorithm = sortAlgorithm.map(_.value),
453                             operationKinds = operationKinds.orElse {
454                               if (questionIds.exists(_.nonEmpty)) {
455                                 Some(OperationKind.unsecuredKinds)
456                               } else {
457                                 Some(OperationKind.publicKinds)
458                               }
459                             },
460                             userTypes = userType,
461                             ideaIds = ideaIds,
462                             keywords = keywords,
463                             excludedProposalIds = excludedProposalIds
464                           )
465                           proposalService
466                             .searchForUser(
467                               userId = userAuth.map(_.user.userId),
468                               query = searchRequest.toSearchQuery(requestContext),
469                               requestContext = requestContext,
470                               preferredLanguage = preferredLanguage,
471                               questionDefaultLanguage = maybeQuestion.map(_.defaultLanguage)
472                             )
473                             .asDirective
474                       }.apply { proposals =>
475                         complete(proposals)
476                       }
477                   }
478               }
479             }
480           }
481         }
482       }
483     }
484 
485     private val maxProposalLength = BusinessConfig.defaultProposalMaxLength
486     private val minProposalLength = FrontConfiguration.defaultProposalMinLength
487 
488     def postProposal: Route =
489       post {
490         path("questions" / questionId / "proposals") { questionId =>
491           makeOperation("PostProposal") { requestContext =>
492             oidcAuth(questionId) { auth: AuthInfo[UserRights] =>
493               decodeRequest {
494                 entity(as[ProposeProposalRequest]) { request: ProposeProposalRequest =>
495                   (
496                     userService.getUser(auth.user.userId).asDirectiveOrNotFound,
497                     questionService
498                       .getQuestion(questionId)
499                       .asDirectiveOrBadRequest(
500                         ValidationError("question", "mandatory", Some("This proposal refers to no known question"))
501                       )
502                   ).mapN((user, question) => {
503                       (
504                         request.content.withMaxLength(maxProposalLength, "content"),
505                         request.content.withMinLength(minProposalLength, "content"),
506                         request.content.toSanitizedInput("content"),
507                         request.language
508                           .predicateValidated(
509                             question.languages.toList.contains,
510                             "language",
511                             "unsupported_language",
512                             Some(s"Language ${request.language.value} is not supported by question ${questionId.value}")
513                           )
514                       ).tupled match {
515                         case Invalid(errsNec) =>
516                           failWith(ValidationFailedError(errsNec.toList)): Directive1[ProposalId]
517                         case Valid(a) =>
518                           proposalService
519                             .propose(
520                               user = user,
521                               requestContext = requestContext,
522                               createdAt = DateHelper.now(),
523                               content = request.content,
524                               question = question,
525                               initialProposal = false,
526                               submittedAsLanguage = request.language,
527                               isAnonymous = request.isAnonymous,
528                               proposalType = ProposalType.ProposalTypeSubmitted
529                             )
530                             .asDirective
531                       }
532                     })
533                     .flatten
534                     .apply(proposalId => complete(StatusCodes.Created -> ProposalIdResponse(proposalId)))
535                 }
536               }
537             }
538           }
539         }
540       }
541 
542     def vote: Route = post {
543       path("questions" / questionId / "proposals" / proposalId / "vote") { (questionId, proposalId) =>
544         makeOperation("VoteProposal") { requestContext =>
545           optionalOidcAuth(questionId) { maybeAuth: Option[AuthInfo[UserRights]] =>
546             decodeRequest {
547               entity(as[VoteProposalRequest]) { request =>
548                 proposalService
549                   .voteProposal(
550                     proposalId = proposalId,
551                     maybeUserId = maybeAuth.map(_.user.userId),
552                     requestContext = requestContext,
553                     voteKey = request.voteKey,
554                     proposalKey = request.proposalKey
555                   )
556                   .asDirectiveOrNotFound
557                   .apply(
558                     votes =>
559                       complete(
560                         VotesResponse
561                           .parseVotes(
562                             votes = votes,
563                             hasVoted = Map(request.voteKey -> true),
564                             votedKey = request.voteKey
565                           )
566                       )
567                   )
568               }
569             }
570           }
571         }
572       }
573     }
574 
575     def unvote: Route = post {
576       path("questions" / questionId / "proposals" / proposalId / "unvote") { (questionId, proposalId) =>
577         makeOperation("UnvoteProposal") { requestContext =>
578           optionalOidcAuth(questionId) { maybeAuth: Option[AuthInfo[UserRights]] =>
579             decodeRequest {
580               entity(as[VoteProposalRequest]) { request =>
581                 proposalService
582                   .unvoteProposal(
583                     proposalId = proposalId,
584                     maybeUserId = maybeAuth.map(_.user.userId),
585                     requestContext = requestContext,
586                     voteKey = request.voteKey,
587                     proposalKey = request.proposalKey
588                   )
589                   .asDirectiveOrNotFound
590                   .apply(
591                     votes =>
592                       complete(
593                         VotesResponse.parseVotes(votes = votes, hasVoted = Map.empty, votedKey = request.voteKey)
594                       )
595                   )
596               }
597             }
598           }
599         }
600       }
601     }
602 
603     def qualification: Route = post {
604       path("questions" / questionId / "proposals" / proposalId / "qualification") { (questionId, proposalId) =>
605         makeOperation("QualificationProposal") { requestContext =>
606           optionalOidcAuth(questionId) { maybeAuth: Option[AuthInfo[UserRights]] =>
607             decodeRequest {
608               entity(as[QualificationProposalRequest]) { request =>
609                 proposalService
610                   .qualifyVote(
611                     proposalId = proposalId,
612                     maybeUserId = maybeAuth.map(_.user.userId),
613                     requestContext = requestContext,
614                     voteKey = request.voteKey,
615                     qualificationKey = request.qualificationKey,
616                     proposalKey = request.proposalKey
617                   )
618                   .asDirectiveOrNotFound { qualification: Qualification =>
619                     complete(
620                       QualificationResponse.parseQualification(qualification = qualification, hasQualified = true)
621                     )
622                   }
623               }
624             }
625           }
626         }
627       }
628     }
629 
630     def unqualification: Route = post {
631       path("questions" / questionId / "proposals" / proposalId / "unqualification") { (questionId, proposalId) =>
632         makeOperation("UnqualificationProposal") { requestContext =>
633           optionalOidcAuth(questionId) { maybeAuth: Option[AuthInfo[UserRights]] =>
634             decodeRequest {
635               entity(as[QualificationProposalRequest]) { request =>
636                 proposalService
637                   .unqualifyVote(
638                     proposalId = proposalId,
639                     maybeUserId = maybeAuth.map(_.user.userId),
640                     requestContext = requestContext,
641                     voteKey = request.voteKey,
642                     qualificationKey = request.qualificationKey,
643                     proposalKey = request.proposalKey
644                   )
645                   .asDirectiveOrNotFound { qualification: Qualification =>
646                     complete(
647                       QualificationResponse.parseQualification(qualification = qualification, hasQualified = false)
648                     )
649                   }
650               }
651             }
652           }
653         }
654       }
655     }
656 
657     def reportProposal: Route =
658       post {
659         path("questions" / questionId / "proposals" / proposalId / "report") { (questionId, proposalId) =>
660           makeOperation("PostProposal") { requestContext =>
661             optionalOidcAuth(questionId) { _ =>
662               decodeRequest {
663                 entity(as[ReportProposalRequest]) { request: ReportProposalRequest =>
664                   Future(
665                     eventBusService.publish(
666                       PublishedProposalEvent.ProposalReportedNotice(
667                         id = proposalId,
668                         proposalLanguage = request.proposalLanguage,
669                         reason = request.reason,
670                         eventDate = DateHelper.now(),
671                         requestContext = requestContext
672                       )
673                     )
674                   ).asDirective
675                     .apply(_ => complete(StatusCodes.OK))
676                 }
677               }
678             }
679           }
680         }
681       }
682   }
683 }