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 akka.http.scaladsl.model.StatusCodes
23 import akka.http.scaladsl.server.directives.Credentials
24 import akka.http.scaladsl.server.directives.Credentials.Provided
25 import akka.http.scaladsl.server.{Directives, Route}
26 import grizzled.slf4j.Logging
27 import io.swagger.annotations._
28 
29 import javax.ws.rs.Path
30 import org.make.api.extensions.MailJetConfigurationComponent
31 import org.make.api.operation.OperationServiceComponent
32 import org.make.api.question.QuestionServiceComponent
33 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
34 import org.make.api.technical.{EventBusServiceComponent, MakeAuthenticationDirectives}
35 import org.make.api.technical.directives.FutureDirectivesExtensions._
36 import org.make.core.auth.UserRights
37 import org.make.core.job.Job
38 import org.make.core.job.Job.JobId.SyncCrmData
39 import org.make.core.{DateHelper, HttpCodes, Validation}
40 import scalaoauth2.provider.AuthInfo
41 
42 import scala.concurrent.ExecutionContext.Implicits.global
43 import scala.util.{Failure, Success}
44 
45 @Api(value = "CRM")
46 @Path(value = "/")
47 trait CrmApi extends Directives {
48 
49   @ApiOperation(
50     value = "consume-mailjet-event",
51     httpMethod = "POST",
52     code = HttpCodes.OK,
53     authorizations = Array(new Authorization(value = "basicAuth"))
54   )
55   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok")))
56   @Path(value = "/technical/mailjet")
57   @ApiImplicitParams(
58     value = Array(
59       new ApiImplicitParam(
60         value = "body",
61         paramType = "body",
62         dataType = "[Lorg.make.api.technical.crm.MailJetBaseEvent;"
63       )
64     )
65   )
66   def webHook: Route
67 
68   @ApiOperation(
69     value = "sync-crm-data",
70     httpMethod = "POST",
71     code = HttpCodes.Accepted,
72     authorizations = Array(
73       new Authorization(
74         value = "MakeApi",
75         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
76       )
77     )
78   )
79   @ApiResponses(
80     value = Array(
81       new ApiResponse(code = HttpCodes.Accepted, message = "Accepted"),
82       new ApiResponse(code = HttpCodes.Conflict, message = "Conflict")
83     )
84   )
85   @Path(value = "/technical/crm/synchronize")
86   def syncCrmData: Route
87 
88   @ApiOperation(
89     value = "anonymize-users",
90     httpMethod = "POST",
91     code = HttpCodes.Accepted,
92     authorizations = Array(
93       new Authorization(
94         value = "MakeApi",
95         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
96       )
97     )
98   )
99   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.Accepted, message = "Accepted")))
100   @Path(value = "/technical/crm/anonymize")
101   def anonymizeUsers: Route
102 
103   @ApiOperation(
104     value = "send-list",
105     httpMethod = "POST",
106     code = HttpCodes.Accepted,
107     authorizations = Array(
108       new Authorization(
109         value = "MakeApi",
110         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
111       )
112     )
113   )
114   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.Accepted, message = "Accepted")))
115   @ApiImplicitParams(
116     value = Array(
117       new ApiImplicitParam(
118         name = "crmList",
119         paramType = "path",
120         dataType = "string",
121         example = "optIn",
122         allowableValues = CrmList.swaggerAllowableValues
123       )
124     )
125   )
126   @Path(value = "/technical/crm/{crmList}/synchronize")
127   def sendListToCrm: Route
128 
129   def routes: Route = webHook ~ syncCrmData ~ anonymizeUsers ~ sendListToCrm
130 }
131 
132 trait CrmApiComponent {
133   def crmApi: CrmApi
134 }
135 
136 trait DefaultCrmApiComponent extends CrmApiComponent with MakeAuthenticationDirectives with Logging {
137   this: MakeDirectivesDependencies
138     with EventBusServiceComponent
139     with MailJetConfigurationComponent
140     with CrmServiceComponent
141     with QuestionServiceComponent
142     with OperationServiceComponent =>
143 
144   override lazy val crmApi: CrmApi = new DefaultCrmApi
145 
146   class DefaultCrmApi extends CrmApi {
147 
148     private def authenticate(credentials: Credentials): Option[String] = {
149       val login = mailJetConfiguration.basicAuthLogin
150       val password = mailJetConfiguration.basicAuthPassword
151       credentials match {
152         case c @ Provided(`login`) if c.verify(password, _.trim) => Some("OK")
153         case _                                                   => None
154       }
155     }
156 
157     override def webHook: Route = {
158       post {
159         path("technical" / "mailjet") {
160           makeOperation("mailjet-webhook") { _ =>
161             authenticateBasic[String]("make-mailjet", authenticate).apply { _ =>
162               decodeRequest {
163 
164                 entity(as[Seq[MailJetEvent]]) { events: Seq[MailJetEvent] =>
165                   // Send all events to event bus
166                   events.foreach { event =>
167                     Validation.validateOptional(
168                       Some(
169                         Validation.validateUserInput(
170                           fieldValue = event.email,
171                           fieldName = "email",
172                           message = Some("Invalid email")
173                         )
174                       ),
175                       event.customCampaign.map(
176                         customCampaign =>
177                           Validation.validateUserInput(
178                             fieldValue = customCampaign,
179                             fieldName = "customCampaign",
180                             message = Some("Invalid customCampaign")
181                           )
182                       ),
183                       event.customId.map(
184                         customId =>
185                           Validation.validateUserInput(
186                             fieldValue = customId,
187                             fieldName = "customId",
188                             message = Some("Invalid customId")
189                           )
190                       ),
191                       event.payload.map(
192                         payload =>
193                           Validation.validateUserInput(
194                             fieldValue = payload,
195                             fieldName = "payload",
196                             message = Some("Invalid payload")
197                           )
198                       )
199                     )
200                     eventBusService.publish(event)
201                   }
202                   complete(StatusCodes.OK)
203                 } ~
204                   entity(as[MailJetEvent]) { event: MailJetEvent =>
205                     eventBusService.publish(event)
206                     complete(StatusCodes.OK)
207                   }
208 
209               }
210             }
211           }
212         }
213       }
214     }
215 
216     override def syncCrmData: Route = post {
217       path("technical" / "crm" / "synchronize") {
218         makeOperation("CrmSynchro") { _ =>
219           makeOAuth2 { auth: AuthInfo[UserRights] =>
220             requireAdminRole(auth.user) {
221               makeOperation(SyncCrmData.value) { _ =>
222                 // The future will take a lot of time to complete,
223                 // so it's better to leave it in the background
224                 crmService.synchronizeContactsWithCrm().asDirective { acceptance =>
225                   if (acceptance.isAccepted) {
226                     complete(StatusCodes.Accepted -> Job.JobId.SyncCrmData)
227                   } else {
228                     complete(StatusCodes.Conflict -> Job.JobId.SyncCrmData)
229                   }
230                 }
231               }
232             }
233           }
234         }
235       }
236     }
237 
238     override def anonymizeUsers: Route = post {
239       path("technical" / "crm" / "anonymize") {
240         makeOperation("CrmAnonymize") { _ =>
241           makeOAuth2 { auth: AuthInfo[UserRights] =>
242             requireAdminRole(auth.user) {
243               makeOperation("AnonymizeUsers") { _ =>
244                 val startTime = System.currentTimeMillis()
245                 crmService.anonymize().onComplete {
246                   case Success(_) =>
247                     logger
248                       .info(s"anonymizing contacts succeeded in ${System.currentTimeMillis() - startTime}ms")
249                   case Failure(e) =>
250                     logger
251                       .error(s"anonymizing contacts failed in ${System.currentTimeMillis() - startTime}ms", e)
252                 }
253                 complete(StatusCodes.Accepted)
254               }
255             }
256           }
257         }
258       }
259     }
260 
261     override def sendListToCrm: Route = post {
262       path("technical" / "crm" / CrmList / "synchronize") { list =>
263         makeOperation("CrmSendList") { _ =>
264           makeOAuth2 { auth: AuthInfo[UserRights] =>
265             requireAdminRole(auth.user) {
266               makeOperation("SynchronizeList") { _ =>
267                 val startTime = System.currentTimeMillis()
268                 crmService
269                   .synchronizeList(
270                     DateHelper.now().toString,
271                     list,
272                     list.targetDirectory(mailJetConfiguration.csvDirectory)
273                   )
274                   .onComplete {
275                     case Success(_) =>
276                       logger
277                         .info(
278                           s"Synchronizing list ${list.value} succeeded in ${System.currentTimeMillis() - startTime}ms"
279                         )
280                     case Failure(e) =>
281                       logger
282                         .error(
283                           s"Synchronizing list ${list.value} failed in ${System.currentTimeMillis() - startTime}ms",
284                           e
285                         )
286                   }
287                 complete(StatusCodes.Accepted)
288               }
289             }
290           }
291         }
292       }
293     }
294 
295   }
296 }