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.technical.crm
21 
22 import cats.implicits._
23 import io.netty.handler.codec.http.QueryStringEncoder
24 import org.make.api.ConfigComponent
25 import org.make.api.crmTemplates.CrmTemplatesServiceComponent
26 import org.make.api.extensions.MailJetTemplateConfigurationComponent
27 import org.make.api.operation.{OperationOfQuestionServiceComponent, OperationServiceComponent}
28 import org.make.api.proposal.{ProposalCoordinatorServiceComponent, ProposalServiceComponent}
29 import org.make.api.question.QuestionServiceComponent
30 import org.make.api.technical.EventBusServiceComponent
31 import org.make.api.technical.Futures.FutureOfOption
32 import org.make.api.technical.crm.DefaultSendMailPublisherServiceComponent.Utm
33 import org.make.api.technical.security.SecurityHelper
34 import org.make.api.user.UserServiceComponent
35 import org.make.core.BusinessConfig._
36 import org.make.core.operation.{Operation, OperationOfQuestion}
37 import org.make.core.sequence.SequenceKind
38 import org.make.core.crmTemplate.CrmTemplateKind._
39 import org.make.core.crmTemplate.{CrmTemplateKind, MonitoringCategory, TemplateId}
40 import org.make.core.proposal.{Proposal, ProposalId, ProposalReportReason, ProposalStatus}
41 import org.make.core.question.{Question, QuestionId}
42 import org.make.core.reference.Country
43 import org.make.core.user.{User, UserId, UserType}
44 import org.make.core._
45 
46 import java.util.Locale
47 import java.time.format.DateTimeFormatter
48 import scala.concurrent.ExecutionContext.Implicits.global
49 import scala.concurrent.Future
50 import org.make.core.reference.Language
51 
52 trait SendMailPublisherServiceComponent {
53   def sendMailPublisherService: SendMailPublisherService
54 }
55 
56 trait SendMailPublisherService {
57   def publishWelcome(user: User, requestContext: RequestContext): Future[Unit]
58 
59   def publishRegistration(user: User, requestContext: RequestContext): Future[Unit]
60 
61   def sendEmailToProposer(
62     proposalId: ProposalId,
63     senderId: UserId,
64     sanitizedHtml: SanitizedHtml,
65     dryRun: Boolean,
66     requestContext: RequestContext
67   ): Future[Unit]
68 
69   def publishRegistrationB2B(user: User, requestContext: RequestContext): Future[Unit]
70 
71   def publishForgottenPassword(user: User, requestContext: RequestContext): Future[Unit]
72 
73   def publishForgottenPasswordOrganisation(organisation: User, requestContext: RequestContext): Future[Unit]
74 
75   def publishEmailChanged(user: User, requestContext: RequestContext, newEmail: String): Future[Unit]
76 
77   def publishAcceptProposal(proposalId: ProposalId): Future[Unit]
78 
79   def publishRefuseProposal(proposalId: ProposalId): Future[Unit]
80 
81   def publishAbusiveProposerWarn(
82     questionId: QuestionId,
83     proposerId: UserId,
84     requestContext: RequestContext
85   ): Future[Unit]
86   def publishAbusiveProposerBlock(
87     questionId: QuestionId,
88     proposerId: UserId,
89     requestContext: RequestContext
90   ): Future[Unit]
91 
92   def resendRegistration(user: User, requestContext: RequestContext): Future[Unit]
93 
94   def sendVoteOnlyNotice(context: RequestContext): Future[Unit]
95 
96   def sendVoteOnlyTest(user: UserId, context: RequestContext): Future[Unit]
97 
98   def publishProposalReportedNotice(
99     proposalId: ProposalId,
100     proposalLanguage: Language,
101     reason: ProposalReportReason
102   ): Future[Unit]
103 }
104 
105 trait DefaultSendMailPublisherServiceComponent
106     extends SendMailPublisherServiceComponent
107     with MailJetTemplateConfigurationComponent
108     with EventBusServiceComponent {
109   this: UserServiceComponent
110     with ProposalCoordinatorServiceComponent
111     with ProposalServiceComponent
112     with QuestionServiceComponent
113     with OperationServiceComponent
114     with CrmClientComponent
115     with PersistentCrmUserServiceComponent
116     with CrmTemplatesServiceComponent
117     with ConfigComponent
118     with OperationOfQuestionServiceComponent =>
119 
120   private def buildUrl(base: String, path: String, maybeUtm: Option[Utm], others: (String, String)*): String = {
121     val builder = new QueryStringEncoder(path)
122     (maybeUtm
123       .fold(Map.empty[String, String])(
124         utm =>
125           Map(
126             "utm_source" -> utm.source,
127             "utm_medium" -> utm.medium,
128             "utm_campaign" -> utm.campaign,
129             "utm_term" -> utm.term,
130             "utm_content" -> utm.content
131           )
132       ) ++ others.toMap).foreachEntry(builder.addParam)
133     s"$base/${builder.toString}"
134   }
135 
136   private def adaptUtmTerm(term: String, userType: UserType): String = {
137     if (userType != UserType.UserTypeUser) {
138       s"${term}acteur"
139     } else {
140       term
141     }
142   }
143 
144   private def adaptUtmSource(isMarketing: Boolean): String = {
145     if (isMarketing) {
146       "crm-marketing"
147     } else {
148       "crm-transac"
149     }
150   }
151 
152   private def getProposalUrl(proposal: Proposal, question: Question, maybeUtm: Option[Utm]): String = {
153     val country: String = proposal.creationContext.country.getOrElse(question.countries.head).value
154 
155     buildUrl(
156       base = mailJetTemplateConfiguration.mainFrontendUrl,
157       path = s"$country/consultation/${question.slug}/proposal/${proposal.proposalId.value}/${proposal.slug}",
158       maybeUtm
159     )
160   }
161 
162   private def getAccountValidationUrl(
163     user: User,
164     verificationToken: String,
165     requestContext: RequestContext,
166     utmCampaign: String
167   ): String = {
168     val country: String = requestContext.country.map(_.value).getOrElse("FR")
169     val questionIdValue: String = requestContext.questionContext.questionId.map(_.value).getOrElse("")
170 
171     buildUrl(
172       base = mailJetTemplateConfiguration.mainFrontendUrl,
173       path = s"${user.country.value}/account-activation/${user.userId.value}/$verificationToken",
174       maybeUtm = Some(Utm(campaign = utmCampaign, term = "validation", content = "cta")),
175       "country" -> country,
176       "question" -> questionIdValue
177     )
178   }
179 
180   private def getForgottenPasswordUrl(
181     user: User,
182     resetToken: String,
183     baseApplicationName: Option[ApplicationName]
184   ): String = {
185     val appPath = s"password-recovery/${user.userId.value}/$resetToken"
186 
187     val (base, path) = baseApplicationName match {
188       case Some(ApplicationName.Backoffice) =>
189         (mailJetTemplateConfiguration.backofficeUrl, s"#/$appPath")
190       case _ =>
191         (mailJetTemplateConfiguration.mainFrontendUrl, s"${user.country}/$appPath")
192     }
193 
194     buildUrl(base = base, path = path, maybeUtm = None)
195   }
196 
197   private def sequenceUrlForProposal(questionSlug: String, proposal: Proposal, maybeUtm: Option[Utm]): String = {
198     val country = proposal.creationContext.country.fold("FR")(_.value)
199 
200     buildUrl(
201       base = mailJetTemplateConfiguration.mainFrontendUrl,
202       path = s"$country/consultation/$questionSlug/selection",
203       maybeUtm,
204       "introCard" -> "false"
205     )
206   }
207 
208   private def buildSequenceUrl(
209     questionSlug: String,
210     sequenceKind: SequenceKind,
211     country: Country,
212     isMarketing: Boolean = false,
213     userType: Option[UserType] = None
214   ): String = {
215     val suffix = sequenceKind match {
216       case SequenceKind.Consensus   => "-popular"
217       case SequenceKind.Controversy => "-controversial"
218       case _                        => ""
219     }
220     buildUrl(
221       base = mailJetTemplateConfiguration.mainFrontendUrl,
222       path = s"${country.value}/consultation/$questionSlug/selection$suffix",
223       maybeUtm = Some(
224         Utm(
225           source = adaptUtmSource(isMarketing),
226           content = "cta",
227           campaign = questionSlug,
228           term = userType.fold("voteonly")(adaptUtmTerm("", _))
229         )
230       )
231     )
232   }
233 
234   private def getUtmCampaignFromQuestionId(questionId: Option[QuestionId]): Future[String] = {
235     questionId match {
236       case Some(QuestionId("")) => Future.successful("unknown")
237       case Some(id)             => questionService.getQuestion(id).map(_.fold("unknown")(_.slug))
238       case None                 => Future.successful("core")
239     }
240   }
241 
242   private def resolveQuestionSlug(country: Country, requestContext: RequestContext): Future[String] = {
243     requestContext.questionContext.questionId
244       .map(questionService.getQuestion)
245       .orElse {
246         requestContext.operationId.map(
247           operationId =>
248             questionService
249               .findQuestion(maybeOperationId = Some(operationId), country = country, language = country.language)
250         )
251       } match {
252       case Some(futureMaybeQuestion) => futureMaybeQuestion.map(_.map(_.slug).getOrElse("unknown"))
253       case None                      => Future.successful("unknown")
254     }
255   }
256 
257   private def generateEmail(
258     recipient: User,
259     templateId: TemplateId,
260     monitoringCategory: String,
261     variables: Map[String, String]
262   ): SendMessages = {
263     SendMessages(
264       SendEmail.create(
265         templateId = Some(templateId.value.toInt),
266         recipients = Seq(Recipient(email = recipient.email, name = recipient.fullName)),
267         variables = Some(variables),
268         customCampaign = None,
269         monitoringCategory = Some(monitoringCategory)
270       )
271     )
272   }
273 
274   override lazy val sendMailPublisherService: SendMailPublisherService = new DefaultSendMailPublisherService
275 
276   class DefaultSendMailPublisherService extends SendMailPublisherService {
277     override def publishWelcome(user: User, baseRequestContext: RequestContext): Future[Unit] = {
278       val requestContext =
279         baseRequestContext.copy(questionContext = baseRequestContext.questionContext
280           .copy(questionId =
281             baseRequestContext.questionContext.questionId.orElse(user.profile.flatMap(_.registerQuestionId))
282           )
283         )
284       resolveQuestionSlug(user.country, requestContext).flatMap { questionSlug =>
285         crmTemplatesService
286           .find(Welcome, requestContext.questionContext.questionId, user.profile.map(_.crmLanguage))
287           .map(_.foreach { templateId =>
288             val variables =
289               Map(
290                 "firstname" -> user.firstName.getOrElse(""),
291                 "registration_context" -> questionSlug,
292                 "operation" -> requestContext.operationId.map(_.value).getOrElse(""),
293                 "question" -> requestContext.questionContext.question.getOrElse(""),
294                 "location" -> requestContext.location.getOrElse(""),
295                 "source" -> requestContext.source.getOrElse("")
296               )
297             eventBusService.publish(generateEmail(user, templateId, MonitoringCategory.welcome, variables))
298           })
299       }
300     }
301 
302     private def localDateFormatter(country: Country): DateTimeFormatter =
303       DateTimeFormatter
304         .ofPattern("d MMMM yyyy")
305         .withLocale(new Locale(country.value.toLowerCase))
306 
307     private val MailjetMaximumBatchSize = 50
308 
309     private def makeVoteOnlyVariables(
310       country: Country,
311       operation: Operation,
312       opQuestion: OperationOfQuestion,
313       question: Question,
314       language: Language
315     ): Map[String, String] =
316       Map(
317         "operation_header" -> opQuestion.consultationHeader.getOrElse(""),
318         "operation_header_alt" -> opQuestion.consultationHeaderAlts
319           .flatMap(_.getTranslation(language))
320           .fold("")(_.value),
321         "proposal_count" -> opQuestion.proposalsCount.toString,
322         "vote_count" -> opQuestion.votesCount.toString,
323         "end_date" -> localDateFormatter(country).format(opQuestion.endDate),
324         "sequence_url" -> buildSequenceUrl(question.slug, SequenceKind.Standard, country, true),
325         "controversial_sequence_url" -> buildSequenceUrl(question.slug, SequenceKind.Controversy, country, true),
326         "popular_sequence_url" -> buildSequenceUrl(question.slug, SequenceKind.Consensus, country, true),
327         "question" -> question.questions.getTranslationUnsafe(language).value,
328         "operation_title" -> opQuestion.operationTitles
329           .getTranslationUnsafe(language),
330         "operation_type" -> operation.operationKind.value.toLowerCase,
331         "partners_logos" -> opQuestion.partnersLogos.getOrElse(""),
332         "partners_logos_alt" -> opQuestion.partnersLogosAlt.fold("")(_.value),
333         "initiators_logos" -> opQuestion.initiatorsLogos.getOrElse(""),
334         "initiators_logos_alt" -> opQuestion.initiatorsLogosAlt.fold("")(_.value)
335       )
336 
337     override def sendVoteOnlyNotice(context: RequestContext): Future[Unit] =
338       context.questionContext.questionId match {
339         case None => Future.failed(new Exception("QuestionId missing"))
340         case Some(questionId) =>
341           (
342             questionService
343               .getQuestion(questionId)
344               .flattenOrFail(s"Could not find question $questionId"),
345             operationOfQuestionService
346               .findByQuestionId(questionId)
347               .flattenOrFail(s"Could not find operation for question $questionId")
348           ).mapN(
349               (question: Question, opQuestion: OperationOfQuestion) =>
350                 operationService
351                   .findOne(opQuestion.operationId)
352                   .flattenOrFail(s"Couldn't find operation ${opQuestion.operationId}")
353                   .flatMap(
354                     operation =>
355                       question.countries
356                         .traverse_(
357                           country =>
358                             persistentCrmUserService
359                               .getActiveConsultationUsers(question.slug, country)
360                               .flatMap(users => {
361                                 users
362                                   .groupBy(_.favoriteLanguage.fold(Language("fr"))(Language(_)))
363                                   .toList
364                                   .traverse_({
365                                     case (language, users) =>
366                                       crmTemplatesService
367                                         .find(VoteOnlyNotice, Some(question.questionId), Some(language))
368                                         .flattenOrFail(s"Template ${VoteOnlyNotice.entryName} for $language not found")
369                                         .flatMap(template => {
370                                           val variables =
371                                             makeVoteOnlyVariables(country, operation, opQuestion, question, language)
372                                           val mailjetVariables = MailjetGlobalsVariables(
373                                             templateId = Some(template.value.toInt),
374                                             variables = Some(variables),
375                                             monitoringCategory = Some(MonitoringCategory.account)
376                                           )
377                                           users
378                                             .sliding(MailjetMaximumBatchSize, MailjetMaximumBatchSize)
379                                             .map(batch => {
380                                               SendMessages(
381                                                 id = SecurityHelper.anonymizeEmail(batch.headOption.fold("-")(_.email)),
382                                                 globals = Some(mailjetVariables),
383                                                 messages = batch.map(
384                                                   c =>
385                                                     SendEmail
386                                                       .create(recipients = Seq(Recipient(c.email, Some(c.fullName))))
387                                                 ),
388                                                 sandboxMode = None
389                                               )
390                                             })
391                                             .toList
392                                             .traverse_(messages => Future(eventBusService.publish(messages)))
393                                         })
394                                   })
395                               })
396                         )
397                   )
398             )
399             .flatten
400       }
401 
402     override def sendVoteOnlyTest(userId: UserId, context: RequestContext): Future[Unit] =
403       context.questionContext.questionId match {
404         case None => Future.failed(new Exception("QuestionId missing"))
405         case Some(questionId) =>
406           (
407             userService.getUser(userId).flattenOrFail(s"Could not find user $userId"),
408             questionService
409               .getQuestion(questionId)
410               .flattenOrFail(s"Could not find question $questionId"),
411             operationOfQuestionService
412               .findByQuestionId(questionId)
413               .flattenOrFail(s"Could not find operation for question $questionId")
414           ).mapN(
415             (user: User, question: Question, opQuestion: OperationOfQuestion) =>
416               operationService
417                 .findOne(opQuestion.operationId)
418                 .flattenOrFail(s"Couldn't find operation ${opQuestion.operationId}")
419                 .flatMap(operation => {
420                   question.languages.traverse_(
421                     language =>
422                       crmTemplatesService
423                         .find(VoteOnlyNotice, Some(questionId), Some(language))
424                         .flattenOrFail(s"Template ${VoteOnlyNotice.entryName} for $language not found")
425                         .flatMap(templateId => {
426                           val country = question.countries.head
427                           val variables = makeVoteOnlyVariables(country, operation, opQuestion, question, language)
428                           val mailjetVariables = MailjetGlobalsVariables(
429                             templateId = Some(templateId.value.toInt),
430                             variables = Some(variables),
431                             monitoringCategory = Some(MonitoringCategory.account)
432                           )
433                           Future {
434                             eventBusService.publish(
435                               SendMessages(
436                                 id = SecurityHelper.anonymizeEmail(user.email),
437                                 globals = Some(mailjetVariables),
438                                 messages =
439                                   List(SendEmail.create(recipients = Seq(Recipient(user.email, user.fullName)))),
440                                 sandboxMode = None
441                               )
442                             )
443                           }
444                         })
445                   )
446                 })
447           )
448       }
449 
450     override def publishRegistration(user: User, requestContext: RequestContext): Future[Unit] = {
451       val questionId = requestContext.questionContext.questionId
452 
453       user.verificationToken match {
454         case Some(verificationToken) =>
455           crmTemplatesService.find(Registration, questionId, user.profile.map(_.crmLanguage)).flatMap {
456             case Some(templateId) =>
457               getUtmCampaignFromQuestionId(questionId).map { utmCampaign =>
458                 eventBusService.publish(
459                   SendMessages(
460                     SendEmail.create(
461                       templateId = Some(templateId.value.toInt),
462                       recipients = Seq(Recipient(email = user.email, name = user.fullName)),
463                       variables = Some(
464                         Map(
465                           "firstname" -> user.firstName.getOrElse(""),
466                           "email_validation_url" -> getAccountValidationUrl(
467                             user,
468                             verificationToken,
469                             requestContext,
470                             utmCampaign
471                           ),
472                           "operation" -> requestContext.operationId.map(_.value).getOrElse(""),
473                           "question" -> requestContext.questionContext.question.getOrElse(""),
474                           "location" -> requestContext.location.getOrElse(""),
475                           "source" -> requestContext.source.getOrElse("")
476                         )
477                       ),
478                       customCampaign = None,
479                       monitoringCategory = Some(MonitoringCategory.account)
480                     )
481                   )
482                 )
483               }
484             case None => Future.unit
485           }
486         case _ =>
487           Future.failed(
488             new IllegalStateException(s"verification token required but not provided for user ${user.userId.value}")
489           )
490       }
491     }
492 
493     def publishResendRegistration(user: User, requestContext: RequestContext): Future[Unit] = {
494       val questionId = requestContext.questionContext.questionId
495 
496       user.verificationToken match {
497         case Some(verificationToken) =>
498           crmTemplatesService.find(ResendRegistration, questionId, user.profile.map(_.crmLanguage)).flatMap {
499             case Some(templateId) =>
500               getUtmCampaignFromQuestionId(questionId).map { utmCampaign =>
501                 eventBusService.publish(
502                   SendMessages(
503                     SendEmail.create(
504                       templateId = Some(templateId.value.toInt),
505                       recipients = Seq(Recipient(email = user.email, name = user.fullName)),
506                       variables = Some(
507                         Map(
508                           "firstname" -> user.firstName.getOrElse(""),
509                           "email_validation_url" -> getAccountValidationUrl(
510                             user,
511                             verificationToken,
512                             requestContext,
513                             utmCampaign
514                           )
515                         )
516                       ),
517                       customCampaign = None,
518                       monitoringCategory = Some(MonitoringCategory.account)
519                     )
520                   )
521                 )
522               }
523             case None => Future.unit
524           }
525         case _ =>
526           Future.failed(
527             new IllegalStateException(s"verification token required but not provided for user ${user.userId.value}")
528           )
529       }
530     }
531 
532     override def publishForgottenPassword(user: User, requestContext: RequestContext): Future[Unit] = {
533       val questionId = requestContext.questionContext.questionId
534 
535       user.resetToken match {
536         case Some(resetToken) =>
537           crmTemplatesService
538             .find(ForgottenPassword, questionId, user.profile.map(_.crmLanguage))
539             .map(_.foreach { templateId =>
540               eventBusService.publish(
541                 SendMessages(
542                   SendEmail.create(
543                     templateId = Some(templateId.value.toInt),
544                     recipients = Seq(Recipient(email = user.email, name = user.fullName)),
545                     variables = Some(
546                       Map(
547                         "firstname" -> user.firstName.getOrElse(""),
548                         "forgotten_password_url" -> getForgottenPasswordUrl(
549                           user,
550                           resetToken,
551                           requestContext.applicationName
552                         ),
553                         "operation" -> requestContext.operationId.map(_.value).getOrElse(""),
554                         "question" -> requestContext.questionContext.question.getOrElse(""),
555                         "location" -> requestContext.location.getOrElse(""),
556                         "source" -> requestContext.source.getOrElse("")
557                       )
558                     ),
559                     customCampaign = None,
560                     monitoringCategory = Some(MonitoringCategory.account)
561                   )
562                 )
563               )
564             })
565         case _ =>
566           Future.failed(
567             new IllegalStateException(s"reset token required but not provided for user ${user.userId.value}")
568           )
569       }
570     }
571 
572     override def publishForgottenPasswordOrganisation(
573       organisation: User,
574       requestContext: RequestContext
575     ): Future[Unit] = {
576       val questionId = requestContext.questionContext.questionId
577 
578       organisation.resetToken match {
579         case Some(resetToken) =>
580           crmTemplatesService
581             .find(B2BForgottenPassword, questionId, organisation.profile.map(_.crmLanguage))
582             .map(_.foreach { templateId =>
583               eventBusService.publish(
584                 SendMessages(
585                   SendEmail.create(
586                     templateId = Some(templateId.value.toInt),
587                     recipients = Seq(Recipient(email = organisation.email, name = organisation.fullName)),
588                     variables = Some(
589                       Map(
590                         "forgotten_password_url" -> getForgottenPasswordUrl(
591                           organisation,
592                           resetToken,
593                           requestContext.applicationName
594                         ),
595                         "operation" -> requestContext.operationId.map(_.value).getOrElse(""),
596                         "question" -> requestContext.questionContext.question.getOrElse(""),
597                         "location" -> requestContext.location.getOrElse(""),
598                         "source" -> requestContext.source.getOrElse("")
599                       )
600                     ),
601                     customCampaign = None,
602                     monitoringCategory = Some(MonitoringCategory.account)
603                   )
604                 )
605               )
606             })
607         case _ =>
608           Future.failed(
609             new IllegalStateException(
610               s"reset token required but not provided for organisation ${organisation.userId.value}"
611             )
612           )
613       }
614     }
615 
616     override def publishEmailChanged(user: User, requestContext: RequestContext, newEmail: String): Future[Unit] = {
617       val questionId = requestContext.questionContext.questionId
618 
619       crmTemplatesService
620         .find(B2BEmailChanged, questionId, user.profile.map(_.crmLanguage))
621         .map(_.foreach { templateId =>
622           eventBusService.publish(generateEmail(user, templateId, MonitoringCategory.account, Map("email" -> newEmail)))
623         })
624     }
625 
626     private def publishModerationEmail(
627       proposalId: ProposalId,
628       variables: (Question, OperationOfQuestion, User, Proposal) => Map[String, String],
629       templateKind: UserType                                     => CrmTemplateKind
630     ): Future[Unit] = {
631 
632       val publishSendEmail = for {
633         proposal <- proposalCoordinatorService
634           .getProposal(proposalId)
635           .flattenOrFail(s"Proposal ${proposalId.value} not found")
636         user <- userService
637           .getUser(proposal.author)
638           .flattenOrFail(s"user ${proposal.author.value}, author of proposal ${proposalId.value} not found")
639         questionId <- Future
640           .successful(proposal.questionId)
641           .flattenOrFail(s"proposal ${proposal.proposalId} doesn't have a question!")
642         question <- questionService
643           .getQuestion(questionId)
644           .flattenOrFail(
645             s"question ${proposal.questionId.fold("''")(_.value)} not found, it is on proposal ${proposal.proposalId}"
646           )
647         operationOfQuestion <- operationOfQuestionService
648           .findByQuestionId(questionId)
649           .flattenOrFail(
650             s"question ${proposal.questionId.fold("''")(_.value)} not found, it is on proposal ${proposal.proposalId}"
651           )
652         templateId <- crmTemplatesService
653           .find(templateKind(user.userType), Some(questionId), user.profile.map(_.crmLanguage))
654           .flattenOrFail(
655             s"no $templateKind crm template for question ${questionId.value} and country ${user.country.value}"
656           )
657       } yield {
658         eventBusService.publish(
659           SendMessages(
660             SendEmail.create(
661               templateId = Some(templateId.value.toInt),
662               recipients = Seq(Recipient(email = user.email, name = user.fullName)),
663               variables = Some(variables(question, operationOfQuestion, user, proposal)),
664               customCampaign = None,
665               monitoringCategory = Some(MonitoringCategory.moderation)
666             )
667           )
668         )
669       }
670 
671       publishSendEmail.orRaise(
672         new IllegalStateException(
673           s"Something went wrong unexpectedly while trying to send moderation email for proposal ${proposalId.value}"
674         )
675       )
676     }
677 
678     override def publishAcceptProposal(proposalId: ProposalId): Future[Unit] = {
679 
680       def variables(
681         question: Question,
682         operationOfQuestion: OperationOfQuestion,
683         user: User,
684         proposal: Proposal
685       ): Map[String, String] = {
686         val term = "publication"
687         Map(
688           "proposal_url" -> getProposalUrl(
689             proposal,
690             question,
691             Some(
692               Utm(
693                 campaign = question.slug,
694                 term = adaptUtmTerm("publication", user.userType),
695                 content = "cta_share",
696                 source = "crm-transac"
697               )
698             )
699           ),
700           "proposal_text" -> proposal.content,
701           "firstname" -> user.firstName.getOrElse(""),
702           "organisation_name" -> user.organisationName.getOrElse(""),
703           "operation" -> question.operationId.map(_.value).getOrElse(""),
704           "question" -> question.questionId.value,
705           "location" -> proposal.creationContext.location.getOrElse(""),
706           "source" -> proposal.creationContext.source.getOrElse(""),
707           "sequence_url" -> sequenceUrlForProposal(
708             question.slug,
709             proposal,
710             Some(
711               Utm(
712                 content = "cta",
713                 campaign = question.slug,
714                 term = adaptUtmTerm(term, user.userType),
715                 source = "crm-transac"
716               )
717             )
718           ),
719           "is_anonymous_proposal" -> proposal.isAnonymous.toString,
720           "is_consultation_vote_only" -> (!operationOfQuestion.canPropose).toString
721         )
722       }
723 
724       def kind(userType: UserType): CrmTemplateKind = {
725         if (userType == UserType.UserTypeUser) {
726           ProposalAccepted
727         } else {
728           B2BProposalAccepted
729         }
730       }
731 
732       publishModerationEmail(proposalId, variables, kind)
733 
734     }
735 
736     override def publishRefuseProposal(proposalId: ProposalId): Future[Unit] = {
737 
738       def variables(
739         question: Question,
740         operationOfQuestion: OperationOfQuestion,
741         user: User,
742         proposal: Proposal
743       ): Map[String, String] = {
744         val term = "refus"
745         Map(
746           "proposal_text" -> proposal.content,
747           "refusal_reason" -> proposal.refusalReason.getOrElse(""),
748           "firstname" -> user.firstName.getOrElse(""),
749           "organisation_name" -> user.organisationName.getOrElse(""),
750           "operation" -> question.operationId.map(_.value).getOrElse(""),
751           "question" -> question.questions
752             .getTranslation(user.profile.map(_.crmLanguage).getOrElse(question.defaultLanguage))
753             .fold(question.slug)(_.value),
754           "location" -> proposal.creationContext.location.getOrElse(""),
755           "source" -> proposal.creationContext.source.getOrElse(""),
756           "sequence_url" -> sequenceUrlForProposal(
757             question.slug,
758             proposal,
759             Some(
760               Utm(
761                 content = "cta",
762                 campaign = question.slug,
763                 term = adaptUtmTerm(term, user.userType),
764                 source = "crm-transac"
765               )
766             )
767           ),
768           "is_consultation_vote_only" -> (!operationOfQuestion.canPropose).toString
769         )
770       }
771 
772       def kind(userType: UserType): CrmTemplateKind = {
773         if (userType == UserType.UserTypeUser) {
774           ProposalRefused
775         } else {
776           B2BProposalRefused
777         }
778       }
779 
780       publishModerationEmail(proposalId, variables, kind)
781     }
782 
783     override def resendRegistration(user: User, requestContext: RequestContext): Future[Unit] = {
784 
785       userService.changeEmailVerificationTokenIfNeeded(user.userId).flatMap {
786         case Some(modifiedUser) => publishResendRegistration(modifiedUser, requestContext)
787         case None               => Future.unit
788       }
789     }
790 
791     override def sendEmailToProposer(
792       proposalId: ProposalId,
793       senderId: UserId,
794       sanitizedHtml: SanitizedHtml,
795       dryRun: Boolean,
796       requestContext: RequestContext
797     ): Future[Unit] =
798       for {
799         proposal <- proposalService
800           .getProposalById(proposalId, requestContext)
801           .flattenOrFail(s"Proposal ${proposalId.value} not found")
802         _ <- if (proposal.status == ProposalStatus.Accepted)
803           Future.unit
804         else
805           Future.failed(
806             ValidationFailedError(Seq(ValidationError("status", "invalid_value", Some("Proposal must be Accepted"))))
807           )
808         proposer <- userService
809           .getUser(proposal.author.userId)
810           .flattenOrFail(s"User ${proposal.author.userId.value} not found")
811         _ <- if (!proposer.isHardBounce)
812           Future.unit
813         else
814           Future.failed(
815             ValidationFailedError(
816               Seq(
817                 ValidationError(
818                   "reachable",
819                   "invalid_value",
820                   Some(s"User ${proposer.userId.value} must not be hard bounce")
821                 )
822               )
823             )
824           )
825         recipient <- if (dryRun)
826           userService
827             .getUser(senderId)
828             .flattenOrFail(s"User ${senderId.value} not found")
829         else
830           Future.successful(proposer)
831         questionId <- Future
832           .successful(proposal.question.map(_.questionId))
833           .flattenOrFail(s"Proposal $proposalId's question no longer exists")
834         question <- questionService
835           .getQuestion(questionId)
836           .flattenOrFail(s"Question $questionId does not exist")
837         templateId <- crmTemplatesService
838           .find(MessageToProposer, Some(questionId), proposer.profile.map(_.crmLanguage))
839           .flattenOrFail(s"Template for ${questionId.value} and country ${recipient.country.value} does not exist")
840       } yield {
841         val variables = Map(
842           "firstname" -> proposer.displayName.getOrElse(""),
843           "question" -> question.questions
844             .getTranslationUnsafe(requestContext.languageContext.language.getOrElse(question.defaultLanguage))
845             .value,
846           "proposal" -> proposal.content
847             .getTranslationUnsafe(proposal.submittedAsLanguage.getOrElse(question.defaultLanguage)),
848           "body" -> sanitizedHtml.html
849         )
850         eventBusService.publish(generateEmail(recipient, templateId, MonitoringCategory.moderation, variables))
851       }
852 
853     private def publishWarningToAbusiveProposer(
854       template: CrmTemplateKind,
855       questionId: QuestionId,
856       proposerId: UserId,
857       languageOpt: Option[Language]
858     ): Future[Unit] =
859       for {
860         proposer <- userService
861           .getUser(proposerId)
862           .flattenOrFail(s"User ${proposerId.value} not found")
863         question <- questionService
864           .getQuestion(questionId)
865           .flattenOrFail(s"Question $questionId does not exist")
866         templateId <- crmTemplatesService
867           .find(template, Some(questionId), proposer.profile.map(_.crmLanguage))
868           .flattenOrFail(s"Template for ${questionId.value} and country ${proposer.country.value} does not exist")
869       } yield {
870         val language = languageOpt.getOrElse(question.defaultLanguage)
871         val variables =
872           Map(
873             "firstname" -> proposer.displayName.orElse(proposer.firstName).getOrElse(""),
874             "question" -> question.questions.getTranslationUnsafe(language).value,
875             "sequence_url" -> buildSequenceUrl(
876               question.slug,
877               SequenceKind.Standard,
878               proposer.country,
879               false,
880               Some(proposer.userType)
881             )
882           )
883         eventBusService.publish(generateEmail(proposer, templateId, MonitoringCategory.moderation, variables))
884       }
885 
886     override def publishAbusiveProposerWarn(
887       questionId: QuestionId,
888       proposerId: UserId,
889       requestContext: RequestContext
890     ): Future[Unit] =
891       publishWarningToAbusiveProposer(
892         MessageToAbusiveWarn,
893         questionId,
894         proposerId,
895         requestContext.languageContext.language
896       )
897 
898     override def publishAbusiveProposerBlock(
899       questionId: QuestionId,
900       proposerId: UserId,
901       requestContext: RequestContext
902     ): Future[Unit] =
903       publishWarningToAbusiveProposer(
904         MessageToAbusiveBlock,
905         questionId,
906         proposerId,
907         requestContext.languageContext.language
908       )
909 
910     override def publishRegistrationB2B(user: User, requestContext: RequestContext): Future[Unit] = {
911       user.resetToken match {
912         case Some(resetToken) =>
913           crmTemplatesService
914             .find(B2BRegistration, requestContext.questionContext.questionId, user.profile.map(_.crmLanguage))
915             .map(_.foreach { templateId =>
916               eventBusService.publish(
917                 SendMessages(
918                   SendEmail.create(
919                     templateId = Some(templateId.value.toInt),
920                     recipients = Seq(Recipient(email = user.email, name = user.fullName)),
921                     variables = Some(
922                       Map(
923                         "mailto" -> user.email,
924                         "forgotten_password_url" -> getForgottenPasswordUrl(
925                           user,
926                           resetToken,
927                           Some(ApplicationName.MainFrontend)
928                         )
929                       )
930                     ),
931                     customCampaign = None,
932                     monitoringCategory = Some(MonitoringCategory.account)
933                   )
934                 )
935               )
936             })
937         case _ =>
938           Future.failed(
939             new IllegalStateException(s"reset token required but not provided for user ${user.userId.value}")
940           )
941       }
942     }
943 
944     override def publishProposalReportedNotice(
945       proposalId: ProposalId,
946       proposalLanguage: Language,
947       reason: ProposalReportReason
948     ): Future[Unit] =
949       proposalCoordinatorService
950         .getProposal(proposalId)
951         .flattenOrFail(s"Proposal ${proposalId.value} not found")
952         .flatMap(
953           proposal =>
954             Future(
955               eventBusService.publish(
956                 SendMessages(
957                   SendEmail.create(
958                     templateId = Some(config.getInt("make-api.report-proposal.template-id")),
959                     variables = Some(
960                       Map(
961                         "reason" -> reason.toString,
962                         "proposal_id" -> proposalId.value,
963                         "proposal_language" -> proposalLanguage.value,
964                         "proposal_text" ->
965                           proposal.contentTranslations
966                             .flatMap(_.getTranslation(proposalLanguage))
967                             .getOrElse(proposal.content),
968                         "proposal_url" -> buildUrl(
969                           mailJetTemplateConfiguration.backofficeUrl,
970                           s"#/moderation/proposals/${proposalId.value}",
971                           None
972                         )
973                       )
974                     ),
975                     recipients =
976                       Seq(Recipient(config.getString("make-api.report-proposal.recipient"), Some("Moderators")))
977                   )
978                 )
979               )
980             )
981         )
982   }
983 }
984 
985 object DefaultSendMailPublisherServiceComponent {
986   final case class Utm(
987     source: String = "crm-transac",
988     medium: String = "email",
989     campaign: String,
990     term: String,
991     content: String
992   )
993 }