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.operation
21 
22 import cats.implicits._
23 import com.sksamuel.elastic4s.Index
24 import com.sksamuel.elastic4s.ElasticDsl._
25 import com.sksamuel.elastic4s.circe._
26 import com.sksamuel.elastic4s.requests.common.RefreshPolicy
27 import com.sksamuel.elastic4s.requests.searches.SearchRequest
28 import com.sksamuel.elastic4s.requests.searches.sort.{FieldSort, SortOrder}
29 import com.sksamuel.elastic4s.requests.searches.queries.compound.BoolQuery
30 import grizzled.slf4j.Logging
31 import io.circe.{Json, Printer}
32 import org.make.api.technical.elasticsearch._
33 import org.make.api.views.Highlights
34 import org.make.core.CirceFormatters
35 import org.make.core.elasticsearch.IndexationStatus
36 import org.make.core.operation.indexed.{
37   IndexedOperationOfQuestion,
38   OperationOfQuestionElasticsearchFieldName,
39   OperationOfQuestionSearchResult
40 }
41 import org.make.core.operation.{OperationOfQuestionSearchFilters, OperationOfQuestionSearchQuery}
42 import org.make.core.question.QuestionId
43 
44 import scala.concurrent.ExecutionContext.Implicits.global
45 import scala.concurrent.Future
46 
47 trait OperationOfQuestionSearchEngineComponent {
48   def elasticsearchOperationOfQuestionAPI: OperationOfQuestionSearchEngine
49 }
50 
51 trait OperationOfQuestionSearchEngine {
52   def findOperationOfQuestionById(questionId: QuestionId): Future[Option[IndexedOperationOfQuestion]]
53   def count(query: OperationOfQuestionSearchQuery): Future[Long]
54   def searchOperationOfQuestions(query: OperationOfQuestionSearchQuery): Future[OperationOfQuestionSearchResult]
55   def indexOperationOfQuestion(record: IndexedOperationOfQuestion, maybeIndex: Option[Index]): Future[IndexationStatus]
56   def indexOperationOfQuestions(
57     records: Seq[IndexedOperationOfQuestion],
58     maybeIndex: Option[Index]
59   ): Future[IndexationStatus]
60   def highlights(): Future[Highlights]
61 }
62 
63 object OperationOfQuestionSearchEngine {
64   val operationOfQuestionIndexName: String = "operation-of-question"
65 }
66 
67 trait DefaultOperationOfQuestionSearchEngineComponent
68     extends OperationOfQuestionSearchEngineComponent
69     with CirceFormatters
70     with Logging {
71   self: ElasticsearchConfigurationComponent with ElasticsearchClientComponent =>
72 
73   override lazy val elasticsearchOperationOfQuestionAPI: OperationOfQuestionSearchEngine =
74     new DefaultOperationOfQuestionSearchEngine
75 
76   class DefaultOperationOfQuestionSearchEngine extends OperationOfQuestionSearchEngine {
77 
78     private lazy val client = elasticsearchClient.client
79 
80     private val operationOfQuestionAlias: Index =
81       elasticsearchConfiguration.operationOfQuestionAliasName
82 
83     // TODO remove once elastic4s-circe upgrades to circe 0.14
84     private implicit val printer: Json => String = Printer.noSpaces.print
85 
86     override def findOperationOfQuestionById(questionId: QuestionId): Future[Option[IndexedOperationOfQuestion]] = {
87       client
88         .executeAsFuture(get(operationOfQuestionAlias, questionId.value))
89         .map(_.toOpt[IndexedOperationOfQuestion])
90     }
91 
92     override def count(query: OperationOfQuestionSearchQuery): Future[Long] = {
93       val request = search(operationOfQuestionAlias)
94         .bool(BoolQuery(must = OperationOfQuestionSearchFilters.getOperationOfQuestionSearchFilters(query)))
95         .limit(0)
96         .trackTotalHits(true)
97 
98       client.executeAsFuture(request).map { response =>
99         response.totalHits
100       }
101     }
102 
103     override def searchOperationOfQuestions(
104       query: OperationOfQuestionSearchQuery
105     ): Future[OperationOfQuestionSearchResult] = {
106       val searchFilters = OperationOfQuestionSearchFilters.getOperationOfQuestionSearchFilters(query)
107       val request: SearchRequest = search(operationOfQuestionAlias)
108         .bool(BoolQuery(must = searchFilters))
109         .sortBy(
110           Seq(
111             OperationOfQuestionSearchFilters.getSort(query),
112             Some(FieldSort(field = OperationOfQuestionElasticsearchFieldName.endDate.field, order = SortOrder.DESC)),
113             Some(FieldSort(field = OperationOfQuestionElasticsearchFieldName.startDate.field, order = SortOrder.DESC))
114           ).flatten
115         )
116         .size(OperationOfQuestionSearchFilters.getLimitSearch(query))
117         .from(OperationOfQuestionSearchFilters.getSkipSearch(query))
118         .trackTotalHits(true)
119 
120       val requestWithAlgorithm = query.sortAlgorithm match {
121         case Some(algorithm) => algorithm.sortDefinition(request)
122         case _               => request
123       }
124 
125       client
126         .executeAsFuture(requestWithAlgorithm)
127         .map { response =>
128           OperationOfQuestionSearchResult(total = response.totalHits, results = response.to[IndexedOperationOfQuestion])
129         }
130     }
131 
132     override def indexOperationOfQuestion(
133       record: IndexedOperationOfQuestion,
134       maybeIndex: Option[Index]
135     ): Future[IndexationStatus] = {
136       val index = maybeIndex.getOrElse(operationOfQuestionAlias)
137       client
138         .executeAsFuture(indexInto(index).doc(record).refresh(RefreshPolicy.IMMEDIATE).id(record.questionId.value))
139         .map(_ => IndexationStatus.Completed)
140         .recover {
141           case e: Exception =>
142             logger.error(s"Indexing upserted operation of question ${record.questionId} failed", e)
143             IndexationStatus.Failed(e)
144         }
145     }
146 
147     override def indexOperationOfQuestions(
148       records: Seq[IndexedOperationOfQuestion],
149       maybeIndex: Option[Index]
150     ): Future[IndexationStatus] = {
151       val index = maybeIndex.getOrElse(operationOfQuestionAlias)
152       client
153         .executeAsFuture(bulk(records.map { record =>
154           indexInto(index).doc(record).refresh(RefreshPolicy.IMMEDIATE).id(record.questionId.value)
155         }))
156         .as(IndexationStatus.Completed)
157         .recover {
158           case e: Exception =>
159             logger.error(s"Indexing ${records.size} operations of questions failed", e)
160             IndexationStatus.Failed(e)
161         }
162     }
163 
164     override def highlights(): Future[Highlights] = {
165       client
166         .executeAsFuture(
167           search(operationOfQuestionAlias)
168             .aggregations(
169               sumAgg(
170                 OperationOfQuestionElasticsearchFieldName.participantsCount.field,
171                 OperationOfQuestionElasticsearchFieldName.participantsCount.field
172               ),
173               sumAgg(
174                 OperationOfQuestionElasticsearchFieldName.proposalsCount.field,
175                 OperationOfQuestionElasticsearchFieldName.proposalsCount.field
176               )
177             )
178             .trackTotalHits(true)
179         )
180         .map { response =>
181           Highlights(
182             participantsCount = response.aggregations
183               .sum(OperationOfQuestionElasticsearchFieldName.participantsCount.field)
184               .valueOpt
185               .fold(0)(_.toInt),
186             proposalsCount = response.aggregations
187               .sum(OperationOfQuestionElasticsearchFieldName.proposalsCount.field)
188               .valueOpt
189               .fold(0)(_.toInt),
190             partnersCount = 0
191           )
192         }
193     }
194   }
195 }