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.operation
21 
22 import java.time.{LocalDate, ZonedDateTime}
23 
24 import cats.data.NonEmptyList
25 import grizzled.slf4j.Logging
26 import org.make.api.extensions.MakeDBExecutionContextComponent
27 import org.make.api.operation.DefaultPersistentOperationOfQuestionServiceComponent.PersistentOperationOfQuestion
28 import org.make.api.operation.DefaultPersistentOperationOfQuestionServiceComponent.PersistentOperationOfQuestion.FlatQuestionWithDetails
29 import org.make.api.operation.DefaultPersistentOperationServiceComponent.{
30   PersistentOperation,
31   PersistentOperationAction
32 }
33 import org.make.api.question.DefaultPersistentQuestionServiceComponent.PersistentQuestion
34 import org.make.api.tag.DefaultPersistentTagServiceComponent
35 import org.make.api.technical.DatabaseTransactions._
36 import org.make.api.technical.PersistentServiceUtils.sortOrderQuery
37 import org.make.api.technical.{PersistentCompanion, ShortenedNames}
38 import org.make.api.technical.ScalikeSupport._
39 import org.make.core.{DateHelper, Order}
40 import org.make.core.technical.Pagination
41 import org.make.core.operation._
42 import org.make.core.reference.Country
43 import org.make.core.user.UserId
44 import scalikejdbc._
45 import spray.json.DefaultJsonProtocol._
46 import spray.json._
47 
48 import scala.concurrent.Future
49 
50 trait DefaultPersistentOperationServiceComponent extends PersistentOperationServiceComponent {
51   this: MakeDBExecutionContextComponent with DefaultPersistentTagServiceComponent =>
52 
53   override lazy val persistentOperationService: PersistentOperationService = new DefaultPersistentOperationService
54 
55   class DefaultPersistentOperationService extends PersistentOperationService with ShortenedNames with Logging {
56 
57     private val operationAlias = PersistentOperation.alias
58     private val operationOfQuestionAlias = PersistentOperationOfQuestion.alias
59     private val operationActionAlias = PersistentOperationAction.operationActionAlias
60     private val questionAlias = PersistentQuestion.alias
61 
62     private val column = PersistentOperation.column
63     private val operationActionColumn = PersistentOperationAction.column
64     private def selectOperation[T]: scalikejdbc.SelectSQLBuilder[T] =
65       select
66         .from(PersistentOperation.as(operationAlias))
67         .leftJoin(PersistentOperationOfQuestion.as(operationOfQuestionAlias))
68         .on(operationAlias.uuid, operationOfQuestionAlias.operationId)
69         .leftJoin(PersistentOperationAction.as(operationActionAlias))
70         .on(operationAlias.uuid, operationActionAlias.operationUuid)
71         .leftJoin(PersistentQuestion.as(questionAlias))
72         .on(questionAlias.questionId, operationOfQuestionAlias.questionId)
73     private def operationWhereOpts(
74       operationIds: Option[Seq[OperationId]],
75       slug: Option[String],
76       operationKinds: Option[Seq[OperationKind]],
77       country: Option[Country],
78       openAt: Option[LocalDate]
79     ): Option[SQLSyntax] =
80       sqls.toAndConditionOpt(
81         operationIds.map(operationIds => sqls.in(operationAlias.uuid, operationIds.map(_.value))),
82         slug.map(slug                 => sqls.like(operationAlias.slug, s"%$slug%")),
83         operationKinds.map(opKinds    => sqls.in(operationAlias.operationKind, opKinds)),
84         country.map(country           => sqls.like(questionAlias.countries, s"%${country.value}%")),
85         openAt.map(
86           openAt =>
87             sqls
88               .le(operationOfQuestionAlias.startDate, openAt)
89               .or(sqls.isNull(operationOfQuestionAlias.startDate))
90         ),
91         openAt.map(
92           openAt =>
93             sqls
94               .ge(operationOfQuestionAlias.endDate, openAt)
95               .or(sqls.isNull(operationOfQuestionAlias.endDate))
96         )
97       )
98 
99     override def find(
100       operationIds: Option[Seq[OperationId]] = None,
101       slug: Option[String] = None,
102       country: Option[Country] = None,
103       openAt: Option[LocalDate] = None
104     ): Future[Seq[Operation]] = {
105       implicit val context: EC = readExecutionContext
106       val futurePersistentOperations: Future[List[PersistentOperation]] = Future(NamedDB("READ").retryableTx {
107         implicit session =>
108           withSQL[PersistentOperation] {
109             selectOperation.where(operationWhereOpts(operationIds, slug, None, country, openAt))
110           }.one(PersistentOperation.apply())
111             .toManies(
112               PersistentOperationAction.opt(operationActionAlias),
113               PersistentOperationOfQuestion.withQuestion(questionAlias.resultName, operationOfQuestionAlias.resultName)
114             )
115             .map { (operation, actions, questions) =>
116               operation.copy(operationActions = actions.toVector, questions = questions.toVector)
117             }
118             .list()
119       })
120 
121       futurePersistentOperations.map(_.map(_.toOperation))
122     }
123 
124     override def findSimple(
125       offset: Pagination.Offset,
126       end: Option[Pagination.End],
127       sort: Option[String],
128       order: Option[Order],
129       slug: Option[String] = None,
130       operationKinds: Option[Seq[OperationKind]]
131     ): Future[Seq[SimpleOperation]] = {
132       implicit val context: EC = readExecutionContext
133       val futurePersistentOperations: Future[List[PersistentOperation]] = Future(NamedDB("READ").retryableTx {
134         implicit session =>
135           withSQL {
136             val query: scalikejdbc.PagingSQLBuilder[PersistentOperation] =
137               select
138                 .from(PersistentOperation.as(operationAlias))
139                 .where(operationWhereOpts(None, slug, operationKinds, None, None))
140             sortOrderQuery(offset, end, sort, order, query)
141           }.map(PersistentOperation.apply()).list()
142       })
143 
144       futurePersistentOperations.map(_.map(_.toSimpleOperation))
145     }
146 
147     override def persist(operation: SimpleOperation): Future[SimpleOperation] = {
148       implicit val context: EC = writeExecutionContext
149       val nowDate: ZonedDateTime = DateHelper.now()
150       Future(NamedDB("WRITE").retryableTx { implicit session =>
151         withSQL {
152           insert
153             .into(PersistentOperation)
154             .namedValues(
155               column.uuid -> operation.operationId.value,
156               column.slug -> operation.slug,
157               column.operationKind -> operation.operationKind,
158               column.operationAuthentication -> operation.operationAuthentication,
159               column.createdAt -> nowDate,
160               column.updatedAt -> nowDate
161             )
162         }.execute()
163       }).map(_ => operation)
164     }
165 
166     override def getById(operationId: OperationId): Future[Option[Operation]] = {
167       implicit val context: EC = readExecutionContext
168       val futureMaybePersistentOperation: Future[Option[PersistentOperation]] = Future(NamedDB("READ").retryableTx {
169         implicit session =>
170           withSQL[PersistentOperation] {
171             selectOperation
172               .where(sqls.eq(operationAlias.uuid, operationId.value))
173           }.one(PersistentOperation.apply())
174             .toManies(
175               PersistentOperationAction.opt(operationActionAlias),
176               PersistentOperationOfQuestion.withQuestion(questionAlias.resultName, operationOfQuestionAlias.resultName)
177             )
178             .map { (operation, actions, questions) =>
179               operation.copy(operationActions = actions.toVector, questions = questions.toVector)
180             }
181             .single()
182       })
183 
184       futureMaybePersistentOperation.map(_.map(_.toOperation))
185     }
186 
187     override def getSimpleById(operationId: OperationId): Future[Option[SimpleOperation]] = {
188       implicit val context: EC = readExecutionContext
189       val futureMaybePersistentOperation: Future[Option[PersistentOperation]] = Future(NamedDB("READ").retryableTx {
190         implicit session =>
191           withSQL[PersistentOperation] {
192             select
193               .from(PersistentOperation.as(operationAlias))
194               .where(sqls.eq(operationAlias.uuid, operationId.value))
195           }.map(PersistentOperation.apply()).single()
196       })
197 
198       futureMaybePersistentOperation.map(_.map(_.toSimpleOperation))
199     }
200 
201     override def getBySlug(slug: String): Future[Option[Operation]] = {
202       implicit val context: EC = readExecutionContext
203       val futureMaybePersistentOperation: Future[Option[PersistentOperation]] = Future(NamedDB("READ").retryableTx {
204         implicit session =>
205           withSQL[PersistentOperation] {
206             selectOperation
207               .where(sqls.eq(operationAlias.slug, slug))
208           }.one(PersistentOperation.apply())
209             .toManies(
210               PersistentOperationAction.opt(operationActionAlias),
211               PersistentOperationOfQuestion.withQuestion(questionAlias.resultName, operationOfQuestionAlias.resultName)
212             )
213             .map { (operation, actions, questions) =>
214               operation.copy(operationActions = actions.toVector, questions = questions.toVector)
215             }
216             .single()
217       })
218 
219       futureMaybePersistentOperation.map(_.map(_.toOperation))
220     }
221 
222     override def modify(operation: SimpleOperation): Future[SimpleOperation] = {
223       implicit val ctx: EC = writeExecutionContext
224       val nowDate: ZonedDateTime = DateHelper.now()
225       Future(NamedDB("WRITE").retryableTx { implicit session =>
226         withSQL {
227           update(PersistentOperation)
228             .set(
229               column.slug -> operation.slug,
230               column.operationKind -> operation.operationKind,
231               column.operationAuthentication -> operation.operationAuthentication,
232               column.updatedAt -> nowDate
233             )
234             .where(
235               sqls
236                 .eq(column.uuid, operation.operationId.value)
237             )
238         }.executeUpdate()
239       }).map(_ => operation)
240     }
241 
242     override def addActionToOperation(action: OperationAction, operationId: OperationId): Future[Boolean] = {
243       implicit val context: EC = writeExecutionContext
244       Future(NamedDB("WRITE").retryableTx { implicit session =>
245         withSQL {
246           insert
247             .into(PersistentOperationAction)
248             .namedValues(
249               operationActionColumn.operationUuid -> operationId.value,
250               operationActionColumn.makeUserUuid -> action.makeUserId.value,
251               operationActionColumn.actionDate -> action.date,
252               operationActionColumn.actionType -> action.actionType,
253               operationActionColumn.arguments -> action.arguments.toJson.compactPrint
254             )
255         }.execute()
256       })
257     }
258 
259     override def count(slug: Option[String] = None, operationKinds: Option[Seq[OperationKind]]): Future[Int] = {
260       implicit val context: EC = readExecutionContext
261       Future(NamedDB("READ").retryableTx { implicit session =>
262         withSQL[PersistentOperation] {
263           select(sqls.count)
264             .from(PersistentOperation.as(operationAlias))
265             .where(operationWhereOpts(None, slug, operationKinds, None, None))
266         }.map(_.int(1)).single().getOrElse(0)
267       })
268     }
269 
270   }
271 }
272 
273 object DefaultPersistentOperationServiceComponent {
274 
275   final case class PersistentOperationAction(
276     operationUuid: String,
277     makeUserUuid: String,
278     actionDate: ZonedDateTime,
279     actionType: String,
280     arguments: Option[String]
281   )
282 
283   final case class PersistentOperation(
284     uuid: String,
285     questions: Seq[FlatQuestionWithDetails],
286     operationActions: Seq[PersistentOperationAction],
287     slug: String,
288     operationKind: String,
289     operationAuthentication: Option[OperationAuthentication],
290     createdAt: ZonedDateTime,
291     updatedAt: ZonedDateTime
292   ) {
293 
294     def toOperation: Operation =
295       Operation(
296         operationId = OperationId(uuid),
297         createdAt = Some(createdAt),
298         updatedAt = Some(updatedAt),
299         slug = slug,
300         operationKind = OperationKind.withValue(operationKind),
301         operationAuthentication = operationAuthentication,
302         events = operationActions
303           .map(
304             action =>
305               OperationAction(
306                 date = action.actionDate,
307                 makeUserId = UserId(action.makeUserUuid),
308                 actionType = action.actionType,
309                 arguments = action.arguments.getOrElse("{}").parseJson.convertTo[Map[String, String]]
310               )
311           )
312           .toList,
313         questions = questions.map(_.toQuestionAndDetails)
314       )
315 
316     def toSimpleOperation: SimpleOperation =
317       SimpleOperation(
318         operationId = OperationId(uuid),
319         slug = slug,
320         createdAt = Some(createdAt),
321         updatedAt = Some(updatedAt),
322         operationKind = OperationKind.withValue(operationKind),
323         operationAuthentication = operationAuthentication
324       )
325   }
326 
327   object PersistentOperationAction
328       extends SQLSyntaxSupport[PersistentOperationAction]
329       with ShortenedNames
330       with Logging {
331 
332     override val columnNames: Seq[String] =
333       Seq("operation_uuid", "make_user_uuid", "action_date", "action_type", "arguments")
334 
335     override val tableName: String = "operation_action"
336 
337     lazy val operationActionAlias: SyntaxProvider[PersistentOperationAction] = syntax("oa")
338 
339     def opt(
340       operationAction: SyntaxProvider[PersistentOperationAction]
341     )(resultSet: WrappedResultSet): Option[PersistentOperationAction] =
342       resultSet
343         .stringOpt(operationAction.resultName.operationUuid)
344         .map(_ => PersistentOperationAction(operationAction.resultName)(resultSet))
345 
346     def apply(
347       operationActionResultName: ResultName[PersistentOperationAction] = operationActionAlias.resultName
348     )(resultSet: WrappedResultSet): PersistentOperationAction = {
349       PersistentOperationAction.apply(
350         operationUuid = resultSet.string(operationActionResultName.operationUuid),
351         makeUserUuid = resultSet.string(operationActionResultName.makeUserUuid),
352         actionDate = resultSet.zonedDateTime(operationActionResultName.actionDate),
353         actionType = resultSet.string(operationActionResultName.actionType),
354         arguments = resultSet.stringOpt(operationActionResultName.arguments)
355       )
356     }
357   }
358 
359   implicit object PersistentOperation
360       extends PersistentCompanion[PersistentOperation, Operation]
361       with ShortenedNames
362       with Logging {
363 
364     override val columnNames: Seq[String] =
365       Seq("uuid", "slug", "operation_kind", "operation_authentication", "created_at", "updated_at")
366     final val swaggerAllowableValues = "uuid,slug,operation_kind,operation_authentication,created_at,updated_at"
367 
368     override val tableName: String = "operation"
369 
370     override lazy val alias: SyntaxProvider[PersistentOperation] = syntax("op")
371 
372     override lazy val defaultSortColumns: NonEmptyList[SQLSyntax] = NonEmptyList.of(alias.slug)
373 
374     @SuppressWarnings(Array("org.wartremover.warts.AsInstanceOf"))
375     def apply(
376       operationResultName: ResultName[PersistentOperation] = alias.resultName
377     )(resultSet: WrappedResultSet): PersistentOperation = {
378       PersistentOperation.apply(
379         uuid = resultSet.string(operationResultName.uuid),
380         slug = resultSet.string(operationResultName.slug),
381         operationKind = resultSet.string(operationResultName.operationKind),
382         operationAuthentication =
383           resultSet.get[Option[OperationAuthentication]](operationResultName.operationAuthentication),
384         operationActions = Seq.empty,
385         questions = Seq.empty,
386         createdAt = resultSet.zonedDateTime(operationResultName.createdAt),
387         updatedAt = resultSet.zonedDateTime(operationResultName.updatedAt)
388       )
389     }
390   }
391 
392 }