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.sequence
21 
22 import com.sksamuel.elastic4s.requests.searches.sort.SortOrder
23 import grizzled.slf4j.Logging
24 import SelectionAlgorithm.{ExplorationSelectionAlgorithm, RandomSelectionAlgorithm, RoundRobinSelectionAlgorithm}
25 import org.make.api.sequence.SequenceBehaviour.ConsensusParam
26 import org.make.api.technical.MakeRandom
27 import org.make.core.proposal
28 import org.make.core.proposal._
29 import org.make.core.proposal.indexed.{IndexedProposal, SequencePool, Zone}
30 import org.make.core.question.QuestionId
31 import org.make.core.sequence._
32 import eu.timepit.refined.auto._
33 
34 import scala.concurrent.Future
35 
36 sealed trait SequenceBehaviour {
37   type Configuration <: BasicSequenceConfiguration
38 
39   type SearchFunction = (
40     QuestionId,
41     Option[String],
42     Option[SequencePool],
43     proposal.SearchQuery,
44     SortAlgorithm
45   ) => Future[Seq[IndexedProposal]]
46 
47   type LogFunction = (Int, QuestionId) => Unit
48 
49   val configuration: SequenceConfiguration
50   def specificConfiguration: Configuration
51   val questionId: QuestionId
52   val maybeSegment: Option[String]
53 
54   def newProposals(search: SearchFunction): Future[Seq[IndexedProposal]] = Future.successful(Nil)
55   def testedProposals(search: SearchFunction): Future[Seq[IndexedProposal]] = Future.successful(Nil)
56   def fallbackProposals(
57     currentSequenceSize: Int,
58     search: SearchFunction,
59     logFallback: LogFunction
60   ): Future[Seq[IndexedProposal]] =
61     Future.successful(Nil)
62   def selectProposals(
63     includedProposals: Seq[IndexedProposal],
64     newProposals: Seq[IndexedProposal],
65     testedProposals: Seq[IndexedProposal]
66   ): Seq[IndexedProposal]
67 }
68 
69 object SequenceBehaviour extends Logging {
70   trait RoundRobinOrRandomBehavior {
71     self: SequenceBehaviour =>
72 
73     override type Configuration = SpecificSequenceConfiguration
74 
75     override def selectProposals(
76       includedProposals: Seq[IndexedProposal],
77       newProposals: Seq[IndexedProposal],
78       testedProposals: Seq[IndexedProposal]
79     ): Seq[IndexedProposal] = {
80       specificConfiguration.selectionAlgorithmName match {
81         case SelectionAlgorithmName.RoundRobin =>
82           RoundRobinSelectionAlgorithm.selectProposalsForSequence(
83             self.specificConfiguration,
84             includedProposals,
85             newProposals,
86             testedProposals
87           )
88         case _ =>
89           RandomSelectionAlgorithm.selectProposalsForSequence(
90             self.specificConfiguration,
91             includedProposals,
92             newProposals,
93             testedProposals
94           )
95       }
96     }
97   }
98 
99   trait ExplorationBehavior {
100     self: SequenceBehaviour =>
101 
102     override type Configuration = ExplorationSequenceConfiguration
103 
104     override def specificConfiguration: ExplorationSequenceConfiguration = self.configuration.mainSequence
105 
106     override def selectProposals(
107       includedProposals: Seq[IndexedProposal],
108       newProposals: Seq[IndexedProposal],
109       testedProposals: Seq[IndexedProposal]
110     ): Seq[IndexedProposal] = {
111       ExplorationSelectionAlgorithm.selectProposalsForSequence(
112         specificConfiguration,
113         self.configuration.nonSequenceVotesWeight,
114         includedProposals,
115         newProposals,
116         testedProposals,
117         self.maybeSegment
118       )
119     }
120 
121     override def fallbackProposals(
122       currentSequenceSize: Int,
123       search: SearchFunction,
124       logFallback: LogFunction
125     ): Future[Seq[IndexedProposal]] = {
126       if (currentSequenceSize < specificConfiguration.sequenceSize) {
127         logFallback(specificConfiguration.sequenceSize - currentSequenceSize, questionId)
128         def sortAlgorithm: SortAlgorithm =
129           maybeSegment.fold[SortAlgorithm](CreationDateAlgorithm(SortOrder.Desc))(SegmentFirstAlgorithm.apply)
130 
131         search(questionId, maybeSegment, None, proposal.SearchQuery(), sortAlgorithm)
132       } else {
133         Future.successful(Nil)
134       }
135     }
136   }
137 
138   final case class Standard(
139     override val configuration: SequenceConfiguration,
140     questionId: QuestionId,
141     maybeSegment: Option[String]
142   ) extends SequenceBehaviour
143       with ExplorationBehavior {
144 
145     override def newProposals(search: SearchFunction): Future[Seq[IndexedProposal]] = {
146       search(
147         questionId,
148         maybeSegment,
149         Some(SequencePool.New),
150         proposal.SearchQuery(),
151         CreationDateAlgorithm(SortOrder.Asc)
152       )
153     }
154 
155     override def testedProposals(search: SearchFunction): Future[Seq[IndexedProposal]] = {
156       search(
157         questionId,
158         maybeSegment,
159         Some(SequencePool.Tested),
160         proposal.SearchQuery(),
161         RandomAlgorithm(MakeRandom.nextInt())
162       )
163     }
164   }
165 
166   final case class ConsensusParam(top20ConsensusThreshold: Option[Double])
167 
168   final case class Consensus(
169     consensusParam: ConsensusParam,
170     override val configuration: SequenceConfiguration,
171     questionId: QuestionId,
172     maybeSegment: Option[String]
173   ) extends SequenceBehaviour
174       with RoundRobinOrRandomBehavior {
175     override val specificConfiguration: SpecificSequenceConfiguration = configuration.popular
176 
177     override def testedProposals(search: SearchFunction): Future[Seq[IndexedProposal]] = {
178       search(
179         questionId,
180         maybeSegment,
181         Some(SequencePool.Tested),
182         proposal.SearchQuery(filters = Some(
183           proposal.SearchFilters(
184             zone = Some(ZoneSearchFilter(Zone.Consensus)),
185             minScoreLowerBound = consensusParam.top20ConsensusThreshold.map(MinScoreLowerBoundSearchFilter)
186           )
187         )
188         ),
189         RandomAlgorithm(MakeRandom.nextInt())
190       )
191     }
192   }
193 
194   final case class Controversy(
195     override val configuration: SequenceConfiguration,
196     questionId: QuestionId,
197     maybeSegment: Option[String]
198   ) extends SequenceBehaviour
199       with RoundRobinOrRandomBehavior {
200 
201     override val specificConfiguration: SpecificSequenceConfiguration = configuration.controversial
202 
203     override def testedProposals(search: SearchFunction): Future[Seq[IndexedProposal]] = {
204       search(
205         questionId,
206         maybeSegment,
207         Some(SequencePool.Tested),
208         proposal.SearchQuery(filters = Some(proposal.SearchFilters(zone = Some(ZoneSearchFilter(Zone.Controversy))))),
209         RandomAlgorithm(MakeRandom.nextInt())
210       )
211     }
212   }
213 
214   final case class Keyword(
215     keyword: ProposalKeywordKey,
216     override val configuration: SequenceConfiguration,
217     questionId: QuestionId,
218     maybeSegment: Option[String]
219   ) extends SequenceBehaviour
220       with RoundRobinOrRandomBehavior {
221 
222     override val specificConfiguration: SpecificSequenceConfiguration = configuration.keyword
223 
224     override def newProposals(search: SearchFunction): Future[Seq[IndexedProposal]] = {
225       search(
226         questionId,
227         maybeSegment,
228         Some(SequencePool.New),
229         proposal.SearchQuery(filters = Some(proposal.SearchFilters(keywords = Some(KeywordsSearchFilter(Seq(keyword)))))
230         ),
231         CreationDateAlgorithm(SortOrder.Asc)
232       )
233     }
234 
235     override def testedProposals(search: SearchFunction): Future[Seq[IndexedProposal]] = {
236       search(
237         questionId,
238         maybeSegment,
239         Some(SequencePool.Tested),
240         proposal.SearchQuery(filters = Some(proposal.SearchFilters(keywords = Some(KeywordsSearchFilter(Seq(keyword)))))
241         ),
242         RandomAlgorithm(MakeRandom.nextInt())
243       )
244     }
245   }
246 }
247 
248 trait SequenceBehaviourProvider[T] {
249   def behaviour(
250     param: T,
251     configuration: SequenceConfiguration,
252     questionId: QuestionId,
253     maybeSegment: Option[String]
254   ): SequenceBehaviour
255 }
256 
257 object SequenceBehaviourProvider {
258 
259   def apply[T](implicit bp: SequenceBehaviourProvider[T]): SequenceBehaviourProvider[T] = bp
260 
261   implicit val standard: SequenceBehaviourProvider[Unit] =
262     (_: Unit, configuration: SequenceConfiguration, questionId: QuestionId, maybeSegment: Option[String]) =>
263       SequenceBehaviour.Standard(configuration, questionId, maybeSegment)
264 
265   implicit val consensus: SequenceBehaviourProvider[ConsensusParam] = (
266     consensusParam: ConsensusParam,
267     configuration: SequenceConfiguration,
268     questionId: QuestionId,
269     maybeSegment: Option[String]
270   ) => SequenceBehaviour.Consensus(consensusParam, configuration, questionId, maybeSegment)
271 
272   implicit val controversy: SequenceBehaviourProvider[Zone.Controversy.type] =
273     (
274       _: Zone.Controversy.type,
275       configuration: SequenceConfiguration,
276       questionId: QuestionId,
277       maybeSegment: Option[String]
278     ) => SequenceBehaviour.Controversy(configuration, questionId, maybeSegment)
279 
280   implicit val keyword: SequenceBehaviourProvider[ProposalKeywordKey] = (
281     keyword: ProposalKeywordKey,
282     configuration: SequenceConfiguration,
283     questionId: QuestionId,
284     maybeSegment: Option[String]
285   ) => SequenceBehaviour.Keyword(keyword, configuration, questionId, maybeSegment)
286 }