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 java.time.ZonedDateTime
23 import com.sksamuel.avro4s
24 import com.sksamuel.avro4s._
25 import grizzled.slf4j.Logging
26 import io.circe.Decoder._
27 import io.circe.{Decoder, DecodingFailure, HCursor}
28 import io.swagger.annotations.ApiModelProperty
29 import org.apache.avro.Schema
30 import org.make.core.{AvroSerializers, CirceFormatters, Sharded}
31 
32 import scala.annotation.meta.field
33 
34 sealed trait MailJetEvent extends Product with Serializable {
35   def email: String
36   def time: Option[Long]
37   def messageId: Option[Long]
38   def campaignId: Option[Long]
39   def contactId: Option[Long]
40   def customCampaign: Option[String]
41   def customId: Option[String]
42   def payload: Option[String]
43 }
44 
45 /**
46   * see Mailjet documentation: https://dev.mailjet.com/guides/
47   */
48 object MailJetEvent {
49   private val eventDecoderMap = Map(
50     "simple" -> MailJetBaseEvent.decoder,
51     "bounce" -> MailJetBounceEvent.decoder,
52     "blocked" -> MailJetBlockedEvent.decoder,
53     "spam" -> MailJetSpamEvent.decoder,
54     "unsub" -> MailJetUnsubscribeEvent.decoder
55   )
56 
57   implicit val decoder: Decoder[MailJetEvent] = (cursor: HCursor) => {
58     cursor.downField("event").as[String].flatMap { event =>
59       eventDecoderMap
60         .get(event)
61         .orElse(eventDecoderMap.get("simple"))
62         .map { decoder =>
63           decoder.apply(cursor)
64         }
65         .getOrElse(Left(DecodingFailure(s"Unknown event type: $event", Nil)))
66     }
67   }
68 }
69 
70 final case class MailJetEventWrapper(version: Int, id: String, date: ZonedDateTime, event: MailJetEvent) extends Sharded
71 
72 object MailJetEventWrapper extends AvroSerializers {
73   implicit lazy val schemaFor: SchemaFor[MailJetEventWrapper] = SchemaFor.gen[MailJetEventWrapper]
74   implicit lazy val avroDecoder: avro4s.Decoder[MailJetEventWrapper] = avro4s.Decoder.gen[MailJetEventWrapper]
75   implicit lazy val avroEncoder: avro4s.Encoder[MailJetEventWrapper] = avro4s.Encoder.gen[MailJetEventWrapper]
76 }
77 
78 sealed trait MailJetErrorRelatedTo {
79   def name: String
80 }
81 object MailJetErrorRelatedTo {
82   case object Recipient extends MailJetErrorRelatedTo {
83     override val name = "recipient"
84   }
85   case object Domain extends MailJetErrorRelatedTo {
86     override val name = "domain"
87   }
88   case object Content extends MailJetErrorRelatedTo {
89     override val name = "content"
90   }
91   case object Spam extends MailJetErrorRelatedTo {
92     override val name = "spam"
93   }
94   case object System extends MailJetErrorRelatedTo {
95     override val name = "system"
96   }
97   case object Mailjet extends MailJetErrorRelatedTo {
98     override val name = "mailjet"
99   }
100 }
101 
102 sealed trait MailJetError extends Product with Serializable {
103   def relatedTo: MailJetErrorRelatedTo
104   def name: String
105 }
106 object MailJetError extends Logging {
107 
108   implicit object MailJetErrorAvroEncoder extends Encoder[MailJetError] {
109     override def encode(value: MailJetError, schema: Schema, fieldMapper: FieldMapper): String = value.name
110   }
111 
112   implicit object MailJetErrorFromValue extends avro4s.Decoder[MailJetError] {
113     @SuppressWarnings(Array("org.wartremover.warts.Throw"))
114     override def decode(value: Any, schema: Schema, fieldMapper: FieldMapper): MailJetError =
115       MailJetError.errorMap
116         .getOrElse(value.toString, throw new IllegalArgumentException(s"$value is not a MailJetError"))
117   }
118 
119   implicit object MailJetErrorToSchema extends SchemaFor[MailJetError] {
120     override def schema(fieldMapper: FieldMapper): Schema = Schema.create(Schema.Type.STRING)
121   }
122 
123   val errorMap: Map[String, MailJetError] = Map(
124     UserUnknown.name -> UserUnknown,
125     MailboxInactive.name -> MailboxInactive,
126     QuotaExceeded.name -> QuotaExceeded,
127     Blacklisted.name -> Blacklisted,
128     SpamReporter.name -> SpamReporter,
129     InvalidDomaine.name -> InvalidDomaine,
130     NoMailHost.name -> NoMailHost,
131     RelayAccessDenied.name -> RelayAccessDenied,
132     Greylisted.name -> Greylisted,
133     Typofix.name -> Typofix,
134     BadOrEmptyTemplate.name -> BadOrEmptyTemplate,
135     ErrorInTemplateLanguage.name -> ErrorInTemplateLanguage,
136     SenderBlocked.name -> SenderBlocked,
137     ContentBlocked.name -> ContentBlocked,
138     PolicyIssue.name -> PolicyIssue,
139     SystemIssue.name -> SystemIssue,
140     ProtocolIssue.name -> ProtocolIssue,
141     ConnectionIssue.name -> ConnectionIssue,
142     Preblocked.name -> Preblocked,
143     DuplicateInCampaign.name -> DuplicateInCampaign
144   )
145 
146   def getError(maybeError: Option[String], maybeErrorRelatedTo: Option[String]): Option[MailJetError] = {
147     maybeError.flatMap { error =>
148       maybeErrorRelatedTo.flatMap { errorRelatedTo =>
149         errorMap.get(error) match {
150           case Some(mailJetError) if mailJetError.relatedTo.name == errorRelatedTo => Some(mailJetError)
151           case None if maybeError.contains("") && maybeErrorRelatedTo.contains("") => None
152           case _ =>
153             logger.warn(s"""MailJet error not defined (error: "$error", errorRelated: "$errorRelatedTo").""")
154             None
155         }
156       }
157     }
158   }
159 
160   case object UserUnknown extends MailJetError {
161     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Recipient
162     override def name: String = "user unknown"
163   }
164   case object MailboxInactive extends MailJetError {
165     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Recipient
166     override def name: String = "mailbox inactive"
167   }
168   case object QuotaExceeded extends MailJetError {
169     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Recipient
170     override def name: String = "quota exceeded"
171   }
172   case object Blacklisted extends MailJetError {
173     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Recipient
174     override def name: String = "blacklisted"
175   }
176   case object SpamReporter extends MailJetError {
177     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Recipient
178     override def name: String = "spam reporter"
179   }
180   case object InvalidDomaine extends MailJetError {
181     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Domain
182     override def name: String = "invalid domain"
183   }
184   case object NoMailHost extends MailJetError {
185     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Domain
186     override def name: String = "no mail host"
187   }
188   case object RelayAccessDenied extends MailJetError {
189     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Domain
190     override def name: String = "relay/access denied"
191   }
192   case object Greylisted extends MailJetError {
193     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Domain
194     override def name: String = "greylisted"
195   }
196   case object Typofix extends MailJetError {
197     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Domain
198     override def name: String = "typofix"
199   }
200   case object BadOrEmptyTemplate extends MailJetError {
201     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Content
202     override def name: String = "bad or empty template"
203   }
204   case object ErrorInTemplateLanguage extends MailJetError {
205     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Content
206     override def name: String = "error in template language"
207   }
208   case object SenderBlocked extends MailJetError {
209     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Spam
210     override def name: String = "sender blocked"
211   }
212   case object ContentBlocked extends MailJetError {
213     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Spam
214     override def name: String = "content blocked"
215   }
216   case object PolicyIssue extends MailJetError {
217     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Spam
218     override def name: String = "policy issue"
219   }
220   case object SystemIssue extends MailJetError {
221     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.System
222     override def name: String = "system issue"
223   }
224   case object ProtocolIssue extends MailJetError {
225     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.System
226     override def name: String = "protocol issue"
227   }
228   case object ConnectionIssue extends MailJetError {
229     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.System
230     override def name: String = "connection issue"
231   }
232   case object Preblocked extends MailJetError {
233     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Mailjet
234     override def name: String = "preblocked"
235   }
236   case object DuplicateInCampaign extends MailJetError {
237     override def relatedTo: MailJetErrorRelatedTo = MailJetErrorRelatedTo.Mailjet
238     override def name: String = "duplicate in campaign"
239   }
240 }
241 
242 @AvroSortPriority(5)
243 final case class MailJetBaseEvent(
244   event: String,
245   override val email: String,
246   @(ApiModelProperty @field)(dataType = "long")
247   override val time: Option[Long],
248   @(ApiModelProperty @field)(dataType = "long")
249   override val messageId: Option[Long],
250   @(ApiModelProperty @field)(dataType = "long")
251   override val campaignId: Option[Long],
252   @(ApiModelProperty @field)(dataType = "long")
253   override val contactId: Option[Long],
254   override val customCampaign: Option[String],
255   override val customId: Option[String],
256   override val payload: Option[String]
257 ) extends MailJetEvent
258 object MailJetBaseEvent extends CirceFormatters {
259   val decoder: Decoder[MailJetBaseEvent] = Decoder.forProduct9(
260     "event",
261     "email",
262     "time",
263     "MessageID",
264     "mj_campaign_id",
265     "mj_contact_id",
266     "customcampaign",
267     "CustomID",
268     "Payload"
269   ) {
270     (
271       event: String,
272       email: String,
273       time: Option[Long],
274       messageId: Option[Long],
275       campaignId: Either[Option[Long], String],
276       contactId: Either[Option[Long], String],
277       customCampaign: Option[String],
278       customId: Option[String],
279       payload: Option[String]
280     ) =>
281       MailJetBaseEvent(
282         event = event,
283         email = email,
284         time = time,
285         messageId = messageId,
286         customCampaign = customCampaign,
287         campaignId = campaignId match {
288           case Left(value) => value
289           case Right(_)    => None
290         },
291         contactId = contactId match {
292           case Left(value) => value
293           case Right(_)    => None
294         },
295         customId = customId,
296         payload = payload
297       )
298   }
299 }
300 
301 @AvroSortPriority(2)
302 final case class MailJetBounceEvent(
303   override val email: String,
304   override val time: Option[Long] = None,
305   override val messageId: Option[Long] = None,
306   override val campaignId: Option[Long] = None,
307   override val contactId: Option[Long] = None,
308   override val customCampaign: Option[String] = None,
309   override val customId: Option[String] = None,
310   override val payload: Option[String] = None,
311   blocked: Boolean,
312   hardBounce: Boolean,
313   error: Option[MailJetError]
314 ) extends MailJetEvent
315 
316 object MailJetBounceEvent extends CirceFormatters {
317   val decoder: Decoder[MailJetBounceEvent] = Decoder.forProduct12(
318     "email",
319     "time",
320     "MessageID",
321     "mj_campaign_id",
322     "mj_contact_id",
323     "customcampaign",
324     "CustomID",
325     "Payload",
326     "blocked",
327     "hard_bounce",
328     "error_related_to",
329     "error"
330   ) {
331     (
332       email: String,
333       time: Option[Long],
334       messageId: Option[Long],
335       campaignId: Either[Option[Long], String],
336       contactId: Either[Option[Long], String],
337       customCampaign: Option[String],
338       customId: Option[String],
339       payload: Option[String],
340       blocked: Either[Boolean, String],
341       hardBounce: Either[Boolean, String],
342       errorRelatedTo: Option[String],
343       error: Option[String]
344     ) =>
345       MailJetBounceEvent(
346         email = email,
347         time = time,
348         messageId = messageId,
349         customCampaign = customCampaign,
350         campaignId = campaignId match {
351           case Left(value) => value
352           case Right(_)    => None
353         },
354         contactId = contactId match {
355           case Left(value) => value
356           case Right(_)    => None
357         },
358         customId = customId,
359         payload = payload,
360         blocked = blocked match {
361           case Left(value) => value
362           case _           => false
363         },
364         hardBounce = hardBounce match {
365           case Left(value) => value
366           case _           => false
367         },
368         error = MailJetError.getError(error, errorRelatedTo)
369       )
370 
371   }
372 }
373 
374 @AvroSortPriority(1)
375 final case class MailJetBlockedEvent(
376   override val email: String,
377   override val time: Option[Long] = None,
378   override val messageId: Option[Long] = None,
379   override val campaignId: Option[Long] = None,
380   override val contactId: Option[Long] = None,
381   override val customCampaign: Option[String] = None,
382   override val customId: Option[String] = None,
383   override val payload: Option[String] = None,
384   error: Option[MailJetError]
385 ) extends MailJetEvent
386 object MailJetBlockedEvent extends CirceFormatters {
387   val decoder: Decoder[MailJetBlockedEvent] = Decoder.forProduct10(
388     "email",
389     "time",
390     "MessageID",
391     "mj_campaign_id",
392     "mj_contact_id",
393     "customcampaign",
394     "CustomID",
395     "Payload",
396     "error_related_to",
397     "error"
398   ) {
399     (
400       email: String,
401       time: Option[Long],
402       messageId: Option[Long],
403       campaignId: Either[Option[Long], String],
404       contactId: Either[Option[Long], String],
405       customCampaign: Option[String],
406       customId: Option[String],
407       payload: Option[String],
408       errorRelatedTo: Option[String],
409       error: Option[String]
410     ) =>
411       MailJetBlockedEvent(
412         email = email,
413         time = time,
414         messageId = messageId,
415         customCampaign = customCampaign,
416         campaignId = campaignId match {
417           case Left(value) => value
418           case Right(_)    => None
419         },
420         contactId = contactId match {
421           case Left(value) => value
422           case Right(_)    => None
423         },
424         customId = customId,
425         payload = payload,
426         error = MailJetError.getError(error, errorRelatedTo)
427       )
428   }
429 }
430 
431 @AvroSortPriority(3)
432 final case class MailJetSpamEvent(
433   override val email: String,
434   override val time: Option[Long] = None,
435   override val messageId: Option[Long] = None,
436   override val campaignId: Option[Long] = None,
437   override val contactId: Option[Long] = None,
438   override val customCampaign: Option[String] = None,
439   override val customId: Option[String] = None,
440   override val payload: Option[String] = None,
441   source: Option[String]
442 ) extends MailJetEvent
443 object MailJetSpamEvent extends CirceFormatters {
444   val decoder: Decoder[MailJetSpamEvent] = Decoder.forProduct9(
445     "email",
446     "time",
447     "MessageID",
448     "mj_campaign_id",
449     "mj_contact_id",
450     "customcampaign",
451     "CustomID",
452     "Payload",
453     "source"
454   ) {
455     (
456       email: String,
457       time: Option[Long],
458       messageId: Option[Long],
459       campaignId: Either[Option[Long], String],
460       contactId: Either[Option[Long], String],
461       customCampaign: Option[String],
462       customId: Option[String],
463       payload: Option[String],
464       source: Option[String]
465     ) =>
466       MailJetSpamEvent(email = email, time = time, messageId = messageId, campaignId = campaignId match {
467         case Left(value) => value
468         case Right(_)    => None
469       }, contactId = contactId match {
470         case Left(value) => value
471         case Right(_)    => None
472       }, customCampaign = customCampaign, customId = customId, payload = payload, source = source)
473   }
474 }
475 
476 @AvroSortPriority(4)
477 final case class MailJetUnsubscribeEvent(
478   email: String,
479   time: Option[Long] = None,
480   messageId: Option[Long] = None,
481   campaignId: Option[Long] = None,
482   contactId: Option[Long] = None,
483   customCampaign: Option[String] = None,
484   customId: Option[String] = None,
485   payload: Option[String] = None,
486   listId: Option[Int],
487   ip: Option[String],
488   geo: Option[String],
489   agent: Option[String]
490 ) extends MailJetEvent
491 object MailJetUnsubscribeEvent extends CirceFormatters {
492   val decoder: Decoder[MailJetUnsubscribeEvent] = Decoder.forProduct12(
493     "email",
494     "time",
495     "MessageID",
496     "mj_campaign_id",
497     "mj_contact_id",
498     "customcampaign",
499     "CustomID",
500     "Payload",
501     "mj_list_id",
502     "ip",
503     "geo",
504     "agent"
505   ) {
506     (
507       email: String,
508       time: Option[Long],
509       messageId: Option[Long],
510       campaignId: Either[Option[Long], String],
511       contactId: Either[Option[Long], String],
512       customCampaign: Option[String],
513       customId: Option[String],
514       payload: Option[String],
515       listId: Either[Option[Int], String],
516       ip: Option[String],
517       geo: Option[String],
518       agent: Option[String]
519     ) =>
520       MailJetUnsubscribeEvent(email = email, time = time, messageId = messageId, campaignId = campaignId match {
521         case Left(value) => value
522         case Right(_)    => None
523       }, contactId = contactId match {
524         case Left(value) => value
525         case Right(_)    => None
526       }, customCampaign = customCampaign, customId = customId, payload = payload, listId = listId match {
527         case Left(value) => value
528         case Right(_)    => None
529       }, ip = ip, geo = geo, agent = agent)
530 
531   }
532 }