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.DefaultPersistentFeatureServiceComponent.PersistentFeature
27 import org.make.api.technical.DatabaseTransactions._
28 import org.make.api.technical.PersistentServiceUtils.sortOrderQuery
29 import org.make.api.technical.ScalikeSupport._
30 import org.make.api.technical.{PersistentCompanion, ShortenedNames}
31 import org.make.core.technical.Pagination
32 import org.make.core.feature.{Feature, FeatureId, FeatureSlug}
33 import org.make.core.Order
34 import scalikejdbc._
35 
36 import scala.concurrent.Future
37 
38 trait DefaultPersistentFeatureServiceComponent extends PersistentFeatureServiceComponent {
39   this: MakeDBExecutionContextComponent =>
40 
41   override lazy val persistentFeatureService: PersistentFeatureService = new DefaultPersistentFeatureService
42 
43   class DefaultPersistentFeatureService extends PersistentFeatureService with ShortenedNames with Logging {
44 
45     private val featureAlias = PersistentFeature.alias
46 
47     private val column = PersistentFeature.column
48 
49     override def get(featureId: FeatureId): Future[Option[Feature]] = {
50       implicit val context: EC = readExecutionContext
51       val futurePersistentFeature = Future(NamedDB("READ").retryableTx { implicit session =>
52         withSQL {
53           select
54             .from(PersistentFeature.as(featureAlias))
55             .where(sqls.eq(featureAlias.id, featureId.value))
56         }.map(PersistentFeature.apply()).single()
57       })
58 
59       futurePersistentFeature.map(_.map(_.toFeature))
60     }
61 
62     def findBySlug(slug: FeatureSlug): Future[Seq[Feature]] = {
63       implicit val context: EC = readExecutionContext
64       val futurePersistentFeatures: Future[List[PersistentFeature]] = Future(NamedDB("READ").retryableTx {
65         implicit session =>
66           withSQL {
67             select
68               .from(PersistentFeature.as(featureAlias))
69               .where(sqls.eq(featureAlias.slug, slug))
70           }.map(PersistentFeature.apply()).list()
71       })
72 
73       futurePersistentFeatures.map(_.map(_.toFeature))
74     }
75 
76     override def persist(feature: Feature): Future[Feature] = {
77       implicit val context: EC = writeExecutionContext
78       Future(NamedDB("WRITE").retryableTx { implicit session =>
79         withSQL {
80           insert
81             .into(PersistentFeature)
82             .namedValues(column.id -> feature.featureId.value, column.slug -> feature.slug, column.name -> feature.name)
83         }.execute()
84       }).map(_ => feature)
85     }
86 
87     override def update(feature: Feature): Future[Option[Feature]] = {
88       implicit val ctx: EC = writeExecutionContext
89       Future(NamedDB("WRITE").retryableTx { implicit session =>
90         withSQL {
91           scalikejdbc
92             .update(PersistentFeature)
93             .set(column.slug -> feature.slug, column.name -> feature.name)
94             .where(sqls.eq(column.id, feature.featureId.value))
95         }.executeUpdate()
96       }).map {
97         case 1 => Some(feature)
98         case 0 => None
99       }
100     }
101 
102     override def remove(featureId: FeatureId): Future[Unit] = {
103       implicit val context: EC = writeExecutionContext
104       Future(NamedDB("WRITE").retryableTx { implicit session =>
105         withSQL {
106           delete
107             .from(PersistentFeature.as(featureAlias))
108             .where(sqls.eq(featureAlias.id, featureId.value))
109         }.update()
110       }).void
111     }
112 
113     override def findAll(): Future[Seq[Feature]] = {
114       implicit val context: EC = readExecutionContext
115       val futurePersistentFeatures: Future[List[PersistentFeature]] = Future(NamedDB("READ").retryableTx {
116         implicit session =>
117           withSQL {
118             select
119               .from(PersistentFeature.as(featureAlias))
120               .orderBy(featureAlias.slug)
121           }.map(PersistentFeature.apply()).list()
122       })
123 
124       futurePersistentFeatures.map(_.map(_.toFeature))
125     }
126 
127     override def findByFeatureIds(featureIds: Seq[FeatureId]): Future[Seq[Feature]] = {
128       implicit val context: EC = readExecutionContext
129       val futurePersistentFeatures: Future[List[PersistentFeature]] = Future(NamedDB("READ").retryableTx {
130         implicit session =>
131           withSQL {
132             select
133               .from(PersistentFeature.as(featureAlias))
134               .where(sqls.in(featureAlias.id, featureIds.map(_.value)))
135               .orderBy(featureAlias.slug)
136           }.map(PersistentFeature.apply()).list()
137       })
138 
139       futurePersistentFeatures.map(_.map(_.toFeature))
140     }
141 
142     override def find(
143       offset: Pagination.Offset,
144       end: Option[Pagination.End],
145       sort: Option[String],
146       order: Option[Order],
147       maybeSlug: Option[String]
148     ): Future[Seq[Feature]] = {
149       implicit val context: EC = readExecutionContext
150 
151       val futurePersistentFeatures: Future[List[PersistentFeature]] = Future(NamedDB("READ").retryableTx {
152         implicit session =>
153           withSQL {
154 
155             val query: scalikejdbc.PagingSQLBuilder[PersistentFeature] =
156               select
157                 .from(PersistentFeature.as(featureAlias))
158                 .where(sqls.toAndConditionOpt(maybeSlug.map(slug => sqls.like(featureAlias.slug, s"%$slug%"))))
159 
160             sortOrderQuery(offset, end, sort, order, query)
161           }.map(PersistentFeature.apply()).list()
162       })
163 
164       futurePersistentFeatures.map(_.map(_.toFeature))
165     }
166 
167     override def count(maybeSlug: Option[String]): Future[Int] = {
168       implicit val context: EC = readExecutionContext
169 
170       Future(NamedDB("READ").retryableTx { implicit session =>
171         withSQL {
172 
173           select(sqls.count)
174             .from(PersistentFeature.as(featureAlias))
175             .where(sqls.toAndConditionOpt(maybeSlug.map(slug => sqls.like(featureAlias.slug, s"%$slug%"))))
176         }.map(_.int(1)).single().getOrElse(0)
177       })
178     }
179   }
180 }
181 
182 object DefaultPersistentFeatureServiceComponent {
183 
184   final case class PersistentFeature(id: String, slug: String, name: String) {
185     def toFeature: Feature =
186       Feature(featureId = FeatureId(id), slug = FeatureSlug(slug), name = name)
187   }
188 
189   implicit object PersistentFeature
190       extends PersistentCompanion[PersistentFeature, Feature]
191       with ShortenedNames
192       with Logging {
193 
194     override val columnNames: Seq[String] = Seq("id", "slug", "name")
195     final val swaggerAllowableValues = "id,slug,name"
196 
197     override val tableName: String = "feature"
198 
199     override lazy val alias: SyntaxProvider[PersistentFeature] = syntax("feature")
200 
201     override lazy val defaultSortColumns: NonEmptyList[SQLSyntax] = NonEmptyList.of(alias.slug)
202 
203     def apply(
204       featureResultName: ResultName[PersistentFeature] = alias.resultName
205     )(resultSet: WrappedResultSet): PersistentFeature = {
206       PersistentFeature.apply(
207         id = resultSet.string(featureResultName.id),
208         slug = resultSet.string(featureResultName.slug),
209         name = resultSet.string(featureResultName.name)
210       )
211     }
212   }
213 
214 }