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 user
22 
23 import com.sksamuel.elastic4s.{ElasticApi, ElasticDsl}
24 import com.sksamuel.elastic4s.requests.common.Operator
25 import com.sksamuel.elastic4s.requests.searches.queries.Query
26 import com.sksamuel.elastic4s.requests.searches.sort.{FieldSort, SortOrder}
27 import org.make.core.technical.Pagination
28 import org.make.core.reference.{Country, Language}
29 import org.make.core.user.indexed.OrganisationElasticsearchFieldNames
30 
31 /**
32   * The class holding the entire search query
33   *
34   * @param filters       organisation of search filters
35   * @param limit         number of items to fetch
36   * @param offset          number of items to skip
37   * @param sortAlgorithm algorithm used for sorting
38   */
39 final case class OrganisationSearchQuery(
40   filters: Option[OrganisationSearchFilters] = None,
41   limit: Option[Pagination.Limit] = None,
42   offset: Option[Pagination.Offset] = None,
43   sort: Option[String] = None,
44   order: Option[Order] = None,
45   sortAlgorithm: Option[OrganisationSortAlgorithm] = None
46 )
47 
48 /**
49   * The class holding the filters
50   *
51   * @param organisationIds   The organisationIds to filter
52   * @param organisationName  Name of the organisation to search
53   * @param slug              Slug to filter
54   * @param description       Description to search
55   * @param country           Country to filter
56   * @param language          Language to filter
57   */
58 final case class OrganisationSearchFilters(
59   organisationIds: Option[OrganisationIdsSearchFilter] = None,
60   organisationName: Option[OrganisationNameSearchFilter] = None,
61   slug: Option[SlugSearchFilter] = None,
62   description: Option[DescriptionSearchFilter] = None,
63   country: Option[CountrySearchFilter] = None,
64   language: Option[LanguageSearchFilter] = None
65 )
66 
67 object OrganisationSearchFilters extends ElasticDsl {
68 
69   def parse(
70     organisationIds: Option[OrganisationIdsSearchFilter] = None,
71     organisationName: Option[OrganisationNameSearchFilter] = None,
72     slug: Option[SlugSearchFilter] = None,
73     description: Option[DescriptionSearchFilter] = None,
74     country: Option[CountrySearchFilter] = None,
75     language: Option[LanguageSearchFilter] = None
76   ): Option[OrganisationSearchFilters] = {
77 
78     (organisationIds, organisationName, slug, description, country, language) match {
79       case (None, None, None, None, None, None) => None
80       case _ =>
81         Some(OrganisationSearchFilters(organisationIds, organisationName, slug, description, country, language))
82     }
83   }
84 
85   /**
86     * Build elasticsearch search filters from searchQuery
87     *
88     * @param organisationSearchQuery search query
89     *
90     * @return sequence of query definitions
91     */
92   def getOrganisationSearchFilters(organisationSearchQuery: OrganisationSearchQuery): Seq[Query] =
93     Seq(
94       buildOrganisationIdsSearchFilter(organisationSearchQuery),
95       buildOrganisationNameSearchFilter(organisationSearchQuery),
96       buildSlugSearchFilter(organisationSearchQuery),
97       buildDescriptionSearchFilter(organisationSearchQuery),
98       buildCountrySearchFilter(organisationSearchQuery),
99       buildLanguageSearchFilter(organisationSearchQuery)
100     ).flatten
101 
102   def getSkipSearch(organisationSearchQuery: OrganisationSearchQuery): Int =
103     organisationSearchQuery.offset.fold(0)(_.extractInt)
104 
105   def getLimitSearch(organisationSearchQuery: OrganisationSearchQuery): Int =
106     organisationSearchQuery.limit.fold(10)(_.extractInt)
107 
108   def getSort(organisationSearchQuery: OrganisationSearchQuery): Option[FieldSort] = {
109     val order = organisationSearchQuery.order.map(_.sortOrder)
110 
111     organisationSearchQuery.sort.map { sort =>
112       val sortFieldName: String = if (sort == OrganisationElasticsearchFieldNames.organisationName) {
113         OrganisationElasticsearchFieldNames.organisationNameKeyword
114       } else {
115         sort
116       }
117       FieldSort(field = sortFieldName, order = order.getOrElse(SortOrder.ASC))
118     }
119   }
120 
121   def buildOrganisationIdsSearchFilter(organisationSearchQuery: OrganisationSearchQuery): Option[Query] = {
122     organisationSearchQuery.filters.flatMap {
123       _.organisationIds match {
124         case Some(OrganisationIdsSearchFilter(Seq(organisationId))) =>
125           Some(ElasticApi.termQuery(OrganisationElasticsearchFieldNames.organisationId, organisationId.value))
126         case Some(OrganisationIdsSearchFilter(organisationIds)) =>
127           Some(ElasticApi.termsQuery(OrganisationElasticsearchFieldNames.organisationId, organisationIds.map(_.value)))
128         case _ => None
129       }
130     }
131   }
132 
133   def buildOrganisationNameSearchFilter(organisationSearchQuery: OrganisationSearchQuery): Option[Query] = {
134     val query: Option[Query] = for {
135       filters                            <- organisationSearchQuery.filters
136       OrganisationNameSearchFilter(text) <- filters.organisationName
137     } yield {
138       val language = filters.language.map(_.language).getOrElse(Language("fr"))
139       val fieldsBoosts: Map[String, Double] =
140         Map(
141           Some(OrganisationElasticsearchFieldNames.organisationName) -> 3d,
142           OrganisationElasticsearchFieldNames.organisationNameLanguageSubfield(language) -> 2d,
143           OrganisationElasticsearchFieldNames.organisationNameLanguageSubfield(language, stemmed = true) -> 1.5d
144         ).collect {
145           case (Some(key), value) => key -> value
146         }
147       functionScoreQuery(multiMatchQuery(text).fields(fieldsBoosts).fuzziness("Auto:4,7").operator(Operator.AND))
148     }
149 
150     query match {
151       case None => None
152       case _    => query
153     }
154   }
155 
156   def buildSlugSearchFilter(organisationSearchQuery: OrganisationSearchQuery): Option[Query] = {
157     organisationSearchQuery.filters.flatMap {
158       _.slug match {
159         case Some(SlugSearchFilter(slug)) =>
160           Some(ElasticApi.termQuery(OrganisationElasticsearchFieldNames.slug, slug))
161         case _ => None
162       }
163     }
164   }
165 
166   def buildDescriptionSearchFilter(organisationSearchQuery: OrganisationSearchQuery): Option[Query] = {
167     organisationSearchQuery.filters.flatMap {
168       _.description match {
169         case Some(DescriptionSearchFilter(description)) =>
170           Some(ElasticApi.matchQuery(OrganisationElasticsearchFieldNames.description, description))
171         case _ => None
172       }
173     }
174   }
175 
176   def buildCountrySearchFilter(organisationSearchQuery: OrganisationSearchQuery): Option[Query] = {
177     organisationSearchQuery.filters.flatMap {
178       _.country match {
179         case Some(CountrySearchFilter(country)) =>
180           Some(ElasticApi.termsQuery(OrganisationElasticsearchFieldNames.country, country.value))
181         case _ => None
182       }
183     }
184   }
185 
186   def buildLanguageSearchFilter(organisationSearchQuery: OrganisationSearchQuery): Option[Query] = {
187     organisationSearchQuery.filters.flatMap {
188       _.language match {
189         case Some(LanguageSearchFilter(language)) =>
190           Some(ElasticApi.termsQuery(OrganisationElasticsearchFieldNames.language, language.value))
191         case _ => None
192       }
193     }
194   }
195 }
196 
197 final case class OrganisationIdsSearchFilter(organisationIds: Seq[UserId])
198 final case class OrganisationNameSearchFilter(text: String)
199 final case class SlugSearchFilter(slug: String)
200 final case class DescriptionSearchFilter(description: String)
201 final case class CountrySearchFilter(country: Country)
202 final case class LanguageSearchFilter(language: Language)