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.user
21 
22 import cats.data.NonEmptyList
23 import grizzled.slf4j.Logging
24 import org.make.api.extensions.MakeDBExecutionContextComponent
25 import org.make.api.technical.DatabaseTransactions._
26 import org.make.api.technical.{PersistentCompanion, ShortenedNames}
27 import org.make.api.technical.ScalikeSupport._
28 import org.make.core.question.QuestionId
29 import org.make.core.user._
30 import scalikejdbc._
31 import cats.implicits._
32 
33 import java.util.UUID
34 import scala.concurrent.Future
35 
36 trait DefaultPersistentUserProposalsServiceComponent
37     extends PersistentUserProposalsServiceComponent
38     with ShortenedNames
39     with Logging {
40 
41   this: MakeDBExecutionContextComponent =>
42 
43   override lazy val persistentUserProposalsService: PersistentUserProposalsService =
44     new DefaultPersistentUserProposalsService
45 
46   class DefaultPersistentUserProposalsService extends PersistentUserProposalsService {
47 
48     import DefaultPersistentUserProposalsServiceComponent.UserProposalsCount
49 
50     private val userProposalsAlias = UserProposalsCount.alias
51     private val column = UserProposalsCount.column
52 
53     private def makePredicates(userId: UserId, questionId: QuestionId) =
54       sqls
55         .eq(column.questionId, questionId.value)
56         .and(sqls.eq(column.userId, userId.value))
57 
58     private def getCounterOpt(userId: UserId, questionId: QuestionId)(implicit ctx: EC): Future[Option[Int]] =
59       Future(NamedDB("READ").retryableTx { implicit session =>
60         withSQL {
61           select(userProposalsAlias.count)
62             .from(UserProposalsCount.as(userProposalsAlias))
63             .where(makePredicates(userId, questionId))
64         }.map(_.int(1)).single()
65       })
66 
67     override def getCounter(userId: UserId, questionId: QuestionId): Future[Int] = {
68       implicit val ctx: EC = readExecutionContext
69       getCounterOpt(userId, questionId).map(_.getOrElse(0))
70     }
71 
72     private def createUserProposalsRow(userId: UserId, questionId: QuestionId)(implicit ctx: EC): Future[Unit] =
73       Future(NamedDB("WRITE").retryableTx { implicit session =>
74         withSQL {
75           insert
76             .into(UserProposalsCount)
77             .namedValues(
78               column.id -> UUID.randomUUID().toString,
79               column.userId -> userId.value,
80               column.questionId -> questionId.value,
81               column.count -> 1.toString
82             )
83         }.execute()
84       })
85 
86     override def incrementCounter(userId: UserId, questionId: QuestionId): Future[Int] = {
87       implicit val ctx: EC = writeExecutionContext
88       getCounterOpt(userId, questionId).flatMap({
89         case Some(count) =>
90           Future(NamedDB("WRITE").retryableTx { implicit session =>
91             withSQL {
92               update(UserProposalsCount)
93                 .set(column.count -> (count + 1).toString)
94                 .where(makePredicates(userId, questionId))
95             }.executeUpdate()
96           }).as(count + 1)
97         case None => createUserProposalsRow(userId, questionId).as(1)
98       })
99     }
100   }
101 }
102 
103 object DefaultPersistentUserProposalsServiceComponent {
104 
105   final case class UserProposalsCount(id: String, userId: String, questionId: String, count: Int)
106 
107   object UserProposalsCount
108       extends SQLSyntaxSupport[UserProposalsCount]
109       with PersistentCompanion[UserProposalsCount, User]
110       with ShortenedNames
111       with Logging {
112 
113     override val columnNames: Seq[String] = Seq("id", "user_id", "question_id", "count")
114 
115     override val tableName: String = "votes_per_user_per_question"
116 
117     override lazy val alias: SyntaxProvider[UserProposalsCount] = syntax("counts")
118 
119     override lazy val defaultSortColumns: NonEmptyList[SQLSyntax] = NonEmptyList.of(alias.questionId)
120 
121     def apply(
122       userPropositionsResultName: ResultName[UserProposalsCount]
123     )(resultSet: WrappedResultSet): UserProposalsCount = {
124       UserProposalsCount(
125         id = resultSet.string(userPropositionsResultName.id),
126         userId = resultSet.string(userPropositionsResultName.userId),
127         questionId = resultSet.string(userPropositionsResultName.questionId),
128         count = resultSet.int(userPropositionsResultName.count)
129       )
130     }
131   }
132 }