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 akka.Done
23 import akka.stream.scaladsl.{Sink, Source}
24 
25 import java.time.LocalDate
26 import io.circe.syntax._
27 import org.make.api.question.PersistentQuestionServiceComponent
28 import org.make.api.tag.PersistentTagServiceComponent
29 import org.make.api.technical.{ActorSystemComponent, IdGeneratorComponent, ShortenedNames}
30 import org.make.core.{DateHelper, Order}
31 import org.make.core.operation._
32 import org.make.core.operation.OperationActionType._
33 import org.make.core.operation.OperationKind.GreatCause
34 import org.make.core.reference.Country
35 import org.make.core.user.UserId
36 
37 import scala.concurrent.ExecutionContext.Implicits.global
38 import scala.concurrent.Future
39 import org.make.core.technical.Pagination._
40 
41 trait DefaultOperationServiceComponent extends OperationServiceComponent with ShortenedNames {
42   this: PersistentOperationServiceComponent
43     with IdGeneratorComponent
44     with PersistentTagServiceComponent
45     with PersistentQuestionServiceComponent
46     with OperationOfQuestionServiceComponent
47     with ActorSystemComponent =>
48 
49   override lazy val operationService: OperationService = new DefaultOperationService
50 
51   class DefaultOperationService extends OperationService {
52 
53     override def find(
54       operationIds: Option[Seq[OperationId]] = None,
55       slug: Option[String] = None,
56       country: Option[Country] = None,
57       openAt: Option[LocalDate] = None
58     ): Future[Seq[Operation]] = {
59 
60       persistentOperationService.find(operationIds = operationIds, slug = slug, country = country, openAt = openAt)
61     }
62 
63     override def findSimple(
64       offset: Offset = Offset.zero,
65       end: Option[End] = None,
66       sort: Option[String] = None,
67       order: Option[Order] = None,
68       slug: Option[String] = None,
69       operationKinds: Option[Seq[OperationKind]]
70     ): Future[Seq[SimpleOperation]] = {
71 
72       persistentOperationService.findSimple(
73         offset = offset,
74         end = end,
75         sort = sort,
76         order = order,
77         slug = slug,
78         operationKinds = operationKinds
79       )
80     }
81 
82     override def findOne(operationId: OperationId): Future[Option[Operation]] = {
83       persistentOperationService.getById(operationId)
84     }
85 
86     override def findOneSimple(operationId: OperationId): Future[Option[SimpleOperation]] = {
87       persistentOperationService.getSimpleById(operationId)
88     }
89 
90     override def findOneBySlug(slug: String): Future[Option[Operation]] = {
91       persistentOperationService.getBySlug(slug)
92     }
93 
94     override def create(
95       userId: UserId,
96       slug: String,
97       operationKind: OperationKind,
98       operationAuthentication: Option[OperationAuthentication]
99     ): Future[OperationId] = {
100       val now = DateHelper.now()
101 
102       val persist: Future[SimpleOperation] = persistentOperationService.persist(
103         SimpleOperation(
104           operationId = idGenerator.nextOperationId(),
105           slug = slug,
106           operationKind = operationKind,
107           operationAuthentication = operationAuthentication,
108           createdAt = Some(now),
109           updatedAt = Some(now)
110         )
111       )
112 
113       def addAction(persisted: SimpleOperation): Future[Boolean] =
114         persistentOperationService
115           .addActionToOperation(
116             OperationAction(
117               makeUserId = userId,
118               actionType = OperationCreateAction.value,
119               arguments = Map("operation" -> operationToString(persisted))
120             ),
121             persisted.operationId
122           )
123 
124       for {
125         persisted <- persist
126         _         <- addAction(persisted)
127       } yield persisted.operationId
128     }
129 
130     override def update(
131       operationId: OperationId,
132       userId: UserId,
133       slug: Option[String] = None,
134       operationKind: Option[OperationKind] = None,
135       operationAuthentication: Option[OperationAuthentication]
136     ): Future[Option[OperationId]] = {
137 
138       persistentOperationService
139         .getById(operationId)
140         .flatMap {
141           case None => Future.successful(None)
142           case Some(operation) =>
143             val modify = persistentOperationService.modify(
144               SimpleOperation(
145                 operationId = operationId,
146                 slug = slug.getOrElse(operation.slug),
147                 operationKind = operationKind.getOrElse(operation.operationKind),
148                 operationAuthentication = operationAuthentication.orElse(operation.operationAuthentication),
149                 createdAt = operation.createdAt,
150                 updatedAt = operation.updatedAt
151               )
152             )
153 
154             def addAction(updated: SimpleOperation): Future[Boolean] =
155               persistentOperationService
156                 .addActionToOperation(
157                   OperationAction(
158                     makeUserId = userId,
159                     actionType = OperationUpdateAction.value,
160                     arguments = Map("operation" -> operationToString(updated))
161                   ),
162                   updated.operationId
163                 )
164 
165             def updateQuestions(updated: SimpleOperation): Future[Done] =
166               Source(operation.questions)
167                 .mapAsync(5) { question =>
168                   operationOfQuestionService.update(
169                     question.details.copy(featured = question.details.featured || updated.operationKind == GreatCause)
170                   )
171                 }
172                 .runWith(Sink.ignore)
173 
174             for {
175               updated <- modify
176               _       <- addAction(updated)
177               _       <- updateQuestions(updated)
178             } yield Some(updated.operationId)
179         }
180     }
181 
182     private def operationToString(operation: SimpleOperation): String = {
183       scala.collection
184         .Map[String, String]("operationId" -> operation.operationId.value)
185         .asJson
186         .toString
187     }
188 
189     override def count(slug: Option[String], operationKinds: Option[Seq[OperationKind]]): Future[Int] = {
190       persistentOperationService.count(slug = slug, operationKinds = operationKinds)
191     }
192 
193   }
194 }