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.feature
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.feature.DefaultPersistentActiveFeatureServiceComponent.PersistentActiveFeature
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.api.technical.ScalikeSupport._
31 import org.make.core.technical.Pagination
32 import org.make.core.feature.{ActiveFeature, ActiveFeatureId, FeatureId}
33 import org.make.core.question.QuestionId
34 import org.make.core.Order
35 import scalikejdbc._
36 
37 import scala.concurrent.Future
38 
39 trait DefaultPersistentActiveFeatureServiceComponent extends PersistentActiveFeatureServiceComponent {
40   this: MakeDBExecutionContextComponent =>
41 
42   override lazy val persistentActiveFeatureService: PersistentActiveFeatureService =
43     new DefaultPersistentActiveFeatureService
44 
45   class DefaultPersistentActiveFeatureService extends PersistentActiveFeatureService with ShortenedNames with Logging {
46 
47     private val activeFeatureAlias = PersistentActiveFeature.alias
48 
49     private val column = PersistentActiveFeature.column
50 
51     override def get(activeFeatureId: ActiveFeatureId): Future[Option[ActiveFeature]] = {
52       implicit val context: EC = readExecutionContext
53       val futurePersistentActiveFeature = Future(NamedDB("READ").retryableTx { implicit session =>
54         withSQL {
55           select
56             .from(PersistentActiveFeature.as(activeFeatureAlias))
57             .where(sqls.eq(activeFeatureAlias.id, activeFeatureId))
58         }.map(PersistentActiveFeature.apply()).single()
59       })
60 
61       futurePersistentActiveFeature.map(_.map(_.toActiveFeature))
62     }
63 
64     override def persist(activeFeature: ActiveFeature): Future[ActiveFeature] = {
65       implicit val context: EC = writeExecutionContext
66       Future(NamedDB("WRITE").retryableTx { implicit session =>
67         withSQL {
68           insert
69             .into(PersistentActiveFeature)
70             .namedValues(
71               column.id -> activeFeature.activeFeatureId,
72               column.featureId -> activeFeature.featureId,
73               column.questionId -> activeFeature.maybeQuestionId
74             )
75         }.execute()
76       }).map(_ => activeFeature)
77     }
78 
79     override def remove(activeFeatureId: ActiveFeatureId): Future[Unit] = {
80       implicit val context: EC = writeExecutionContext
81       Future(NamedDB("WRITE").retryableTx { implicit session =>
82         withSQL {
83           delete
84             .from(PersistentActiveFeature.as(activeFeatureAlias))
85             .where(sqls.eq(activeFeatureAlias.id, activeFeatureId))
86         }.update()
87       }).void
88     }
89 
90     override def find(
91       offset: Pagination.Offset,
92       end: Option[Pagination.End],
93       sort: Option[String],
94       order: Option[Order],
95       maybeQuestionId: Option[Seq[QuestionId]],
96       featureId: Option[Seq[FeatureId]]
97     ): Future[Seq[ActiveFeature]] = {
98       implicit val context: EC = readExecutionContext
99 
100       val futurePersistentActiveFeatures: Future[List[PersistentActiveFeature]] = Future(NamedDB("READ").retryableTx {
101         implicit session =>
102           withSQL {
103             val query: scalikejdbc.PagingSQLBuilder[PersistentActiveFeature] =
104               select
105                 .from(PersistentActiveFeature.as(activeFeatureAlias))
106                 .where(
107                   sqls.toAndConditionOpt(
108                     maybeQuestionId.map(sqls.in(activeFeatureAlias.questionId, _)),
109                     featureId.map(sqls.in(activeFeatureAlias.featureId, _))
110                   )
111                 )
112             sortOrderQuery(offset, end, sort, order, query)
113           }.map(PersistentActiveFeature.apply()).list()
114       })
115 
116       futurePersistentActiveFeatures.map(_.map(_.toActiveFeature))
117     }
118 
119     override def count(maybeQuestionId: Option[QuestionId]): Future[Int] = {
120       implicit val context: EC = readExecutionContext
121 
122       Future(NamedDB("READ").retryableTx { implicit session =>
123         withSQL {
124           select(sqls.count)
125             .from(PersistentActiveFeature.as(activeFeatureAlias))
126             .where(
127               sqls.toAndConditionOpt(
128                 maybeQuestionId.map(questionId => sqls.eq(activeFeatureAlias.questionId, questionId))
129               )
130             )
131         }.map(_.int(1)).single().getOrElse(0)
132       })
133     }
134   }
135 }
136 
137 object DefaultPersistentActiveFeatureServiceComponent {
138 
139   final case class PersistentActiveFeature(id: String, featureId: String, questionId: Option[String]) {
140     def toActiveFeature: ActiveFeature =
141       ActiveFeature(
142         activeFeatureId = ActiveFeatureId(id),
143         featureId = FeatureId(featureId),
144         maybeQuestionId = questionId.map(QuestionId(_))
145       )
146   }
147 
148   implicit object PersistentActiveFeature
149       extends PersistentCompanion[PersistentActiveFeature, ActiveFeature]
150       with ShortenedNames
151       with Logging {
152 
153     override val columnNames: Seq[String] = Seq("id", "feature_id", "question_id")
154     final val swaggerAllowableValues = "id,feature_id,question_id"
155 
156     override val tableName: String = "active_feature"
157 
158     override lazy val alias: SyntaxProvider[PersistentActiveFeature] = syntax("active_feature")
159 
160     override lazy val defaultSortColumns: NonEmptyList[SQLSyntax] = NonEmptyList.of(alias.id)
161 
162     def apply(
163       activeFeatureResultName: ResultName[PersistentActiveFeature] = alias.resultName
164     )(resultSet: WrappedResultSet): PersistentActiveFeature = {
165       PersistentActiveFeature.apply(
166         id = resultSet.string(activeFeatureResultName.id),
167         featureId = resultSet.string(activeFeatureResultName.featureId),
168         questionId = resultSet.stringOpt(activeFeatureResultName.questionId)
169       )
170     }
171   }
172 
173 }