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 idea
22 
23 import com.sksamuel.elastic4s.{ElasticApi, ElasticDsl}
24 import com.sksamuel.elastic4s.requests.searches.queries.Query
25 import com.sksamuel.elastic4s.requests.searches.sort.{FieldSort, SortOrder}
26 import com.sksamuel.elastic4s.requests.searches.suggestion.Fuzziness
27 import org.make.core.technical.Pagination
28 import org.make.core.idea.indexed.IdeaElasticsearchFieldNames
29 import org.make.core.operation.OperationId
30 import org.make.core.question.QuestionId
31 import org.make.core.reference.Language
32 
33 /**
34   * The class holding the entire search query
35   *
36   * @param filters idea of search filters
37   * @param limit   number of items to fetch
38   * @param offset  number of items to skip
39   */
40 final case class IdeaSearchQuery(
41   filters: Option[IdeaSearchFilters] = None,
42   limit: Option[Pagination.Limit] = None,
43   offset: Option[Pagination.Offset] = None,
44   sort: Option[String] = None,
45   order: Option[Order] = None,
46   language: Option[Language] = None
47 )
48 
49 /**
50   * The class holding the filters
51   *
52   * @param name        Name to search into idea
53   * @param questionId  The questionId to filter
54   */
55 final case class IdeaSearchFilters(
56   name: Option[NameSearchFilter] = None,
57   questionId: Option[QuestionIdSearchFilter] = None,
58   status: Option[StatusSearchFilter] = None
59 )
60 
61 object IdeaSearchFilters extends ElasticDsl {
62 
63   def parse(
64     name: Option[NameSearchFilter] = None,
65     questionId: Option[QuestionIdSearchFilter] = None
66   ): Option[IdeaSearchFilters] = {
67 
68     (name, questionId) match {
69       case (None, None) => None
70       case _ =>
71         Some(IdeaSearchFilters(name, questionId))
72     }
73   }
74 
75   /**
76     * Build elasticsearch search filters from searchQuery
77     *
78     * @param ideaSearchQuery search query
79     *
80     * @return sequence of query definitions
81     */
82   def getIdeaSearchFilters(ideaSearchQuery: IdeaSearchQuery): Seq[Query] =
83     Seq(
84       buildNameSearchFilter(ideaSearchQuery),
85       buildQuestionIdSearchFilter(ideaSearchQuery),
86       buildStatusSearchFilter(ideaSearchQuery)
87     ).flatten
88 
89   def getSkipSearch(ideaSearchQuery: IdeaSearchQuery): Int =
90     ideaSearchQuery.offset.fold(0)(_.extractInt)
91 
92   def getLimitSearch(ideaSearchQuery: IdeaSearchQuery): Int =
93     ideaSearchQuery.limit.fold(10)(_.extractInt)
94 
95   def getSort(ideaSearchQuery: IdeaSearchQuery): Option[FieldSort] = {
96     val order = ideaSearchQuery.order.map(_.sortOrder)
97 
98     ideaSearchQuery.sort.map { sort =>
99       val sortFieldName: String = if (sort == "name") {
100         "name.keyword"
101       } else {
102         sort
103       }
104       FieldSort(field = sortFieldName, order = order.getOrElse(SortOrder.ASC))
105     }
106   }
107 
108   def buildNameSearchFilter(ideaSearchQuery: IdeaSearchQuery): Option[Query] = {
109     def languageOmission(boostedLanguage: String): Double =
110       if (ideaSearchQuery.language.contains(Language(boostedLanguage))) 1 else 0
111 
112     for {
113       filters                            <- ideaSearchQuery.filters
114       NameSearchFilter(text, maybeFuzzy) <- filters.name
115     } yield {
116       val fieldsBoosts: Map[String, Double] = Map(
117         IdeaElasticsearchFieldNames.name -> 3d,
118         IdeaElasticsearchFieldNames.nameFr -> 2d * languageOmission("fr"),
119         IdeaElasticsearchFieldNames.nameEn -> 2d * languageOmission("en"),
120         IdeaElasticsearchFieldNames.nameIt -> 2d * languageOmission("it"),
121         IdeaElasticsearchFieldNames.nameDe -> 2d * languageOmission("de"),
122         IdeaElasticsearchFieldNames.nameBg -> 2d * languageOmission("bg"),
123         IdeaElasticsearchFieldNames.nameCs -> 2d * languageOmission("cs"),
124         IdeaElasticsearchFieldNames.nameDa -> 2d * languageOmission("da"),
125         IdeaElasticsearchFieldNames.nameNl -> 2d * languageOmission("nl"),
126         IdeaElasticsearchFieldNames.nameFi -> 2d * languageOmission("fi"),
127         IdeaElasticsearchFieldNames.nameEl -> 2d * languageOmission("el"),
128         IdeaElasticsearchFieldNames.nameHu -> 2d * languageOmission("hu"),
129         IdeaElasticsearchFieldNames.nameLv -> 2d * languageOmission("lv"),
130         IdeaElasticsearchFieldNames.nameLt -> 2d * languageOmission("lt"),
131         IdeaElasticsearchFieldNames.namePt -> 2d * languageOmission("pt"),
132         IdeaElasticsearchFieldNames.nameRo -> 2d * languageOmission("ro"),
133         IdeaElasticsearchFieldNames.nameEs -> 2d * languageOmission("es"),
134         IdeaElasticsearchFieldNames.nameSv -> 2d * languageOmission("sv"),
135         IdeaElasticsearchFieldNames.nameHr -> 2d * languageOmission("hr"),
136         IdeaElasticsearchFieldNames.nameEt -> 2d * languageOmission("et"),
137         IdeaElasticsearchFieldNames.nameMt -> 2d * languageOmission("mt"),
138         IdeaElasticsearchFieldNames.nameSk -> 2d * languageOmission("sk"),
139         IdeaElasticsearchFieldNames.nameSl -> 2d * languageOmission("sl"),
140         IdeaElasticsearchFieldNames.nameUk -> 2d * languageOmission("uk"),
141         IdeaElasticsearchFieldNames.nameGeneral -> 1d
142       ).filter { case (_, boost) => boost != 0 }
143       maybeFuzzy match {
144         case Some(fuzzy) =>
145           ElasticApi
146             .should(
147               multiMatchQuery(text)
148                 .fields(fieldsBoosts)
149                 .boost(2f),
150               multiMatchQuery(text)
151                 .fields(fieldsBoosts)
152                 .fuzziness(fuzzy)
153                 .boost(1f)
154             )
155         case None =>
156           ElasticApi
157             .multiMatchQuery(text)
158             .fields(fieldsBoosts)
159       }
160     }
161   }
162 
163   def buildQuestionIdSearchFilter(ideaSearchQuery: IdeaSearchQuery): Option[Query] = {
164     ideaSearchQuery.filters.flatMap {
165       _.questionId match {
166         case Some(QuestionIdSearchFilter(questionId)) =>
167           Some(ElasticApi.termQuery(IdeaElasticsearchFieldNames.questionId, questionId.value))
168         case _ => None
169       }
170     }
171   }
172 
173   def buildStatusSearchFilter(ideaSearchQuery: IdeaSearchQuery): Option[Query] = {
174     val query: Option[Query] = ideaSearchQuery.filters.flatMap {
175       _.status.map {
176         case StatusSearchFilter(Seq(status)) =>
177           ElasticApi.termQuery(IdeaElasticsearchFieldNames.status, status.value)
178         case StatusSearchFilter(status) =>
179           ElasticApi.termsQuery(IdeaElasticsearchFieldNames.status, status.map(_.value))
180         case _ =>
181           ElasticApi.termsQuery(IdeaElasticsearchFieldNames.status, IdeaStatus.Activated.value)
182       }
183     }
184 
185     query match {
186       case None => None
187       case _    => query
188     }
189   }
190 
191 }
192 
193 final case class NameSearchFilter(text: String, fuzzy: Option[Fuzziness] = None)
194 final case class QuestionIdSearchFilter(questionId: QuestionId)
195 final case class OperationIdSearchFilter(operationId: OperationId)
196 final case class QuestionSearchFilter(question: String)
197 final case class StatusSearchFilter(status: Seq[IdeaStatus])
198 final case class ContextSearchFilter(
199   operation: Option[OperationId] = None,
200   source: Option[String] = None,
201   location: Option[String] = None,
202   question: Option[String] = None
203 )
204 final case class SlugSearchFilter(slug: String)
205 final case class IdeaSearchFilter(ideaId: IdeaId)
206 final case class Limit(value: Int)
207 
208 final case class Skip(value: Int)