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 cats.implicits._
23 import eu.timepit.refined.types.numeric._
24 import grizzled.slf4j.Logging
25 import org.make.api.extensions.MakeDBExecutionContextComponent
26 import org.make.api.sequence.DefaultPersistentSequenceConfigurationServiceComponent.{
27   PersistentExplorationSequenceConfiguration,
28   PersistentSequenceConfiguration,
29   PersistentSpecificSequenceConfiguration
30 }
31 import org.make.api.technical.DatabaseTransactions._
32 import org.make.api.technical.ScalikeSupport._
33 import org.make.api.technical.ShortenedNames
34 import org.make.core.DateHelper
35 import org.make.core.question.QuestionId
36 import org.make.core.sequence._
37 import org.make.core.technical.RefinedTypes.Ratio
38 import scalikejdbc._
39 
40 import java.time.ZonedDateTime
41 import scala.concurrent.Future
42 
43 trait DefaultPersistentSequenceConfigurationServiceComponent extends PersistentSequenceConfigurationComponent {
44   this: MakeDBExecutionContextComponent =>
45 
46   implicit val specificSequenceConfigurationIdBinder: Binders[SpecificSequenceConfigurationId] =
47     stringValueBinders[SpecificSequenceConfigurationId](SpecificSequenceConfigurationId.apply)
48 
49   override lazy val persistentSequenceConfigurationService: PersistentSequenceConfigurationService =
50     new DefaultPersistentSequenceConfigurationService
51 
52   class DefaultPersistentSequenceConfigurationService
53       extends PersistentSequenceConfigurationService
54       with ShortenedNames
55       with Logging {
56 
57     private val alias = PersistentSequenceConfiguration.alias
58     private val mainSequenceAlias = PersistentExplorationSequenceConfiguration.syntax("main_sequence_configuration")
59     private val controversialSequenceAlias =
60       PersistentSpecificSequenceConfiguration.syntax("controversial_sequence_configuration")
61     private val popularSequenceAlias = PersistentSpecificSequenceConfiguration.syntax("popular_sequence_configuration")
62     private val keywordSequenceAlias = PersistentSpecificSequenceConfiguration.syntax("keyword_sequence_configuration")
63     private val column = PersistentSequenceConfiguration.column
64     private val specificColumn = PersistentSpecificSequenceConfiguration.column
65     private val explorationColumn = PersistentExplorationSequenceConfiguration.column
66 
67     private def selectSequenceConfiguration[T]: scalikejdbc.SelectSQLBuilder[T] =
68       select
69         .from(PersistentSequenceConfiguration.as(alias))
70         .leftJoin(PersistentExplorationSequenceConfiguration.as(mainSequenceAlias))
71         .on(alias.main, mainSequenceAlias.explorationSequenceConfigurationId)
72         .leftJoin(PersistentSpecificSequenceConfiguration.as(controversialSequenceAlias))
73         .on(alias.controversial, controversialSequenceAlias.id)
74         .leftJoin(PersistentSpecificSequenceConfiguration.as(popularSequenceAlias))
75         .on(alias.popular, popularSequenceAlias.id)
76         .leftJoin(PersistentSpecificSequenceConfiguration.as(keywordSequenceAlias))
77         .on(alias.keyword, keywordSequenceAlias.id)
78 
79     private def findOne[A: ParameterBinderFactory](name: SQLSyntax, value: A) = {
80       implicit val context: EC = readExecutionContext
81       val futurePersistentTag = Future(NamedDB("READ").retryableTx { implicit session =>
82         withSQL {
83           selectSequenceConfiguration.where(sqls.eq(name, value))
84         }.map(
85             PersistentSequenceConfiguration
86               .apply(
87                 alias.resultName,
88                 mainSequenceAlias.resultName,
89                 controversialSequenceAlias.resultName,
90                 popularSequenceAlias.resultName,
91                 keywordSequenceAlias.resultName
92               )
93           )
94           .single()
95       })
96 
97       futurePersistentTag.map(_.map(_.toSequenceConfiguration))
98     }
99 
100     override def findOne(questionId: QuestionId): Future[Option[SequenceConfiguration]] =
101       findOne(alias.questionId, questionId)
102 
103     override def findAll(): Future[Seq[SequenceConfiguration]] = {
104       implicit val context: EC = readExecutionContext
105 
106       val futurePersistentSequenceConfig = Future(NamedDB("READ").retryableTx { implicit session =>
107         withSQL {
108           selectSequenceConfiguration
109         }.map(
110             PersistentSequenceConfiguration.apply(
111               alias.resultName,
112               mainSequenceAlias.resultName,
113               controversialSequenceAlias.resultName,
114               popularSequenceAlias.resultName,
115               keywordSequenceAlias.resultName
116             )
117           )
118           .list()
119       })
120 
121       futurePersistentSequenceConfig.map(_.map(_.toSequenceConfiguration))
122     }
123 
124     private def insertConfig(sequenceConfig: SequenceConfiguration): Future[Boolean] = {
125       implicit val context: EC = writeExecutionContext
126       Future(NamedDB("WRITE").retryableTx { implicit session =>
127         withSQL {
128           insert
129             .into(PersistentSequenceConfiguration)
130             .namedValues(
131               column.sequenceId -> sequenceConfig.questionId,
132               column.questionId -> sequenceConfig.questionId,
133               column.main -> sequenceConfig.mainSequence.explorationSequenceConfigurationId,
134               column.controversial -> sequenceConfig.controversial.specificSequenceConfigurationId,
135               column.popular -> sequenceConfig.popular.specificSequenceConfigurationId,
136               column.keyword -> sequenceConfig.keyword.specificSequenceConfigurationId,
137               column.newProposalsVoteThreshold -> sequenceConfig.newProposalsVoteThreshold,
138               column.testedProposalsEngagementThreshold -> sequenceConfig.testedProposalsEngagementThreshold,
139               column.testedProposalsScoreThreshold -> sequenceConfig.testedProposalsScoreThreshold,
140               column.testedProposalsControversyThreshold -> sequenceConfig.testedProposalsControversyThreshold,
141               column.testedProposalsMaxVotesThreshold -> sequenceConfig.testedProposalsMaxVotesThreshold,
142               column.createdAt -> DateHelper.now(),
143               column.updatedAt -> DateHelper.now(),
144               column.nonSequenceVotesWeight -> sequenceConfig.nonSequenceVotesWeight
145             )
146         }.execute()
147       })
148     }
149 
150     private def insertSpecificConfig(specificSequenceConfig: SpecificSequenceConfiguration): Future[Boolean] = {
151       implicit val context: EC = writeExecutionContext
152       Future(NamedDB("WRITE").retryableTx { implicit session =>
153         withSQL {
154           insert
155             .into(PersistentSpecificSequenceConfiguration)
156             .namedValues(
157               specificColumn.id -> specificSequenceConfig.specificSequenceConfigurationId,
158               specificColumn.sequenceSize -> specificSequenceConfig.sequenceSize,
159               specificColumn.newProposalsRatio -> specificSequenceConfig.newProposalsRatio,
160               specificColumn.maxTestedProposalCount -> specificSequenceConfig.maxTestedProposalCount,
161               specificColumn.selectionAlgorithmName -> specificSequenceConfig.selectionAlgorithmName
162             )
163         }.execute()
164       })
165     }
166 
167     private def insertExplorationConfig(config: ExplorationSequenceConfiguration): Future[Boolean] = {
168       implicit val context: EC = writeExecutionContext
169       Future(NamedDB("WRITE").retryableTx { implicit session =>
170         withSQL {
171           insert
172             .into(PersistentExplorationSequenceConfiguration)
173             .namedValues(
174               explorationColumn.explorationSequenceConfigurationId -> config.explorationSequenceConfigurationId,
175               explorationColumn.sequenceSize -> config.sequenceSize,
176               explorationColumn.maxTestedProposalCount -> config.maxTestedProposalCount,
177               explorationColumn.newRatio -> config.newRatio,
178               explorationColumn.controversyRatio -> config.controversyRatio,
179               explorationColumn.topSorter -> config.topSorter,
180               explorationColumn.controversySorter -> config.controversySorter,
181               explorationColumn.keywordsThreshold -> config.keywordsThreshold,
182               explorationColumn.candidatesPoolSize -> config.candidatesPoolSize,
183               explorationColumn.strongOpinionThreshold -> config.sequenceThresholds.strongOpinion,
184               explorationColumn.neutralOpinionThreshold -> config.sequenceThresholds.neutralOpinion,
185               explorationColumn.weakOpinionThreshold -> config.sequenceThresholds.weakOpinion
186             )
187         }.execute()
188       })
189     }
190 
191     private def updateConfig(sequenceConfig: SequenceConfiguration): Future[Int] = {
192       implicit val context: EC = writeExecutionContext
193       Future(NamedDB("WRITE").retryableTx { implicit session =>
194         withSQL {
195           update(PersistentSequenceConfiguration)
196             .set(
197               column.main -> sequenceConfig.mainSequence.explorationSequenceConfigurationId,
198               column.controversial -> sequenceConfig.controversial.specificSequenceConfigurationId,
199               column.popular -> sequenceConfig.popular.specificSequenceConfigurationId,
200               column.keyword -> sequenceConfig.keyword.specificSequenceConfigurationId,
201               column.newProposalsVoteThreshold -> sequenceConfig.newProposalsVoteThreshold,
202               column.testedProposalsEngagementThreshold -> sequenceConfig.testedProposalsEngagementThreshold,
203               column.testedProposalsScoreThreshold -> sequenceConfig.testedProposalsScoreThreshold,
204               column.testedProposalsControversyThreshold -> sequenceConfig.testedProposalsControversyThreshold,
205               column.testedProposalsMaxVotesThreshold -> sequenceConfig.testedProposalsMaxVotesThreshold,
206               column.updatedAt -> DateHelper.now(),
207               column.nonSequenceVotesWeight -> sequenceConfig.nonSequenceVotesWeight
208             )
209             .where(
210               sqls
211                 .eq(column.questionId, sequenceConfig.questionId)
212             )
213         }.update()
214       })
215     }
216 
217     private def updateSpecificConfig(specificSequenceConfig: SpecificSequenceConfiguration): Future[Int] = {
218       implicit val context: EC = writeExecutionContext
219       Future(NamedDB("WRITE").retryableTx { implicit session =>
220         withSQL {
221           update(PersistentSpecificSequenceConfiguration)
222             .set(
223               specificColumn.sequenceSize -> specificSequenceConfig.sequenceSize,
224               specificColumn.newProposalsRatio -> specificSequenceConfig.newProposalsRatio,
225               specificColumn.maxTestedProposalCount -> specificSequenceConfig.maxTestedProposalCount,
226               specificColumn.selectionAlgorithmName -> specificSequenceConfig.selectionAlgorithmName
227             )
228             .where(
229               sqls
230                 .eq(specificColumn.id, specificSequenceConfig.specificSequenceConfigurationId)
231             )
232         }.update()
233       })
234     }
235 
236     private def updateExplorationConfig(config: ExplorationSequenceConfiguration): Future[Int] = {
237       implicit val context: EC = writeExecutionContext
238       Future(NamedDB("WRITE").retryableTx { implicit session =>
239         withSQL {
240           update(PersistentExplorationSequenceConfiguration)
241             .set(
242               explorationColumn.sequenceSize -> config.sequenceSize,
243               explorationColumn.maxTestedProposalCount -> config.maxTestedProposalCount,
244               explorationColumn.newRatio -> config.newRatio,
245               explorationColumn.controversyRatio -> config.controversyRatio,
246               explorationColumn.topSorter -> config.topSorter,
247               explorationColumn.controversySorter -> config.controversySorter,
248               explorationColumn.keywordsThreshold -> config.keywordsThreshold,
249               explorationColumn.candidatesPoolSize -> config.candidatesPoolSize,
250               explorationColumn.strongOpinionThreshold -> config.sequenceThresholds.strongOpinion,
251               explorationColumn.neutralOpinionThreshold -> config.sequenceThresholds.neutralOpinion,
252               explorationColumn.weakOpinionThreshold -> config.sequenceThresholds.weakOpinion
253             )
254             .where(
255               sqls.eq(explorationColumn.explorationSequenceConfigurationId, config.explorationSequenceConfigurationId)
256             )
257         }.update()
258       })
259     }
260 
261     private def deleteConfig(questionId: QuestionId): Future[Unit] = {
262       implicit val context: EC = readExecutionContext
263       Future(NamedDB("WRITE").retryableTx { implicit session =>
264         withSQL {
265           deleteFrom(PersistentSequenceConfiguration)
266             .where(sqls.eq(PersistentSequenceConfiguration.column.questionId, questionId.value))
267         }.execute()
268       }).void
269     }
270 
271     private def deleteSpecificConfig(specificSequenceConfigurationId: SpecificSequenceConfigurationId): Future[Unit] = {
272       implicit val context: EC = readExecutionContext
273       Future(NamedDB("WRITE").retryableTx { implicit session =>
274         withSQL {
275           deleteFrom(PersistentSpecificSequenceConfiguration)
276             .where(sqls.eq(PersistentSpecificSequenceConfiguration.column.id, specificSequenceConfigurationId))
277         }.execute()
278       }).void
279     }
280 
281     private def deleteExplorationConfig(
282       explorationSequenceConfigurationId: ExplorationSequenceConfigurationId
283     ): Future[Unit] = {
284       implicit val context: EC = readExecutionContext
285       Future(NamedDB("WRITE").retryableTx { implicit session =>
286         withSQL {
287           deleteFrom(PersistentExplorationSequenceConfiguration)
288             .where(sqls.eq(explorationColumn.explorationSequenceConfigurationId, explorationSequenceConfigurationId))
289         }.execute()
290       }).void
291     }
292 
293     private def insertAllConfig(sequenceConfiguration: SequenceConfiguration): Future[Boolean] = {
294       implicit val context: EC = writeExecutionContext
295       for {
296         _      <- insertExplorationConfig(sequenceConfiguration.mainSequence)
297         _      <- insertSpecificConfig(sequenceConfiguration.controversial)
298         _      <- insertSpecificConfig(sequenceConfiguration.popular)
299         _      <- insertSpecificConfig(sequenceConfiguration.keyword)
300         result <- insertConfig(sequenceConfiguration)
301       } yield result
302     }
303 
304     private def updateAllConfig(sequenceConfiguration: SequenceConfiguration): Future[Int] = {
305       implicit val context: EC = writeExecutionContext
306       for {
307         _      <- updateExplorationConfig(sequenceConfiguration.mainSequence)
308         _      <- updateSpecificConfig(sequenceConfiguration.controversial)
309         _      <- updateSpecificConfig(sequenceConfiguration.popular)
310         _      <- updateSpecificConfig(sequenceConfiguration.keyword)
311         result <- updateConfig(sequenceConfiguration)
312       } yield result
313     }
314 
315     private def deleteAllConfig(sequenceConfiguration: SequenceConfiguration): Future[Unit] = {
316       implicit val context: EC = writeExecutionContext
317       for {
318         _ <- deleteConfig(sequenceConfiguration.questionId)
319         _ <- deleteExplorationConfig(sequenceConfiguration.mainSequence.explorationSequenceConfigurationId)
320         _ <- deleteSpecificConfig(sequenceConfiguration.controversial.specificSequenceConfigurationId)
321         _ <- deleteSpecificConfig(sequenceConfiguration.popular.specificSequenceConfigurationId)
322         _ <- deleteSpecificConfig(sequenceConfiguration.keyword.specificSequenceConfigurationId)
323       } yield {}
324     }
325 
326     override def persist(sequenceConfig: SequenceConfiguration): Future[Boolean] = {
327       implicit val context: EC = writeExecutionContext
328       findOne(sequenceConfig.questionId).flatMap {
329         case Some(_) => updateAllConfig(sequenceConfig).map(_ == 1)
330         case None    => insertAllConfig(sequenceConfig)
331       }
332     }
333 
334     override def delete(questionId: QuestionId): Future[Unit] = {
335       implicit val context: EC = writeExecutionContext
336       findOne(questionId).flatMap {
337         case Some(sequenceConfig) => deleteAllConfig(sequenceConfig)
338         case None                 => Future.successful({})
339       }
340     }
341   }
342 }
343 
344 object DefaultPersistentSequenceConfigurationServiceComponent {
345 
346   final case class PersistentSequenceConfiguration(
347     sequenceId: String,
348     questionId: String,
349     main: PersistentExplorationSequenceConfiguration,
350     controversial: PersistentSpecificSequenceConfiguration,
351     popular: PersistentSpecificSequenceConfiguration,
352     keyword: PersistentSpecificSequenceConfiguration,
353     newProposalsVoteThreshold: Int,
354     testedProposalsEngagementThreshold: Option[Double],
355     testedProposalsScoreThreshold: Option[Double],
356     testedProposalsControversyThreshold: Option[Double],
357     testedProposalsMaxVotesThreshold: Option[Int],
358     createdAt: ZonedDateTime,
359     updatedAt: ZonedDateTime,
360     nonSequenceVotesWeight: Double
361   ) {
362     def toSequenceConfiguration: SequenceConfiguration = {
363       SequenceConfiguration(
364         questionId = QuestionId(questionId),
365         mainSequence = main.toExplorationSequenceConfiguration,
366         controversial = controversial.toSpecificSequenceConfiguration,
367         popular = popular.toSpecificSequenceConfiguration,
368         keyword = keyword.toSpecificSequenceConfiguration,
369         newProposalsVoteThreshold = newProposalsVoteThreshold,
370         testedProposalsEngagementThreshold = testedProposalsEngagementThreshold,
371         testedProposalsScoreThreshold = testedProposalsScoreThreshold,
372         testedProposalsControversyThreshold = testedProposalsControversyThreshold,
373         testedProposalsMaxVotesThreshold = testedProposalsMaxVotesThreshold,
374         nonSequenceVotesWeight = nonSequenceVotesWeight
375       )
376     }
377   }
378 
379   object PersistentSequenceConfiguration
380       extends SQLSyntaxSupport[PersistentSequenceConfiguration]
381       with ShortenedNames
382       with Logging {
383 
384     override val columnNames: Seq[String] =
385       Seq(
386         "sequence_id",
387         "question_id",
388         "main",
389         "controversial",
390         "popular",
391         "keyword",
392         "new_proposals_vote_threshold",
393         "tested_proposals_engagement_threshold",
394         "tested_proposals_score_threshold",
395         "tested_proposals_controversy_threshold",
396         "tested_proposals_max_votes_threshold",
397         "created_at",
398         "updated_at",
399         "non_sequence_votes_weight"
400       )
401 
402     override val tableName: String = "sequence_configuration"
403 
404     lazy val alias
405       : QuerySQLSyntaxProvider[SQLSyntaxSupport[PersistentSequenceConfiguration], PersistentSequenceConfiguration] =
406       syntax("sequence_configuration")
407 
408     val specificSequenceConfigurationResultName: ResultName[PersistentSpecificSequenceConfiguration] =
409       PersistentSpecificSequenceConfiguration.alias.resultName
410 
411     def apply(
412       resultName: ResultName[PersistentSequenceConfiguration],
413       mainSequenceResultName: ResultName[PersistentExplorationSequenceConfiguration],
414       controversialSequenceResultName: ResultName[PersistentSpecificSequenceConfiguration],
415       popularSequenceResultName: ResultName[PersistentSpecificSequenceConfiguration],
416       keywordSequenceResultName: ResultName[PersistentSpecificSequenceConfiguration]
417     )(resultSet: WrappedResultSet): PersistentSequenceConfiguration = {
418       PersistentSequenceConfiguration.apply(
419         sequenceId = resultSet.string(resultName.sequenceId),
420         questionId = resultSet.string(resultName.questionId),
421         main = PersistentExplorationSequenceConfiguration(mainSequenceResultName)(resultSet),
422         controversial = PersistentSpecificSequenceConfiguration(controversialSequenceResultName)(resultSet),
423         popular = PersistentSpecificSequenceConfiguration(popularSequenceResultName)(resultSet),
424         keyword = PersistentSpecificSequenceConfiguration(keywordSequenceResultName)(resultSet),
425         newProposalsVoteThreshold = resultSet.int(resultName.newProposalsVoteThreshold),
426         testedProposalsEngagementThreshold = resultSet.doubleOpt(resultName.testedProposalsEngagementThreshold),
427         testedProposalsScoreThreshold = resultSet.doubleOpt(resultName.testedProposalsScoreThreshold),
428         testedProposalsControversyThreshold = resultSet.doubleOpt(resultName.testedProposalsControversyThreshold),
429         testedProposalsMaxVotesThreshold = resultSet.intOpt(resultName.testedProposalsMaxVotesThreshold),
430         createdAt = resultSet.zonedDateTime(resultName.createdAt),
431         updatedAt = resultSet.zonedDateTime(resultName.updatedAt),
432         nonSequenceVotesWeight = resultSet.double(resultName.nonSequenceVotesWeight)
433       )
434     }
435   }
436 
437   object PersistentExplorationSequenceConfiguration
438       extends SQLSyntaxSupport[PersistentExplorationSequenceConfiguration] {
439     override val columnNames: Seq[String] =
440       Seq(
441         "exploration_sequence_configuration_id",
442         "sequence_size",
443         "max_tested_proposal_count",
444         "new_ratio",
445         "controversy_ratio",
446         "top_sorter",
447         "controversy_sorter",
448         "keywords_threshold",
449         "candidates_pool_size",
450         "strong_opinion_threshold",
451         "neutral_opinion_threshold",
452         "weak_opinion_threshold"
453       )
454     override def tableName: String = "exploration_sequence_configuration"
455 
456     def apply(
457       rn: ResultName[PersistentExplorationSequenceConfiguration]
458     )(rs: WrappedResultSet): PersistentExplorationSequenceConfiguration =
459       PersistentExplorationSequenceConfiguration(
460         explorationSequenceConfigurationId = rs.string(rn.explorationSequenceConfigurationId),
461         sequenceSize = rs.get[PosInt](rn.sequenceSize),
462         maxTestedProposalCount = rs.get[PosInt](rn.maxTestedProposalCount),
463         newRatio = rs.get[Ratio](rn.newRatio),
464         controversyRatio = rs.get[Ratio](rn.controversyRatio),
465         topSorter = rs.string(rn.topSorter),
466         controversySorter = rs.string(rn.controversySorter),
467         keywordsThreshold = rs.get[Ratio](rn.keywordsThreshold),
468         candidatesPoolSize = rs.int(rn.candidatesPoolSize),
469         strongOpinionThreshold = rs.get[Ratio](rn.strongOpinionThreshold),
470         neutralOpinionThreshold = rs.get[Ratio](rn.neutralOpinionThreshold),
471         weakOpinionThreshold = rs.get[Ratio](rn.weakOpinionThreshold)
472       )
473   }
474 
475   final case class PersistentExplorationSequenceConfiguration(
476     explorationSequenceConfigurationId: String,
477     sequenceSize: PosInt,
478     maxTestedProposalCount: PosInt,
479     newRatio: Ratio,
480     controversyRatio: Ratio,
481     topSorter: String,
482     controversySorter: String,
483     keywordsThreshold: Ratio,
484     candidatesPoolSize: Int,
485     strongOpinionThreshold: Ratio,
486     neutralOpinionThreshold: Ratio,
487     weakOpinionThreshold: Ratio
488   ) {
489     val toExplorationSequenceConfiguration: ExplorationSequenceConfiguration = ExplorationSequenceConfiguration(
490       explorationSequenceConfigurationId = ExplorationSequenceConfigurationId(explorationSequenceConfigurationId),
491       sequenceSize = sequenceSize,
492       maxTestedProposalCount = maxTestedProposalCount,
493       newRatio = newRatio,
494       controversyRatio = controversyRatio,
495       topSorter = ExplorationSortAlgorithm.withValue(topSorter),
496       controversySorter = ExplorationSortAlgorithm.withValue(controversySorter),
497       keywordsThreshold = keywordsThreshold,
498       candidatesPoolSize = candidatesPoolSize,
499       sequenceThresholds = ExplorationSequenceConfiguration
500         .SequenceThresholds(strongOpinionThreshold, neutralOpinionThreshold, weakOpinionThreshold)
501     )
502   }
503 
504   final case class PersistentSpecificSequenceConfiguration(
505     id: String,
506     sequenceSize: PosInt,
507     newProposalsRatio: Double,
508     maxTestedProposalCount: PosInt,
509     selectionAlgorithmName: String
510   ) {
511     def toSpecificSequenceConfiguration: SpecificSequenceConfiguration = {
512       SpecificSequenceConfiguration(
513         specificSequenceConfigurationId = SpecificSequenceConfigurationId(id),
514         sequenceSize = sequenceSize,
515         newProposalsRatio = newProposalsRatio,
516         maxTestedProposalCount = maxTestedProposalCount,
517         selectionAlgorithmName = SelectionAlgorithmName.withValue(selectionAlgorithmName)
518       )
519     }
520   }
521 
522   object PersistentSpecificSequenceConfiguration
523       extends SQLSyntaxSupport[PersistentSpecificSequenceConfiguration]
524       with ShortenedNames
525       with Logging {
526 
527     override val columnNames: Seq[String] =
528       Seq("id", "sequence_size", "new_proposals_ratio", "max_tested_proposal_count", "selection_algorithm_name")
529 
530     override val tableName: String = "specific_sequence_configuration"
531 
532     lazy val alias
533       : QuerySQLSyntaxProvider[SQLSyntaxSupport[PersistentSpecificSequenceConfiguration], PersistentSpecificSequenceConfiguration] =
534       syntax("specific_sequence_configuration")
535 
536     def apply(
537       resultName: ResultName[PersistentSpecificSequenceConfiguration] = alias.resultName
538     )(resultSet: WrappedResultSet): PersistentSpecificSequenceConfiguration = {
539       PersistentSpecificSequenceConfiguration.apply(
540         id = resultSet.string(resultName.id),
541         sequenceSize = resultSet.get[PosInt](resultName.sequenceSize),
542         newProposalsRatio = resultSet.double(resultName.newProposalsRatio),
543         maxTestedProposalCount = resultSet.get[PosInt](resultName.maxTestedProposalCount),
544         selectionAlgorithmName = resultSet.string(resultName.selectionAlgorithmName)
545       )
546     }
547   }
548 }