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.tag
21 
22 import java.time.ZonedDateTime
23 
24 import cats.data.NonEmptyList
25 import grizzled.slf4j.Logging
26 import org.make.api.extensions.MakeDBExecutionContextComponent
27 import org.make.api.tag.DefaultPersistentTagServiceComponent.PersistentTag
28 import org.make.api.tagtype.DefaultPersistentTagTypeServiceComponent.PersistentTagType
29 import org.make.api.technical.DatabaseTransactions._
30 import org.make.api.technical.PersistentServiceUtils.sortOrderQuery
31 import org.make.api.technical.{PersistentCompanion, ShortenedNames}
32 import org.make.api.technical.ScalikeSupport._
33 import org.make.core.{DateHelper, Order}
34 import org.make.core.technical.Pagination
35 import org.make.core.operation.OperationId
36 import org.make.core.question.QuestionId
37 import org.make.core.tag.{Tag, TagDisplay, TagId, TagTypeId}
38 import scalikejdbc._
39 
40 import scala.concurrent.Future
41 import scala.util.Success
42 
43 trait DefaultPersistentTagServiceComponent extends PersistentTagServiceComponent {
44   this: MakeDBExecutionContextComponent =>
45 
46   override lazy val persistentTagService: PersistentTagService = new DefaultPersistentTagService
47 
48   class DefaultPersistentTagService extends PersistentTagService with ShortenedNames with Logging {
49 
50     private val tagAlias = PersistentTag.alias
51     private val tagTypeAlias = PersistentTagType.tagTypeAlias
52 
53     private val column = PersistentTag.column
54 
55     override def findByQuestion(questionId: QuestionId): Future[Seq[Tag]] = {
56       implicit val context: EC = readExecutionContext
57       val futurePersistentTag = Future(NamedDB("READ").retryableTx { implicit session =>
58         withSQL {
59           select
60             .from(PersistentTag.as(tagAlias))
61             .where(sqls.eq(tagAlias.questionId, questionId))
62         }.map(PersistentTag.apply()).list()
63       })
64 
65       futurePersistentTag.map(_.map(_.toTag))
66     }
67 
68     override def get(tagId: TagId): Future[Option[Tag]] = {
69       implicit val context: EC = readExecutionContext
70       val futurePersistentTag = Future(NamedDB("READ").retryableTx { implicit session =>
71         withSQL {
72           select
73             .from(PersistentTag.as(tagAlias))
74             .where(sqls.eq(tagAlias.id, tagId))
75         }.map(PersistentTag.apply()).single()
76       })
77 
78       futurePersistentTag.map(_.map(_.toTag))
79     }
80 
81     override def findAll(): Future[Seq[Tag]] = {
82       implicit val context: EC = readExecutionContext
83       val futurePersistentTags: Future[List[PersistentTag]] = Future(NamedDB("READ").retryableTx { implicit session =>
84         withSQL {
85           select
86             .from(PersistentTag.as(tagAlias))
87             .orderBy(tagAlias.weight, tagAlias.label)
88         }.map(PersistentTag.apply()).list()
89       })
90 
91       futurePersistentTags.map(_.map(_.toTag))
92     }
93 
94     override def findAllFromIds(tagsIds: Seq[TagId]): Future[Seq[Tag]] = {
95       implicit val context: EC = readExecutionContext
96       val futurePersistentTags: Future[List[PersistentTag]] = Future(NamedDB("READ").retryableTx { implicit session =>
97         withSQL {
98           select
99             .from(PersistentTag.as(tagAlias))
100             .where(sqls.in(tagAlias.id, tagsIds.distinct))
101         }.map(PersistentTag.apply()).list()
102       })
103 
104       futurePersistentTags.map(_.map(_.toTag))
105     }
106 
107     override def findAllDisplayed(): Future[Seq[Tag]] = {
108       implicit val context: EC = readExecutionContext
109       val futurePersistentTags: Future[List[PersistentTag]] = Future(NamedDB("READ").retryableTx { implicit session =>
110         withSQL {
111           select
112             .from(PersistentTag.as(tagAlias))
113             .leftJoin(PersistentTagType.as(tagTypeAlias))
114             .on(tagAlias.tagTypeId, tagTypeAlias.id)
115             .where(
116               sqls
117                 .eq(tagAlias.display, TagDisplay.Displayed)
118                 .or(
119                   sqls
120                     .eq(tagAlias.display, TagDisplay.Inherit)
121                     .and(sqls.eq(tagTypeAlias.display, TagDisplay.Displayed))
122                 )
123             )
124             .orderBy(tagAlias.weight, tagAlias.label)
125         }.map(PersistentTag.apply()).list()
126       })
127 
128       futurePersistentTags.map(_.map(_.toTag))
129     }
130 
131     def findByLabel(label: String): Future[Seq[Tag]] = {
132       implicit val context: EC = readExecutionContext
133       val preparedLabel: String = label.replace("%", "\\%")
134       val futurePersistentTags: Future[List[PersistentTag]] = Future(NamedDB("READ").retryableTx { implicit session =>
135         withSQL {
136           select
137             .from(PersistentTag.as(tagAlias))
138             .where(sqls.eq(tagAlias.label, preparedLabel))
139         }.map(PersistentTag.apply()).list()
140       })
141 
142       futurePersistentTags.map(_.map(_.toTag))
143     }
144 
145     def findByLabelLike(partialLabel: String): Future[Seq[Tag]] = {
146       implicit val context: EC = readExecutionContext
147       val preparedPartialLabel: String = partialLabel.replace("%", "\\%")
148       val futurePersistentTags: Future[List[PersistentTag]] = Future(NamedDB("READ").retryableTx { implicit session =>
149         withSQL {
150           select
151             .from(PersistentTag.as(tagAlias))
152             .where(sqls.like(tagAlias.label, s"%$preparedPartialLabel%"))
153         }.map(PersistentTag.apply()).list()
154       })
155 
156       futurePersistentTags.map(_.map(_.toTag))
157     }
158 
159     override def persist(tag: Tag): Future[Tag] = {
160       implicit val context: EC = writeExecutionContext
161       val nowDate: ZonedDateTime = DateHelper.now()
162       Future(NamedDB("WRITE").retryableTx { implicit session =>
163         withSQL {
164           insert
165             .into(PersistentTag)
166             .namedValues(
167               column.id -> tag.tagId,
168               column.label -> tag.label,
169               column.display -> tag.display,
170               column.tagTypeId -> tag.tagTypeId,
171               column.operationId -> tag.operationId,
172               column.questionId -> tag.questionId,
173               column.weight -> tag.weight,
174               column.createdAt -> nowDate,
175               column.updatedAt -> nowDate
176             )
177         }.execute()
178       }).map(_ => tag)
179     }
180 
181     override def update(tag: Tag): Future[Option[Tag]] = {
182       implicit val ctx: EC = writeExecutionContext
183       val nowDate: ZonedDateTime = DateHelper.now()
184       Future(NamedDB("WRITE").retryableTx { implicit session =>
185         withSQL {
186           scalikejdbc
187             .update(PersistentTag)
188             .set(
189               column.label -> tag.label,
190               column.display -> tag.display,
191               column.tagTypeId -> tag.tagTypeId,
192               column.operationId -> tag.operationId,
193               column.questionId -> tag.questionId,
194               column.weight -> tag.weight,
195               column.updatedAt -> nowDate
196             )
197             .where(sqls.eq(column.id, tag.tagId))
198         }.executeUpdate()
199       }).map {
200         case 1 => Some(tag)
201         case 0 =>
202           logger.error(s"Tag '${tag.tagId.value}' not found")
203           None
204       }
205     }
206 
207     override def remove(tagId: TagId): Future[Int] = {
208       implicit val context: EC = writeExecutionContext
209       val result: Future[Int] = Future(NamedDB("WRITE").retryableTx { implicit session =>
210         withSQL {
211           delete
212             .from(PersistentTag.as(tagAlias))
213             .where(sqls.eq(tagAlias.id, tagId))
214         }.update()
215       })
216 
217       result.onComplete {
218         case Success(0) => logger.info(s"Expected 1 row to be removed and get 0 rows with tag ${tagId.value}")
219         case Success(rows) =>
220           if (rows != 1) {
221             logger.warn(s"Expected 1 row to be removed and get $rows rows with tag ${tagId.value}")
222           } else {
223             logger.debug(s"Remove of tag ${tagId.value} success")
224           }
225         case _ =>
226       }
227 
228       result
229     }
230 
231     override def find(
232       offset: Pagination.Offset,
233       end: Option[Pagination.End],
234       sort: Option[String],
235       order: Option[Order],
236       onlyDisplayed: Boolean,
237       persistentTagFilter: PersistentTagFilter
238     ): Future[Seq[Tag]] = {
239       implicit val context: EC = readExecutionContext
240 
241       val futurePersistentTags: Future[List[PersistentTag]] = Future(NamedDB("READ").retryableTx { implicit session =>
242         withSQL {
243 
244           val query: scalikejdbc.PagingSQLBuilder[PersistentTag] =
245             select
246               .from(PersistentTag.as(tagAlias))
247               .leftJoin(PersistentTagType.as(tagTypeAlias))
248               .on(tagAlias.tagTypeId, tagTypeAlias.id)
249               .where(
250                 sqls.toAndConditionOpt(
251                   persistentTagFilter.tagIds.map(tIds => sqls.in(tagAlias.id, tIds)),
252                   persistentTagFilter.label
253                     .map(
254                       label => sqls.like(sqls"lower(${tagAlias.label})", s"%${label.toLowerCase.replace("%", "\\%")}%")
255                     ),
256                   persistentTagFilter.tagTypeId.map(tagTypeId => sqls.eq(tagAlias.tagTypeId, tagTypeId)),
257                   persistentTagFilter.questionIds.map(qIds    => sqls.in(tagAlias.questionId, qIds)),
258                   if (onlyDisplayed) {
259                     Some(
260                       sqls
261                         .eq(tagAlias.display, TagDisplay.Displayed)
262                         .or(
263                           sqls
264                             .eq(tagAlias.display, TagDisplay.Inherit)
265                             .and(sqls.eq(tagTypeAlias.display, TagDisplay.Displayed))
266                         )
267                     )
268                   } else {
269                     None
270                   }
271                 )
272               )
273 
274           sortOrderQuery(offset, end, sort, order, query)
275         }.map(PersistentTag.apply()).list()
276       })
277 
278       futurePersistentTags.map(_.map(_.toTag))
279     }
280 
281     override def count(persistentTagFilter: PersistentTagFilter): Future[Int] = {
282       implicit val context: EC = readExecutionContext
283 
284       Future(NamedDB("READ").retryableTx { implicit session =>
285         withSQL {
286 
287           select(sqls.count)
288             .from(PersistentTag.as(tagAlias))
289             .where(
290               sqls.toAndConditionOpt(
291                 persistentTagFilter.tagIds.map(tIds => sqls.in(tagAlias.id, tIds)),
292                 persistentTagFilter.label
293                   .map(
294                     label => sqls.like(sqls"lower(${tagAlias.label})", s"%${label.toLowerCase.replace("%", "\\%")}%")
295                   ),
296                 persistentTagFilter.tagTypeId.map(tagTypeId => sqls.eq(tagAlias.tagTypeId, tagTypeId)),
297                 persistentTagFilter.questionIds.map(qIds    => sqls.in(tagAlias.questionId, qIds))
298               )
299             )
300         }.map(_.int(1)).single().getOrElse(0)
301       })
302     }
303   }
304 }
305 
306 object DefaultPersistentTagServiceComponent {
307 
308   final case class PersistentTag(
309     id: String,
310     label: String,
311     display: TagDisplay,
312     tagTypeId: String,
313     operationId: Option[String],
314     questionId: Option[String],
315     weight: Float,
316     createdAt: ZonedDateTime,
317     updatedAt: ZonedDateTime
318   ) {
319     def toTag: Tag =
320       Tag(
321         tagId = TagId(id),
322         label = label,
323         display = display,
324         tagTypeId = TagTypeId(tagTypeId),
325         operationId = operationId.map(OperationId(_)),
326         questionId = questionId.map(QuestionId(_)),
327         weight = weight
328       )
329   }
330 
331   implicit object PersistentTag extends PersistentCompanion[PersistentTag, Tag] with ShortenedNames with Logging {
332 
333     override val columnNames: Seq[String] =
334       Seq("id", "label", "display", "tag_type_id", "operation_id", "weight", "created_at", "updated_at", "question_id")
335     final val swaggerAllowableValues =
336       "id,label,display,tag_type_id,operation_id,weight,created_at,updated_at,question_id"
337 
338     override val tableName: String = "tag"
339 
340     override lazy val alias: SyntaxProvider[PersistentTag] = syntax("tag")
341 
342     override lazy val defaultSortColumns: NonEmptyList[SQLSyntax] = NonEmptyList.of(alias.weight, alias.label)
343 
344     def apply(
345       tagResultName: ResultName[PersistentTag] = alias.resultName
346     )(resultSet: WrappedResultSet): PersistentTag = {
347       PersistentTag.apply(
348         id = resultSet.string(tagResultName.id),
349         label = resultSet.string(tagResultName.label),
350         display = TagDisplay(resultSet.string(tagResultName.display)),
351         tagTypeId = resultSet.string(tagResultName.tagTypeId),
352         operationId = resultSet.stringOpt(tagResultName.operationId),
353         questionId = resultSet.stringOpt(tagResultName.questionId),
354         weight = resultSet.float(tagResultName.weight),
355         createdAt = resultSet.zonedDateTime(tagResultName.createdAt),
356         updatedAt = resultSet.zonedDateTime(tagResultName.updatedAt)
357       )
358     }
359   }
360 
361 }