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.proposal
21 
22 import java.time.ZonedDateTime
23 import akka.actor.typed.ActorRef
24 import akka.util.Timeout
25 import grizzled.slf4j.Logging
26 import org.make.api.proposal.ProposalActorResponse.VotesActorResponse
27 import org.make.api.technical.{ActorSystemComponent, TimeSettings}
28 import org.make.api.technical.BetterLoggingActors._
29 import org.make.core.history.HistoryActions.{VoteAndQualifications, VoteTrust}
30 import org.make.core.proposal._
31 import org.make.core.question.Question
32 import org.make.core.reference.Language
33 import org.make.core.tag.TagId
34 import org.make.core.technical.Multilingual
35 import org.make.core.user.{User, UserId}
36 import org.make.core.{RequestContext, ValidationError, ValidationFailedError}
37 
38 import scala.concurrent.ExecutionContext.Implicits.global
39 import scala.concurrent.Future
40 
41 trait ProposalCoordinatorComponent {
42   def proposalCoordinator: ActorRef[ProposalCommand]
43 }
44 
45 trait ProposalCoordinatorService {
46 
47   /**
48     * Retrieve a Proposal without logging it
49     *
50     * @param proposalId the proposal to retrieve
51     * @return the given proposal if exists
52     */
53   def getProposal(proposalId: ProposalId): Future[Option[Proposal]]
54 
55   /**
56     * Retrieves a proposal by id and log the fact that it was seen
57     *
58     * @param proposalId the proposal viewed by the user
59     * @param requestContext the context of the request
60     * @return the proposal as viewed by the user
61     */
62   def viewProposal(proposalId: ProposalId, requestContext: RequestContext): Future[Option[Proposal]]
63 
64   def propose(
65     proposalId: ProposalId,
66     requestContext: RequestContext,
67     user: User,
68     createdAt: ZonedDateTime,
69     content: String,
70     submittedAsLanguage: Language,
71     isAnonymous: Boolean,
72     question: Question,
73     initialProposal: Boolean,
74     proposalType: ProposalType
75   ): Future[ProposalId]
76   def update(
77     moderator: UserId,
78     proposalId: ProposalId,
79     requestContext: RequestContext,
80     updatedAt: ZonedDateTime,
81     newContent: Option[String],
82     newTranslations: Option[Multilingual[String]],
83     tags: Seq[TagId],
84     question: Question
85   ): Future[Option[Proposal]]
86   def updateVotes(
87     moderator: UserId,
88     proposalId: ProposalId,
89     requestContext: RequestContext,
90     updatedAt: ZonedDateTime,
91     votes: Seq[UpdateVoteRequest]
92   ): Future[Option[Proposal]]
93   def accept(
94     moderator: UserId,
95     proposalId: ProposalId,
96     requestContext: RequestContext,
97     sendNotificationEmail: Boolean,
98     newContent: Option[String],
99     newTranslations: Option[Multilingual[String]],
100     question: Question,
101     tags: Seq[TagId]
102   ): Future[Option[Proposal]]
103   def refuse(
104     moderator: UserId,
105     proposalId: ProposalId,
106     requestContext: RequestContext,
107     sendNotificationEmail: Boolean,
108     refusalReason: Option[String]
109   ): Future[Option[Proposal]]
110   def postpone(moderator: UserId, proposalId: ProposalId, requestContext: RequestContext): Future[Option[Proposal]]
111   def vote(params: VoteProposalParams): Future[Option[VotesActorResponse]]
112   def unvote(params: VoteProposalParams): Future[Option[VotesActorResponse]]
113   def qualification(
114     proposalId: ProposalId,
115     maybeUserId: Option[UserId],
116     requestContext: RequestContext,
117     voteKey: VoteKey,
118     qualificationKey: QualificationKey,
119     vote: Option[VoteAndQualifications],
120     voteTrust: VoteTrust
121   ): Future[Option[Qualification]]
122   def unqualification(
123     proposalId: ProposalId,
124     maybeUserId: Option[UserId],
125     requestContext: RequestContext,
126     voteKey: VoteKey,
127     qualificationKey: QualificationKey,
128     vote: Option[VoteAndQualifications],
129     voteTrust: VoteTrust
130   ): Future[Option[Qualification]]
131   def lock(
132     proposalId: ProposalId,
133     moderatorId: UserId,
134     moderatorName: Option[String],
135     requestContext: RequestContext
136   ): Future[Option[UserId]]
137   def patch(
138     proposalId: ProposalId,
139     userId: UserId,
140     changes: PatchProposalRequest,
141     requestContext: RequestContext
142   ): Future[Option[Proposal]]
143   def setKeywords(
144     proposalId: ProposalId,
145     keywords: Seq[ProposalKeyword],
146     requestContext: RequestContext
147   ): Future[Option[Proposal]]
148 }
149 
150 trait ProposalCoordinatorServiceComponent {
151   def proposalCoordinatorService: ProposalCoordinatorService
152 }
153 
154 trait DefaultProposalCoordinatorServiceComponent extends ProposalCoordinatorServiceComponent with Logging {
155   self: ActorSystemComponent with ProposalCoordinatorComponent =>
156 
157   override lazy val proposalCoordinatorService: ProposalCoordinatorService = new DefaultProposalCoordinatorService
158 
159   class DefaultProposalCoordinatorService extends ProposalCoordinatorService {
160 
161     implicit val timeout: Timeout = TimeSettings.defaultTimeout
162 
163     override def getProposal(proposalId: ProposalId): Future[Option[Proposal]] = {
164       (proposalCoordinator ?? (GetProposal(proposalId, RequestContext.empty, _))).map(asOption)
165     }
166 
167     override def viewProposal(proposalId: ProposalId, requestContext: RequestContext): Future[Option[Proposal]] = {
168       (proposalCoordinator ?? (ViewProposalCommand(proposalId, requestContext, _))).map(asOption)
169     }
170 
171     override def propose(
172       proposalId: ProposalId,
173       requestContext: RequestContext,
174       user: User,
175       createdAt: ZonedDateTime,
176       content: String,
177       submittedAsLanguage: Language,
178       isAnonymous: Boolean,
179       question: Question,
180       initialProposal: Boolean,
181       proposalType: ProposalType
182     ): Future[ProposalId] = {
183       (proposalCoordinator ?? (ProposeCommand(
184         proposalId,
185         requestContext,
186         user,
187         createdAt,
188         content,
189         submittedAsLanguage,
190         isAnonymous,
191         question,
192         initialProposal,
193         proposalType,
194         _
195       ))).map(_.value)
196     }
197 
198     override def update(
199       moderator: UserId,
200       proposalId: ProposalId,
201       requestContext: RequestContext,
202       updatedAt: ZonedDateTime,
203       newContent: Option[String],
204       newTranslations: Option[Multilingual[String]],
205       tags: Seq[TagId],
206       question: Question
207     ): Future[Option[Proposal]] = {
208       (proposalCoordinator ?? (UpdateProposalCommand(
209         moderator,
210         proposalId,
211         requestContext,
212         updatedAt,
213         newContent,
214         newTranslations,
215         tags,
216         question,
217         _
218       ))).flatMap(shapeResponse)
219     }
220 
221     override def updateVotes(
222       moderator: UserId,
223       proposalId: ProposalId,
224       requestContext: RequestContext,
225       updatedAt: ZonedDateTime,
226       votes: Seq[UpdateVoteRequest]
227     ): Future[Option[Proposal]] = {
228       (proposalCoordinator ?? (UpdateProposalVotesCommand(moderator, proposalId, requestContext, updatedAt, votes, _)))
229         .flatMap(shapeResponse)
230     }
231 
232     override def accept(
233       moderator: UserId,
234       proposalId: ProposalId,
235       requestContext: RequestContext,
236       sendNotificationEmail: Boolean,
237       newContent: Option[String],
238       newTranslations: Option[Multilingual[String]],
239       question: Question,
240       tags: Seq[TagId]
241     ): Future[Option[Proposal]] = {
242       (proposalCoordinator ?? (AcceptProposalCommand(
243         moderator,
244         proposalId,
245         requestContext,
246         sendNotificationEmail,
247         newContent,
248         newTranslations,
249         question,
250         tags,
251         _
252       ))).flatMap(shapeResponse)
253     }
254 
255     override def refuse(
256       moderator: UserId,
257       proposalId: ProposalId,
258       requestContext: RequestContext,
259       sendNotificationEmail: Boolean,
260       refusalReason: Option[String]
261     ): Future[Option[Proposal]] = {
262       (proposalCoordinator ?? (RefuseProposalCommand(
263         moderator,
264         proposalId,
265         requestContext,
266         sendNotificationEmail,
267         refusalReason,
268         _
269       ))).flatMap(shapeResponse)
270     }
271 
272     override def postpone(
273       moderator: UserId,
274       proposalId: ProposalId,
275       requestContext: RequestContext
276     ): Future[Option[Proposal]] = {
277       (proposalCoordinator ?? (PostponeProposalCommand(moderator, proposalId, requestContext, _)))
278         .flatMap(shapeResponse)
279     }
280 
281     override def vote(params: VoteProposalParams): Future[Option[VotesActorResponse]] = {
282       (proposalCoordinator ?? (VoteProposalCommand(
283         params.proposalId,
284         params.maybeUserId,
285         params.requestContext,
286         params.voteKey,
287         params.maybeOrganisationId,
288         params.vote,
289         params.voteTrust,
290         params.newProposalsVoteThreshold,
291         _
292       ))).flatMap(shapeResponse)
293     }
294 
295     override def unvote(params: VoteProposalParams): Future[Option[VotesActorResponse]] = {
296       (proposalCoordinator ?? (UnvoteProposalCommand(
297         params.proposalId,
298         params.maybeUserId,
299         params.requestContext,
300         params.voteKey,
301         params.maybeOrganisationId,
302         params.vote,
303         params.voteTrust,
304         params.newProposalsVoteThreshold,
305         _
306       ))).flatMap(shapeResponse)
307     }
308 
309     override def qualification(
310       proposalId: ProposalId,
311       maybeUserId: Option[UserId],
312       requestContext: RequestContext,
313       voteKey: VoteKey,
314       qualificationKey: QualificationKey,
315       vote: Option[VoteAndQualifications],
316       voteTrust: VoteTrust
317     ): Future[Option[Qualification]] = {
318       (proposalCoordinator ?? (QualifyVoteCommand(
319         proposalId,
320         maybeUserId,
321         requestContext,
322         voteKey,
323         qualificationKey,
324         vote,
325         voteTrust,
326         _
327       ))).flatMap(shapeResponse)
328     }
329 
330     override def unqualification(
331       proposalId: ProposalId,
332       maybeUserId: Option[UserId],
333       requestContext: RequestContext,
334       voteKey: VoteKey,
335       qualificationKey: QualificationKey,
336       vote: Option[VoteAndQualifications],
337       voteTrust: VoteTrust
338     ): Future[Option[Qualification]] = {
339       (proposalCoordinator ?? (UnqualifyVoteCommand(
340         proposalId,
341         maybeUserId,
342         requestContext,
343         voteKey,
344         qualificationKey,
345         vote,
346         voteTrust,
347         _
348       ))).flatMap(shapeResponse)
349     }
350 
351     override def lock(
352       proposalId: ProposalId,
353       moderatorId: UserId,
354       moderatorName: Option[String],
355       requestContext: RequestContext
356     ): Future[Option[UserId]] = {
357       (proposalCoordinator ?? (LockProposalCommand(proposalId, moderatorId, moderatorName, requestContext, _)))
358         .flatMap(shapeResponse)
359     }
360 
361     override def patch(
362       proposalId: ProposalId,
363       userId: UserId,
364       changes: PatchProposalRequest,
365       requestContext: RequestContext
366     ): Future[Option[Proposal]] = {
367       (proposalCoordinator ?? (PatchProposalCommand(proposalId, userId, changes, requestContext, _))).map(asOption)
368     }
369 
370     override def setKeywords(
371       proposalId: ProposalId,
372       keywords: Seq[ProposalKeyword],
373       requestContext: RequestContext
374     ): Future[Option[Proposal]] = {
375       (proposalCoordinator ?? (SetKeywordsCommand(proposalId, keywords, requestContext, _))).map(asOption)
376     }
377 
378     private def asOption[E, T](response: ProposalActorResponse[E, T]): Option[T] = response match {
379       case ProposalActorResponse.Envelope(value) => Some(value)
380       case _: ProposalActorResponse.Error[E]     => None
381     }
382 
383     private def shapeResponse[E, T](response: ProposalActorResponse[E, T]): Future[Option[T]] = response match {
384       case ProposalActorResponse.Error.AlreadyLockedBy(moderatorName) =>
385         Future.failed(
386           ValidationFailedError(errors = Seq(ValidationError("moderatorName", "already_locked", Some(moderatorName))))
387         )
388       case ProposalActorResponse.Error.HistoryError(error) => Future.failed(error)
389       case ProposalActorResponse.Error.InvalidStateError(message) =>
390         Future.failed(ValidationFailedError(errors = Seq(ValidationError("status", "invalid_state", Some(message)))))
391       case other => Future.successful(asOption(other))
392     }
393   }
394 }
395 
396 final case class VoteProposalParams(
397   proposalId: ProposalId,
398   maybeUserId: Option[UserId],
399   requestContext: RequestContext,
400   voteKey: VoteKey,
401   maybeOrganisationId: Option[UserId],
402   vote: Option[VoteAndQualifications],
403   voteTrust: VoteTrust,
404   newProposalsVoteThreshold: Int
405 )