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.user
21 
22 import akka.actor.typed.{ActorSystem, Behavior}
23 import akka.util.Timeout
24 import grizzled.slf4j.Logging
25 import org.make.api.technical.KafkaConsumerBehavior.Protocol
26 import org.make.api.technical.crm.SendMailPublisherService
27 import org.make.api.technical.{KafkaConsumerBehavior, TimeSettings}
28 import org.make.api.userhistory._
29 import org.make.core.user.{User, UserId}
30 import org.make.core.user.UserType._
31 
32 import scala.concurrent.ExecutionContext.Implicits.global
33 import scala.concurrent.Future
34 
35 class UserEmailConsumerBehavior(userService: UserService, sendMailPublisherService: SendMailPublisherService)
36     extends KafkaConsumerBehavior[UserEventWrapper]
37     with Logging {
38 
39   override protected val topicKey: String = UserProducerBehavior.topicKey
40   override val groupId = "user-email"
41 
42   implicit val timeout: Timeout = TimeSettings.defaultTimeout
43 
44   override def handleMessage(message: UserEventWrapper)(system: ActorSystem[_]): Future[_] = {
45     message.event match {
46       case event: ResetPasswordEvent              => handleResetPasswordEvent(event)
47       case event: UserRegisteredEvent             => handleUserRegisteredEvent(event)
48       case event: UserValidatedAccountEvent       => handleUserValidatedAccountEvent(event)
49       case event: UserConnectedEvent              => doNothing(event)
50       case event: UserUpdatedTagEvent             => doNothing(event)
51       case event: ResendValidationEmailEvent      => handleResendValidationEmailEvent(event)
52       case event: OrganisationRegisteredEvent     => handleOrganisationRegisteredEvent(event)
53       case event: OrganisationUpdatedEvent        => doNothing(event)
54       case event: OrganisationEmailChangedEvent   => handleOrganisationEmailChangedEvent(event)
55       case event: PersonalityEmailChangedEvent    => handlePersonalityEmailChangedEvent(event)
56       case event: OrganisationInitializationEvent => doNothing(event)
57       case event: UserUpdatedOptInNewsletterEvent => doNothing(event)
58       case event: UserAnonymizedEvent             => doNothing(event)
59       case event: UserFollowEvent                 => doNothing(event)
60       case event: UserUnfollowEvent               => doNothing(event)
61       case event: UserUploadAvatarEvent           => doNothing(event)
62       case event: PersonalityRegisteredEvent      => handlePersonalityRegisteredEvent(event)
63       case event: VoteOnlyEvent                   => handleVoteOnlyEvent(event)
64       case event: VoteOnlyTestEvent               => handleVoteOnlyTestEvent(event)
65     }
66   }
67 
68   def handleResendValidationEmailEvent(event: ResendValidationEmailEvent): Future[Unit] = {
69     getUserWithValidEmail(event.userId).flatMap {
70       case Some(user) =>
71         sendMailPublisherService.resendRegistration(user, event.requestContext)
72       case None => Future.unit
73     }
74   }
75 
76   def handleUserValidatedAccountEvent(event: UserValidatedAccountEvent): Future[Unit] = {
77     getUserWithValidEmail(event.userId).flatMap {
78       case Some(user) if user.isB2C =>
79         sendMailPublisherService.publishWelcome(user, event.requestContext)
80       case _ => Future.unit
81     }
82   }
83 
84   def handleOrganisationRegisteredEvent(event: OrganisationRegisteredEvent): Future[Unit] = {
85     getUserWithValidEmail(event.userId).flatMap {
86       case Some(user) if user.hashedPassword.isEmpty =>
87         sendMailPublisherService.publishRegistrationB2B(user, event.requestContext)
88       case _ => Future.unit
89     }
90   }
91 
92   def handlePersonalityRegisteredEvent(event: PersonalityRegisteredEvent): Future[Unit] = {
93     getUserWithValidEmail(event.userId).flatMap {
94       case Some(user) if user.hashedPassword.isEmpty =>
95         sendMailPublisherService.publishRegistrationB2B(user, event.requestContext)
96       case _ => Future.unit
97     }
98   }
99 
100   def handleUserRegisteredEvent(event: UserRegisteredEvent): Future[Unit] = {
101     getUserWithValidEmail(event.userId).flatMap {
102       case Some(user) if user.isB2C && !event.isSocialLogin =>
103         sendMailPublisherService.publishRegistration(user, event.requestContext)
104       case _ => Future.unit
105     }
106   }
107 
108   private def handleResetPasswordEvent(event: ResetPasswordEvent): Future[Unit] = {
109     getUserWithValidEmail(event.userId).flatMap {
110       case Some(user) if user.isB2B =>
111         sendMailPublisherService.publishForgottenPasswordOrganisation(user, event.requestContext)
112       case Some(user) =>
113         sendMailPublisherService.publishForgottenPassword(user, event.requestContext)
114       case None => Future.unit
115     }
116   }
117 
118   private def handleOrganisationEmailChangedEvent(event: OrganisationEmailChangedEvent): Future[Unit] = {
119     getUserWithValidEmail(event.userId).flatMap {
120       case Some(organisation) =>
121         sendMailPublisherService.publishEmailChanged(
122           user = organisation,
123           requestContext = event.requestContext,
124           newEmail = event.newEmail
125         )
126       case None => Future.unit
127     }
128   }
129 
130   private def handlePersonalityEmailChangedEvent(event: PersonalityEmailChangedEvent): Future[Unit] = {
131     getUserWithValidEmail(event.userId).flatMap {
132       case Some(personality) =>
133         sendMailPublisherService.publishEmailChanged(
134           user = personality,
135           requestContext = event.requestContext,
136           newEmail = event.newEmail
137         )
138       case None => Future.unit
139     }
140   }
141 
142   private def handleVoteOnlyEvent(event: VoteOnlyEvent): Future[Unit] =
143     sendMailPublisherService.sendVoteOnlyNotice(event.requestContext).recover(logger.error(_))
144 
145   private def handleVoteOnlyTestEvent(event: VoteOnlyTestEvent): Future[Unit] =
146     sendMailPublisherService.sendVoteOnlyTest(event.userId, event.requestContext).recover(logger.error(_))
147 
148   private def getUserWithValidEmail(userId: UserId): Future[Option[User]] = {
149     userService.getUser(userId).map {
150       case Some(user) if user.isHardBounce =>
151         info(s"a hardbounced user (${user.userId}) will be ignored by email consumer")
152         None
153       case Some(user) => Some(user)
154       case None =>
155         warn(s"can't find user with id $userId")
156         None
157     }
158   }
159 }
160 
161 object UserEmailConsumerBehavior {
162   def apply(userService: UserService, sendMailPublisherService: SendMailPublisherService): Behavior[Protocol] =
163     new UserEmailConsumerBehavior(userService, sendMailPublisherService).createBehavior(name)
164   val name: String = "user-consumer"
165 }