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 akka.actor.typed.Behavior
23 import akka.util.Timeout
24 import org.make.api.proposal.PublishedProposalEvent._
25 import org.make.api.user.PersistentUserProposalsService
26 import org.make.api.technical.crm.SendMailPublisherService
27 import org.make.api.technical.{KafkaConsumerBehavior, TimeSettings, ValueNotFoundException}
28 
29 import scala.concurrent.Future
30 import scala.concurrent.ExecutionContext.Implicits.global
31 import akka.actor.typed.ActorSystem
32 
33 class ProposalEmailConsumerBehavior(
34   sendMailPublisherService: SendMailPublisherService,
35   userProposalsService: PersistentUserProposalsService
36 ) extends KafkaConsumerBehavior[ProposalEventWrapper] {
37 
38   override protected val topicKey: String = ProposalKafkaProducerBehavior.topicKey
39   override val groupId = "proposal-email"
40 
41   implicit val timeout: Timeout = TimeSettings.defaultTimeout
42 
43   override def handleMessage(message: ProposalEventWrapper)(system: ActorSystem[_]): Future[Unit] = {
44     message.event match {
45       case event: ProposalAccepted             => handleProposalAccepted(event)
46       case event: ProposalRefused              => handleProposalRefused(event)
47       case event: ProposalReportedNotice       => handleProposalReported(event)
48       case event: ProposalPostponed            => doNothing(event)
49       case event: ProposalViewed               => doNothing(event)
50       case event: ProposalUpdated              => doNothing(event)
51       case event: ProposalVotesVerifiedUpdated => doNothing(event)
52       case event: ProposalVotesUpdated         => doNothing(event)
53       case event: ReindexProposal              => doNothing(event)
54       case event: ProposalProposed             => handleProposalProposed(event, MaxPropositionsThresholds(system))
55       case event: ProposalVoted                => doNothing(event)
56       case event: ProposalUnvoted              => doNothing(event)
57       case event: ProposalQualified            => doNothing(event)
58       case event: ProposalUnqualified          => doNothing(event)
59       case event: SimilarProposalsAdded        => doNothing(event)
60       case event: ProposalLocked               => doNothing(event)
61       case event: ProposalPatched              => doNothing(event)
62       case event: ProposalAddedToOperation     => doNothing(event)
63       case event: ProposalRemovedFromOperation => doNothing(event)
64       case event: ProposalAnonymized           => doNothing(event)
65       case event: ProposalKeywordsSet          => doNothing(event)
66     }
67   }
68 
69   def handleProposalAccepted(event: ProposalAccepted): Future[Unit] = {
70     if (event.sendValidationEmail) {
71       sendMailPublisherService.publishAcceptProposal(event.id)
72     } else {
73       Future.unit
74     }
75   }
76 
77   def handleProposalRefused(event: ProposalRefused): Future[Unit] = {
78     if (event.sendRefuseEmail) {
79       sendMailPublisherService.publishRefuseProposal(event.id)
80     } else {
81       Future.unit
82     }
83   }
84 
85   def handleProposalReported(event: ProposalReportedNotice): Future[Unit] =
86     sendMailPublisherService.publishProposalReportedNotice(event.id, event.proposalLanguage, event.reason)
87 
88   def handleProposalProposed(
89     event: ProposalProposed,
90     maxPropositionsThresholds: MaxPropositionsThresholds
91   ): Future[Unit] =
92     event.question match {
93       case None =>
94         Future.failed(ValueNotFoundException("No question was attached to the proposal"))
95       case Some(questionId) =>
96         val authorId = event.author.userId
97         userProposalsService
98           .incrementCounter(authorId, questionId)
99           .flatMap({
100             case maxPropositionsThresholds.warnThreshold =>
101               sendMailPublisherService.publishAbusiveProposerWarn(questionId, authorId, event.requestContext)
102             case maxPropositionsThresholds.blockThreshold =>
103               sendMailPublisherService.publishAbusiveProposerBlock(questionId, authorId, event.requestContext)
104             case _ =>
105               Future.unit
106           })
107     }
108 }
109 
110 object ProposalEmailConsumerActor {
111   val name: String = "proposal-emails-consumer"
112   def apply(
113     sendMailPublisherService: SendMailPublisherService,
114     userProposalsService: PersistentUserProposalsService
115   ): Behavior[KafkaConsumerBehavior.Protocol] =
116     new ProposalEmailConsumerBehavior(sendMailPublisherService, userProposalsService)
117       .createBehavior(name)
118 }