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.keyword
21 
22 import grizzled.slf4j.Logging
23 import org.make.api.extensions.MakeDBExecutionContextComponent
24 import org.make.api.technical.DatabaseTransactions._
25 import org.make.api.technical.ScalikeSupport._
26 import org.make.api.technical.ShortenedNames
27 import org.make.core.technical.Pagination
28 import org.make.core.keyword.Keyword
29 import org.make.core.question.QuestionId
30 import scalikejdbc._
31 
32 import scala.concurrent.Future
33 
34 trait DefaultPersistentKeywordServiceComponent extends PersistentKeywordServiceComponent {
35   this: MakeDBExecutionContextComponent =>
36 
37   override lazy val persistentKeywordService: PersistentKeywordService = new DefaultPersistentKeywordService
38 
39   class DefaultPersistentKeywordService
40       extends PersistentKeywordService
41       with ShortenedNames
42       with SQLSyntaxSupport[Keyword]
43       with Logging {
44     private val keywords = SQLSyntaxSupportFactory[Keyword]()
45     private val kw = keywords.syntax
46 
47     override def get(key: String, questionId: QuestionId): Future[Option[Keyword]] = {
48       implicit val context: EC = readExecutionContext
49       Future(NamedDB("READ").retryableTx { implicit session =>
50         withSQL {
51           select
52             .from(keywords.as(kw))
53             .where
54             .eq(kw.key, key)
55             .and
56             .eq(kw.questionId, questionId)
57             .orderBy(kw.key)
58             .asc
59         }.map(keywords.apply(kw.resultName)).single()
60       })
61     }
62 
63     override def findAll(questionId: QuestionId): Future[Seq[Keyword]] = {
64       implicit val context: EC = readExecutionContext
65       Future(NamedDB("READ").retryableTx { implicit session =>
66         withSQL {
67           select
68             .from(keywords.as(kw))
69             .where(sqls.eq(kw.questionId, questionId))
70             .orderBy(kw.key)
71             .asc
72         }.map(keywords.apply(kw.resultName)).list()
73       })
74     }
75 
76     override def findTop(questionId: QuestionId, limit: Pagination.Limit): Future[Seq[Keyword]] = {
77       implicit val context: EC = readExecutionContext
78       Future(NamedDB("READ").retryableTx { implicit session =>
79         withSQL {
80           select
81             .from(keywords.as(kw))
82             .where
83             .eq(kw.questionId, questionId)
84             .and
85             .eq(kw.topKeyword, true)
86             .orderBy(kw.score)
87             .desc
88             .limit(limit.extractInt)
89         }.map(keywords.apply(kw.resultName)).list()
90       })
91     }
92 
93     def resetTop(questionId: QuestionId): Future[Unit] = {
94       implicit val context: EC = writeExecutionContext
95       Future(NamedDB("WRITE").retryableTx { implicit session =>
96         withSQL {
97           update(keywords)
98             .set(keywords.column.topKeyword -> false)
99             .where
100             .eq(kw.topKeyword, true)
101             .and
102             .eq(kw.questionId, questionId)
103         }.update()
104       })
105     }
106 
107     def createKeywords(questionId: QuestionId, items: Seq[Keyword]): Future[Unit] = {
108       implicit val context: EC = writeExecutionContext
109       Future(NamedDB("WRITE").retryableTx { implicit session =>
110         def values(keyword: Keyword, columns: Seq[SQLSyntax]): Seq[ParameterBinder] = {
111           val namedValues = autoNamedValues(keyword, keywords.column)
112           columns.map(namedValues(_))
113         }
114         items match {
115           case Seq() => true
116           case _ =>
117             val columnsNames: Seq[SQLSyntax] = keywords.column.columns.toSeq
118             withSQL {
119               insert
120                 .into(keywords)
121                 .columns(columnsNames: _*)
122                 .multipleValues(items.map(values(_, columnsNames)): _*)
123             }.execute()
124         }
125       })
126     }
127 
128     def updateTop(questionId: QuestionId, items: Seq[Keyword]): Future[Unit] = {
129       implicit val context: EC = writeExecutionContext
130       Future(NamedDB("WRITE").retryableTx { implicit session =>
131         items.foreach { keyword =>
132           withSQL {
133             update(keywords)
134               .set(autoNamedValues(keyword, keywords.column, "key", "questionId"))
135               .where
136               .eq(kw.key, keyword.key)
137               .and
138               .eq(kw.questionId, keyword.questionId)
139           }.update()
140         }
141       })
142     }
143 
144   }
145 }