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.idea
21 
22 import java.time.ZonedDateTime
23 
24 import cats.implicits._
25 import grizzled.slf4j.Logging
26 import org.make.api.extensions.MakeDBExecutionContextComponent
27 import org.make.api.idea.DefaultPersistentIdeaServiceComponent.PersistentIdea
28 import org.make.api.technical.DatabaseTransactions._
29 import org.make.api.technical.ScalikeSupport._
30 import org.make.api.technical.ShortenedNames
31 import org.make.core.DateHelper
32 import org.make.core.idea.{Idea, IdeaId, IdeaStatus}
33 import org.make.core.operation.OperationId
34 import org.make.core.question.QuestionId
35 import scalikejdbc._
36 
37 import scala.concurrent.Future
38 
39 trait DefaultPersistentIdeaServiceComponent extends PersistentIdeaServiceComponent {
40   this: MakeDBExecutionContextComponent =>
41 
42   override lazy val persistentIdeaService: PersistentIdeaService = new DefaultPersistentIdeaService
43 
44   class DefaultPersistentIdeaService extends PersistentIdeaService with ShortenedNames with Logging {
45 
46     private val ideaAlias = PersistentIdea.ideaAlias
47     private val column = PersistentIdea.column
48 
49     override def findOne(ideaId: IdeaId): Future[Option[Idea]] = {
50       implicit val context: EC = readExecutionContext
51       val futurePersistentIdea = Future(NamedDB("READ").retryableTx { implicit session =>
52         withSQL {
53           select
54             .from(PersistentIdea.as(ideaAlias))
55             .where(sqls.eq(ideaAlias.id, ideaId.value))
56         }.map(PersistentIdea.apply()).single()
57       })
58 
59       futurePersistentIdea.map(_.map(_.toIdea))
60     }
61 
62     override def findOneByName(questionId: QuestionId, name: String): Future[Option[Idea]] = {
63       implicit val context: EC = readExecutionContext
64       val futurePersistentIdea = Future(NamedDB("READ").retryableTx { implicit session =>
65         withSQL {
66           select
67             .from(PersistentIdea.as(ideaAlias))
68             .where(sqls.eq(ideaAlias.questionId, questionId.value).and(sqls.eq(ideaAlias.name, name)))
69         }.map(PersistentIdea.apply()).single()
70       })
71 
72       futurePersistentIdea.map(_.map(_.toIdea))
73     }
74 
75     override def findAll(ideaFilters: IdeaFiltersRequest): Future[Seq[Idea]] = {
76       implicit val context: EC = readExecutionContext
77 
78       val futurePersistentIdeas = Future(NamedDB("READ").retryableTx { implicit session =>
79         withSQL {
80           select
81             .from(PersistentIdea.as(ideaAlias))
82             .where(
83               sqls.toAndConditionOpt(
84                 ideaFilters.questionId.map(questionId => sqls.eq(ideaAlias.questionId, questionId.value))
85               )
86             )
87         }.map(PersistentIdea.apply()).list()
88       })
89 
90       futurePersistentIdeas.map(_.map(_.toIdea))
91     }
92 
93     def findAllByIdeaIds(ids: Seq[IdeaId]): Future[Seq[Idea]] = {
94       implicit val cxt: EC = readExecutionContext
95       val futurePersistentIdeas = Future(NamedDB("READ").retryableTx { implicit session =>
96         withSQL {
97           select
98             .from(PersistentIdea.as(ideaAlias))
99             .where(sqls.in(ideaAlias.id, ids.map(_.value)))
100         }.map(PersistentIdea.apply()).list()
101       })
102 
103       futurePersistentIdeas.map(_.map(_.toIdea))
104     }
105 
106     override def persist(idea: Idea): Future[Idea] = {
107       implicit val context: EC = writeExecutionContext
108       Future(NamedDB("WRITE").retryableTx { implicit session =>
109         withSQL {
110           insert
111             .into(PersistentIdea)
112             .namedValues(
113               column.id -> idea.ideaId.value,
114               column.name -> idea.name,
115               column.questionId -> idea.questionId.map(_.value),
116               column.operationId -> idea.operationId.map(_.value),
117               column.status -> idea.status,
118               column.createdAt -> DateHelper.now(),
119               column.updatedAt -> DateHelper.now()
120             )
121         }.execute()
122       }).as(idea)
123     }
124 
125     override def modify(ideaId: IdeaId, name: String, status: IdeaStatus): Future[Int] = {
126       implicit val context: EC = writeExecutionContext
127       Future(NamedDB("WRITE").retryableTx { implicit session =>
128         withSQL {
129           update(PersistentIdea)
130             .set(column.name -> name, column.updatedAt -> DateHelper.now(), column.status -> status)
131             .where(
132               sqls
133                 .eq(column.id, ideaId.value)
134             )
135         }.update()
136       })
137     }
138 
139     override def updateIdea(idea: Idea): Future[Int] = {
140       implicit val context: EC = writeExecutionContext
141       Future(NamedDB("WRITE").retryableTx { implicit session =>
142         withSQL {
143           update(PersistentIdea)
144             .set(
145               column.name -> idea.name,
146               column.operationId -> idea.operationId.map(_.value),
147               column.questionId -> idea.questionId.map(_.value),
148               column.status -> idea.status,
149               column.updatedAt -> DateHelper.now()
150             )
151             .where(
152               sqls
153                 .eq(column.id, idea.ideaId.value)
154             )
155         }.update()
156       })
157     }
158   }
159 }
160 
161 object DefaultPersistentIdeaServiceComponent {
162 
163   final case class PersistentIdea(
164     id: String,
165     name: String,
166     question: Option[String],
167     questionId: Option[String],
168     operationId: Option[String],
169     status: Option[String],
170     createdAt: ZonedDateTime,
171     updatedAt: ZonedDateTime
172   ) {
173     def toIdea: Idea =
174       Idea(
175         ideaId = IdeaId(id),
176         name = name,
177         questionId = questionId.map(QuestionId.apply),
178         operationId = operationId.map(OperationId.apply),
179         status = status.flatMap(IdeaStatus.withValueOpt).getOrElse(IdeaStatus.Activated),
180         createdAt = Some(createdAt),
181         updatedAt = Some(updatedAt)
182       )
183   }
184 
185   object PersistentIdea extends SQLSyntaxSupport[PersistentIdea] with ShortenedNames with Logging {
186 
187     override val columnNames: Seq[String] =
188       Seq("id", "name", "question_id", "operation_id", "question", "status", "created_at", "updated_at")
189 
190     override val tableName: String = "idea"
191 
192     lazy val ideaAlias: QuerySQLSyntaxProvider[SQLSyntaxSupport[PersistentIdea], PersistentIdea] = syntax("idea")
193 
194     def apply(
195       ideaResultName: ResultName[PersistentIdea] = ideaAlias.resultName
196     )(resultSet: WrappedResultSet): PersistentIdea = {
197       PersistentIdea.apply(
198         id = resultSet.string(ideaResultName.id),
199         name = resultSet.string(ideaResultName.name),
200         question = resultSet.stringOpt(ideaResultName.question),
201         questionId = resultSet.stringOpt(ideaResultName.questionId),
202         operationId = resultSet.stringOpt(ideaResultName.operationId),
203         status = resultSet.stringOpt(ideaResultName.status),
204         createdAt = resultSet.zonedDateTime(ideaResultName.createdAt),
205         updatedAt = resultSet.zonedDateTime(ideaResultName.updatedAt)
206       )
207     }
208   }
209 }