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.sequence
21 
22 import enumeratum.EnumEntry.Lowercase
23 import enumeratum.{Circe, Enum, EnumEntry}
24 import enumeratum.values.{StringCirceEnum, StringEnum, StringEnumEntry}
25 import eu.timepit.refined.auto._
26 import eu.timepit.refined.types.numeric._
27 import io.circe.{Codec, Decoder, Encoder}
28 import io.swagger.annotations.ApiModelProperty
29 import org.make.core._
30 import org.make.core.question.QuestionId
31 import org.make.core.technical.RefinedTypes.Ratio
32 
33 import scala.annotation.meta.field
34 
35 sealed abstract class SelectionAlgorithmName(val value: String) extends StringEnumEntry
36 object SelectionAlgorithmName extends StringEnum[SelectionAlgorithmName] with StringCirceEnum[SelectionAlgorithmName] {
37 
38   final case object Bandit extends SelectionAlgorithmName("Bandit")
39   final case object RoundRobin extends SelectionAlgorithmName("RoundRobin")
40   final case object Random extends SelectionAlgorithmName("Random")
41 
42   override val values: IndexedSeq[SelectionAlgorithmName] = findValues
43   final val swaggerAllowableValues = "Bandit,RoundRobin,Random"
44 }
45 
46 final case class SequenceConfiguration(
47   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
48   questionId: QuestionId,
49   mainSequence: ExplorationSequenceConfiguration,
50   controversial: SpecificSequenceConfiguration,
51   popular: SpecificSequenceConfiguration,
52   keyword: SpecificSequenceConfiguration,
53   newProposalsVoteThreshold: Int,
54   @(ApiModelProperty @field)(dataType = "double") testedProposalsEngagementThreshold: Option[Double],
55   @(ApiModelProperty @field)(dataType = "double") testedProposalsScoreThreshold: Option[Double],
56   @(ApiModelProperty @field)(dataType = "double") testedProposalsControversyThreshold: Option[Double],
57   @(ApiModelProperty @field)(dataType = "int") testedProposalsMaxVotesThreshold: Option[Int],
58   nonSequenceVotesWeight: Double
59 )
60 
61 object SequenceConfiguration {
62 
63   val default: SequenceConfiguration = SequenceConfiguration(
64     questionId = QuestionId("default-question"),
65     mainSequence = ExplorationSequenceConfiguration.default(ExplorationSequenceConfigurationId("default-sequence")),
66     controversial =
67       SpecificSequenceConfiguration.otherSequenceDefault(SpecificSequenceConfigurationId("default-controversial")),
68     popular = SpecificSequenceConfiguration.otherSequenceDefault(SpecificSequenceConfigurationId("default-popular")),
69     keyword = SpecificSequenceConfiguration.otherSequenceDefault(SpecificSequenceConfigurationId("default-keyword")),
70     newProposalsVoteThreshold = 10,
71     testedProposalsEngagementThreshold = None,
72     testedProposalsScoreThreshold = None,
73     testedProposalsControversyThreshold = None,
74     testedProposalsMaxVotesThreshold = Some(1500),
75     nonSequenceVotesWeight = 0.5
76   )
77 
78 }
79 
80 sealed trait BasicSequenceConfiguration {
81   def sequenceSize: PosInt
82   def maxTestedProposalCount: PosInt
83 }
84 
85 final case class ExplorationSequenceConfiguration(
86   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
87   explorationSequenceConfigurationId: ExplorationSequenceConfigurationId,
88   @(ApiModelProperty @field)(dataType = "int", allowableValues = "range[1, infinity]", required = true)
89   sequenceSize: PosInt,
90   @(ApiModelProperty @field)(dataType = "int", allowableValues = "range[1, infinity]", required = true)
91   maxTestedProposalCount: PosInt,
92   @(ApiModelProperty @field)(dataType = "double", allowableValues = "range[0, 1]", required = true)
93   newRatio: Ratio,
94   @(ApiModelProperty @field)(dataType = "double", allowableValues = "range[0, 1]", required = true)
95   controversyRatio: Ratio,
96   @(ApiModelProperty @field)(
97     dataType = "string",
98     required = true,
99     allowableValues = ExplorationSortAlgorithm.swaggerAllowableValues
100   )
101   topSorter: ExplorationSortAlgorithm,
102   @(ApiModelProperty @field)(
103     dataType = "string",
104     required = true,
105     allowableValues = ExplorationSortAlgorithm.swaggerAllowableValues
106   )
107   controversySorter: ExplorationSortAlgorithm,
108   @(ApiModelProperty @field)(dataType = "double", allowableValues = "range[0, 1]", required = true)
109   keywordsThreshold: Ratio,
110   candidatesPoolSize: Int,
111   @(ApiModelProperty @field)(dataType = "double", example = "0.6", required = true)
112   sequenceThresholds: ExplorationSequenceConfiguration.SequenceThresholds
113 ) extends BasicSequenceConfiguration
114 
115 object ExplorationSequenceConfiguration {
116 
117   final case class SequenceThresholds(
118     @(ApiModelProperty @field)(dataType = "double", example = "0.6", required = true)
119     strongOpinion: Ratio,
120     @(ApiModelProperty @field)(dataType = "double", example = "0.4", required = true)
121     neutralOpinion: Ratio,
122     @(ApiModelProperty @field)(dataType = "double", example = "0.15", required = true)
123     weakOpinion: Ratio
124   )
125   object SequenceThresholds {
126     import eu.timepit.refined.auto._
127     val default: SequenceThresholds = SequenceThresholds(strongOpinion = 0.6, neutralOpinion = 0.4, weakOpinion = 0.15)
128   }
129 
130   def default(id: ExplorationSequenceConfigurationId): ExplorationSequenceConfiguration =
131     ExplorationSequenceConfiguration(
132       id,
133       sequenceSize = 12,
134       maxTestedProposalCount = 1000,
135       newRatio = 0.3,
136       controversyRatio = 0.3,
137       topSorter = ExplorationSortAlgorithm.Equalizer,
138       controversySorter = ExplorationSortAlgorithm.Equalizer,
139       keywordsThreshold = 0.2,
140       candidatesPoolSize = 10,
141       sequenceThresholds = SequenceThresholds.default
142     )
143 }
144 
145 final case class ExplorationSequenceConfigurationId(value: String) extends StringValue
146 
147 object ExplorationSequenceConfigurationId {
148   implicit val codec: Codec[ExplorationSequenceConfigurationId] =
149     Codec.from(Decoder[String].map(ExplorationSequenceConfigurationId.apply), Encoder[String].contramap(_.value))
150 }
151 
152 sealed abstract class ExplorationSortAlgorithm(val value: String) extends StringEnumEntry
153 
154 object ExplorationSortAlgorithm
155     extends StringEnum[ExplorationSortAlgorithm]
156     with StringCirceEnum[ExplorationSortAlgorithm] {
157 
158   case object Bandit extends ExplorationSortAlgorithm("bandit")
159   case object Random extends ExplorationSortAlgorithm("random")
160   case object Equalizer extends ExplorationSortAlgorithm("equalizer")
161 
162   override val values: IndexedSeq[ExplorationSortAlgorithm] = findValues
163   final val swaggerAllowableValues = "bandit,random,equalizer"
164 }
165 
166 final case class SpecificSequenceConfiguration(
167   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
168   specificSequenceConfigurationId: SpecificSequenceConfigurationId,
169   @(ApiModelProperty @field)(dataType = "int", example = "12", allowableValues = "range[1, infinity]", required = true)
170   sequenceSize: PosInt = 12,
171   @(ApiModelProperty @field)(dataType = "double", example = "0.3", required = true)
172   newProposalsRatio: Double = 0.3,
173   @(ApiModelProperty @field)(
174     dataType = "int",
175     example = "1000",
176     allowableValues = "range[1, infinity]",
177     required = true
178   )
179   maxTestedProposalCount: PosInt = 1000,
180   @(ApiModelProperty @field)(
181     dataType = "string",
182     required = true,
183     allowableValues = SelectionAlgorithmName.swaggerAllowableValues
184   )
185   selectionAlgorithmName: SelectionAlgorithmName = SelectionAlgorithmName.Bandit
186 ) extends BasicSequenceConfiguration
187 
188 object SpecificSequenceConfiguration {
189 
190   def otherSequenceDefault(id: SpecificSequenceConfigurationId): SpecificSequenceConfiguration =
191     SpecificSequenceConfiguration(
192       specificSequenceConfigurationId = id,
193       newProposalsRatio = 0,
194       selectionAlgorithmName = SelectionAlgorithmName.Random
195     )
196 }
197 
198 final case class SpecificSequenceConfigurationId(value: String) extends StringValue
199 
200 object SpecificSequenceConfigurationId {
201   implicit val specificSequenceConfigurationIdCodec: Codec[SpecificSequenceConfigurationId] =
202     Codec.from(Decoder[String].map(SpecificSequenceConfigurationId.apply), Encoder[String].contramap(_.value))
203 }
204 
205 sealed abstract class SequenceKind extends EnumEntry with Lowercase
206 
207 object SequenceKind extends Enum[SequenceKind] {
208 
209   case object Standard extends SequenceKind
210   case object Consensus extends SequenceKind
211   case object Controversy extends SequenceKind
212   case object Keyword extends SequenceKind
213 
214   override val values: IndexedSeq[SequenceKind] = findValues
215   final val swaggerAllowableValues = "Standard,Consensus,Controversy,Keyword"
216 
217   implicit val encoder: Encoder[SequenceKind] = Circe.encoderLowercase(this)
218   implicit val decoder: Decoder[SequenceKind] = Circe.decodeCaseInsensitive(this)
219 }