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 enumeratum.values.{StringCirceEnum, StringEnum, StringEnumEntry}
23 import io.circe.syntax._
24 import io.circe.{Decoder, Encoder, Json}
25 import org.make.api.technical.security.SecurityHelper
26 import org.make.core.user.UserId
27 
28 import scala.util.matching.Regex
29 
30 final case class TemplateErrorReporting(email: String, name: Option[String])
31 
32 object TemplateErrorReporting {
33   implicit val encoder: Encoder[TemplateErrorReporting] =
34     (reporting: TemplateErrorReporting) => {
35 
36       val fields: Seq[(String, Json)] =
37         Seq("Email" -> Some(reporting.email.asJson), "Name" -> reporting.name.map(_.asJson)).collect {
38           case (name, Some(value)) => name -> value
39         }
40       Json.obj(fields: _*)
41     }
42 }
43 
44 final case class SendEmail(
45   from: Option[Recipient] = None,
46   subject: Option[String] = None,
47   textPart: Option[String] = None,
48   htmlPart: Option[String] = None,
49   useTemplateLanguage: Option[Boolean] = Some(true),
50   templateId: Option[Int] = None,
51   variables: Option[Map[String, String]] = None,
52   recipients: Seq[Recipient],
53   headers: Option[Map[String, String]] = None,
54   emailId: Option[String] = None,
55   customCampaign: Option[String] = None,
56   monitoringCategory: Option[String] = None,
57   templateErrorReporting: Option[TemplateErrorReporting] = None
58 ) {
59   override def toString =
60     s"SendEmail: (from = $from, subject = $subject, textPart = $textPart, htmlPart = $htmlPart, useTemplateLanguage = $useTemplateLanguage, templateId = $templateId, variables = $variables, recipients = ${recipients
61       .map(_.toAnonymizedString)}, headers = $headers, emailId = $emailId, customCampaign = $customCampaign, monitoringCategory = $monitoringCategory)"
62 }
63 
64 object SendEmail {
65 
66   def create(
67     from: Option[Recipient] = None,
68     subject: Option[String] = None,
69     textPart: Option[String] = None,
70     htmlPart: Option[String] = None,
71     useTemplateLanguage: Option[Boolean] = Some(true),
72     templateId: Option[Int] = None,
73     variables: Option[Map[String, String]] = None,
74     recipients: Seq[Recipient],
75     headers: Option[Map[String, String]] = None,
76     emailId: Option[String] = None,
77     customCampaign: Option[String] = None,
78     monitoringCategory: Option[String] = None,
79     templateErrorReporting: Option[TemplateErrorReporting] = None
80   ): SendEmail = {
81 
82     SendEmail(
83       from,
84       subject,
85       textPart,
86       htmlPart,
87       useTemplateLanguage,
88       templateId,
89       variables,
90       recipients,
91       headers,
92       emailId,
93       customCampaign,
94       monitoringCategory,
95       templateErrorReporting
96     )
97   }
98 
99   implicit val encoder: Encoder[SendEmail] =
100     (sendEmail: SendEmail) => {
101 
102       val fields: Seq[(String, Json)] =
103         Seq(
104           "From" -> sendEmail.from.map(_.asJson),
105           "Subject" -> sendEmail.subject.map(_.asJson),
106           "TextPart" -> sendEmail.textPart.map(_.asJson),
107           "HTMLPart" -> sendEmail.htmlPart.map(_.asJson),
108           "TemplateLanguage" -> sendEmail.useTemplateLanguage.map(_.asJson),
109           "TemplateID" -> sendEmail.templateId.map(_.asJson),
110           "To" -> Some(sendEmail.recipients.asJson),
111           "Headers" -> sendEmail.headers.map(_.asJson),
112           "CustomID" -> sendEmail.emailId.map(_.asJson),
113           "CustomCampaign" -> sendEmail.customCampaign.map(_.asJson),
114           "MonitoringCategory" -> sendEmail.monitoringCategory.map(_.asJson),
115           "TemplateErrorReporting" -> sendEmail.templateErrorReporting.map(_.asJson),
116           "Variables" -> sendEmail.variables.flatMap { variables =>
117             if (variables.isEmpty) {
118               None
119             } else {
120               Some(variables.asJson)
121             }
122           }
123         ).collect {
124           case (name, Some(value)) => name -> value
125         }
126       Json.obj(fields: _*)
127     }
128 }
129 
130 final case class MailjetGlobalsVariables(
131   from: Option[Recipient] = None,
132   subject: Option[String] = None,
133   textPart: Option[String] = None,
134   htmlPart: Option[String] = None,
135   useTemplateLanguage: Option[Boolean] = Some(true),
136   templateId: Option[Int] = None,
137   variables: Option[Map[String, String]] = None,
138   headers: Option[Map[String, String]] = None,
139   emailId: Option[String] = None,
140   customCampaign: Option[String] = None,
141   monitoringCategory: Option[String] = None,
142   templateErrorReporting: Option[TemplateErrorReporting] = None
143 )
144 
145 object MailjetGlobalsVariables {
146   implicit val encoder: Encoder[MailjetGlobalsVariables] =
147     (globals: MailjetGlobalsVariables) => {
148 
149       val fields: Seq[(String, Json)] =
150         Seq(
151           "From" -> globals.from.map(_.asJson),
152           "Subject" -> globals.subject.map(_.asJson),
153           "TextPart" -> globals.textPart.map(_.asJson),
154           "HTMLPart" -> globals.htmlPart.map(_.asJson),
155           "TemplateLanguage" -> globals.useTemplateLanguage.map(_.asJson),
156           "TemplateID" -> globals.templateId.map(_.asJson),
157           "Headers" -> globals.headers.map(_.asJson),
158           "CustomID" -> globals.emailId.map(_.asJson),
159           "CustomCampaign" -> globals.customCampaign.map(_.asJson),
160           "MonitoringCategory" -> globals.monitoringCategory.map(_.asJson),
161           "TemplateErrorReporting" -> globals.templateErrorReporting.map(_.asJson),
162           "Variables" -> globals.variables.flatMap { variables =>
163             if (variables.isEmpty) {
164               None
165             } else {
166               Some(variables.asJson)
167             }
168           }
169         ).collect {
170           case (name, Some(value)) => name -> value
171         }
172       Json.obj(fields: _*)
173     }
174 }
175 
176 final case class SendMessages(
177   id: String,
178   globals: Option[MailjetGlobalsVariables],
179   messages: Seq[SendEmail],
180   sandboxMode: Option[Boolean]
181 )
182 
183 object SendMessages {
184 
185   val SandboxEmail: Regex = "^([^@]+)@example\\.com$".r
186 
187   def sandboxMode(message: SendEmail): Option[Boolean] = {
188     if (message.recipients.forall(_.email match {
189           case SandboxEmail(_) => true
190           case _               => false
191         })) {
192       Some(true)
193     } else {
194       None
195     }
196   }
197 
198   def apply(message: SendEmail): SendMessages = {
199     SendMessages(
200       id = message.recipients.headOption.map(head => SecurityHelper.anonymizeEmail(head.email)).getOrElse("unknown"),
201       globals = None,
202       messages = Seq(message),
203       sandboxMode = sandboxMode(message)
204     )
205   }
206 
207   implicit val encoder: Encoder[SendMessages] = { sendMessages: SendMessages =>
208     val fields: Seq[(String, Json)] =
209       Seq(
210         "Globals" -> sendMessages.globals.map(_.asJson),
211         "Messages" -> Some(sendMessages.messages.asJson),
212         "SandboxMode" -> sendMessages.sandboxMode.map(_.asJson)
213       ).collect {
214         case (name, Some(value)) => name -> value
215       }
216 
217     Json.obj(fields: _*)
218   }
219 }
220 
221 final case class TransactionDetail(
222   status: String,
223   customId: String,
224   to: Seq[EmailDetail],
225   cc: Seq[EmailDetail],
226   bcc: Seq[EmailDetail]
227 )
228 
229 object TransactionDetail {
230   implicit val decoder: Decoder[TransactionDetail] =
231     Decoder.forProduct5("Status", "CustomID", "To", "Cc", "Bcc")(TransactionDetail.apply)
232 }
233 
234 final case class SendResult(sent: Seq[TransactionDetail])
235 
236 object SendResult {
237   implicit val decoder: Decoder[SendResult] = Decoder.forProduct1("Messages")(SendResult.apply)
238 }
239 
240 final case class EmailDetail(email: String, messageUUID: String, messageId: Long, messageHref: String)
241 
242 object EmailDetail {
243   implicit val decoder: Decoder[EmailDetail] =
244     Decoder.forProduct4("Email", "MessageUUID", "MessageID", "MessageHref")(EmailDetail.apply)
245 }
246 
247 final case class Recipient(email: String, name: Option[String] = None, variables: Option[Map[String, String]] = None) {
248   def toAnonymizedString: String =
249     s"Recipient: (email = ${SecurityHelper.anonymizeEmail(email)}, name = ${name.flatMap(_.headOption)}, variables = $variables)"
250 
251   override def toString =
252     s"Recipient: (email = $email, name = ${name.flatMap(_.headOption)}, variables = $variables)"
253 }
254 
255 object Recipient {
256   implicit val encoder: Encoder[Recipient] =
257     (recipient: Recipient) => {
258       val fields: Seq[(String, Json)] =
259         Seq(
260           "Email" -> Some(recipient.email.asJson),
261           "Name" -> recipient.name.map(_.asJson),
262           "Variables" -> recipient.variables.flatMap { values =>
263             if (values.isEmpty) {
264               None
265             } else {
266               Some(values.asJson)
267             }
268           }
269         ).collect {
270           case (name, Some(value)) => name -> value
271         }
272 
273       Json.obj(fields: _*)
274 
275     }
276 }
277 
278 final case class ManageContact(
279   email: String,
280   name: String,
281   action: ManageContactAction,
282   properties: Option[ContactProperties] = None
283 )
284 
285 object ManageContact {
286   implicit val encoder: Encoder[ManageContact] = Encoder.forProduct4("Email", "Name", "Action", "Properties") {
287     manageContact: ManageContact =>
288       (manageContact.email, manageContact.name, manageContact.action, manageContact.properties)
289   }
290 }
291 
292 sealed abstract class ManageContactAction(val value: String) extends StringEnumEntry
293 
294 object ManageContactAction extends StringEnum[ManageContactAction] with StringCirceEnum[ManageContactAction] {
295 
296   case object AddForce extends ManageContactAction("addForce")
297   case object AddNoForce extends ManageContactAction("addnoforce")
298   case object Remove extends ManageContactAction("remove")
299   case object Unsubscribe extends ManageContactAction("unsub")
300 
301   override val values: IndexedSeq[ManageContactAction] = findValues
302 
303 }
304 
305 final case class ImportOptions(dateTimeFormat: String) {
306   override def toString: String = {
307     s"""{"DateTimeFormat": "$dateTimeFormat","TimezoneOffset": 0,"FieldNames": ${ContactProperties.getCsvHeader}}"""
308   }
309 }
310 
311 final case class CsvImport(listId: String, csvId: String, method: ManageContactAction, importOptions: String)
312 
313 object CsvImport {
314   implicit val encoder: Encoder[CsvImport] =
315     Encoder.forProduct4("ContactsListID", "DataID", "Method", "ImportOptions") { csvImport: CsvImport =>
316       (csvImport.listId, csvImport.csvId, csvImport.method, csvImport.importOptions)
317     }
318 }
319 
320 final case class Contact(email: String, name: Option[String] = None, properties: Option[ContactProperties] = None) {
321   def toStringCsv: String = {
322     properties match {
323       case None       => ""
324       case Some(prop) => s"""\"$email\",${prop.toStringCsv}${String.format("%n")}"""
325     }
326   }
327 }
328 object Contact {
329   implicit val encoder: Encoder[Contact] = Encoder.forProduct3("Email", "Name", "Properties") { contact: Contact =>
330     (contact.email, contact.name, contact.properties)
331   }
332 }
333 
334 final case class ContactList(listId: String, action: ManageContactAction)
335 object ContactList {
336   implicit val encoder: Encoder[ContactList] = Encoder.forProduct2("ListID", "Action") { contactList: ContactList =>
337     (contactList.listId, contactList.action)
338   }
339 }
340 
341 final case class ManageManyContacts(contacts: Seq[Contact], contactList: Seq[ContactList])
342 object ManageManyContacts {
343   implicit val encoder: Encoder[ManageManyContacts] = Encoder.forProduct2("Contacts", "ContactsLists") {
344     manageManyContacts: ManageManyContacts =>
345       (manageManyContacts.contacts, manageManyContacts.contactList)
346   }
347 }
348 
349 final case class ContactProperty[T](name: String, value: Option[T])
350 
351 object ContactProperty {
352   trait ToJson[T] {
353     def toJson(obj: T): Json
354   }
355 
356   implicit val StringToJson: ToJson[String] = Json.fromString(_)
357   implicit val IntToJson: ToJson[Int] = Json.fromInt(_)
358   implicit val BooleanToJson: ToJson[Boolean] = Json.fromBoolean(_)
359 
360   implicit def encoder[T](implicit toJson: ToJson[T]): Encoder[ContactProperty[T]] =
361     (contactProperty: ContactProperty[T]) => {
362       val fields: Seq[(String, Json)] =
363         Seq("Name" -> Some(contactProperty.name.asJson), "Value" -> contactProperty.value.map(toJson.toJson)).collect {
364           case (name, Some(value)) => name -> value
365         }
366 
367       Json.obj(fields: _*)
368     }
369 }
370 
371 final case class ContactData(data: Seq[ContactProperty[_]])
372 object ContactData {
373   @SuppressWarnings(Array("org.wartremover.warts.AsInstanceOf", "org.wartremover.warts.Throw"))
374   implicit val encoder: Encoder[ContactData] = Encoder.forProduct1("Data") { contactData: ContactData =>
375     contactData.data.map {
376       case a @ ContactProperty(_, None)             => a.asInstanceOf[ContactProperty[String]].asJson
377       case a @ ContactProperty(_, Some(_: String))  => a.asInstanceOf[ContactProperty[String]].asJson
378       case a @ ContactProperty(_, Some(_: Int))     => a.asInstanceOf[ContactProperty[Int]].asJson
379       case a @ ContactProperty(_, Some(_: Boolean)) => a.asInstanceOf[ContactProperty[Boolean]].asJson
380       case other =>
381         throw new IllegalStateException(s"Unable to convert ${other.toString}")
382     }
383   }
384 }
385 
386 final case class ContactProperties(
387   userId: Option[UserId],
388   firstName: Option[String],
389   postalCode: Option[String],
390   dateOfBirth: Option[String],
391   emailValidationStatus: Option[Boolean],
392   emailHardBounceValue: Option[Boolean],
393   unsubscribeStatus: Option[Boolean],
394   accountCreationDate: Option[String],
395   accountCreationSource: Option[String],
396   accountCreationOrigin: Option[String],
397   accountCreationSlug: Option[String],
398   accountCreationLocation: Option[String],
399   favoriteCountry: Option[String],
400   favoriteLanguage: Option[String],
401   totalProposals: Option[Int],
402   totalVotes: Option[Int],
403   firstContributionDate: Option[String],
404   lastContributionDate: Option[String],
405   operationActivity: Option[String],
406   sourceActivity: Option[String],
407   daysOfActivity: Option[Int],
408   daysOfActivity30: Option[Int],
409   userType: Option[String],
410   accountType: Option[String],
411   updatedAt: Option[String],
412   daysBeforeDeletion: Option[Int],
413   lastActivityDate: Option[String],
414   sessionsCount: Option[Int],
415   eventsCount: Option[Int]
416 ) {
417   def toContactPropertySeq: Seq[ContactProperty[_]] = {
418     Field.fieldsList.map { field =>
419       ContactProperty(field.fieldName, field.extractValue(this))
420     }
421   }
422 
423   def toStringCsv: String = {
424     toContactPropertySeq.map { property =>
425       property.value match {
426         case None           => ""
427         case Some(property) => s"""\"${property.toString.replace("\"", "\\\"")}\""""
428       }
429     }.mkString(",")
430   }
431 
432   def toPersistentCrmUser(email: String, fullName: String): PersistentCrmUser = PersistentCrmUser(
433     userId = userId.map(_.value).getOrElse(""),
434     email = email,
435     fullName = fullName,
436     firstname = firstName.getOrElse(""),
437     zipcode = postalCode,
438     dateOfBirth = dateOfBirth,
439     emailValidationStatus = emailValidationStatus.getOrElse(false),
440     emailHardbounceStatus = emailHardBounceValue.getOrElse(false),
441     unsubscribeStatus = unsubscribeStatus.getOrElse(false),
442     accountCreationDate = accountCreationDate,
443     accountCreationSource = accountCreationSource,
444     accountCreationOrigin = accountCreationOrigin,
445     accountCreationOperation = accountCreationSlug,
446     accountCreationLocation = accountCreationLocation,
447     favoriteCountry = favoriteCountry,
448     favoriteLanguage = favoriteLanguage,
449     totalNumberProposals = totalProposals,
450     totalNumberVotes = totalVotes,
451     firstContributionDate = firstContributionDate,
452     lastContributionDate = lastContributionDate,
453     operationActivity = operationActivity,
454     sourceActivity = sourceActivity,
455     daysOfActivity = daysOfActivity,
456     daysOfActivity30d = daysOfActivity30,
457     userType = userType,
458     accountType = accountType,
459     daysBeforeDeletion = daysBeforeDeletion,
460     lastActivityDate = lastActivityDate,
461     sessionsCount = sessionsCount,
462     eventsCount = eventsCount
463   )
464 
465 }
466 
467 object ContactProperties {
468   @SuppressWarnings(Array("org.wartremover.warts.AsInstanceOf", "org.wartremover.warts.Throw"))
469   implicit val encoder: Encoder[ContactProperties] =
470     (contactProperties: ContactProperties) => {
471       Json.fromFields(contactProperties.toContactPropertySeq.map {
472         case property @ ContactProperty(_, None)                 => (property.name, None.asJson)
473         case property @ ContactProperty(_, Some(value: String))  => (property.name, Some(value).asJson)
474         case property @ ContactProperty(_, Some(value: Int))     => (property.name, Some(value).asJson)
475         case property @ ContactProperty(_, Some(value: Boolean)) => (property.name, Some(value).asJson)
476         case other =>
477           throw new IllegalStateException(s"Unable to convert ${other.toString}")
478       })
479     }
480 
481   val getCsvHeader: String = {
482     ("email" +: Field.fieldsList.map(_.fieldName)).map(name => s"""\"$name\"""").mkString("[", ",", "]")
483   }
484 }
485 
486 final case class Field[T](fieldName: String, extractValue: ContactProperties => Option[T])
487 
488 object Field {
489   val fieldsList: Seq[Field[_]] = {
490     Seq(
491       Field("UserId", _.userId.map(_.value)),
492       Field("Firstname", _.firstName),
493       Field("Zipcode", _.postalCode),
494       Field("Date_Of_Birth", _.dateOfBirth),
495       Field("Email_Validation_Status", _.emailValidationStatus),
496       Field("Email_Hardbounce_Status", _.emailHardBounceValue),
497       Field("Unsubscribe_Status", _.unsubscribeStatus),
498       Field("Account_Creation_Date", _.accountCreationDate),
499       Field("Account_creation_source", _.accountCreationSource),
500       Field("Account_creation_origin", _.accountCreationOrigin),
501       Field("Account_Creation_Operation", _.accountCreationSlug),
502       Field("Account_Creation_Location", _.accountCreationLocation),
503       Field("Favorite_country", _.favoriteCountry),
504       Field("Favorite_language", _.favoriteLanguage),
505       Field("Total_Number_Proposals", _.totalProposals),
506       Field("Total_number_votes", _.totalVotes),
507       Field("First_Contribution_Date", _.firstContributionDate),
508       Field("Last_Contribution_Date", _.lastContributionDate),
509       Field("Operation_activity", _.operationActivity),
510       Field("Source_activity", _.sourceActivity),
511       Field("Days_of_Activity", _.daysOfActivity),
512       Field("Days_of_Activity_30d", _.daysOfActivity30),
513       Field("User_type", _.userType),
514       Field("Account_type", _.accountType),
515       Field("Updated_at", _.updatedAt),
516       Field("Days_before_deletion", _.daysBeforeDeletion),
517       Field("Last_activity_date", _.lastActivityDate),
518       Field("Sessions_count", _.sessionsCount),
519       Field("Events_count", _.eventsCount)
520     )
521   }
522 }