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.server._
24 import akka.http.scaladsl.unmarshalling.Unmarshaller._
25 import com.sksamuel.elastic4s.requests.searches.suggestion.Fuzziness
26 import eu.timepit.refined.api.Refined
27 import eu.timepit.refined.auto._
28 import eu.timepit.refined.numeric._
29 import grizzled.slf4j.Logging
30 import io.circe.refined._
31 import io.swagger.annotations._
32 import org.make.api.demographics.{DemographicsCardServiceComponent}
33 import org.make.api.feature.{ActiveFeatureServiceComponent, FeatureServiceComponent}
34 import org.make.api.keyword.KeywordServiceComponent
35 import org.make.api.operation.{
36   OperationOfQuestionSearchEngineComponent,
37   OperationOfQuestionServiceComponent,
38   OperationServiceComponent
39 }
40 import org.make.api.organisation.{OrganisationServiceComponent, OrganisationsSearchResultResponse}
41 import org.make.api.partner.PartnerServiceComponent
42 import org.make.api.personality.PersonalityRoleServiceComponent
43 import org.make.api.proposal.{
44   ProposalResponse,
45   ProposalSearchEngineComponent,
46   ProposalServiceComponent,
47   ProposalsResultResponse,
48   ProposalsResultSeededResponse
49 }
50 import org.make.api.sequence.{SequenceConfigurationComponent, SequenceServiceComponent}
51 import org.make.api.tag.TagServiceComponent
52 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
53 import org.make.api.technical.{EndpointType, MakeAuthenticationDirectives}
54 import org.make.api.technical.directives.FutureDirectivesExtensions._
55 import org.make.core.Validation.validateField
56 import org.make.core.auth.UserRights
57 import org.make.core.technical.Pagination
58 import org.make.core.feature.FeatureSlug
59 import org.make.core.feature.FeatureSlug.DisplayIntroCardWidget
60 import org.make.core.keyword.Keyword
61 import org.make.core.operation._
62 import org.make.core.operation.indexed.{IndexedOperationOfQuestion, OperationOfQuestionElasticsearchFieldName}
63 import org.make.core.partner.PartnerKind
64 import org.make.core.personality.PersonalityRoleId
65 import org.make.core.proposal.{
66   MinScoreLowerBoundSearchFilter,
67   PopularAlgorithm,
68   QuestionSearchFilter,
69   SearchFilters,
70   SearchQuery,
71   SequencePoolSearchFilter,
72   ZoneSearchFilter
73 }
74 import org.make.core.proposal.indexed.{SequencePool, Zone}
75 import org.make.core.question.{Question, QuestionId, TopProposalsMode}
76 import org.make.core.reference.{Country, Language}
77 import org.make.core.user.{CountrySearchFilter => _, DescriptionSearchFilter => _, LanguageSearchFilter => _, _}
78 import org.make.core.{HttpCodes, Order, ParameterExtractors, RequestContext, Validation}
79 import scalaoauth2.provider.AuthInfo
80 
81 import javax.ws.rs.Path
82 import scala.concurrent.ExecutionContext.Implicits.global
83 import scala.concurrent.Future
84 
85 trait QuestionApiComponent {
86   def questionApi: QuestionApi
87 }
88 
89 @Api(value = "Questions")
90 @Path(value = "/questions")
91 trait QuestionApi extends Directives {
92 
93   @ApiOperation(value = "get-question-details", httpMethod = "GET", code = HttpCodes.OK)
94   @ApiImplicitParams(
95     value = Array(
96       new ApiImplicitParam(name = "questionSlugOrQuestionId", paramType = "path", dataType = "string"),
97       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string")
98     )
99   )
100   @ApiResponses(
101     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[QuestionDetailsResponse]))
102   )
103   @Path(value = "/{questionSlugOrQuestionId}/details")
104   def questionDetails: Route
105 
106   @ApiOperation(value = "get-search-question", httpMethod = "GET", code = HttpCodes.OK)
107   @ApiImplicitParams(
108     value = Array(
109       new ApiImplicitParam(name = "questionIds", paramType = "query", dataType = "string"),
110       new ApiImplicitParam(name = "questionContent", paramType = "query", dataType = "string"),
111       new ApiImplicitParam(name = "description", paramType = "query", dataType = "string"),
112       new ApiImplicitParam(
113         name = "operationKinds",
114         paramType = "query",
115         dataType = "string",
116         allowableValues = OperationKind.swaggerAllowableValues
117       ),
118       new ApiImplicitParam(name = "language", paramType = "query", dataType = "string"),
119       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string"),
120       new ApiImplicitParam(name = "country", paramType = "query", dataType = "string"),
121       new ApiImplicitParam(
122         name = "limit",
123         paramType = "query",
124         dataType = "int",
125         allowableValues = "range[0, infinity]"
126       ),
127       new ApiImplicitParam(
128         name = "skip",
129         paramType = "query",
130         dataType = "int",
131         allowableValues = "range[0, infinity]"
132       ),
133       new ApiImplicitParam(
134         name = "sort",
135         paramType = "query",
136         dataType = "string",
137         allowableValues = OperationOfQuestionElasticsearchFieldName.swaggerAllowableValues
138       ),
139       new ApiImplicitParam(
140         name = "order",
141         paramType = "query",
142         dataType = "string",
143         allowableValues = Order.swaggerAllowableValues
144       )
145     )
146   )
147   @ApiResponses(
148     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[SearchQuestionsResponse]))
149   )
150   @Path(value = "/search")
151   def searchQuestions: Route
152 
153   @ApiOperation(value = "get-question-popular-tags", httpMethod = "GET", code = HttpCodes.OK)
154   @ApiImplicitParams(
155     value = Array(
156       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
157       new ApiImplicitParam(
158         name = "limit",
159         paramType = "query",
160         dataType = "int",
161         allowableValues = "range[0, infinity]"
162       ),
163       new ApiImplicitParam(name = "skip", paramType = "query", dataType = "int", allowableValues = "range[0, infinity]")
164     )
165   )
166   @ApiResponses(
167     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[PopularTagResponse]]))
168   )
169   @Path(value = "/{questionId}/popular-tags")
170   def getPopularTags: Route
171 
172   @ApiOperation(value = "get-top-proposals", httpMethod = "GET", code = HttpCodes.OK)
173   @ApiImplicitParams(
174     value = Array(
175       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
176       new ApiImplicitParam(name = "limit", paramType = "query", dataType = "int"),
177       new ApiImplicitParam(
178         name = "mode",
179         paramType = "query",
180         dataType = "string",
181         allowableValues = TopProposalsMode.swaggerAllowableValues,
182         allowEmptyValue = true
183       )
184     )
185   )
186   @ApiResponses(
187     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ProposalsResultResponse]))
188   )
189   @Path(value = "/{questionId}/top-proposals")
190   def getTopProposals: Route
191 
192   @ApiOperation(value = "get-question-partners", httpMethod = "GET", code = HttpCodes.OK)
193   @ApiImplicitParams(
194     value = Array(
195       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
196       new ApiImplicitParam(
197         name = "sortAlgorithm",
198         paramType = "query",
199         dataType = "string",
200         allowableValues = OrganisationAlgorithmSelector.swaggerAllowableValues
201       ),
202       new ApiImplicitParam(
203         name = "partnerKind",
204         paramType = "query",
205         dataType = "string",
206         allowableValues = PartnerKind.swaggerAllowableValues
207       ),
208       new ApiImplicitParam(
209         name = "limit",
210         paramType = "query",
211         dataType = "int",
212         allowableValues = "range[0, infinity]"
213       ),
214       new ApiImplicitParam(name = "skip", paramType = "query", dataType = "int", allowableValues = "range[0, infinity]")
215     )
216   )
217   @ApiResponses(
218     value =
219       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[OrganisationsSearchResultResponse]))
220   )
221   @Path(value = "/{questionId}/partners")
222   def getPartners: Route
223 
224   @ApiOperation(value = "get-question-personalities", httpMethod = "GET", code = HttpCodes.OK)
225   @ApiImplicitParams(
226     value = Array(
227       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
228       new ApiImplicitParam(name = "personalityRoleId", paramType = "query", dataType = "string"),
229       new ApiImplicitParam(
230         name = "limit",
231         paramType = "query",
232         dataType = "int",
233         allowableValues = "range[0, infinity]"
234       ),
235       new ApiImplicitParam(name = "skip", paramType = "query", dataType = "int", allowableValues = "range[0, infinity]")
236     )
237   )
238   @ApiResponses(
239     value = Array(
240       new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[QuestionPersonalityResponseWithTotal])
241     )
242   )
243   @Path(value = "/{questionId}/personalities")
244   def getPersonalities: Route
245 
246   @ApiOperation(value = "list-questions", httpMethod = "GET", code = HttpCodes.OK)
247   @ApiImplicitParams(
248     value = Array(
249       new ApiImplicitParam(name = "country", paramType = "query", dataType = "string", example = "FR", required = true),
250       new ApiImplicitParam(name = "language", paramType = "query", dataType = "string", example = "fr"),
251       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string", example = "fr"),
252       new ApiImplicitParam(
253         name = "status",
254         paramType = "query",
255         dataType = "string",
256         allowableValues = OperationOfQuestion.Status.swaggerAllowableValues
257       ),
258       new ApiImplicitParam(
259         name = "limit",
260         paramType = "query",
261         dataType = "int",
262         allowableValues = "range[0, infinity]"
263       ),
264       new ApiImplicitParam(
265         name = "skip",
266         paramType = "query",
267         dataType = "int",
268         allowableValues = "range[0, infinity]"
269       ),
270       new ApiImplicitParam(
271         name = "sortAlgorithm",
272         paramType = "query",
273         dataType = "string",
274         allowableValues = SortAlgorithm.swaggerAllowableValues
275       )
276     )
277   )
278   @ApiResponses(
279     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[QuestionListResponse]))
280   )
281   @Path(value = "/")
282   def listQuestions: Route
283 
284   @ApiOperation(value = "featured-proposals", httpMethod = "GET", code = HttpCodes.OK)
285   @ApiImplicitParams(
286     value = Array(
287       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
288       new ApiImplicitParam(
289         name = "maxPartnerProposals",
290         paramType = "query",
291         dataType = "int",
292         required = true,
293         allowableValues = "range[0, infinity]"
294       ),
295       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string", example = "fr"),
296       new ApiImplicitParam(
297         name = "limit",
298         paramType = "query",
299         dataType = "int",
300         required = true,
301         allowableValues = "range[0, infinity]"
302       ),
303       new ApiImplicitParam(name = "seed", paramType = "query", dataType = "int")
304     )
305   )
306   @ApiResponses(
307     value =
308       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ProposalsResultSeededResponse]))
309   )
310   @Path(value = "/{questionId}/featured-proposals")
311   def featuredProposals: Route
312 
313   @ApiOperation(value = "get-keywords", httpMethod = "GET", code = HttpCodes.OK)
314   @ApiImplicitParams(
315     value = Array(
316       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
317       new ApiImplicitParam(
318         name = "limit",
319         paramType = "query",
320         dataType = "int",
321         required = true,
322         allowableValues = "range[0, infinity]"
323       )
324     )
325   )
326   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[Keyword]])))
327   @Path(value = "/{questionId}/keywords")
328   def getKeywords: Route
329 
330   def routes: Route =
331     questionDetails ~ searchQuestions ~ getPopularTags ~ getTopProposals ~ getPartners ~
332       getPersonalities ~ listQuestions ~ featuredProposals ~ getKeywords
333 }
334 
335 trait DefaultQuestionApiComponent
336     extends QuestionApiComponent
337     with SequenceServiceComponent
338     with MakeAuthenticationDirectives
339     with Logging
340     with ParameterExtractors {
341 
342   this: MakeDirectivesDependencies
343     with DemographicsCardServiceComponent
344     with ActiveFeatureServiceComponent
345     with FeatureServiceComponent
346     with KeywordServiceComponent
347     with OperationOfQuestionSearchEngineComponent
348     with OperationOfQuestionServiceComponent
349     with OperationServiceComponent
350     with OrganisationServiceComponent
351     with PartnerServiceComponent
352     with PersonalityRoleServiceComponent
353     with ProposalSearchEngineComponent
354     with ProposalServiceComponent
355     with QuestionServiceComponent
356     with SequenceConfigurationComponent
357     with TagServiceComponent =>
358 
359   override lazy val questionApi: QuestionApi = new DefaultQuestionApi
360 
361   class DefaultQuestionApi extends QuestionApi {
362 
363     private val questionId: PathMatcher1[QuestionId] = Segment.map(id => QuestionId(id))
364     private val questionSlugOrQuestionId: PathMatcher1[String] = Segment
365 
366     private def zoneCount(zone: Zone, indexedOoq: IndexedOperationOfQuestion, question: Question): Future[Long] =
367       elasticsearchProposalAPI.countProposals(
368         SearchQuery(filters = Some(
369           SearchFilters(
370             minScoreLowerBound = Option
371               .when(zone == Zone.Consensus)(indexedOoq.top20ConsensusThreshold.map(MinScoreLowerBoundSearchFilter))
372               .flatten,
373             question = Some(QuestionSearchFilter(Seq(question.questionId))),
374             sequencePool = Some(SequencePoolSearchFilter(SequencePool.Tested)),
375             zone = Some(ZoneSearchFilter(zone))
376           )
377         )
378         )
379       )
380 
381     // TODO: remove the public access once authent is handled in server side
382     override def questionDetails: Route = get {
383       path("questions" / questionSlugOrQuestionId / "details") { questionSlugOrQuestionId =>
384         makeOperation("GetQuestionDetails", EndpointType.Public) { _ =>
385           optionalOidcAuthBySlug(questionSlugOrQuestionId, oidcConfigOnErrorResponse = true) { _ =>
386             parameters("preferredLanguage".as[Language].?) { maybePreferredLanguage =>
387               questionService
388                 .getQuestionByQuestionIdValueOrSlug(questionSlugOrQuestionId)
389                 .asDirectiveOrNotFound
390                 .flatMap(
391                   question =>
392                     (
393                       operationOfQuestionService
394                         .findByQuestionId(question.questionId)
395                         .asDirectiveOrNotFound,
396                       elasticsearchOperationOfQuestionAPI
397                         .findOperationOfQuestionById(question.questionId)
398                         .asDirectiveOrNotFound,
399                       partnerService
400                         .find(
401                           questionId = Some(question.questionId),
402                           organisationId = None,
403                           offset = Pagination.Offset.zero,
404                           end = None,
405                           sort = Some("weight"),
406                           order = Some(Order.desc),
407                           partnerKind = None
408                         )
409                         .asDirective,
410                       findActiveFeatureSlugsByQuestionId(question.questionId).asDirective
411                     ).tupled.flatMap({
412                       case (operationOfQuestion, indexedOoq, partners, activeFeatureSlugs) =>
413                         val returnedLanguage =
414                           maybePreferredLanguage
415                             .filter(question.languages.toList.contains)
416                             .getOrElse(question.defaultLanguage)
417                         val demographicsCardCountF =
418                           demographicsCardService.count(questionId = Some(question.questionId))
419                         (
420                           operationService.findOne(operationOfQuestion.operationId).asDirectiveOrNotFound,
421                           findActiveFeatureData(question, activeFeatureSlugs, maybePreferredLanguage).asDirective,
422                           organisationService
423                             .find(
424                               offset = Pagination.Offset.zero,
425                               end = Some(Pagination.End(partners.length)),
426                               sort = None,
427                               order = None,
428                               ids = Some(partners.flatMap(_.organisationId)),
429                               organisationName = None
430                             )
431                             .asDirective,
432                           zoneCount(Zone.Consensus, indexedOoq, question).asDirective,
433                           zoneCount(Zone.Controversy, indexedOoq, question).asDirective,
434                           demographicsCardCountF.asDirective
435                         ).mapN(
436                           (
437                             operation,
438                             activeFeaturesData,
439                             organisations,
440                             consensusCount,
441                             controversyCount,
442                             demographicsCardCount
443                           ) =>
444                             QuestionDetailsResponse(
445                               question,
446                               operation,
447                               operationOfQuestion,
448                               partners,
449                               organisations,
450                               activeFeatureSlugs,
451                               controversyCount,
452                               consensusCount,
453                               activeFeaturesData,
454                               demographicsCardCount,
455                               maybePreferredLanguage,
456                               returnedLanguage
457                             )
458                         )
459                     })
460                 )
461                 .apply(complete(_))
462             }
463           }
464         }
465       }
466     }
467 
468     private def findActiveFeatureSlugsByQuestionId(questionId: QuestionId): Future[Seq[FeatureSlug]] = {
469       activeFeatureService.find(maybeQuestionId = Some(Seq(questionId))).flatMap { activeFeatures =>
470         featureService.findByFeatureIds(activeFeatures.map(_.featureId)).map(_.map(_.slug))
471       }
472     }
473 
474     private def findActiveFeatureData(
475       question: Question,
476       features: Seq[FeatureSlug],
477       preferredLanguage: Option[Language]
478     ): Future[ActiveFeatureData] = {
479       val futureTopProposal: Future[Option[ProposalResponse]] = if (features.contains(DisplayIntroCardWidget)) {
480         proposalService
481           .searchInIndex(
482             query = SearchQuery(
483               limit = Some(Pagination.Limit(1)),
484               sortAlgorithm = Some(PopularAlgorithm),
485               filters = Some(SearchFilters(question = Some(QuestionSearchFilter(Seq(question.questionId)))))
486             ),
487             requestContext = RequestContext.empty
488           )
489           .map(_.results)
490           .flatMap {
491             case Seq() => Future.successful(None)
492             case proposal +: _ =>
493               val futureThreshold: Future[Int] = proposal.question.map(_.questionId) match {
494                 case Some(questionId) =>
495                   sequenceConfigurationService
496                     .getSequenceConfigurationByQuestionId(questionId)
497                     .map(_.newProposalsVoteThreshold)
498                 case None => Future.successful(0)
499               }
500 
501               futureThreshold.map { newProposalsVoteThreshold =>
502                 Some(
503                   ProposalResponse(
504                     indexedProposal = proposal,
505                     myProposal = false,
506                     voteAndQualifications = None,
507                     proposalKey = "not-votable",
508                     newProposalsVoteThreshold = newProposalsVoteThreshold,
509                     preferredLanguage = preferredLanguage,
510                     questionDefaultLanguage = Some(question.defaultLanguage)
511                   )
512                 )
513               }
514           }
515       } else {
516         Future.successful(None)
517       }
518 
519       for {
520         topProposal <- futureTopProposal
521       } yield ActiveFeatureData(topProposal)
522     }
523 
524     override def searchQuestions: Route = get {
525       path("questions" / "search") {
526         makeOperation("SearchQuestion") { _ =>
527           parameters(
528             "questionIds".as[Seq[QuestionId]].?,
529             "questionContent".?,
530             "description".?,
531             "operationKinds".as[Seq[OperationKind]].?,
532             "preferredLanguage".as[Language].?,
533             "language".as[Language].?,
534             "country".as[Country].?,
535             "limit".as[Pagination.Limit].?,
536             "skip".as[Pagination.Offset].?,
537             "sort".as[OperationOfQuestionElasticsearchFieldName].?,
538             "order".as[Order].?
539           ) {
540             (
541               questionIds: Option[Seq[QuestionId]],
542               questionContent: Option[String],
543               description: Option[String],
544               operationKinds: Option[Seq[OperationKind]],
545               maybePreferredLanguage: Option[Language],
546               language: Option[Language],
547               country: Option[Country],
548               limit: Option[Pagination.Limit],
549               offset: Option[Pagination.Offset],
550               sort: Option[OperationOfQuestionElasticsearchFieldName],
551               order: Option[Order]
552             ) =>
553               val filters: Option[OperationOfQuestionSearchFilters] = Some(
554                 OperationOfQuestionSearchFilters(
555                   questionIds = questionIds.map(QuestionIdsSearchFilter.apply),
556                   question = questionContent.map(QuestionContentSearchFilter(_, Some(Fuzziness.Auto))),
557                   description = description.map(DescriptionSearchFilter.apply),
558                   country = country.map(CountrySearchFilter.apply),
559                   language = language.map(LanguageSearchFilter.apply),
560                   operationKinds = operationKinds
561                     .map(_.filter(OperationKind.unsecuredKinds.contains))
562                     .map(OperationKindsSearchFilter.apply)
563                 )
564               )
565               val searchQuery: OperationOfQuestionSearchQuery =
566                 OperationOfQuestionSearchQuery(
567                   filters = filters,
568                   limit = limit,
569                   offset = offset,
570                   sort = sort,
571                   order = order
572                 )
573               operationOfQuestionService.search(searchQuery).asDirective { searchResult =>
574                 complete(
575                   SearchQuestionsResponse(
576                     total = searchResult.total,
577                     results = searchResult.results.map(SearchQuestionResponse.apply(_, maybePreferredLanguage))
578                   )
579                 )
580               }
581           }
582         }
583 
584       }
585     }
586 
587     override def getPopularTags: Route = get {
588       path("questions" / questionId / "popular-tags") { questionId =>
589         makeOperation("GetQuestionPopularTags") { _ =>
590           optionalOidcAuth(questionId) { _ =>
591             parameters("limit".as[Int].?, "skip".as[Int].?) { (limit: Option[Int], offset: Option[Int]) =>
592               questionService.getCachedQuestion(questionId).asDirectiveOrNotFound { _ =>
593                 val offsetOrZero = offset.getOrElse(0)
594                 val size = limit.fold(Int.MaxValue)(_ + offsetOrZero)
595 
596                 elasticsearchProposalAPI.getPopularTagsByProposal(questionId, size).asDirective { popularTagsResponse =>
597                   val popularTags = popularTagsResponse.sortBy(_.proposalCount * -1).drop(offsetOrZero)
598                   complete(popularTags)
599                 }
600               }
601             }
602           }
603         }
604       }
605     }
606 
607     override def getTopProposals: Route = get {
608       path("questions" / questionId / "top-proposals") { questionId =>
609         makeOperation("GetTopProposals") { requestContext =>
610           optionalOidcAuth(questionId) { _ =>
611             parameters("limit".as[Int].?, "mode".as[TopProposalsMode].?) {
612               (limit: Option[Int], mode: Option[TopProposalsMode]) =>
613                 optionalMakeOAuth2 { userAuth: Option[AuthInfo[UserRights]] =>
614                   questionService.getCachedQuestion(questionId).asDirectiveOrNotFound { _ =>
615                     proposalService
616                       .getTopProposals(
617                         maybeUserId = userAuth.map(_.user.userId),
618                         questionId = questionId,
619                         size = limit.getOrElse(10),
620                         mode = mode,
621                         requestContext = requestContext
622                       )
623                       .asDirective
624                       .apply(complete(_))
625                   }
626                 }
627             }
628           }
629         }
630       }
631     }
632 
633     override def getPartners: Route = get {
634       path("questions" / questionId / "partners") { questionId =>
635         makeOperation("GetQuestionPartners") { _ =>
636           optionalOidcAuth(questionId) { _ =>
637             parameters(
638               "sortAlgorithm".as[OrganisationAlgorithmSelector].?,
639               "partnerKind".as[PartnerKind].?,
640               "limit".as[Pagination.Limit].?,
641               "skip".as[Pagination.Offset].?
642             ) {
643               (
644                 sortAlgorithm: Option[OrganisationAlgorithmSelector],
645                 partnerKind: Option[PartnerKind],
646                 limit: Option[Pagination.Limit],
647                 offset: Option[Pagination.Offset]
648               ) =>
649                 questionService.getCachedQuestion(questionId).asDirectiveOrNotFound { _ =>
650                   partnerService
651                     .find(
652                       offset = Pagination.Offset.zero,
653                       end = Some(Pagination.End(1000)),
654                       sort = None,
655                       order = None,
656                       questionId = Some(questionId),
657                       organisationId = None,
658                       partnerKind = partnerKind
659                     )
660                     .asDirective { partners =>
661                       val organisationsIds = partners.flatMap(_.organisationId)
662                       val sortAlgo = sortAlgorithm.flatMap(_.select(Some(questionId)))
663                       questionService.getPartners(questionId, organisationsIds, sortAlgo, limit, offset).asDirective {
664                         results =>
665                           complete(OrganisationsSearchResultResponse.fromOrganisationSearchResult(results))
666                       }
667                     }
668                 }
669             }
670           }
671         }
672       }
673     }
674 
675     override def getPersonalities: Route = {
676       get {
677         path("questions" / questionId / "personalities") { questionId =>
678           makeOperation("GetQuestionPersonalities") { _ =>
679             optionalOidcAuth(questionId) { _ =>
680               parameters("personalityRole".as[String].?, "limit".as[Pagination.Limit].?, "skip".as[Pagination.Offset].?) {
681                 (personalityRole: Option[String], limit: Option[Pagination.Limit], offset: Option[Pagination.Offset]) =>
682                   personalityRoleService
683                     .find(
684                       offset = Pagination.Offset.zero,
685                       end = None,
686                       sort = None,
687                       order = None,
688                       roleIds = None,
689                       name = personalityRole
690                     )
691                     .asDirective { roles =>
692                       val personalityRoleId: Option[PersonalityRoleId] = roles match {
693                         case Seq(role) if personalityRole.nonEmpty => Some(role.personalityRoleId)
694                         case _                                     => None
695                       }
696                       Validation.validate(
697                         Validation.validateField(
698                           field = "personalityRole",
699                           key = "invalid_content",
700                           condition = personalityRole.forall(_ => personalityRoleId.isDefined),
701                           message = s"$personalityRole is not a valid personality role"
702                         )
703                       )
704                       questionService
705                         .getQuestionPersonalities(
706                           offset = offset.orZero,
707                           end = limit.map(_.toEnd(offset.orZero)),
708                           questionId = questionId,
709                           personalityRoleId = personalityRoleId
710                         )
711                         .asDirective { questionPersonalities =>
712                           val response = QuestionPersonalityResponseWithTotal(
713                             total = questionPersonalities.size,
714                             results = questionPersonalities.sortBy(_.lastName)
715                           )
716                           complete(response)
717                         }
718                     }
719               }
720             }
721           }
722         }
723       }
724     }
725 
726     override def listQuestions: Route = {
727       get {
728         path("questions") {
729           makeOperation("ListQuestions") { _ =>
730             parameters(
731               "preferredLanguage".as[Language].?,
732               "country".as[Country],
733               "language".as[Language].?,
734               "status".as[OperationOfQuestion.Status].?,
735               "limit".as[Pagination.Limit].?,
736               "skip".as[Pagination.Offset].?,
737               "sortAlgorithm".as[SortAlgorithm].?
738             ) {
739               (
740                 maybePreferredLanguage: Option[Language],
741                 country: Country,
742                 maybeLanguage: Option[Language],
743                 maybeStatus: Option[OperationOfQuestion.Status],
744                 limit: Option[Pagination.Limit],
745                 offset: Option[Pagination.Offset],
746                 sortAlgorithm: Option[SortAlgorithm]
747               ) =>
748                 val filters = OperationOfQuestionSearchFilters(
749                   country = Some(CountrySearchFilter(country)),
750                   language = maybeLanguage.map(LanguageSearchFilter.apply),
751                   status = maybeStatus.map(status => StatusSearchFilter(status))
752                 )
753                 operationOfQuestionService
754                   .search(
755                     OperationOfQuestionSearchQuery(
756                       filters = Some(filters),
757                       limit = limit,
758                       offset = offset,
759                       sortAlgorithm = sortAlgorithm
760                     )
761                   )
762                   .asDirective { operationOfQuestions =>
763                     complete(
764                       QuestionListResponse(
765                         results = operationOfQuestions.results
766                           .map(QuestionOfOperationResponse.apply(_, maybePreferredLanguage)),
767                         total = operationOfQuestions.total
768                       )
769                     )
770                   }
771             }
772           }
773         }
774       }
775     }
776 
777     override def featuredProposals: Route = get {
778       path("questions" / questionId / "featured-proposals") { questionId =>
779         makeOperation("GetFeaturedProposals") { requestContext =>
780           optionalOidcAuth(questionId) { _ =>
781             parameters(
782               "maxPartnerProposals".as[Int Refined NonNegative],
783               "preferredLanguage".as[Language].?,
784               "limit".as[Int Refined Positive],
785               "seed".as[Int].?
786             ) { (maxPartnerProposals, preferredLanguage, limit, seed) =>
787               Validation.validate(
788                 validateField(
789                   "maxPartnerProposals",
790                   "invalid_value",
791                   maxPartnerProposals.value <= limit.value,
792                   "maxPartnerProposals should be lower or equal to limit"
793                 )
794               )
795               optionalMakeOAuth2 { userAuth: Option[AuthInfo[UserRights]] =>
796                 questionService.getCachedQuestion(questionId).asDirectiveOrNotFound { question =>
797                   proposalService
798                     .questionFeaturedProposals(
799                       questionId = questionId,
800                       maxPartnerProposals = maxPartnerProposals.value,
801                       preferredLanguage = preferredLanguage,
802                       questionDefaultLanguage = Some(question.defaultLanguage),
803                       limit = new Pagination.Limit(limit),
804                       seed = seed,
805                       maybeUserId = userAuth.map(_.user.userId),
806                       requestContext = requestContext
807                     )
808                     .asDirective
809                     .apply(complete(_))
810                 }
811               }
812             }
813           }
814         }
815       }
816     }
817 
818     override def getKeywords: Route = get {
819       path("questions" / questionId / "keywords") { questionId =>
820         makeOperation("GetKeywords") { _ =>
821           optionalOidcAuth(questionId) { _ =>
822             parameters("limit".as[Int]) { (limit: Int) =>
823               questionService.getCachedQuestion(questionId).asDirectiveOrNotFound { _ =>
824                 keywordService
825                   .findTop(questionId, Pagination.Limit(limit))
826                   .asDirective
827                   .apply(complete(_))
828               }
829             }
830           }
831         }
832       }
833     }
834   }
835 }