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.{ActorSystem, Behavior}
23 import akka.util.Timeout
24 import grizzled.slf4j.Logging
25 import org.make.api.proposal.PublishedProposalEvent._
26 import org.make.api.technical.KafkaConsumerBehavior.Protocol
27 import org.make.api.technical.{KafkaConsumerBehavior, TimeSettings}
28 import org.make.api.userhistory._
29 
30 import scala.concurrent.Future
31 
32 class ProposalUserHistoryConsumerBehavior(userHistoryCoordinatorService: UserHistoryCoordinatorService)
33     extends KafkaConsumerBehavior[ProposalEventWrapper]
34     with Logging {
35 
36   override protected val topicKey: String = ProposalKafkaProducerBehavior.topicKey
37   override val groupId = "proposal-user-history"
38 
39   implicit val timeout: Timeout = TimeSettings.defaultTimeout
40 
41   override def handleMessage(message: ProposalEventWrapper)(system: ActorSystem[_]): Future[_] = {
42     message.event match {
43       case event: ProposalProposed             => handleProposalProposed(event)
44       case event: ProposalAccepted             => handleProposalAccepted(event)
45       case event: ProposalRefused              => handleProposalRefused(event)
46       case event: ProposalReportedNotice       => doNothing(event)
47       case event: ProposalPostponed            => handleProposalPostponed(event)
48       case event: ProposalLocked               => handleProposalLocked(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: ProposalVoted                => doNothing(event)
55       case event: ProposalUnvoted              => doNothing(event)
56       case event: ProposalQualified            => doNothing(event)
57       case event: ProposalUnqualified          => doNothing(event)
58       case event: SimilarProposalsAdded        => doNothing(event)
59       case event: ProposalPatched              => doNothing(event)
60       case event: ProposalAddedToOperation     => doNothing(event)
61       case event: ProposalRemovedFromOperation => doNothing(event)
62       case event: ProposalAnonymized           => doNothing(event)
63       case event: ProposalKeywordsSet          => doNothing(event)
64     }
65 
66   }
67 
68   def handleProposalProposed(event: ProposalProposed): Future[Unit] = {
69     userHistoryCoordinatorService.logHistory(
70       LogUserProposalEvent(
71         userId = event.userId,
72         requestContext = event.requestContext,
73         action = UserAction(
74           date = event.eventDate,
75           actionType = LogUserProposalEvent.action,
76           arguments = UserProposal(content = event.content)
77         )
78       )
79     )
80     Future.unit
81   }
82 
83   def handleProposalLocked(event: ProposalLocked): Future[Unit] = {
84     userHistoryCoordinatorService.logHistory(
85       LogLockProposalEvent(
86         userId = event.moderatorId,
87         moderatorName = event.moderatorName,
88         requestContext = event.requestContext,
89         action = UserAction(date = event.eventDate, actionType = ProposalLocked.actionType, arguments = event)
90       )
91     )
92     Future.unit
93   }
94 
95   def handleProposalAccepted(event: ProposalAccepted): Future[Unit] = {
96     userHistoryCoordinatorService.logHistory(
97       LogAcceptProposalEvent(
98         userId = event.moderator,
99         requestContext = event.requestContext,
100         action = UserAction(date = event.eventDate, actionType = ProposalAccepted.actionType, arguments = event)
101       )
102     )
103     Future.unit
104   }
105 
106   def handleProposalRefused(event: ProposalRefused): Future[Unit] = {
107     userHistoryCoordinatorService.logHistory(
108       LogRefuseProposalEvent(
109         userId = event.moderator,
110         requestContext = event.requestContext,
111         action = UserAction(date = event.eventDate, actionType = ProposalRefused.actionType, arguments = event)
112       )
113     )
114     Future.unit
115   }
116 
117   def handleProposalPostponed(event: ProposalPostponed): Future[Unit] = {
118     userHistoryCoordinatorService.logHistory(
119       LogPostponeProposalEvent(
120         userId = event.moderator,
121         requestContext = event.requestContext,
122         action = UserAction(date = event.eventDate, actionType = ProposalPostponed.actionType, arguments = event)
123       )
124     )
125     Future.unit
126   }
127 }
128 
129 object ProposalUserHistoryConsumerBehavior {
130   val name: String = "proposal-user-history-consumer"
131 
132   def apply(userHistoryCoordinatorService: UserHistoryCoordinatorService): Behavior[Protocol] =
133     new ProposalUserHistoryConsumerBehavior(userHistoryCoordinatorService).createBehavior(name)
134 }