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.personality
21 
22 import cats.data.NonEmptyList
23 import cats.implicits._
24 import grizzled.slf4j.Logging
25 import org.make.api.extensions.MakeDBExecutionContextComponent
26 import org.make.api.personality.DefaultPersistentQuestionPersonalityServiceComponent.PersistentPersonality
27 import org.make.api.technical.DatabaseTransactions._
28 import org.make.api.technical.PersistentServiceUtils.sortOrderQuery
29 import org.make.api.technical.{PersistentCompanion, ShortenedNames}
30 import org.make.core.technical.Pagination
31 import org.make.core.personality.{Personality, PersonalityId, PersonalityRoleId}
32 import org.make.core.question.QuestionId
33 import org.make.core.user.UserId
34 import org.make.core.Order
35 import scalikejdbc._
36 
37 import scala.concurrent.Future
38 
39 trait DefaultPersistentQuestionPersonalityServiceComponent extends PersistentQuestionPersonalityServiceComponent {
40   this: MakeDBExecutionContextComponent =>
41 
42   override lazy val persistentQuestionPersonalityService: DefaultPersistentQuestionPersonalityService =
43     new DefaultPersistentQuestionPersonalityService
44 
45   class DefaultPersistentQuestionPersonalityService extends PersistentQuestionPersonalityService with ShortenedNames {
46 
47     private val personalityAlias = PersistentPersonality.alias
48 
49     private val column = PersistentPersonality.column
50 
51     override def persist(personality: Personality): Future[Personality] = {
52       implicit val context: EC = writeExecutionContext
53       Future(NamedDB("WRITE").retryableTx { implicit session =>
54         withSQL {
55           insert
56             .into(PersistentPersonality)
57             .namedValues(
58               column.id -> personality.personalityId.value,
59               column.userId -> personality.userId.value,
60               column.questionId -> personality.questionId.value,
61               column.personalityRoleId -> personality.personalityRoleId.value
62             )
63         }.execute()
64       }).map(_ => personality)
65     }
66 
67     override def modify(personality: Personality): Future[Personality] = {
68       implicit val context: EC = writeExecutionContext
69       Future(NamedDB("WRITE").retryableTx { implicit session =>
70         withSQL {
71           update(PersistentPersonality)
72             .set(
73               column.userId -> personality.userId.value,
74               column.questionId -> personality.questionId.value,
75               column.personalityRoleId -> personality.personalityRoleId.value
76             )
77             .where(sqls.eq(column.id, personality.personalityId.value))
78         }.execute()
79       }).map(_ => personality)
80     }
81 
82     override def getById(personalityId: PersonalityId): Future[Option[Personality]] = {
83       implicit val context: EC = readExecutionContext
84       Future(NamedDB("READ").retryableTx { implicit session =>
85         withSQL {
86           select
87             .from(PersistentPersonality.as(personalityAlias))
88             .where(sqls.eq(personalityAlias.id, personalityId.value))
89         }.map(PersistentPersonality.apply()).single()
90       }).map(_.map(_.toPersonality))
91     }
92 
93     override def find(
94       offset: Pagination.Offset,
95       end: Option[Pagination.End],
96       sort: Option[String],
97       order: Option[Order],
98       userId: Option[UserId],
99       questionId: Option[QuestionId],
100       personalityRoleId: Option[PersonalityRoleId]
101     ): Future[Seq[Personality]] = {
102       implicit val context: EC = readExecutionContext
103       Future(NamedDB("READ").retryableTx { implicit session =>
104         withSQL {
105           val query: scalikejdbc.PagingSQLBuilder[PersistentPersonality] = select
106             .from(PersistentPersonality.as(personalityAlias))
107             .where(
108               sqls.toAndConditionOpt(
109                 userId.map(userId          => sqls.eq(personalityAlias.userId, userId.value)),
110                 questionId.map(questionId  => sqls.eq(personalityAlias.questionId, questionId.value)),
111                 personalityRoleId.map(role => sqls.eq(personalityAlias.personalityRoleId, role.value))
112               )
113             )
114 
115           sortOrderQuery(offset, end, sort, order, query)
116         }.map(PersistentPersonality.apply()).list()
117       }).map(_.map(_.toPersonality))
118     }
119 
120     def count(
121       userId: Option[UserId],
122       questionId: Option[QuestionId],
123       personalityRoleId: Option[PersonalityRoleId]
124     ): Future[Int] = {
125       implicit val context: EC = readExecutionContext
126       Future(NamedDB("READ").retryableTx { implicit session =>
127         withSQL {
128           select(sqls.count)
129             .from(PersistentPersonality.as(personalityAlias))
130             .where(
131               sqls.toAndConditionOpt(
132                 questionId.map(questionId  => sqls.eq(personalityAlias.questionId, questionId.value)),
133                 userId.map(userId          => sqls.eq(personalityAlias.userId, userId.value)),
134                 personalityRoleId.map(role => sqls.eq(personalityAlias.personalityRoleId, role.value))
135               )
136             )
137         }.map(_.int(1)).single().getOrElse(0)
138       })
139     }
140 
141     override def delete(personalityId: PersonalityId): Future[Unit] = {
142       implicit val context: EC = readExecutionContext
143       Future(NamedDB("WRITE").retryableTx { implicit session =>
144         withSQL {
145           deleteFrom(PersistentPersonality)
146             .where(sqls.eq(PersistentPersonality.column.id, personalityId.value))
147         }.execute()
148       }).void
149     }
150 
151   }
152 }
153 
154 object DefaultPersistentQuestionPersonalityServiceComponent {
155 
156   final case class PersistentPersonality(id: String, userId: String, questionId: String, personalityRoleId: String) {
157     def toPersonality: Personality = {
158       Personality(
159         personalityId = PersonalityId(id),
160         userId = UserId(userId),
161         questionId = QuestionId(questionId),
162         personalityRoleId = PersonalityRoleId(personalityRoleId)
163       )
164     }
165   }
166 
167   implicit object PersistentPersonality
168       extends PersistentCompanion[PersistentPersonality, Personality]
169       with ShortenedNames
170       with Logging {
171 
172     override val columnNames: Seq[String] =
173       Seq("id", "user_id", "question_id", "personality_role_id")
174     final val swaggerAllowableValues = "id,user_id,question_id,personality_role_id"
175 
176     override val tableName: String = "personality"
177 
178     override lazy val alias: SyntaxProvider[PersistentPersonality] = syntax("personality")
179 
180     override lazy val defaultSortColumns: NonEmptyList[SQLSyntax] = NonEmptyList.of(alias.id)
181 
182     def apply(
183       personalityResultName: ResultName[PersistentPersonality] = alias.resultName
184     )(resultSet: WrappedResultSet): PersistentPersonality = {
185       PersistentPersonality.apply(
186         id = resultSet.string(personalityResultName.id),
187         userId = resultSet.string(personalityResultName.userId),
188         questionId = resultSet.string(personalityResultName.questionId),
189         personalityRoleId = resultSet.string(personalityResultName.personalityRoleId)
190       )
191     }
192   }
193 
194 }