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.question
21 
22 import java.time.ZonedDateTime
23 import cats.implicits._
24 import cats.data.NonEmptyList
25 import eu.timepit.refined.api.Refined
26 import eu.timepit.refined.collection._
27 import grizzled.slf4j.Logging
28 import scalikejdbc._
29 import org.make.api.extensions.MakeDBExecutionContextComponent
30 import org.make.api.question.DefaultPersistentQuestionServiceComponent.PersistentQuestion
31 import org.make.api.technical.ScalikeSupport._
32 import org.make.api.technical.DatabaseTransactions.RichDatabase
33 import org.make.api.technical.PersistentServiceUtils.sortOrderQuery
34 import org.make.api.technical.{PersistentCompanion, ShortenedNames}
35 import org.make.core.DateHelper
36 import org.make.core.technical.Multilingual, Multilingual._
37 import org.make.core.operation.OperationId
38 import org.make.core.question.{Question, QuestionId}
39 import org.make.core.reference.{Country, Language}
40 
41 import scala.concurrent.Future
42 
43 trait DefaultPersistentQuestionServiceComponent extends PersistentQuestionServiceComponent {
44   this: MakeDBExecutionContextComponent =>
45 
46   lazy val persistentQuestionService: PersistentQuestionService = new DefaultPersistentQuestionService
47 
48   class DefaultPersistentQuestionService extends PersistentQuestionService with ShortenedNames with Logging {
49 
50     private val column = PersistentQuestion.column
51     private val questionAlias = PersistentQuestion.alias
52 
53     override def find(request: SearchQuestionRequest): Future[Seq[Question]] = {
54 
55       implicit val context: EC = readExecutionContext
56       Future(NamedDB("READ").retryableTx { implicit session =>
57         withSQL {
58           val query: scalikejdbc.ConditionSQLBuilder[PersistentQuestion] = select
59             .from(PersistentQuestion.as(questionAlias))
60             .where(
61               sqls.toAndConditionOpt(
62                 request.country.map(country => sqls.like(questionAlias.countries, s"%${country.value}%")),
63                 request.language
64                   .map(language => sqls.isNotNull(sqls"array_position(${questionAlias.languages}, ${language.value})")),
65                 request.maybeOperationIds
66                   .map(operationIds                      => sqls.in(questionAlias.operationId, operationIds.map(_.value))),
67                 request.maybeSlug.map(slug               => sqls.eq(questionAlias.slug, slug)),
68                 request.maybeQuestionIds.map(questionIds => sqls.in(questionAlias.questionId, questionIds.map(_.value)))
69               )
70             )
71           val offset = request.offset.orZero
72           val end = request.end
73           sortOrderQuery(offset, end, request.sort, request.order, query)
74         }.map(PersistentQuestion.apply()).list()
75       }).map(_.map(_.toQuestion))
76 
77     }
78 
79     override def count(request: SearchQuestionRequest): Future[Int] = {
80       implicit val context: EC = readExecutionContext
81       Future(NamedDB("READ").retryableTx { implicit session =>
82         withSQL {
83           select(sqls.count)
84             .from(PersistentQuestion.as(questionAlias))
85             .where(
86               sqls.toAndConditionOpt(
87                 request.country.map(country => sqls.like(questionAlias.countries, s"%${country.value}%")),
88                 request.language
89                   .map(language => sqls.isNotNull(sqls"array_position(${questionAlias.languages}, ${language.value})")),
90                 request.maybeOperationIds
91                   .map(operationIds                      => sqls.in(questionAlias.operationId, operationIds.map(_.value))),
92                 request.maybeQuestionIds.map(questionIds => sqls.in(questionAlias.questionId, questionIds.map(_.value)))
93               )
94             )
95         }.map(_.int(1)).single().getOrElse(0)
96       })
97     }
98 
99     override def getById(questionId: QuestionId): Future[Option[Question]] = {
100       implicit val context: EC = readExecutionContext
101       Future(NamedDB("READ").retryableTx { implicit session =>
102         withSQL {
103           select
104             .from(PersistentQuestion.as(questionAlias))
105             .where(sqls.eq(questionAlias.questionId, questionId.value))
106         }.map(PersistentQuestion.apply()).single()
107       }).map(_.map(_.toQuestion))
108     }
109 
110     override def getByQuestionIdValueOrSlug(questionIdValueOrSlug: String): Future[Option[Question]] = {
111       implicit val context: EC = readExecutionContext
112       Future(NamedDB("READ").retryableTx { implicit session =>
113         withSQL {
114           select
115             .from(PersistentQuestion.as(questionAlias))
116             .where(
117               sqls
118                 .eq(questionAlias.slug, questionIdValueOrSlug)
119                 .or(sqls.eq(questionAlias.questionId, questionIdValueOrSlug))
120             )
121         }.map(PersistentQuestion.apply()).single()
122       }).map(_.map(_.toQuestion))
123     }
124 
125     override def getByIds(questionIds: Seq[QuestionId]): Future[Seq[Question]] = {
126       implicit val context: EC = readExecutionContext
127       Future(NamedDB("READ").retryableTx { implicit session =>
128         withSQL {
129           select
130             .from(PersistentQuestion.as(questionAlias))
131             .where(sqls.in(questionAlias.questionId, questionIds.map(_.value)))
132         }.map(PersistentQuestion.apply()).list()
133       }).map(_.map(_.toQuestion))
134     }
135 
136     override def persist(question: Question): Future[Question] = {
137       implicit val context: EC = writeExecutionContext
138       Future(NamedDB("WRITE").retryableTx { implicit session =>
139         withSQL {
140           val now = DateHelper.now()
141           insert
142             .into(PersistentQuestion)
143             .namedValues(
144               column.questionId -> question.questionId.value,
145               column.slug -> question.slug,
146               column.createdAt -> now,
147               column.questions -> question.questions,
148               column.countries -> question.countries.toList.mkString(","),
149               column.defaultLanguage -> question.defaultLanguage.value,
150               column.languages -> session.connection
151                 .createArrayOf("VARCHAR", question.languages.map(_.value).toList.toArray),
152               column.shortTitles -> question.shortTitles,
153               column.operationId -> question.operationId.map(_.value),
154               column.updatedAt -> now
155             )
156         }.execute()
157       }).as(question)
158     }
159 
160     override def modify(question: Question): Future[Question] = {
161       implicit val context: EC = writeExecutionContext
162       Future(NamedDB("WRITE").retryableTx { implicit session =>
163         withSQL {
164           val now = DateHelper.now()
165           update(PersistentQuestion)
166             .set(
167               PersistentQuestion.column.countries -> question.countries.toList.mkString(","),
168               PersistentQuestion.column.defaultLanguage -> question.defaultLanguage.value,
169               PersistentQuestion.column.languages -> session.connection
170                 .createArrayOf("VARCHAR", question.languages.map(_.value).toList.toArray),
171               PersistentQuestion.column.questions -> question.questions,
172               PersistentQuestion.column.slug -> question.slug,
173               PersistentQuestion.column.shortTitles -> question.shortTitles,
174               PersistentQuestion.column.operationId -> question.operationId.map(_.value),
175               PersistentQuestion.column.updatedAt -> now
176             )
177             .where(sqls.eq(PersistentQuestion.column.questionId, question.questionId.value))
178         }.execute()
179       }).as(question)
180     }
181 
182     override def delete(questionId: QuestionId): Future[Unit] = {
183       implicit val context: EC = readExecutionContext
184       Future(NamedDB("WRITE").retryableTx { implicit session =>
185         withSQL {
186           deleteFrom(PersistentQuestion)
187             .where(sqls.eq(PersistentQuestion.column.questionId, questionId.value))
188         }.execute()
189       }).void
190     }
191   }
192 }
193 
194 object DefaultPersistentQuestionServiceComponent {
195 
196   @SuppressWarnings(Array("org.wartremover.warts.ArrayEquals"))
197   final case class PersistentQuestion(
198     questionId: String,
199     countries: String,
200     defaultLanguage: String,
201     languages: Array[String],
202     questions: Multilingual[String Refined NonEmpty],
203     shortTitles: Option[Multilingual[String Refined NonEmpty]],
204     slug: String,
205     createdAt: ZonedDateTime,
206     updatedAt: ZonedDateTime,
207     operationId: Option[String]
208   ) {
209 
210     def toQuestion: Question = {
211       Question(
212         questionId = QuestionId(this.questionId),
213         slug = this.slug,
214         countries = NonEmptyList.fromListUnsafe(countries.split(',').map(Country(_)).toList),
215         defaultLanguage = Language(defaultLanguage),
216         languages = NonEmptyList.fromListUnsafe(languages.toList.map(Language.apply)),
217         questions = this.questions,
218         shortTitles = this.shortTitles,
219         operationId = this.operationId.map(OperationId(_))
220       )
221     }
222   }
223 
224   implicit object PersistentQuestion
225       extends PersistentCompanion[PersistentQuestion, Question]
226       with ShortenedNames
227       with Logging {
228 
229     override val columnNames: Seq[String] =
230       Seq(
231         "question_id",
232         "countries",
233         "default_language",
234         "languages",
235         "questions",
236         "created_at",
237         "updated_at",
238         "operation_id",
239         "slug",
240         "short_titles"
241       )
242     final val swaggerAllowableValues =
243       "question_id,countries,default_language,languages,questions,created_at,updated_at,operation_id,slug,short_titles"
244 
245     override val tableName: String = "question"
246 
247     override lazy val alias: SyntaxProvider[PersistentQuestion] = syntax("question")
248 
249     override lazy val defaultSortColumns: NonEmptyList[SQLSyntax] = NonEmptyList.of(alias.questionId)
250 
251     private lazy val resultName: ResultName[PersistentQuestion] = alias.resultName
252 
253     @SuppressWarnings(Array("org.wartremover.warts.AsInstanceOf"))
254     def apply(
255       questionResultName: ResultName[PersistentQuestion] = resultName
256     )(resultSet: WrappedResultSet): PersistentQuestion = {
257 
258       PersistentQuestion(
259         questionId = resultSet.string(questionResultName.questionId),
260         slug = resultSet.string(questionResultName.slug),
261         countries = resultSet.string(questionResultName.countries),
262         defaultLanguage = resultSet.get(questionResultName.defaultLanguage),
263         languages = resultSet
264           .arrayOpt(questionResultName.languages)
265           .map(_.getArray.asInstanceOf[Array[String]])
266           .getOrElse(Array()),
267         questions = resultSet.get(questionResultName.questions),
268         shortTitles = resultSet.get(questionResultName.shortTitles),
269         createdAt = resultSet.zonedDateTime(questionResultName.createdAt),
270         updatedAt = resultSet.zonedDateTime(questionResultName.updatedAt),
271         operationId = resultSet.stringOpt(questionResultName.operationId)
272       )
273     }
274   }
275 }