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 com.sksamuel.elastic4s.ElasticApi._
23 import com.sksamuel.elastic4s.ElasticDsl.{functionScoreQuery, scriptScore}
24 import com.sksamuel.elastic4s.requests.script.Script
25 import com.sksamuel.elastic4s.requests.searches.SearchRequest
26 import com.sksamuel.elastic4s.requests.searches.collapse.CollapseRequest
27 import com.sksamuel.elastic4s.requests.searches.queries.InnerHit
28 import com.sksamuel.elastic4s.requests.searches.queries.funcscorer.{CombineFunction, WeightScore}
29 import com.sksamuel.elastic4s.requests.searches.sort.{FieldSort, ScoreSort, SortOrder}
30 import enumeratum.values.{StringEnum, StringEnumEntry}
31 import org.make.core.proposal.indexed.ProposalElasticsearchFieldName
32 import org.make.core.technical.enumeratum.EnumKeys.StringEnumKeys
33 import org.make.core.user.UserType
34 
35 sealed trait SortAlgorithm {
36   def sortDefinition(request: SearchRequest): SearchRequest
37   protected def docField(value: ProposalElasticsearchFieldName): String = s"doc['${value.field}']"
38 }
39 
40 trait RandomBaseAlgorithm {
41   def seed: Int
42 }
43 
44 // Sorts randomly from the given seed
45 final case class RandomAlgorithm(override val seed: Int) extends SortAlgorithm with RandomBaseAlgorithm {
46   override def sortDefinition(request: SearchRequest): SearchRequest = {
47     request.query.map { query =>
48       request.query(functionScoreQuery().query(query).functions(randomScore(seed = seed).fieldName("id")))
49     }.getOrElse(request)
50 
51   }
52 }
53 
54 /*
55  * This algorithm aims to show hot quality content to the user.
56  * Which means:
57  * - tagged proposals will be chosen in priority
58  * - Recent proposals will have a priority boost
59  * - Proposals on which organisations have voted will be boosted
60  */
61 final case class TaggedFirstAlgorithm(override val seed: Int) extends SortAlgorithm with RandomBaseAlgorithm {
62 
63   override def sortDefinition(request: SearchRequest): SearchRequest = {
64     request
65       .query(
66         functionScoreQuery()
67           .query(request.query.getOrElse(matchAllQuery()))
68           .functions(
69             WeightScore(50d, Some(existsQuery(ProposalElasticsearchFieldName.tagId.field))),
70             WeightScore(
71               10d,
72               Some(scriptQuery(s"${docField(ProposalElasticsearchFieldName.organisationId)}.size() > 1"))
73             ),
74             WeightScore(
75               5d,
76               Some(scriptQuery(s"${docField(ProposalElasticsearchFieldName.organisationId)}.size() == 1"))
77             ),
78             exponentialScore(field = ProposalElasticsearchFieldName.createdAt.field, scale = "7d", origin = "now")
79               .weight(30d)
80               .decay(0.33d),
81             randomScore(seed = seed).fieldName("id").weight(5d)
82           )
83           .scoreMode("sum")
84           .boostMode(CombineFunction.Replace)
85       )
86   }
87 }
88 
89 // Sorts the proposals by most actor votes and then randomly from the given seed
90 final case class ActorVoteAlgorithm(override val seed: Int) extends SortAlgorithm with RandomBaseAlgorithm {
91   override def sortDefinition(request: SearchRequest): SearchRequest = {
92     val scriptActorVoteNumber = s"${docField(ProposalElasticsearchFieldName.organisationId)}.size()"
93     val actorVoteScript = s"$scriptActorVoteNumber > 0 ? ($scriptActorVoteNumber + 1) * 10 : 1"
94     request.query.map { query =>
95       request
96         .query(
97           functionScoreQuery()
98             .query(query)
99             .functions(scriptScore(Script(script = actorVoteScript)), randomScore(seed = seed).fieldName("id"))
100             .scoreMode("sum")
101             .boostMode(CombineFunction.Sum)
102         )
103     }.getOrElse(request)
104   }
105 }
106 
107 // Sort proposal by their controversy score
108 case object ControversyAlgorithm extends SortAlgorithm {
109   override def sortDefinition(request: SearchRequest): SearchRequest = {
110     request.sortByFieldDesc(ProposalElasticsearchFieldName.controversyLowerBound.field)
111   }
112 }
113 
114 // Sort proposal by their top score
115 case object PopularAlgorithm extends SortAlgorithm {
116   override def sortDefinition(request: SearchRequest): SearchRequest = {
117     request.sortByFieldDesc(ProposalElasticsearchFieldName.scoreLowerBound.field)
118   }
119 }
120 
121 case object B2BFirstAlgorithm extends SortAlgorithm {
122   override def sortDefinition(request: SearchRequest): SearchRequest = {
123     val userTypeScript =
124       s"""${docField(ProposalElasticsearchFieldName.authorUserType)}.value == \"${UserType.UserTypeUser.value}\" ? 1 : 100"""
125     request.query.map { query =>
126       request
127         .query(
128           functionScoreQuery()
129             .query(query)
130             .functions(scriptScore(Script(script = userTypeScript)))
131             .boostMode(CombineFunction.Replace)
132         )
133         .sortBy(ScoreSort(SortOrder.Desc) +: request.sorts)
134     }.getOrElse(request)
135   }
136 }
137 
138 final case class CreationDateAlgorithm(order: SortOrder) extends SortAlgorithm {
139   override def sortDefinition(request: SearchRequest): SearchRequest =
140     request.sortBy(FieldSort(field = ProposalElasticsearchFieldName.createdAt.field, order = order))
141 }
142 
143 final case class SegmentFirstAlgorithm(segment: String) extends SortAlgorithm {
144   override def sortDefinition(request: SearchRequest): SearchRequest = {
145     val segmentField = docField(ProposalElasticsearchFieldName.segment)
146     val pointsIfMatchesSegmentScript =
147       s"""$segmentField.size() > 0 && $segmentField.value == "$segment" ? 10 : 1"""
148     request.query.map { query =>
149       request.query(
150         functionScoreQuery()
151           .query(query)
152           .functions(
153             scriptScore(Script(pointsIfMatchesSegmentScript)),
154             gaussianScore(ProposalElasticsearchFieldName.createdAt.field, "now", "7d")
155               .decay(0.8d)
156           )
157           .scoreMode("sum")
158           .boostMode(CombineFunction.Replace)
159       )
160     }.getOrElse(request)
161   }
162 }
163 
164 case object Featured extends SortAlgorithm {
165   override def sortDefinition(request: SearchRequest): SearchRequest = {
166     val sort = FieldSort(field = ProposalElasticsearchFieldName.createdAt.field, order = SortOrder.Desc)
167     request
168       .collapse(
169         CollapseRequest(ProposalElasticsearchFieldName.authorUserId.field).inner(InnerHit("last").sortBy(sort).size(1))
170       )
171       .sortBy(sort)
172   }
173 }
174 
175 sealed abstract class AlgorithmSelector(val value: String, val build: Int => SortAlgorithm) extends StringEnumEntry
176 
177 case object AlgorithmSelector extends StringEnum[AlgorithmSelector] with StringEnumKeys[AlgorithmSelector] {
178 
179   case object Random extends AlgorithmSelector("random", randomSeed => RandomAlgorithm(randomSeed))
180 
181   case object TaggedFirst extends AlgorithmSelector("taggedFirst", randomSeed => TaggedFirstAlgorithm(randomSeed))
182 
183   case object ActorVote extends AlgorithmSelector("actorVote", randomSeed => ActorVoteAlgorithm(randomSeed))
184 
185   case object Controversy extends AlgorithmSelector("controversy", _ => ControversyAlgorithm)
186 
187   case object Popular extends AlgorithmSelector("popular", _ => PopularAlgorithm)
188 
189   case object B2BFirst extends AlgorithmSelector("B2BFirst", _ => B2BFirstAlgorithm)
190 
191   override val values: IndexedSeq[AlgorithmSelector] = findValues
192 
193   def select(sortAlgorithm: Option[String], randomSeed: Int): Option[SortAlgorithm] =
194     sortAlgorithm.flatMap(withValueOpt).map(_.build(randomSeed))
195 
196 }