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
21 package operation
22 
23 import java.time.{ZoneOffset, ZonedDateTime}
24 import java.time.format.DateTimeFormatter
25 import cats.data.NonEmptyList
26 import com.sksamuel.elastic4s.{ElasticApi, ElasticDsl}
27 import com.sksamuel.elastic4s.requests.common.Operator
28 import com.sksamuel.elastic4s.requests.searches.queries.{Query, RangeQuery}
29 import com.sksamuel.elastic4s.requests.searches.sort.{FieldSort, SortOrder}
30 import com.sksamuel.elastic4s.requests.searches.suggestion.Fuzziness
31 import org.make.core.technical.Pagination
32 import org.make.core.operation.indexed.OperationOfQuestionElasticsearchFieldName
33 import org.make.core.question.QuestionId
34 import org.make.core.reference.{Country, Language}
35 
36 final case class OperationOfQuestionSearchQuery(
37   filters: Option[OperationOfQuestionSearchFilters] = None,
38   limit: Option[Pagination.Limit] = None,
39   offset: Option[Pagination.Offset] = None,
40   sort: Option[OperationOfQuestionElasticsearchFieldName] = None,
41   order: Option[Order] = None,
42   sortAlgorithm: Option[SortAlgorithm] = None
43 )
44 
45 final case class OperationOfQuestionSearchFilters(
46   questionIds: Option[QuestionIdsSearchFilter] = None,
47   question: Option[QuestionContentSearchFilter] = None,
48   slug: Option[SlugSearchFilter] = None,
49   description: Option[DescriptionSearchFilter] = None,
50   country: Option[CountrySearchFilter] = None,
51   language: Option[LanguageSearchFilter] = None,
52   startDate: Option[StartDateSearchFilter] = None,
53   endDate: Option[EndDateSearchFilter] = None,
54   operationKinds: Option[OperationKindsSearchFilter] = None,
55   featured: Option[FeaturedSearchFilter] = None,
56   status: Option[StatusSearchFilter] = None,
57   hasResults: Option[HasResultsSearchFilter.type] = None
58 )
59 
60 object OperationOfQuestionSearchFilters extends ElasticDsl {
61 
62   def parse(
63     questionIds: Option[QuestionIdsSearchFilter],
64     question: Option[QuestionContentSearchFilter],
65     slug: Option[SlugSearchFilter] = None,
66     description: Option[DescriptionSearchFilter] = None,
67     country: Option[CountrySearchFilter] = None,
68     language: Option[LanguageSearchFilter] = None,
69     startDate: Option[StartDateSearchFilter] = None,
70     endDate: Option[EndDateSearchFilter] = None,
71     operationKind: Option[OperationKindsSearchFilter] = None,
72     featured: Option[FeaturedSearchFilter] = None,
73     status: Option[StatusSearchFilter] = None
74   ): Option[OperationOfQuestionSearchFilters] = {
75     (questionIds, question, slug, description, country, language, startDate, endDate, operationKind, featured, status) match {
76       case (None, None, None, None, None, None, None, None, None, None, None) => None
77       case _ =>
78         Some(
79           OperationOfQuestionSearchFilters(
80             questionIds,
81             question,
82             slug,
83             description,
84             country,
85             language,
86             startDate,
87             endDate,
88             operationKind,
89             featured,
90             status
91           )
92         )
93     }
94   }
95 
96   def getOperationOfQuestionSearchFilters(
97     operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery
98   ): Seq[Query] = {
99     Seq(
100       buildQuestionIdsSearchFilter(operationOfQuestionSearchQuery),
101       buildQuestionContentSearchFilter(operationOfQuestionSearchQuery),
102       buildSlugSearchFilter(operationOfQuestionSearchQuery),
103       buildCountrySearchFilter(operationOfQuestionSearchQuery),
104       buildLanguageSearchFilter(operationOfQuestionSearchQuery),
105       buildStartDateSearchFilter(operationOfQuestionSearchQuery),
106       buildEndDateSearchFilter(operationOfQuestionSearchQuery),
107       buildOperationKindSearchFilter(operationOfQuestionSearchQuery),
108       buildFeaturedSearchFilter(operationOfQuestionSearchQuery),
109       buildStatusSearchFilter(operationOfQuestionSearchQuery),
110       buildHasResultsSearchFilter(operationOfQuestionSearchQuery)
111     ).flatten
112   }
113 
114   def getSkipSearch(operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery): Int =
115     operationOfQuestionSearchQuery.offset.fold(0)(_.extractInt)
116 
117   def getLimitSearch(operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery): Int =
118     operationOfQuestionSearchQuery.limit.fold(10)(_.extractInt)
119 
120   def getSort(operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery): Option[FieldSort] = {
121     val order = operationOfQuestionSearchQuery.order.map(_.sortOrder)
122 
123     operationOfQuestionSearchQuery.sort.map { sort =>
124       val sortFieldName = if (sort == OperationOfQuestionElasticsearchFieldName.question) {
125         OperationOfQuestionElasticsearchFieldName.questionKeyword
126       } else {
127         sort
128       }
129       FieldSort(field = sortFieldName.field, order = order.getOrElse(SortOrder.Asc))
130     }
131   }
132 
133   def buildQuestionIdsSearchFilter(operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery): Option[Query] = {
134     operationOfQuestionSearchQuery.filters.flatMap {
135       _.questionIds match {
136         case Some(QuestionIdsSearchFilter(Seq(questionId))) =>
137           Some(ElasticApi.termQuery(OperationOfQuestionElasticsearchFieldName.questionId.field, questionId.value))
138         case Some(QuestionIdsSearchFilter(questionIds)) =>
139           Some(
140             ElasticApi.termsQuery(OperationOfQuestionElasticsearchFieldName.questionId.field, questionIds.map(_.value))
141           )
142         case _ => None
143       }
144     }
145   }
146 
147   def buildQuestionContentSearchFilter(
148     operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery
149   ): Option[Query] = {
150     def languageOmission(boostedLanguage: String): Double =
151       if (operationOfQuestionSearchQuery.filters.flatMap(_.language).forall(_.language == Language(boostedLanguage))) 1
152       else 0
153 
154     val query: Option[Query] = for {
155       filters                              <- operationOfQuestionSearchQuery.filters
156       QuestionContentSearchFilter(text, _) <- filters.question
157     } yield {
158       val fieldsBoosts: Map[String, Double] =
159         Map(
160           OperationOfQuestionElasticsearchFieldName.questionFr -> 2d * languageOmission("fr"),
161           OperationOfQuestionElasticsearchFieldName.questionFrStemmed -> 1.5d * languageOmission("fr"),
162           OperationOfQuestionElasticsearchFieldName.questionEn -> 2d * languageOmission("en"),
163           OperationOfQuestionElasticsearchFieldName.questionEnStemmed -> 1.5d * languageOmission("en"),
164           OperationOfQuestionElasticsearchFieldName.questionIt -> 2d * languageOmission("it"),
165           OperationOfQuestionElasticsearchFieldName.questionItStemmed -> 1.5d * languageOmission("it"),
166           OperationOfQuestionElasticsearchFieldName.questionDe -> 2d * languageOmission("de"),
167           OperationOfQuestionElasticsearchFieldName.questionDeStemmed -> 1.5d * languageOmission("de"),
168           OperationOfQuestionElasticsearchFieldName.questionBg -> 2d * languageOmission("bg"),
169           OperationOfQuestionElasticsearchFieldName.questionBgStemmed -> 1.5d * languageOmission("bg"),
170           OperationOfQuestionElasticsearchFieldName.questionCs -> 2d * languageOmission("cs"),
171           OperationOfQuestionElasticsearchFieldName.questionCsStemmed -> 1.5d * languageOmission("cs"),
172           OperationOfQuestionElasticsearchFieldName.questionDa -> 2d * languageOmission("da"),
173           OperationOfQuestionElasticsearchFieldName.questionDaStemmed -> 1.5d * languageOmission("da"),
174           OperationOfQuestionElasticsearchFieldName.questionNl -> 2d * languageOmission("nl"),
175           OperationOfQuestionElasticsearchFieldName.questionNlStemmed -> 1.5d * languageOmission("nl"),
176           OperationOfQuestionElasticsearchFieldName.questionFi -> 2d * languageOmission("fi"),
177           OperationOfQuestionElasticsearchFieldName.questionFiStemmed -> 1.5d * languageOmission("fi"),
178           OperationOfQuestionElasticsearchFieldName.questionEl -> 2d * languageOmission("el"),
179           OperationOfQuestionElasticsearchFieldName.questionElStemmed -> 1.5d * languageOmission("el"),
180           OperationOfQuestionElasticsearchFieldName.questionHu -> 2d * languageOmission("hu"),
181           OperationOfQuestionElasticsearchFieldName.questionHuStemmed -> 1.5d * languageOmission("hu"),
182           OperationOfQuestionElasticsearchFieldName.questionLv -> 2d * languageOmission("lv"),
183           OperationOfQuestionElasticsearchFieldName.questionLvStemmed -> 1.5d * languageOmission("lv"),
184           OperationOfQuestionElasticsearchFieldName.questionLt -> 2d * languageOmission("lt"),
185           OperationOfQuestionElasticsearchFieldName.questionLtStemmed -> 1.5d * languageOmission("lt"),
186           OperationOfQuestionElasticsearchFieldName.questionPt -> 2d * languageOmission("pt"),
187           OperationOfQuestionElasticsearchFieldName.questionPtStemmed -> 1.5d * languageOmission("pt"),
188           OperationOfQuestionElasticsearchFieldName.questionRo -> 2d * languageOmission("ro"),
189           OperationOfQuestionElasticsearchFieldName.questionRoStemmed -> 1.5d * languageOmission("ro"),
190           OperationOfQuestionElasticsearchFieldName.questionEs -> 2d * languageOmission("es"),
191           OperationOfQuestionElasticsearchFieldName.questionEsStemmed -> 1.5d * languageOmission("es"),
192           OperationOfQuestionElasticsearchFieldName.questionSv -> 2d * languageOmission("sv"),
193           OperationOfQuestionElasticsearchFieldName.questionSvStemmed -> 1.5d * languageOmission("sv"),
194           OperationOfQuestionElasticsearchFieldName.questionPl -> 2d * languageOmission("pl"),
195           OperationOfQuestionElasticsearchFieldName.questionPlStemmed -> 1.5d * languageOmission("pl"),
196           OperationOfQuestionElasticsearchFieldName.questionHr -> 2d * languageOmission("hr"),
197           OperationOfQuestionElasticsearchFieldName.questionEt -> 2d * languageOmission("et"),
198           OperationOfQuestionElasticsearchFieldName.questionMt -> 2d * languageOmission("mt"),
199           OperationOfQuestionElasticsearchFieldName.questionSk -> 2d * languageOmission("sk"),
200           OperationOfQuestionElasticsearchFieldName.questionSl -> 2d * languageOmission("sl"),
201           OperationOfQuestionElasticsearchFieldName.questionUk -> 2d * languageOmission("uk")
202         ).filter { case (_, boost) => boost != 0 }.map { case (field, boost) => (field.field, boost) }
203       multiMatchQuery(text).fields(fieldsBoosts).fuzziness("Auto:4,7").operator(Operator.AND)
204     }
205 
206     query
207   }
208 
209   def buildSlugSearchFilter(operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery): Option[Query] = {
210     operationOfQuestionSearchQuery.filters.flatMap {
211       _.slug match {
212         case Some(SlugSearchFilter(slug)) =>
213           Some(ElasticApi.wildcardQuery(OperationOfQuestionElasticsearchFieldName.slug.field, s"*$slug*"))
214         case None => None
215       }
216     }
217   }
218 
219   def buildCountrySearchFilter(operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery): Option[Query] = {
220     operationOfQuestionSearchQuery.filters.flatMap {
221       _.country match {
222         case Some(CountrySearchFilter(country)) =>
223           Some(ElasticApi.termsQuery(OperationOfQuestionElasticsearchFieldName.countries.field, country.value))
224         case _ => None
225       }
226     }
227   }
228 
229   def buildLanguageSearchFilter(operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery): Option[Query] = {
230     operationOfQuestionSearchQuery.filters.flatMap {
231       _.language match {
232         case Some(LanguageSearchFilter(language)) =>
233           Some(ElasticApi.termsQuery(OperationOfQuestionElasticsearchFieldName.languages.field, language.value))
234         case _ => None
235       }
236     }
237   }
238 
239   private def dateRangeQuery(
240     fieldName: String,
241     lte: Option[ZonedDateTime],
242     gte: Option[ZonedDateTime]
243   ): Option[RangeQuery] = {
244     val dateFormatter: DateTimeFormatter =
245       DateTimeFormatter.ofPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'").withZone(ZoneOffset.UTC)
246     val query = ElasticApi.rangeQuery(fieldName)
247     (lte.map(_.format(dateFormatter)), gte.map(_.format(dateFormatter))) match {
248       case (Some(l), Some(g)) => Some(query.lte(l).gte(g))
249       case (Some(l), None)    => Some(query.lte(l))
250       case (None, Some(g))    => Some(query.gte(g))
251       case (None, None)       => None
252     }
253   }
254 
255   def buildStartDateSearchFilter(operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery): Option[Query] = {
256     operationOfQuestionSearchQuery.filters.flatMap {
257       _.startDate match {
258         case Some(StartDateSearchFilter(lte, gte)) =>
259           dateRangeQuery(OperationOfQuestionElasticsearchFieldName.startDate.field, lte, gte)
260         case None => None
261       }
262     }
263   }
264 
265   def buildEndDateSearchFilter(operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery): Option[Query] = {
266     operationOfQuestionSearchQuery.filters.flatMap {
267       _.endDate match {
268         case Some(EndDateSearchFilter(lte, gte)) =>
269           dateRangeQuery(OperationOfQuestionElasticsearchFieldName.endDate.field, lte, gte)
270         case None => None
271       }
272     }
273   }
274 
275   def buildOperationKindSearchFilter(operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery): Option[Query] = {
276     operationOfQuestionSearchQuery.filters.flatMap {
277       _.operationKinds match {
278         case Some(OperationKindsSearchFilter(Seq(operationKind))) =>
279           Some(ElasticApi.termQuery(OperationOfQuestionElasticsearchFieldName.operationKind.field, operationKind.value))
280         case Some(OperationKindsSearchFilter(operationKinds)) =>
281           Some(
282             ElasticApi
283               .termsQuery(OperationOfQuestionElasticsearchFieldName.operationKind.field, operationKinds.map(_.value))
284           )
285         case None =>
286           Some(
287             ElasticApi.termsQuery(
288               OperationOfQuestionElasticsearchFieldName.operationKind.field,
289               OperationKind.publicKinds.map(_.value)
290             )
291           )
292       }
293     }
294   }
295 
296   def buildFeaturedSearchFilter(operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery): Option[Query] = {
297     operationOfQuestionSearchQuery.filters.flatMap {
298       _.featured match {
299         case Some(FeaturedSearchFilter(featured)) =>
300           Some(ElasticApi.termQuery(OperationOfQuestionElasticsearchFieldName.featured.field, featured))
301         case _ => None
302       }
303     }
304   }
305 
306   def buildStatusSearchFilter(operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery): Option[Query] = {
307     operationOfQuestionSearchQuery.filters.flatMap {
308       _.status match {
309         case Some(StatusSearchFilter(NonEmptyList(status, Nil))) =>
310           Some(
311             ElasticApi.termQuery(OperationOfQuestionElasticsearchFieldName.status.field, status.entryName.toLowerCase)
312           )
313         case Some(StatusSearchFilter(statuses)) =>
314           Some(
315             ElasticApi.termsQuery(
316               OperationOfQuestionElasticsearchFieldName.status.field,
317               statuses.map(_.entryName.toLowerCase).toList
318             )
319           )
320         case _ => None
321       }
322     }
323   }
324 
325   def buildHasResultsSearchFilter(operationOfQuestionSearchQuery: OperationOfQuestionSearchQuery): Option[Query] = {
326     operationOfQuestionSearchQuery.filters.flatMap {
327       _.hasResults match {
328         case Some(HasResultsSearchFilter) =>
329           Some(ElasticApi.existsQuery(OperationOfQuestionElasticsearchFieldName.resultsLink.field))
330         case _ => None
331       }
332     }
333   }
334 
335 }
336 
337 final case class QuestionIdsSearchFilter(questionIds: Seq[QuestionId])
338 final case class QuestionContentSearchFilter(text: String, fuzzy: Option[Fuzziness] = None)
339 final case class SlugSearchFilter(slug: String)
340 final case class DescriptionSearchFilter(description: String)
341 final case class CountrySearchFilter(country: Country)
342 final case class LanguageSearchFilter(language: Language)
343 final case class StartDateSearchFilter(lte: Option[ZonedDateTime], gte: Option[ZonedDateTime])
344 final case class EndDateSearchFilter(lte: Option[ZonedDateTime], gte: Option[ZonedDateTime])
345 final case class OperationKindsSearchFilter(operationKinds: Seq[OperationKind])
346 final case class FeaturedSearchFilter(featured: Boolean)
347 case object HasResultsSearchFilter
348 final case class StatusSearchFilter(status: NonEmptyList[OperationOfQuestion.Status])
349 
350 object StatusSearchFilter {
351   def apply(head: OperationOfQuestion.Status, tail: OperationOfQuestion.Status*): StatusSearchFilter =
352     StatusSearchFilter(NonEmptyList.of(head, tail: _*))
353 }