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.sessionhistory
21 
22 import org.make.api.technical.MakeEventSerializer
23 import org.make.api.technical.security.SecurityConfiguration
24 import org.make.core.{RequestContextLanguage, RequestContextQuestion, SprayJsonFormatters}
25 import org.make.core.question.QuestionId
26 import org.make.core.reference.Language
27 import spray.json.DefaultJsonProtocol._
28 import spray.json.JsObject
29 import spray.json.lenses.JsonLenses._
30 import stamina._
31 import stamina.json.{from, JsonPersister}
32 
33 final class SessionHistorySerializers(securityConfiguration: SecurityConfiguration) extends SprayJsonFormatters {
34 
35   private val activeSessionSerializer: JsonPersister[Active, V2] = json.persister[Active, V2](
36     "active-session",
37     from[V1]
38       .to[V2](
39         _.update(
40           "sessionHistory" / "events" / * / "context" / "questionContext" ! set[RequestContextQuestion](
41             RequestContextQuestion.empty
42           )
43         ).update(
44           "sessionHistory" / "events" / * / "context" / "languageContext" ! set[RequestContextLanguage](
45             RequestContextLanguage.empty
46           )
47         )
48       )
49   )
50 
51   private val closedSessionSerializer: JsonPersister[Closed, V1] = json.persister[Closed]("closed-session")
52 
53   private val transformingSessionSerializer: JsonPersister[Transforming, V2] =
54     json.persister[Transforming, V2](
55       "transforming-session",
56       from[V1]
57         .to[V2](
58           _.update(
59             "sessionHistory" / "events" / * / "context" / "questionContext" ! set[RequestContextQuestion](
60               RequestContextQuestion.empty
61             )
62           ).update(
63               "sessionHistory" / "events" / * / "context" / "languageContext" ! set[RequestContextLanguage](
64                 RequestContextLanguage.empty
65               )
66             )
67             .update("requestContext" / "questionContext" ! set[RequestContextQuestion](RequestContextQuestion.empty))
68             .update("requestContext" / "languageContext" ! set[RequestContextLanguage](RequestContextLanguage.empty))
69         )
70     )
71 
72   private val expiredSessionSerializer: JsonPersister[Expired, V1] = json.persister[Expired]("expired-session")
73 
74   private val logSessionSearchEventSerializer: JsonPersister[LogSessionSearchProposalsEvent, V4] =
75     json.persister[LogSessionSearchProposalsEvent, V4](
76       "session-history-search-proposal",
77       from[V1]
78         .to[V2](_.update("context" / "customData" ! set[Map[String, String]](Map.empty)))
79         .to[V3](
80           _.update(
81             "context" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))
82           )
83         )
84         .to[V4] { json =>
85           val language = json.extract[Language]("context" / "language".?)
86           val question = json.extract[String]("context" / "question".?)
87           val questionId = json.extract[QuestionId]("context" / "questionId".?)
88           json
89             .update(
90               "context" / "questionContext" ! set[RequestContextQuestion](
91                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
92               )
93             )
94             .update(
95               "context" / "languageContext" ! set[RequestContextLanguage](
96                 RequestContextLanguage.empty.copy(language = language)
97               )
98             )
99         }
100     )
101 
102   private val logSessionVoteEventSerializer: JsonPersister[LogSessionVoteEvent, V5] =
103     json.persister[LogSessionVoteEvent, V5](
104       "session-history-vote-proposal",
105       from[V1]
106         .to[V2](_.update("action" / "arguments" / "trust" ! set[String]("trusted")))
107         .to[V3](_.update("context" / "customData" ! set[Map[String, String]](Map.empty)))
108         .to[V4](
109           _.update(
110             "context" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))
111           )
112         )
113         .to[V5] { json =>
114           val language = json.extract[Language]("context" / "language".?)
115           val question = json.extract[String]("context" / "question".?)
116           val questionId = json.extract[QuestionId]("context" / "questionId".?)
117           json
118             .update(
119               "context" / "questionContext" ! set[RequestContextQuestion](
120                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
121               )
122             )
123             .update(
124               "context" / "languageContext" ! set[RequestContextLanguage](
125                 RequestContextLanguage.empty.copy(language = language)
126               )
127             )
128         }
129     )
130 
131   private val logSessionUnvoteEventSerializer: JsonPersister[LogSessionUnvoteEvent, V5] =
132     json.persister[LogSessionUnvoteEvent, V5](
133       "session-history-unvote-proposal",
134       from[V1]
135         .to[V2](_.update("action" / "arguments" / "trust" ! set[String]("trusted")))
136         .to[V3](_.update("context" / "customData" ! set[Map[String, String]](Map.empty)))
137         .to[V4](
138           _.update(
139             "context" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))
140           )
141         )
142         .to[V5] { json =>
143           val language = json.extract[Language]("context" / "language".?)
144           val question = json.extract[String]("context" / "question".?)
145           val questionId = json.extract[QuestionId]("context" / "questionId".?)
146           json
147             .update(
148               "context" / "questionContext" ! set[RequestContextQuestion](
149                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
150               )
151             )
152             .update(
153               "context" / "languageContext" ! set[RequestContextLanguage](
154                 RequestContextLanguage.empty.copy(language = language)
155               )
156             )
157         }
158     )
159 
160   private val logSessionQualificationEventSerializer: JsonPersister[LogSessionQualificationEvent, V5] =
161     json.persister[LogSessionQualificationEvent, V5](
162       "session-history-qualificaion-vote",
163       from[V1]
164         .to[V2](_.update("action" / "arguments" / "trust" ! set[String]("trusted")))
165         .to[V3](_.update("context" / "customData" ! set[Map[String, String]](Map.empty)))
166         .to[V4](
167           _.update(
168             "context" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))
169           )
170         )
171         .to[V5] { json =>
172           val language = json.extract[Language]("context" / "language".?)
173           val question = json.extract[String]("context" / "question".?)
174           val questionId = json.extract[QuestionId]("context" / "questionId".?)
175           json
176             .update(
177               "context" / "questionContext" ! set[RequestContextQuestion](
178                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
179               )
180             )
181             .update(
182               "context" / "languageContext" ! set[RequestContextLanguage](
183                 RequestContextLanguage.empty.copy(language = language)
184               )
185             )
186         }
187     )
188 
189   private val logSessionUnqualificationEventSerializer: JsonPersister[LogSessionUnqualificationEvent, V5] =
190     json.persister[LogSessionUnqualificationEvent, V5](
191       "session-history-unqualificaion-vote",
192       from[V1]
193         .to[V2](_.update("action" / "arguments" / "trust" ! set[String]("trusted")))
194         .to[V3](_.update("context" / "customData" ! set[Map[String, String]](Map.empty)))
195         .to[V4](
196           _.update(
197             "context" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))
198           )
199         )
200         .to[V5] { json =>
201           val language = json.extract[Language]("context" / "language".?)
202           val question = json.extract[String]("context" / "question".?)
203           val questionId = json.extract[QuestionId]("context" / "questionId".?)
204           json
205             .update(
206               "context" / "questionContext" ! set[RequestContextQuestion](
207                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
208               )
209             )
210             .update(
211               "context" / "languageContext" ! set[RequestContextLanguage](
212                 RequestContextLanguage.empty.copy(language = language)
213               )
214             )
215         }
216     )
217 
218   private val logSessionTransformedEventSerializer: JsonPersister[SessionTransformed, V4] =
219     json.persister[SessionTransformed, V4](
220       "session-transformed",
221       from[V1]
222         .to[V2](_.update("context" / "customData" ! set[Map[String, String]](Map.empty)))
223         .to[V3](
224           _.update(
225             "context" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))
226           )
227         )
228         .to[V4] { json =>
229           val language = json.extract[Language]("context" / "language".?)
230           val question = json.extract[String]("context" / "question".?)
231           val questionId = json.extract[QuestionId]("context" / "questionId".?)
232           json
233             .update(
234               "context" / "questionContext" ! set[RequestContextQuestion](
235                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
236               )
237             )
238             .update(
239               "context" / "languageContext" ! set[RequestContextLanguage](
240                 RequestContextLanguage.empty.copy(language = language)
241               )
242             )
243         }
244     )
245 
246   private val logSessionExpiredSerializer: JsonPersister[SessionExpired, V3] =
247     json.persister[SessionExpired, V3](
248       "session-expired",
249       from[V1]
250         .to[V2](
251           _.update(
252             "context" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))
253           )
254         )
255         .to[V3] { json =>
256           val language = json.extract[Language]("context" / "language".?)
257           val question = json.extract[String]("context" / "question".?)
258           val questionId = json.extract[QuestionId]("context" / "questionId".?)
259           json
260             .update(
261               "context" / "questionContext" ! set[RequestContextQuestion](
262                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
263               )
264             )
265             .update(
266               "context" / "languageContext" ! set[RequestContextLanguage](
267                 RequestContextLanguage.empty.copy(language = language)
268               )
269             )
270         }
271     )
272 
273   private val logSessionStartSequenceEventSerializer: JsonPersister[LogSessionStartSequenceEvent, V4] =
274     json.persister[LogSessionStartSequenceEvent, V4](
275       "session-history-start-sequence",
276       from[V1]
277         .to[V2](_.update("context" / "customData" ! set[Map[String, String]](Map.empty)))
278         .to[V3](
279           _.update(
280             "context" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))
281           )
282         )
283         .to[V4] { json =>
284           val language = json.extract[Language]("context" / "language".?)
285           val question = json.extract[String]("context" / "question".?)
286           val questionId = json.extract[QuestionId]("context" / "questionId".?)
287           json
288             .update(
289               "context" / "questionContext" ! set[RequestContextQuestion](
290                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
291               )
292             )
293             .update(
294               "context" / "languageContext" ! set[RequestContextLanguage](
295                 RequestContextLanguage.empty.copy(language = language)
296               )
297             )
298         }
299     )
300 
301   private val SessionHistorySerializer: JsonPersister[SessionHistory, V5] =
302     json.persister[SessionHistory, V5](
303       "session-history",
304       from[V1]
305         .to[V2] { json =>
306           val eventsToMigrate = Set(
307             "LogSessionVoteEvent",
308             "LogSessionUnvoteEvent",
309             "LogSessionQualificationEvent",
310             "LogSessionUnqualificationEvent"
311           )
312           json.update(
313             "events" /
314               filter("type".is[String](value => eventsToMigrate.contains(value))) /
315               "action" /
316               "arguments" /
317               "trust" !
318               set[String]("trusted")
319           )
320         }
321         .to[V3](_.update("events" / * / "context" / "customData" ! set[Map[String, String]](Map.empty)))
322         .to[V4](
323           _.update(
324             "events" / * / "context" ! modify[JsObject](
325               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
326             )
327           )
328         )
329         .to[V5](
330           _.update(
331             "events" / * / "context" / "questionContext" ! set[RequestContextQuestion](RequestContextQuestion.empty)
332           ).update(
333             "events" / * / "context" / "languageContext" ! set[RequestContextLanguage](RequestContextLanguage.empty)
334           )
335         )
336     )
337 
338   private val saveLastEventDateSerializer: JsonPersister[SaveLastEventDate, V3] =
339     json.persister[SaveLastEventDate, V3](
340       "save-last-event-date",
341       from[V1]
342         .to[V2](
343           _.update(
344             "context" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))
345           )
346         )
347         .to[V3] { json =>
348           val language = json.extract[Language]("context" / "language".?)
349           val question = json.extract[String]("context" / "question".?)
350           val questionId = json.extract[QuestionId]("context" / "questionId".?)
351           json
352             .update(
353               "context" / "questionContext" ! set[RequestContextQuestion](
354                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
355               )
356             )
357             .update(
358               "context" / "languageContext" ! set[RequestContextLanguage](
359                 RequestContextLanguage.empty.copy(language = language)
360               )
361             )
362         }
363     )
364 
365   private val sessionTransformingEventSerializer: JsonPersister[SessionTransforming, V2] =
366     json.persister[SessionTransforming, V2](
367       "session-transforming-event",
368       from[V1]
369         .to[V2] { json =>
370           val language = json.extract[Language]("context" / "language".?)
371           val question = json.extract[String]("context" / "question".?)
372           val questionId = json.extract[QuestionId]("context" / "questionId".?)
373           json
374             .update(
375               "context" / "questionContext" ! set[RequestContextQuestion](
376                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
377               )
378             )
379             .update(
380               "context" / "languageContext" ! set[RequestContextLanguage](
381                 RequestContextLanguage.empty.copy(language = language)
382               )
383             )
384         }
385     )
386 
387   val serializers: Seq[JsonPersister[_, _]] =
388     Seq(
389       activeSessionSerializer,
390       closedSessionSerializer,
391       transformingSessionSerializer,
392       expiredSessionSerializer,
393       logSessionSearchEventSerializer,
394       logSessionVoteEventSerializer,
395       logSessionUnvoteEventSerializer,
396       logSessionQualificationEventSerializer,
397       logSessionUnqualificationEventSerializer,
398       logSessionTransformedEventSerializer,
399       logSessionExpiredSerializer,
400       logSessionStartSequenceEventSerializer,
401       saveLastEventDateSerializer,
402       SessionHistorySerializer,
403       sessionTransformingEventSerializer
404     )
405 }
406 
407 object SessionHistorySerializers {
408   def apply(securityConfiguration: SecurityConfiguration): SessionHistorySerializers =
409     new SessionHistorySerializers(securityConfiguration)
410 }