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.nio.file.Path
23 import io.circe.Decoder
24 import org.make.api.technical.crm.BasicCrmResponse._
25 import org.make.api.technical.crm.CrmClient.{Account, Marketing, Transactional}
26 import org.make.api.technical.security.SecurityHelper
27 import org.make.core.Order
28 
29 import scala.concurrent.{ExecutionContext, Future}
30 import org.make.core.technical.Pagination
31 
32 trait CrmClient {
33 
34   def manageContactList(manageContactList: ManageManyContacts, account: Account = Marketing)(
35     implicit executionContext: ExecutionContext
36   ): Future[ManageManyContactsResponse]
37 
38   def manageContactListWithCsv(csvImport: CsvImport, account: Account = Marketing)(
39     implicit executionContext: ExecutionContext
40   ): Future[ManageContactsWithCsvResponse]
41 
42   def sendCsv(listId: String, csv: Path, account: Account = Marketing)(
43     implicit executionContext: ExecutionContext
44   ): Future[SendCsvResponse]
45 
46   def monitorCsvImport(jobId: Long, account: Account = Marketing)(
47     implicit executionContext: ExecutionContext
48   ): Future[ManageContactsWithCsvResponse]
49 
50   def sendEmail(message: SendMessages, account: Account = Transactional)(
51     implicit executionContext: ExecutionContext
52   ): Future[SendEmailResponse]
53 
54   def getUsersInformationMailFromList(
55     listId: Option[String] = None,
56     sort: Option[String] = None,
57     order: Option[Order] = None,
58     countOnly: Option[Boolean] = None,
59     limit: Pagination.Limit,
60     offset: Pagination.Offset = Pagination.Offset(0),
61     account: Account = Marketing
62   )(implicit executionContext: ExecutionContext): Future[ContactsResponse]
63 
64   def getContactsProperties(offset: Int, limit: Pagination.Limit, account: Account = Marketing)(
65     implicit executionContext: ExecutionContext
66   ): Future[GetMailjetContactProperties]
67 
68   def deleteContactByEmail(email: String, account: Account)(implicit executionContext: ExecutionContext): Future[Unit]
69 
70   def deleteContactById(contactId: String, account: Account)(implicit executionContext: ExecutionContext): Future[Unit]
71 }
72 
73 object CrmClient {
74   sealed trait Account
75 
76   case object Marketing extends Account
77   case object Transactional extends Account
78 }
79 
80 trait CrmClientComponent {
81   def crmClient: CrmClient
82 }
83 
84 final case class SendEmailResponse(messages: Seq[SentEmail])
85 
86 object SendEmailResponse {
87   implicit val decoder: Decoder[SendEmailResponse] =
88     Decoder.forProduct1("Messages")(SendEmailResponse.apply)
89 }
90 
91 final case class SendCsvResponse(csvId: Long)
92 
93 object SendCsvResponse {
94   implicit val decoder: Decoder[SendCsvResponse] =
95     Decoder.forProduct1("ID")(SendCsvResponse.apply)
96 }
97 
98 final case class SentEmail(
99   status: String,
100   errors: Option[Seq[SendMessageError]],
101   customId: String,
102   to: Seq[MessageDetails],
103   cc: Seq[MessageDetails],
104   bcc: Seq[MessageDetails]
105 ) {
106   override def toString: String =
107     s"SentEmail: (status = $status, errors = ${errors.map(_.mkString("[", ",", "]"))}, customId = $customId, to = ${to
108       .mkString("[", ",", "]")}, cc = ${cc.mkString("[", ",", "]")}, bcc = ${bcc.mkString("[", ",", "]")})"
109 }
110 
111 object SentEmail {
112   implicit val decoder: Decoder[SentEmail] =
113     Decoder.forProduct6("Status", "Errors", "CustomID", "To", "Cc", "Bcc")(SentEmail.apply)
114 }
115 
116 final case class SendMessageError(
117   errorIdentifier: String,
118   errorCode: String,
119   statusCode: Int,
120   errorMessage: String,
121   errorRelatedTo: String
122 ) {
123   override def toString: String =
124     s"SendMessageError: (errorIdentifier = $errorIdentifier, errorCode = $errorCode, " +
125       s"statusCode = $statusCode, errorMessage = $errorMessage, errorRelatedTo = $errorRelatedTo)"
126 }
127 
128 object SendMessageError {
129   implicit val decoder: Decoder[SendMessageError] =
130     Decoder.forProduct5("ErrorIdentifier", "ErrorCode", "StatusCode", "ErrorMessage", "ErrorRelatedTo")(
131       SendMessageError.apply
132     )
133 }
134 
135 final case class MessageDetails(email: String, messageUuid: String, messageId: Long, messageHref: String) {
136   override def toString: String =
137     s"MessageDetails: (email = ${SecurityHelper.anonymizeEmail(email)}, messageUuid = $messageUuid, " +
138       s"messageId = $messageId, messageHref = $messageHref)"
139 }
140 
141 object MessageDetails {
142   implicit val decoder: Decoder[MessageDetails] =
143     Decoder.forProduct4("Email", "MessageUUID", "MessageID", "MessageHref")(MessageDetails.apply)
144 }
145 
146 final case class BasicCrmResponse[T](count: Int, total: Int, data: Seq[T])
147 
148 object BasicCrmResponse {
149   def createDecoder[T](implicit tDecoder: Decoder[T]): Decoder[BasicCrmResponse[T]] =
150     Decoder.forProduct3("Count", "Total", "Data")(BasicCrmResponse.apply)
151 
152   type ContactsResponse = BasicCrmResponse[ContactDataResponse]
153   type ManageManyContactsResponse = BasicCrmResponse[JobId]
154   type GetMailjetContactProperties = BasicCrmResponse[MailjetContactProperties]
155   type ManageContactsWithCsvResponse = BasicCrmResponse[CsvImportResponse]
156 
157   implicit val contactsResponseDecoder: Decoder[ContactsResponse] = createDecoder[ContactDataResponse]
158   implicit val manageManyContactsResponseDecoder: Decoder[ManageManyContactsResponse] = createDecoder[JobId]
159   implicit val getMailjetContactPropertiesResponseDecoder: Decoder[GetMailjetContactProperties] =
160     createDecoder[MailjetContactProperties]
161   implicit val manageContactsWithCsvResponseDecoder: Decoder[ManageContactsWithCsvResponse] =
162     createDecoder[CsvImportResponse]
163 }
164 
165 final case class CsvImportResponse(jobId: Long, dataId: Long, errorCount: Int, status: String)
166 
167 object CsvImportResponse {
168   implicit val decoder: Decoder[CsvImportResponse] =
169     Decoder.forProduct4("ID", "DataID", "Errcount", "Status")(CsvImportResponse.apply)
170 }
171 
172 final case class ContactDataResponse(
173   isExcludedFromCampaigns: Boolean,
174   name: String,
175   createdAt: String,
176   deliveredCount: Int,
177   email: String,
178   exclusionFromCampaignsUpdatedAt: String,
179   id: Long,
180   isOptInPending: Boolean,
181   isSpamComplaining: Boolean,
182   lastActivityAt: String,
183   lastUpdateAt: String
184 )
185 
186 object ContactDataResponse {
187   implicit val decoder: Decoder[ContactDataResponse] =
188     Decoder.forProduct11(
189       "IsExcludedFromCampaigns",
190       "Name",
191       "CreatedAt",
192       "DeliveredCount",
193       "Email",
194       "ExclusionFromCampaignsUpdatedAt",
195       "ID",
196       "IsOptInPending",
197       "IsSpamComplaining",
198       "LastActivityAt",
199       "LastUpdateAt"
200     )(ContactDataResponse.apply)
201 }
202 
203 final case class JobId(jobId: Long)
204 
205 object JobId {
206   implicit val decoder: Decoder[JobId] =
207     Decoder.forProduct1("JobID")(JobId.apply)
208 }
209 
210 final case class MailjetContactProperties(properties: Seq[MailjetProperty], contactId: Long)
211 object MailjetContactProperties {
212   implicit val decoder: Decoder[MailjetContactProperties] =
213     Decoder.forProduct2("Data", "ContactID")(MailjetContactProperties.apply)
214 }
215 
216 final case class MailjetProperty(name: String, value: String)
217 object MailjetProperty {
218   implicit val decoder: Decoder[MailjetProperty] = Decoder.forProduct2("Name", "Value")(MailjetProperty.apply)
219 }