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.tracking
21 
22 import akka.http.scaladsl.model.StatusCodes
23 import akka.http.scaladsl.server.{Route, RouteConcatenation}
24 import cats.syntax.all._
25 import grizzled.slf4j.Logging
26 import io.circe.Decoder
27 import io.circe.generic.semiauto.deriveDecoder
28 import io.swagger.annotations._
29 import org.make.api.demographics.DemographicsCardServiceComponent
30 import org.make.api.question.QuestionServiceComponent
31 import org.make.api.operation.OperationOfQuestionServiceComponent
32 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
33 import org.make.api.technical.directives.FutureDirectivesExtensions._
34 import org.make.api.technical.monitoring.MonitoringServiceComponent
35 import org.make.api.technical.{EndpointType, EventBusServiceComponent, MakeAuthenticationDirectives, MakeDirectives}
36 import org.make.core._
37 import org.make.core.auth.UserRights
38 import org.make.core.demographics.{DemographicsCard, DemographicsCardId}
39 import org.make.core.question.QuestionId
40 import org.make.core.reference.Country
41 import org.make.core.session.SessionId
42 import org.slf4j.event.Level
43 import scalaoauth2.provider.AuthInfo
44 
45 import javax.ws.rs.Path
46 import scala.annotation.meta.field
47 import scala.util.Try
48 
49 @Api(value = "Tracking")
50 @Path(value = "/tracking")
51 trait TrackingApi extends RouteConcatenation {
52 
53   @ApiOperation(value = "front-events", httpMethod = "POST", code = HttpCodes.NoContent)
54   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
55   @ApiImplicitParams(
56     value = Array(
57       new ApiImplicitParam(
58         name = "body",
59         paramType = "body",
60         dataType = "org.make.api.technical.tracking.FrontTrackingRequest"
61       )
62     )
63   )
64   @Path(value = "/front")
65   def frontTracking: Route
66 
67   @ApiOperation(value = "panoramic-events", httpMethod = "POST", code = HttpCodes.NoContent)
68   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
69   @ApiImplicitParams(
70     value = Array(
71       new ApiImplicitParam(
72         name = "body",
73         paramType = "body",
74         dataType = "org.make.api.technical.tracking.PanoramicTrackingRequest"
75       )
76     )
77   )
78   @Path(value = "/panoramic")
79   def panoramicTracking: Route
80 
81   @ApiOperation(value = "front-performance", httpMethod = "POST", code = HttpCodes.NoContent)
82   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
83   @ApiImplicitParams(
84     value = Array(
85       new ApiImplicitParam(
86         name = "body",
87         paramType = "body",
88         dataType = "org.make.api.technical.tracking.FrontPerformanceRequest"
89       )
90     )
91   )
92   @Path(value = "/performance")
93   def trackFrontPerformances: Route
94 
95   @ApiOperation(value = "backoffice-logs", httpMethod = "POST", code = HttpCodes.NoContent)
96   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
97   @ApiImplicitParams(
98     value = Array(
99       new ApiImplicitParam(
100         name = "body",
101         paramType = "body",
102         dataType = "org.make.api.technical.tracking.BackofficeLogs"
103       )
104     )
105   )
106   @Path(value = "/backoffice/logs")
107   def backofficeLogs: Route
108 
109   @ApiOperation(value = "track-demographics-v2", httpMethod = "POST", code = HttpCodes.NoContent)
110   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
111   @ApiImplicitParams(
112     value = Array(
113       new ApiImplicitParam(
114         name = "body",
115         paramType = "body",
116         dataType = "org.make.api.technical.tracking.DemographicsV2TrackingRequest"
117       )
118     )
119   )
120   @Path(value = "/demographics-v2")
121   def trackDemographicsV2: Route
122 
123   final def routes: Route =
124     backofficeLogs ~ frontTracking ~ panoramicTracking ~ trackFrontPerformances ~ trackDemographicsV2
125 }
126 
127 trait TrackingApiComponent {
128   def trackingApi: TrackingApi
129 }
130 
131 trait DefaultTrackingApiComponent extends TrackingApiComponent with MakeDirectives {
132   this: MakeDirectivesDependencies
133     with DemographicsCardServiceComponent
134     with OperationOfQuestionServiceComponent
135     with EventBusServiceComponent
136     with MakeAuthenticationDirectives
137     with MonitoringServiceComponent
138     with QuestionServiceComponent
139     with Logging =>
140 
141   override lazy val trackingApi: TrackingApi = new DefaultTrackingApi
142 
143   class DefaultTrackingApi extends TrackingApi {
144 
145     def backofficeLogs: Route = {
146       post {
147         path("tracking" / "backoffice" / "logs") {
148           makeOperation("BackofficeLogs") { _ =>
149             makeOAuth2 { auth: AuthInfo[UserRights] =>
150               requireModerationRole(auth.user) {
151                 decodeRequest {
152                   entity(as[BackofficeLogs]) { request: BackofficeLogs =>
153                     (request.level match {
154                       case Level.DEBUG => logger.debug(_: String)
155                       case Level.ERROR => logger.error(_: String)
156                       case Level.INFO  => logger.info(_: String)
157                       case Level.TRACE => logger.trace(_: String)
158                       case Level.WARN  => logger.warn(_: String)
159                     })(request.message)
160                     complete(StatusCodes.NoContent)
161                   }
162                 }
163               }
164             }
165           }
166         }
167       }
168     }
169 
170     def frontTracking: Route =
171       post {
172         path("tracking" / "front") {
173           makeOperation("TrackingFront", EndpointType.Public) { requestContext: RequestContext =>
174             decodeRequest {
175               entity(as[FrontTrackingRequest]) { request: FrontTrackingRequest =>
176                 eventBusService.publish(request.toEvent(requestContext = requestContext))
177                 complete(StatusCodes.NoContent)
178               }
179             }
180           }
181         }
182       }
183 
184     def panoramicTracking: Route =
185       post {
186         path("tracking" / "panoramic") {
187           makeOperation("TrackingPanoramic", EndpointType.Public) { _ =>
188             decodeRequest {
189               entity(as[PanoramicTrackingRequest]) { request: PanoramicTrackingRequest =>
190                 eventBusService.publish(request.toEvent())
191                 complete(StatusCodes.NoContent)
192               }
193             }
194           }
195         }
196       }
197 
198     def trackFrontPerformances: Route =
199       post {
200         path("tracking" / "performance") {
201           makeOperation("PerformanceTracking", EndpointType.Public) { _ =>
202             decodeRequest {
203               entity(as[FrontPerformanceRequest]) { request =>
204                 monitoringService.monitorPerformance(request.applicationName, request.timings)
205                 complete(StatusCodes.NoContent)
206               }
207             }
208           }
209         }
210       }
211 
212     def trackDemographicsV2: Route = {
213       post {
214         path("tracking" / "demographics-v2") {
215           makeOperation("DemographicsTrackingV2", EndpointType.Public, anonymize = true) {
216             requestContext: RequestContext =>
217               decodeRequest {
218                 entity(as[DemographicsV2TrackingRequest]) { request =>
219                   val questionNotFoundError = ValidationError(
220                     "questionId",
221                     "not_found",
222                     Some(s"Question ${request.questionId.value} doesn't exist")
223                   )
224                   val cardNotFoundError = ValidationError(
225                     "demographicsCardId",
226                     "not_found",
227                     Some(s"DemographicsCard ${request.demographicsCardId.value} doesn't exist")
228                   )
229                   (
230                     questionService.getQuestion(request.questionId).asDirectiveOrBadRequest(questionNotFoundError),
231                     demographicsCardService.get(request.demographicsCardId).asDirectiveOrBadRequest(cardNotFoundError),
232                     operationOfQuestionService
233                       .findByQuestionId(request.questionId)
234                       .asDirectiveOrBadRequest(questionNotFoundError)
235                   ).mapN({
236                       case (question, card, operationOfQuestion) =>
237                         val allowedValues = card.parameters.map(_.value).toList.toSet
238                         Validation.validate(
239                           Seq(
240                             Validation.validateField(
241                               "value",
242                               "invalid_value",
243                               request.value.forall(allowedValues.contains),
244                               s"Value ${request.value} is not one of the allowed values ${allowedValues.mkString(", ")}"
245                             ),
246                             Validation.validateField(
247                               "token",
248                               "invalid_value",
249                               demographicsCardService
250                                 .isTokenValid(request.token, request.demographicsCardId, request.questionId),
251                               s"Invalid token. Token might be expired or contain invalid value"
252                             ),
253                             Validation.validateField(
254                               "demographicsCardId",
255                               "invalid_value",
256                               card.questionId == request.questionId,
257                               s"Demographics card ${request.demographicsCardId} is not active for question ${request.questionId}"
258                             ),
259                             Validation.validateField(
260                               "country",
261                               "invalid_value",
262                               question.countries.exists(_ == request.country),
263                               s"Country ${request.country} is not defined in question ${request.questionId}"
264                             ),
265                             Validation.validateField(
266                               "sessionId",
267                               "invalid_mode",
268                               request.sessionId.isEmpty || request.sessionId.isDefined && operationOfQuestion.sessionBindingMode,
269                               s"Session binding mode is not activated on this card : ${request.demographicsCardId}"
270                             )
271                           ): _*
272                         )
273                         eventBusService.publish(request.toEvent(requestContext.applicationName, card.dataType))
274                     })
275                     .apply(_ => complete(StatusCodes.NoContent))
276                 }
277               }
278           }
279         }
280       }
281     }
282   }
283 }
284 
285 final case class BackofficeLogs(level: Level, message: String)
286 
287 object BackofficeLogs {
288   implicit val levelDecoder: Decoder[Level] = Decoder[String].emapTry(name => Try(Level.valueOf(name.toUpperCase)))
289   implicit val decoder: Decoder[BackofficeLogs] = deriveDecoder
290 }
291 
292 final case class FrontTrackingRequest(
293   eventType: String,
294   eventName: Option[String],
295   @(ApiModelProperty @field)(dataType = "map[string]") eventParameters: Option[Map[String, String]]
296 ) {
297   def toEvent(requestContext: RequestContext): TrackingEvent = {
298     TrackingEvent(
299       eventProvider = "front",
300       eventType = Some(eventType),
301       eventName = eventName,
302       eventParameters = eventParameters,
303       requestContext = requestContext,
304       createdAt = DateHelper.now()
305     )
306   }
307 
308 }
309 
310 object FrontTrackingRequest {
311   implicit val decoder: Decoder[FrontTrackingRequest] =
312     Decoder.forProduct3("eventType", "eventName", "eventParameters")(FrontTrackingRequest.apply)
313 }
314 
315 final case class PanoramicTrackingRequest(
316   eventType: String,
317   eventName: Option[String],
318   @(ApiModelProperty @field)(dataType = "map[string]") eventParameters: Option[Map[String, String]]
319 ) {
320   def toEvent(): PanoramicEvent = {
321     PanoramicEvent(
322       eventProvider = "panoramic",
323       eventType = Some(eventType),
324       eventName = eventName,
325       eventParameters = eventParameters,
326       createdAt = DateHelper.now()
327     )
328   }
329 
330 }
331 
332 object PanoramicTrackingRequest {
333   implicit val decoder: Decoder[PanoramicTrackingRequest] =
334     Decoder.forProduct3("eventType", "eventName", "eventParameters")(PanoramicTrackingRequest.apply)
335 }
336 
337 final case class FrontPerformanceRequest(applicationName: String, timings: FrontPerformanceTimings)
338 
339 object FrontPerformanceRequest {
340   implicit val decoder: Decoder[FrontPerformanceRequest] = deriveDecoder[FrontPerformanceRequest]
341 }
342 
343 final case class FrontPerformanceTimings(
344   connectStart: Long,
345   connectEnd: Long,
346   domComplete: Long,
347   domContentLoadedEventEnd: Long,
348   domContentLoadedEventStart: Long,
349   domInteractive: Long,
350   domLoading: Long,
351   domainLookupEnd: Long,
352   domainLookupStart: Long,
353   fetchStart: Long,
354   loadEventEnd: Long,
355   loadEventStart: Long,
356   navigationStart: Long,
357   redirectEnd: Long,
358   redirectStart: Long,
359   requestStart: Long,
360   responseEnd: Long,
361   responseStart: Long,
362   secureConnectionStart: Long,
363   unloadEventEnd: Long,
364   unloadEventStart: Long
365 )
366 object FrontPerformanceTimings {
367   implicit val decoder: Decoder[FrontPerformanceTimings] = deriveDecoder[FrontPerformanceTimings]
368 }
369 
370 final case class DemographicsV2TrackingRequest(
371   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
372   demographicsCardId: DemographicsCardId,
373   @(ApiModelProperty @field)(dataType = "string", example = "18-24")
374   value: Option[String],
375   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
376   questionId: QuestionId,
377   @(ApiModelProperty @field)(dataType = "string", example = "core", required = true)
378   source: String,
379   @(ApiModelProperty @field)(dataType = "string", example = "FR", required = true)
380   country: Country,
381   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
382   sessionId: Option[SessionId],
383   @(ApiModelProperty @field)(dataType = "map[string]", required = true)
384   parameters: Map[String, String],
385   @(ApiModelProperty @field)(dataType = "string", example = "yFUMk1+KSVeFh0NQnTXrdA==", required = true)
386   token: String
387 ) {
388   def toEvent(applicationName: Option[ApplicationName], cardDataType: String): DemographicEvent =
389     DemographicEvent(
390       demographic = cardDataType,
391       value = value.getOrElse(DemographicsCard.SKIPPED),
392       questionId = questionId,
393       source = source,
394       country = country,
395       applicationName = applicationName,
396       sessionId = sessionId,
397       parameters = parameters,
398       autoSubmit = false
399     )
400 
401 }
402 
403 object DemographicsV2TrackingRequest {
404   implicit val decoder: Decoder[DemographicsV2TrackingRequest] = deriveDecoder[DemographicsV2TrackingRequest]
405 }