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.core.proposal
21 
22 import java.time.format.DateTimeFormatter
23 import java.time.{ZoneOffset, ZonedDateTime}
24 
25 import cats.data.NonEmptyList
26 import cats.implicits._
27 import com.sksamuel.elastic4s.{ElasticApi, ElasticDsl}
28 import com.sksamuel.elastic4s.requests.common.Operator
29 import com.sksamuel.elastic4s.requests.searches.queries.funcscorer.WeightScore
30 import com.sksamuel.elastic4s.requests.searches.queries.matches.MatchQuery
31 import com.sksamuel.elastic4s.requests.searches.queries.{Query, RangeQuery}
32 import com.sksamuel.elastic4s.requests.searches.sort.{FieldSort, SortOrder}
33 import org.make.core.Validation.{validate, validateField}
34 import org.make.core.technical.Pagination
35 import org.make.core.common.indexed.{Sort => IndexedSort}
36 import org.make.core.idea.IdeaId
37 import org.make.core.operation.{OperationId, OperationKind}
38 import org.make.core.proposal.indexed.{ProposalElasticsearchFieldName, SequencePool, Zone}
39 import org.make.core.question.QuestionId
40 import org.make.core.reference.{Country, LabelId, Language}
41 import org.make.core.tag.TagId
42 import org.make.core.user.{UserId, UserType}
43 
44 /**
45   * The class holding the entire search query
46   *
47   * @param filters        sequence of search filters
48   * @param sort           sequence of sorts options
49   * @param limit          number of items to fetch
50   * @param offset         number of items to skip
51   * @param language       language to boost the query for. NOT A FILTER.
52   * @param sortAlgorithm algorithm used for sorting
53   */
54 final case class SearchQuery(
55   filters: Option[SearchFilters] = None,
56   excludes: Option[SearchFilters] = None,
57   sort: Option[IndexedSort] = None,
58   limit: Option[Pagination.Limit] = None,
59   offset: Option[Pagination.Offset] = None,
60   language: Option[Language] = None,
61   sortAlgorithm: Option[SortAlgorithm] = None
62 ) {
63   def getSeed: Option[Int] =
64     sortAlgorithm.flatMap {
65       case algorithm: RandomBaseAlgorithm => Some(algorithm.seed)
66       case _                              => None
67     }
68 }
69 
70 final case class SearchFilters(
71   proposal: Option[ProposalSearchFilter] = None,
72   initialProposal: Option[InitialProposalFilter] = None,
73   tags: Option[TagsSearchFilter] = None,
74   labels: Option[LabelsSearchFilter] = None,
75   operation: Option[OperationSearchFilter] = None,
76   question: Option[QuestionSearchFilter] = None,
77   content: Option[ContentSearchFilter] = None,
78   status: Option[StatusSearchFilter] = None,
79   context: Option[ContextSearchFilter] = None,
80   slug: Option[SlugSearchFilter] = None,
81   idea: Option[IdeaSearchFilter] = None,
82   languages: Option[NonEmptyList[LanguageSearchFilter]] = None,
83   country: Option[CountrySearchFilter] = None,
84   users: Option[UserSearchFilter] = None,
85   minVotesCount: Option[MinVotesCountSearchFilter] = None,
86   toEnrich: Option[ToEnrichSearchFilter] = None,
87   isAnonymous: Option[IsAnonymousSearchFiler] = None,
88   minScore: Option[MinScoreSearchFilter] = None,
89   createdAt: Option[CreatedAtSearchFilter] = None,
90   sequencePool: Option[SequencePoolSearchFilter] = None,
91   sequenceSegmentPool: Option[SequencePoolSearchFilter] = None,
92   operationKinds: Option[OperationKindsSearchFilter] = None,
93   questionIsOpen: Option[QuestionIsOpenSearchFilter] = None,
94   segment: Option[SegmentSearchFilter] = None,
95   userTypes: Option[UserTypesSearchFilter] = None,
96   proposalTypes: Option[ProposalTypesSearchFilter] = None,
97   zone: Option[ZoneSearchFilter] = None,
98   segmentZone: Option[ZoneSearchFilter] = None,
99   minScoreLowerBound: Option[MinScoreLowerBoundSearchFilter] = None,
100   keywords: Option[KeywordsSearchFilter] = None,
101   submittedAsLanguages: Option[SubmittedAsLanguagesFilter] = None
102 )
103 
104 object SearchFilters extends ElasticDsl {
105 
106   def parse(
107     proposals: Option[ProposalSearchFilter] = None,
108     initialProposal: Option[InitialProposalFilter] = None,
109     tags: Option[TagsSearchFilter] = None,
110     labels: Option[LabelsSearchFilter] = None,
111     operation: Option[OperationSearchFilter] = None,
112     question: Option[QuestionSearchFilter] = None,
113     content: Option[ContentSearchFilter] = None,
114     status: Option[StatusSearchFilter] = None,
115     slug: Option[SlugSearchFilter] = None,
116     context: Option[ContextSearchFilter] = None,
117     idea: Option[IdeaSearchFilter] = None,
118     languages: Option[NonEmptyList[LanguageSearchFilter]] = None,
119     country: Option[CountrySearchFilter] = None,
120     user: Option[UserSearchFilter] = None,
121     minVotesCount: Option[MinVotesCountSearchFilter] = None,
122     toEnrich: Option[ToEnrichSearchFilter] = None,
123     isAnonymous: Option[IsAnonymousSearchFiler] = None,
124     minScore: Option[MinScoreSearchFilter] = None,
125     createdAt: Option[CreatedAtSearchFilter] = None,
126     sequencePool: Option[SequencePoolSearchFilter] = None,
127     sequenceSegmentPool: Option[SequencePoolSearchFilter] = None,
128     operationKinds: Option[OperationKindsSearchFilter] = None,
129     questionIsOpen: Option[QuestionIsOpenSearchFilter] = None,
130     segment: Option[SegmentSearchFilter] = None,
131     userTypes: Option[UserTypesSearchFilter] = None,
132     proposalTypes: Option[ProposalTypesSearchFilter] = None,
133     zone: Option[ZoneSearchFilter] = None,
134     segmentZone: Option[ZoneSearchFilter] = None,
135     minScoreLowerBound: Option[MinScoreLowerBoundSearchFilter] = None,
136     keywords: Option[KeywordsSearchFilter] = None,
137     submittedAsLanguages: Option[SubmittedAsLanguagesFilter] = None
138   ): Option[SearchFilters] = {
139 
140     Seq[Option[Any]](
141       proposals,
142       initialProposal,
143       tags,
144       labels,
145       operation,
146       question,
147       content,
148       status,
149       slug,
150       context,
151       idea,
152       languages,
153       country,
154       user,
155       minVotesCount,
156       toEnrich,
157       isAnonymous,
158       minScore,
159       createdAt,
160       sequencePool,
161       sequenceSegmentPool,
162       operationKinds,
163       questionIsOpen,
164       segment,
165       userTypes,
166       proposalTypes,
167       zone,
168       segmentZone,
169       minScoreLowerBound,
170       keywords,
171       submittedAsLanguages
172     ).flatten match {
173       case Seq() => None
174       case _ =>
175         Some(
176           SearchFilters(
177             proposals,
178             initialProposal,
179             tags,
180             labels,
181             operation,
182             question,
183             content,
184             status,
185             context,
186             slug,
187             idea,
188             languages,
189             country,
190             user,
191             minVotesCount,
192             toEnrich,
193             isAnonymous,
194             minScore,
195             createdAt,
196             sequencePool,
197             sequenceSegmentPool,
198             operationKinds,
199             questionIsOpen,
200             segment,
201             userTypes,
202             proposalTypes,
203             zone,
204             segmentZone,
205             minScoreLowerBound,
206             keywords,
207             submittedAsLanguages
208           )
209         )
210     }
211   }
212 
213   def merge(base: Option[SearchFilters], fallback: Option[SearchFilters]): Option[SearchFilters] =
214     parse(
215       base.flatMap(_.proposal).orElse(fallback.flatMap(_.proposal)),
216       base.flatMap(_.initialProposal).orElse(fallback.flatMap(_.initialProposal)),
217       base.flatMap(_.tags).orElse(fallback.flatMap(_.tags)),
218       base.flatMap(_.labels).orElse(fallback.flatMap(_.labels)),
219       base.flatMap(_.operation).orElse(fallback.flatMap(_.operation)),
220       base.flatMap(_.question).orElse(fallback.flatMap(_.question)),
221       base.flatMap(_.content).orElse(fallback.flatMap(_.content)),
222       base.flatMap(_.status).orElse(fallback.flatMap(_.status)),
223       base.flatMap(_.slug).orElse(fallback.flatMap(_.slug)),
224       base.flatMap(_.context).orElse(fallback.flatMap(_.context)),
225       base.flatMap(_.idea).orElse(fallback.flatMap(_.idea)),
226       base.flatMap(_.languages).orElse(fallback.flatMap(_.languages)),
227       base.flatMap(_.country).orElse(fallback.flatMap(_.country)),
228       base.flatMap(_.users).orElse(fallback.flatMap(_.users)),
229       base.flatMap(_.minVotesCount).orElse(fallback.flatMap(_.minVotesCount)),
230       base.flatMap(_.toEnrich).orElse(fallback.flatMap(_.toEnrich)),
231       base.flatMap(_.isAnonymous).orElse(fallback.flatMap(_.isAnonymous)),
232       base.flatMap(_.minScore).orElse(fallback.flatMap(_.minScore)),
233       base.flatMap(_.createdAt).orElse(fallback.flatMap(_.createdAt)),
234       base.flatMap(_.sequencePool).orElse(fallback.flatMap(_.sequencePool)),
235       base.flatMap(_.sequenceSegmentPool).orElse(fallback.flatMap(_.sequenceSegmentPool)),
236       base.flatMap(_.operationKinds).orElse(fallback.flatMap(_.operationKinds)),
237       base.flatMap(_.questionIsOpen).orElse(fallback.flatMap(_.questionIsOpen)),
238       base.flatMap(_.segment).orElse(fallback.flatMap(_.segment)),
239       base.flatMap(_.userTypes).orElse(fallback.flatMap(_.userTypes)),
240       base.flatMap(_.proposalTypes).orElse(fallback.flatMap(_.proposalTypes)),
241       base.flatMap(_.zone).orElse(fallback.flatMap(_.zone)),
242       base.flatMap(_.segmentZone).orElse(fallback.flatMap(_.segmentZone)),
243       base.flatMap(_.minScoreLowerBound).orElse(fallback.flatMap(_.minScoreLowerBound)),
244       base.flatMap(_.keywords).orElse(fallback.flatMap(_.keywords)),
245       base.flatMap(_.submittedAsLanguages).orElse(fallback.flatMap(_.submittedAsLanguages))
246     )
247 
248   /**
249     * Build elasticsearch search filters from searchQuery
250     *
251     * @param searchQuery search query
252     * @return sequence of query definitions
253     */
254   def getSearchFilters(searchQuery: SearchQuery): Seq[Query] =
255     Seq(
256       buildProposalSearchFilter(searchQuery.filters),
257       buildInitialProposalSearchFilter(searchQuery.filters),
258       buildTagsSearchFilter(searchQuery.filters),
259       buildOperationSearchFilter(searchQuery.filters),
260       buildContentSearchFilter(searchQuery),
261       buildStatusSearchFilter(searchQuery.filters),
262       buildContextOperationSearchFilter(searchQuery.filters),
263       buildContextSourceSearchFilter(searchQuery.filters),
264       buildContextLocationSearchFilter(searchQuery.filters),
265       buildContextQuestionSlugSearchFilter(searchQuery.filters),
266       buildSlugSearchFilter(searchQuery.filters),
267       buildIdeaSearchFilter(searchQuery.filters),
268       buildLanguageSearchFilter(searchQuery.filters),
269       buildCountrySearchFilter(searchQuery.filters),
270       buildUserSearchFilter(searchQuery.filters),
271       buildQuestionSearchFilter(searchQuery.filters),
272       buildMinVotesCountSearchFilter(searchQuery.filters),
273       buildToEnrichSearchFilter(searchQuery.filters),
274       buildIsAnonymousSearchFilter(searchQuery.filters),
275       buildMinScoreSearchFilter(searchQuery.filters),
276       buildCreatedAtSearchFilter(searchQuery.filters),
277       buildSequencePoolSearchFilter(searchQuery.filters),
278       buildSequenceSegmentPoolSearchFilter(searchQuery.filters),
279       buildOperationKindSearchFilter(searchQuery.filters),
280       buildQuestionIsOpenSearchFilter(searchQuery.filters),
281       buildSegmentSearchFilter(searchQuery.filters),
282       buildUserTypesSearchFilter(searchQuery.filters),
283       buildProposalTypesSearchFilter(searchQuery.filters),
284       buildSegmentZoneSearchFilter(searchQuery.filters),
285       buildZoneSearchFilter(searchQuery.filters),
286       buildMinScoreLowerBoundSearchFilter(searchQuery.filters),
287       buildKeywordsSearchFilter(searchQuery.filters),
288       buildSubmittedAsLanguagesSearchFilter(searchQuery.filters)
289     ).flatten
290 
291   def getExcludeFilters(searchQuery: SearchQuery): Seq[Query] = {
292     Seq(buildProposalSearchFilter(searchQuery.excludes), buildIsAnonymousSearchFilter(searchQuery.excludes)).flatten
293   }
294 
295   def getSort(searchQuery: SearchQuery): Option[FieldSort] =
296     searchQuery.sort.flatMap { sort =>
297       sort.field.map { field =>
298         FieldSort(field = field, order = sort.mode.getOrElse(SortOrder.ASC))
299       }
300     }
301 
302   def getSkipSearch(searchQuery: SearchQuery): Int =
303     searchQuery.offset.fold(0)(_.extractInt)
304 
305   def getLimitSearch(searchQuery: SearchQuery): Int =
306     searchQuery.limit.fold(10)(_.extractInt) // TODO get default value from configurations
307 
308   def buildProposalSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
309     filters.flatMap {
310       _.proposal match {
311         case Some(ProposalSearchFilter(Seq(proposalId))) =>
312           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.id.field, proposalId.value))
313         case Some(ProposalSearchFilter(proposalIds)) =>
314           Some(ElasticApi.termsQuery(ProposalElasticsearchFieldName.id.field, proposalIds.map(_.value)))
315         case _ => None
316       }
317     }
318   }
319 
320   def buildQuestionSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
321     filters.flatMap {
322       _.question match {
323         case Some(QuestionSearchFilter(Seq(questionId))) =>
324           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.questionId.field, questionId.value))
325         case Some(QuestionSearchFilter(questionIds)) =>
326           Some(ElasticApi.termsQuery(ProposalElasticsearchFieldName.questionId.field, questionIds.map(_.value)))
327         case _ => None
328       }
329     }
330   }
331 
332   def buildUserSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
333     filters.flatMap {
334       _.users match {
335         case Some(UserSearchFilter(Seq(userId))) =>
336           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.authorUserId.field, userId.value))
337         case Some(UserSearchFilter(userIds)) =>
338           Some(ElasticApi.termsQuery(ProposalElasticsearchFieldName.authorUserId.field, userIds.map(_.value)))
339         case _ => None
340       }
341     }
342   }
343 
344   def buildInitialProposalSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
345     filters.flatMap {
346       _.initialProposal.map { initialProposal =>
347         ElasticApi.termQuery(
348           field = ProposalElasticsearchFieldName.initialProposal.field,
349           value = initialProposal.isInitialProposal
350         )
351       }
352     }
353   }
354 
355   def buildTagsSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
356     filters.flatMap {
357       _.tags match {
358         case Some(TagsSearchFilter(Seq(tagId))) =>
359           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.tagId.field, tagId.value))
360         case Some(TagsSearchFilter(tags)) =>
361           Some(ElasticApi.termsQuery(ProposalElasticsearchFieldName.tagId.field, tags.map(_.value)))
362         case _ => None
363       }
364     }
365   }
366 
367   def buildOperationSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
368     filters.flatMap {
369       _.operation match {
370         case Some(OperationSearchFilter(Seq(operationId))) =>
371           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.operationId.field, operationId.value))
372         case Some(OperationSearchFilter(operationIds)) =>
373           Some(
374             ElasticApi
375               .termsQuery(ProposalElasticsearchFieldName.operationId.field, operationIds.map(_.value))
376           )
377         case _ => None
378       }
379     }
380   }
381 
382   def buildContextOperationSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
383     val operationFilter: Option[Query] = for {
384       filters   <- filters
385       context   <- filters.context
386       operation <- context.operation
387     } yield ElasticApi.matchQuery(ProposalElasticsearchFieldName.contextOperation.field, operation.value)
388 
389     operationFilter
390   }
391 
392   def buildContextSourceSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
393     val sourceFilter: Option[Query] = for {
394       filters <- filters
395       context <- filters.context
396       source  <- context.source
397     } yield ElasticApi.matchQuery(ProposalElasticsearchFieldName.contextSource.field, source)
398 
399     sourceFilter
400   }
401 
402   def buildContextLocationSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
403     val locationFilter: Option[Query] = for {
404       filters  <- filters
405       context  <- filters.context
406       location <- context.location
407     } yield ElasticApi.matchQuery(ProposalElasticsearchFieldName.contextLocation.field, location)
408 
409     locationFilter
410   }
411 
412   def buildContextQuestionSlugSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
413     val questionFilter: Option[Query] = for {
414       filters  <- filters
415       context  <- filters.context
416       question <- context.questionSlug
417     } yield ElasticApi.matchQuery(ProposalElasticsearchFieldName.contextQuestionSlug.field, question)
418 
419     questionFilter
420   }
421 
422   def buildSlugSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
423     val slugFilter: Option[Query] = for {
424       filters    <- filters
425       slugFilter <- filters.slug
426     } yield ElasticApi.termQuery(ProposalElasticsearchFieldName.slug.field, slugFilter.slug)
427 
428     slugFilter
429   }
430 
431   def buildContentSearchFilter(searchQuery: SearchQuery): Option[Query] = {
432     def languageOmission(boostedLanguage: String): Double =
433       if (searchQuery.filters.flatMap(_.languages).forall(_.exists(_.language.value === boostedLanguage))) 1
434       else 0
435 
436     for {
437       filters                   <- searchQuery.filters
438       ContentSearchFilter(text) <- filters.content
439     } yield {
440       val fieldsBoosts =
441         Map(
442           ProposalElasticsearchFieldName.contentFr -> 2d * languageOmission("fr"),
443           ProposalElasticsearchFieldName.contentFrStemmed -> 1.5d * languageOmission("fr"),
444           ProposalElasticsearchFieldName.contentEn -> 2d * languageOmission("en"),
445           ProposalElasticsearchFieldName.contentEnStemmed -> 1.5d * languageOmission("en"),
446           ProposalElasticsearchFieldName.contentIt -> 2d * languageOmission("it"),
447           ProposalElasticsearchFieldName.contentItStemmed -> 1.5d * languageOmission("it"),
448           ProposalElasticsearchFieldName.contentDe -> 2d * languageOmission("de"),
449           ProposalElasticsearchFieldName.contentDeStemmed -> 1.5d * languageOmission("de"),
450           ProposalElasticsearchFieldName.contentBg -> 2d * languageOmission("bg"),
451           ProposalElasticsearchFieldName.contentBgStemmed -> 1.5d * languageOmission("bg"),
452           ProposalElasticsearchFieldName.contentCs -> 2d * languageOmission("cs"),
453           ProposalElasticsearchFieldName.contentCsStemmed -> 1.5d * languageOmission("cs"),
454           ProposalElasticsearchFieldName.contentDa -> 2d * languageOmission("da"),
455           ProposalElasticsearchFieldName.contentDaStemmed -> 1.5d * languageOmission("da"),
456           ProposalElasticsearchFieldName.contentNl -> 2d * languageOmission("nl"),
457           ProposalElasticsearchFieldName.contentNlStemmed -> 1.5d * languageOmission("nl"),
458           ProposalElasticsearchFieldName.contentFi -> 2d * languageOmission("fi"),
459           ProposalElasticsearchFieldName.contentFiStemmed -> 1.5d * languageOmission("fi"),
460           ProposalElasticsearchFieldName.contentEl -> 2d * languageOmission("el"),
461           ProposalElasticsearchFieldName.contentElStemmed -> 1.5d * languageOmission("el"),
462           ProposalElasticsearchFieldName.contentHu -> 2d * languageOmission("hu"),
463           ProposalElasticsearchFieldName.contentHuStemmed -> 1.5d * languageOmission("hu"),
464           ProposalElasticsearchFieldName.contentLv -> 2d * languageOmission("lv"),
465           ProposalElasticsearchFieldName.contentLvStemmed -> 1.5d * languageOmission("lv"),
466           ProposalElasticsearchFieldName.contentLt -> 2d * languageOmission("lt"),
467           ProposalElasticsearchFieldName.contentLtStemmed -> 1.5d * languageOmission("lt"),
468           ProposalElasticsearchFieldName.contentPt -> 2d * languageOmission("pt"),
469           ProposalElasticsearchFieldName.contentPtStemmed -> 1.5d * languageOmission("pt"),
470           ProposalElasticsearchFieldName.contentRo -> 2d * languageOmission("ro"),
471           ProposalElasticsearchFieldName.contentRoStemmed -> 1.5d * languageOmission("ro"),
472           ProposalElasticsearchFieldName.contentEs -> 2d * languageOmission("es"),
473           ProposalElasticsearchFieldName.contentEsStemmed -> 1.5d * languageOmission("es"),
474           ProposalElasticsearchFieldName.contentSv -> 2d * languageOmission("sv"),
475           ProposalElasticsearchFieldName.contentSvStemmed -> 1.5d * languageOmission("sv"),
476           ProposalElasticsearchFieldName.contentPl -> 2d * languageOmission("pl"),
477           ProposalElasticsearchFieldName.contentPlStemmed -> 1.5d * languageOmission("pl"),
478           ProposalElasticsearchFieldName.contentHr -> 2d * languageOmission("hr"),
479           ProposalElasticsearchFieldName.contentEt -> 2d * languageOmission("et"),
480           ProposalElasticsearchFieldName.contentMt -> 2d * languageOmission("mt"),
481           ProposalElasticsearchFieldName.contentSk -> 2d * languageOmission("sk"),
482           ProposalElasticsearchFieldName.contentSl -> 2d * languageOmission("sl"),
483           ProposalElasticsearchFieldName.contentUk -> 2d * languageOmission("uk")
484         ).filter { case (_, boost) => boost != 0 }.map { case (field, boost) => (field.field, boost) }
485       functionScoreQuery(multiMatchQuery(text).fields(fieldsBoosts).fuzziness("Auto:4,7").operator(Operator.AND))
486         .functions(
487           WeightScore(
488             weight = 2d,
489             filter = Some(MatchQuery(field = ProposalElasticsearchFieldName.questionIsOpen.field, value = true))
490           )
491         )
492 
493     }
494   }
495 
496   def buildStatusSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
497     val query: Option[Query] = filters.flatMap {
498       _.status.map {
499         case StatusSearchFilter(Seq(proposalStatus)) =>
500           ElasticApi.termQuery(ProposalElasticsearchFieldName.status.field, proposalStatus.value)
501         case StatusSearchFilter(proposalStatuses) =>
502           ElasticApi.termsQuery(ProposalElasticsearchFieldName.status.field, proposalStatuses.map(_.value))
503       }
504     }
505 
506     query match {
507       case None =>
508         Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.status.field, ProposalStatus.Accepted.value))
509       case _ => query
510     }
511   }
512 
513   def buildIdeaSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
514     filters.flatMap {
515       _.idea match {
516         case Some(IdeaSearchFilter(Seq(idea))) =>
517           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.ideaId.field, idea.value))
518         case Some(IdeaSearchFilter(ideas)) =>
519           Some(ElasticApi.termsQuery(ProposalElasticsearchFieldName.ideaId.field, ideas.map(_.value)))
520         case _ => None
521       }
522     }
523   }
524 
525   def buildLanguageSearchFilter(filters: Option[SearchFilters]): Option[Query] =
526     filters
527       .flatMap(_.languages)
528       .map(_.map(_.language.value).toList)
529       .map(ElasticApi.termsQuery(ProposalElasticsearchFieldName.language.field, _))
530 
531   def buildCountrySearchFilter(filters: Option[SearchFilters]): Option[Query] = {
532     filters.flatMap {
533       _.country match {
534         case Some(CountrySearchFilter(country)) =>
535           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.questionCountries.field, country.value))
536         case _ => None
537       }
538     }
539   }
540 
541   def buildMinVotesCountSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
542     filters.flatMap {
543       _.minVotesCount match {
544         case Some(MinVotesCountSearchFilter(minVotesCount)) =>
545           Some(ElasticApi.rangeQuery(ProposalElasticsearchFieldName.votesCount.field).gte(minVotesCount))
546         case _ => None
547       }
548     }
549   }
550 
551   def buildToEnrichSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
552     filters.flatMap {
553       _.toEnrich match {
554         case Some(ToEnrichSearchFilter(toEnrich)) =>
555           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.toEnrich.field, toEnrich))
556         case _ => None
557       }
558     }
559   }
560 
561   def buildIsAnonymousSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
562     filters.flatMap {
563       _.isAnonymous match {
564         case Some(IsAnonymousSearchFiler(isAnonymous)) =>
565           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.isAnonymous.field, isAnonymous))
566         case _ => None
567       }
568     }
569   }
570 
571   def buildMinScoreSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
572     filters.flatMap {
573       _.minScore match {
574         case Some(MinScoreSearchFilter(minScore)) =>
575           Some(ElasticApi.rangeQuery(ProposalElasticsearchFieldName.scoreUpperBound.field).gte(minScore))
576         case _ => None
577       }
578     }
579   }
580 
581   def buildCreatedAtSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
582     filters.flatMap {
583       _.createdAt match {
584         case Some(CreatedAtSearchFilter(maybeBefore, maybeAfter)) =>
585           val createdAtRangeQuery: RangeQuery = ElasticApi.rangeQuery(ProposalElasticsearchFieldName.createdAt.field)
586           val dateFormatter: DateTimeFormatter =
587             DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").withZone(ZoneOffset.UTC)
588           (
589             maybeBefore.map(before => before.format(dateFormatter)),
590             maybeAfter.map(after   => after.format(dateFormatter))
591           ) match {
592             case (Some(before), Some(after)) => Some(createdAtRangeQuery.lt(before).gt(after))
593             case (Some(before), None)        => Some(createdAtRangeQuery.lt(before))
594             case (None, Some(after))         => Some(createdAtRangeQuery.gte(after))
595             case _                           => None
596           }
597         case _ => None
598       }
599     }
600   }
601 
602   def buildSequencePoolSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
603     filters.flatMap {
604       _.sequencePool match {
605         case Some(SequencePoolSearchFilter(sequencePool)) =>
606           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.sequencePool.field, sequencePool.value))
607         case _ => None
608       }
609     }
610   }
611 
612   def buildSequenceSegmentPoolSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
613     filters.flatMap {
614       _.sequenceSegmentPool match {
615         case Some(SequencePoolSearchFilter(sequencePool)) =>
616           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.sequenceSegmentPool.field, sequencePool.value))
617         case _ => None
618       }
619     }
620   }
621 
622 //TODO: To avoid a pattern matching to precise, can't we just use `termsQuery` ?
623   def buildOperationKindSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
624     filters.flatMap {
625       _.operationKinds match {
626         case Some(OperationKindsSearchFilter(Seq(operationKind))) =>
627           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.operationKind.field, operationKind.value))
628         case Some(OperationKindsSearchFilter(operationKinds)) =>
629           Some(ElasticApi.termsQuery(ProposalElasticsearchFieldName.operationKind.field, operationKinds.map(_.value)))
630         case _ => None
631       }
632     }
633   }
634 
635   def buildQuestionIsOpenSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
636     filters.flatMap {
637       _.questionIsOpen match {
638         case Some(QuestionIsOpenSearchFilter(isOpen)) =>
639           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.questionIsOpen.field, isOpen))
640         case _ => None
641       }
642     }
643   }
644 
645   def buildSegmentSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
646     filters.flatMap {
647       _.segment match {
648         case Some(SegmentSearchFilter(segment)) =>
649           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.segment.field, segment))
650         case _ => None
651       }
652     }
653   }
654 
655   def buildUserTypesSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
656     filters.flatMap {
657       _.userTypes match {
658         case Some(UserTypesSearchFilter(Seq(userType))) =>
659           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.authorUserType.field, userType.value))
660         case Some(UserTypesSearchFilter(userTypes)) =>
661           Some(ElasticApi.termsQuery(ProposalElasticsearchFieldName.authorUserType.field, userTypes.map(_.value)))
662         case _ => None
663       }
664     }
665   }
666 
667   def buildProposalTypesSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
668     filters.flatMap {
669       _.proposalTypes match {
670         case Some(ProposalTypesSearchFilter(Seq(proposalType))) =>
671           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.proposalType.field, proposalType.value))
672         case Some(ProposalTypesSearchFilter(proposalTypes)) =>
673           Some(ElasticApi.termsQuery(ProposalElasticsearchFieldName.proposalType.field, proposalTypes.map(_.value)))
674         case _ => None
675       }
676     }
677   }
678 
679   def buildZoneSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
680     filters.flatMap {
681       _.zone match {
682         case Some(ZoneSearchFilter(zone)) =>
683           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.zone.field, zone.value))
684         case _ => None
685       }
686     }
687   }
688 
689   def buildSegmentZoneSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
690     filters.flatMap {
691       _.segmentZone match {
692         case Some(ZoneSearchFilter(zone)) =>
693           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.segmentZone.field, zone.value))
694         case _ => None
695       }
696     }
697   }
698 
699   def buildMinScoreLowerBoundSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
700     filters.flatMap {
701       _.minScoreLowerBound match {
702         case Some(MinScoreLowerBoundSearchFilter(minLowerBound)) =>
703           Some(ElasticApi.rangeQuery(ProposalElasticsearchFieldName.scoreLowerBound.field).gte(minLowerBound))
704         case _ => None
705       }
706     }
707   }
708 
709   def buildKeywordsSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
710     filters.flatMap {
711       _.keywords match {
712         case Some(KeywordsSearchFilter(Seq(keywordKey))) =>
713           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.keywordKey.field, keywordKey.value))
714         case Some(KeywordsSearchFilter(keywordsKeys)) =>
715           Some(ElasticApi.termsQuery(ProposalElasticsearchFieldName.keywordKey.field, keywordsKeys.map(_.value)))
716         case _ => None
717       }
718     }
719   }
720 
721   def buildSubmittedAsLanguagesSearchFilter(filters: Option[SearchFilters]): Option[Query] = {
722     filters.flatMap {
723       _.submittedAsLanguages match {
724         case Some(SubmittedAsLanguagesFilter(Seq(language))) =>
725           Some(ElasticApi.termQuery(ProposalElasticsearchFieldName.language.field, language.value))
726         case Some(SubmittedAsLanguagesFilter(language)) =>
727           Some(ElasticApi.termsQuery(ProposalElasticsearchFieldName.language.field, language.map(_.value)))
728         case _ => None
729       }
730     }
731   }
732 }
733 
734 final case class ProposalSearchFilter(proposalIds: Seq[ProposalId])
735 
736 final case class UserSearchFilter(userIds: Seq[UserId])
737 
738 final case class InitialProposalFilter(isInitialProposal: Boolean)
739 
740 final case class QuestionSearchFilter(questionIds: Seq[QuestionId])
741 
742 final case class TagsSearchFilter(tagIds: Seq[TagId]) {
743   validate(validateField("tagIds", "mandatory", tagIds.nonEmpty, "ids cannot be empty in tag search filters"))
744 }
745 
746 final case class LabelsSearchFilter(labelIds: Seq[LabelId]) {
747   validate(validateField("labelIds", "mandatory", labelIds.nonEmpty, "ids cannot be empty in label search filters"))
748 }
749 
750 final case class OperationSearchFilter(operationIds: Seq[OperationId])
751 
752 final case class CreatedAtSearchFilter(before: Option[ZonedDateTime], after: Option[ZonedDateTime])
753 
754 final case class ContentSearchFilter(text: String)
755 
756 final case class StatusSearchFilter(status: Seq[ProposalStatus])
757 
758 final case class ContextSearchFilter(
759   operation: Option[OperationId] = None,
760   source: Option[String] = None,
761   location: Option[String] = None,
762   questionSlug: Option[String] = None
763 )
764 
765 final case class SlugSearchFilter(slug: String)
766 
767 final case class IdeaSearchFilter(ideaIds: Seq[IdeaId])
768 
769 final case class Limit(value: Int)
770 
771 final case class Skip(value: Int)
772 
773 final case class CountrySearchFilter(country: Country)
774 final case class LanguageSearchFilter(language: Language)
775 final case class MinVotesCountSearchFilter(minVotesCount: Int)
776 final case class ToEnrichSearchFilter(toEnrich: Boolean)
777 final case class IsAnonymousSearchFiler(isAnonymous: Boolean)
778 final case class MinScoreSearchFilter(minScore: Double)
779 final case class SequencePoolSearchFilter(sequencePool: SequencePool)
780 final case class OperationKindsSearchFilter(kinds: Seq[OperationKind])
781 final case class QuestionIsOpenSearchFilter(isOpen: Boolean)
782 final case class SegmentSearchFilter(segment: String)
783 final case class UserTypesSearchFilter(userTypes: Seq[UserType])
784 final case class ProposalTypesSearchFilter(proposalTypes: Seq[ProposalType])
785 final case class ZoneSearchFilter(zone: Zone)
786 final case class MinScoreLowerBoundSearchFilter(minLowerBound: Double)
787 final case class KeywordsSearchFilter(keywordsKeys: Seq[ProposalKeywordKey])
788 final case class SubmittedAsLanguagesFilter(submittedAsLanguages: Seq[Language])