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.proposal
21 
22 import org.make.api.proposal.ProposalActor.State
23 import org.make.api.proposal.ProposalEvent._
24 import org.make.api.proposal.PublishedProposalEvent._
25 import org.make.api.technical.MakeEventSerializer
26 import org.make.api.technical.security.SecurityConfiguration
27 import org.make.core.proposal._
28 import org.make.core.question.QuestionId
29 import org.make.core.reference.Language
30 import org.make.core.technical.Multilingual
31 import org.make.core.user.UserId
32 import org.make.core.{RequestContextLanguage, RequestContextQuestion, SprayJsonFormatters}
33 import spray.json.DefaultJsonProtocol._
34 import spray.json.lenses.JsonLenses._
35 import spray.json.{DefaultJsonProtocol, JsObject, RootJsonFormat}
36 import stamina._
37 import stamina.json._
38 
39 import java.time.ZonedDateTime
40 import scala.util.chaining.scalaUtilChainingOps
41 
42 final class ProposalSerializers(securityConfiguration: SecurityConfiguration) extends SprayJsonFormatters {
43 
44   private val proposalProposedSerializer: JsonPersister[ProposalProposed, V9] =
45     persister[ProposalProposed, V9](
46       "proposal-proposed",
47       from[V1]
48         .to[V2](
49           _.update("language" ! set[Option[String]](Some("fr")))
50             .update("country" ! set[Option[String]](Some("FR")))
51         )
52         .to[V3] {
53           _.update("initialProposal" ! set[Boolean](false))
54         }
55         .to[V4](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
56         .to[V5](
57           _.update(
58             "requestContext" ! modify[JsObject](
59               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
60             )
61           )
62         )
63         .to[V6] { json =>
64           val language = json.extract[String]("language".?)
65           json.update("submittedAsLanguage" ! set(language))
66         }
67         .to[V7] { json =>
68           val language = json.extract[Language]("requestContext" / "language".?)
69           val question = json.extract[String]("requestContext" / "question".?)
70           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
71           json
72             .update(
73               "requestContext" / "questionContext" ! set[RequestContextQuestion](
74                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
75               )
76             )
77             .update(
78               "requestContext" / "languageContext" ! set[RequestContextLanguage](
79                 RequestContextLanguage.empty.copy(language = language)
80               )
81             )
82         }
83         .to[V8] {
84           _.update("isAnonymous" ! set[Boolean](false))
85         }
86         .to[V9] { json =>
87           val isInitial = json.extract[Boolean]("initialProposal")
88           if (isInitial) {
89             json.update("proposalType" ! set[ProposalType](ProposalType.ProposalTypeInitial))
90           } else {
91             json.update("proposalType" ! set[ProposalType](ProposalType.ProposalTypeSubmitted))
92           }
93         }
94     )
95 
96   private val proposalViewedSerializer: JsonPersister[ProposalViewed, V4] =
97     persister[ProposalViewed, V4](
98       "proposal-viewed",
99       from[V1]
100         .to[V2](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
101         .to[V3](
102           _.update(
103             "requestContext" ! modify[JsObject](
104               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
105             )
106           )
107         )
108         .to[V4] { json =>
109           val language = json.extract[Language]("requestContext" / "language".?)
110           val question = json.extract[String]("requestContext" / "question".?)
111           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
112           json
113             .update(
114               "requestContext" / "questionContext" ! set[RequestContextQuestion](
115                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
116               )
117             )
118             .update(
119               "requestContext" / "languageContext" ! set[RequestContextLanguage](
120                 RequestContextLanguage.empty.copy(language = language)
121               )
122             )
123         }
124     )
125 
126   private val proposalUpdatedSerializer: JsonPersister[ProposalUpdated, V4] =
127     persister[ProposalUpdated, V4](
128       "proposal-updated",
129       from[V1]
130         .to[V2](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
131         .to[V3](
132           _.update(
133             "requestContext" ! modify[JsObject](
134               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
135             )
136           )
137         )
138         .to[V4] { json =>
139           val language = json.extract[Language]("requestContext" / "language".?)
140           val question = json.extract[String]("requestContext" / "question".?)
141           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
142           json
143             .update(
144               "requestContext" / "questionContext" ! set[RequestContextQuestion](
145                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
146               )
147             )
148             .update(
149               "requestContext" / "languageContext" ! set[RequestContextLanguage](
150                 RequestContextLanguage.empty.copy(language = language)
151               )
152             )
153         }
154     )
155 
156   private val proposalAcceptedSerializer: JsonPersister[ProposalAccepted, V4] =
157     persister[ProposalAccepted, V4](
158       "proposal-accepted",
159       from[V1]
160         .to[V2](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
161         .to[V3](
162           _.update(
163             "requestContext" ! modify[JsObject](
164               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
165             )
166           )
167         )
168         .to[V4] { json =>
169           val language = json.extract[Language]("requestContext" / "language".?)
170           val question = json.extract[String]("requestContext" / "question".?)
171           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
172           json
173             .update(
174               "requestContext" / "questionContext" ! set[RequestContextQuestion](
175                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
176               )
177             )
178             .update(
179               "requestContext" / "languageContext" ! set[RequestContextLanguage](
180                 RequestContextLanguage.empty.copy(language = language)
181               )
182             )
183         }
184     )
185 
186   private val proposalRefusedSerializer: JsonPersister[ProposalRefused, V4] =
187     persister[ProposalRefused, V4](
188       "proposal-refused",
189       from[V1]
190         .to[V2](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
191         .to[V3](
192           _.update(
193             "requestContext" ! modify[JsObject](
194               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
195             )
196           )
197         )
198         .to[V4] { json =>
199           val language = json.extract[Language]("requestContext" / "language".?)
200           val question = json.extract[String]("requestContext" / "question".?)
201           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
202           json
203             .update(
204               "requestContext" / "questionContext" ! set[RequestContextQuestion](
205                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
206               )
207             )
208             .update(
209               "requestContext" / "languageContext" ! set[RequestContextLanguage](
210                 RequestContextLanguage.empty.copy(language = language)
211               )
212             )
213         }
214     )
215 
216   private val proposalPostponedSerializer: JsonPersister[ProposalPostponed, V4] =
217     persister[ProposalPostponed, V4](
218       "proposal-postponed",
219       from[V1]
220         .to[V2](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
221         .to[V3](
222           _.update(
223             "requestContext" ! modify[JsObject](
224               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
225             )
226           )
227         )
228         .to[V4] { json =>
229           val language = json.extract[Language]("requestContext" / "language".?)
230           val question = json.extract[String]("requestContext" / "question".?)
231           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
232           json
233             .update(
234               "requestContext" / "questionContext" ! set[RequestContextQuestion](
235                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
236               )
237             )
238             .update(
239               "requestContext" / "languageContext" ! set[RequestContextLanguage](
240                 RequestContextLanguage.empty.copy(language = language)
241               )
242             )
243         }
244     )
245 
246   private val proposalVotesVerifiedUpdatedSerializer: JsonPersister[ProposalVotesVerifiedUpdated, V4] =
247     persister[ProposalVotesVerifiedUpdated, V4](
248       "proposal-votes-verified-updated",
249       from[V1]
250         .to[V2](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
251         .to[V3](
252           _.update(
253             "requestContext" ! modify[JsObject](
254               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
255             )
256           )
257         )
258         .to[V4] { json =>
259           val updatedVerifiedVotes = json.extract[Seq[Vote]]("votesVerified")
260           json.update(
261             "updatedVerifiedVotes" ! set[Option[VotingOptions]](
262               Some(LegacyVotesConverter.convertSeqToVotingOptions(updatedVerifiedVotes))
263             )
264           )
265         }
266     )
267 
268   private val proposalVotesUpdatedSerializer: JsonPersister[ProposalVotesUpdated, V4] =
269     persister[ProposalVotesUpdated, V4](
270       "proposal-votes-updated",
271       from[V1]
272         .to[V2](
273           _.update(
274             "requestContext" ! modify[JsObject](
275               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
276             )
277           )
278         )
279         .to[V3] { json =>
280           val updatedVotes = json.extract[Seq[Vote]]("newVotes")
281           json.update(
282             "updatedVotes" ! set[Option[VotingOptions]](
283               Some(LegacyVotesConverter.convertSeqToVotingOptions(updatedVotes))
284             )
285           )
286         }
287         .to[V4] { json =>
288           val language = json.extract[Language]("requestContext" / "language".?)
289           val question = json.extract[String]("requestContext" / "question".?)
290           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
291           json
292             .update(
293               "requestContext" / "questionContext" ! set[RequestContextQuestion](
294                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
295               )
296             )
297             .update(
298               "requestContext" / "languageContext" ! set[RequestContextLanguage](
299                 RequestContextLanguage.empty.copy(language = language)
300               )
301             )
302         }
303     )
304 
305   private val proposalVotedSerializer: JsonPersister[ProposalVoted, V7] =
306     persister[ProposalVoted, V7](
307       "proposal-voted",
308       from[V1]
309         .to[V2](_.update("organisationInfo" ! set[Option[OrganisationInfo]](None)))
310         .to[V3] { json =>
311           val organisationId =
312             json.extract[Option[OrganisationInfo]]("organisationInfo".?).flatMap(_.map(_.organisationId.value))
313           organisationId.fold(json) { id =>
314             json.update("maybeOrganisationId" ! set[String](id))
315           }
316         }
317         .to[V4](_.update("voteTrust" ! set[String]("trusted")))
318         .to[V5](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
319         .to[V6](
320           _.update(
321             "requestContext" ! modify[JsObject](
322               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
323             )
324           )
325         )
326         .to[V7] { json =>
327           val language = json.extract[Language]("requestContext" / "language".?)
328           val question = json.extract[String]("requestContext" / "question".?)
329           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
330           json
331             .update(
332               "requestContext" / "questionContext" ! set[RequestContextQuestion](
333                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
334               )
335             )
336             .update(
337               "requestContext" / "languageContext" ! set[RequestContextLanguage](
338                 RequestContextLanguage.empty.copy(language = language)
339               )
340             )
341         }
342     )
343 
344   private val proposalUnvotedSerializer: JsonPersister[ProposalUnvoted, V7] =
345     persister[ProposalUnvoted, V7](
346       "proposal-unvoted",
347       from[V1]
348         .to[V2](_.update("organisationInfo" ! set[Option[OrganisationInfo]](None)))
349         .to[V3] { json =>
350           val organisationInfo =
351             json.extract[Option[OrganisationInfo]]("organisationInfo".?).flatMap(_.map(_.organisationId.value))
352           organisationInfo.fold(json) { id =>
353             json.update("maybeOrganisationId" ! set[String](id))
354           }
355         }
356         .to[V4](_.update("voteTrust" ! set[String]("trusted")))
357         .to[V5](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
358         .to[V6](
359           _.update(
360             "requestContext" ! modify[JsObject](
361               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
362             )
363           )
364         )
365         .to[V7] { json =>
366           val language = json.extract[Language]("requestContext" / "language".?)
367           val question = json.extract[String]("requestContext" / "question".?)
368           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
369           json
370             .update(
371               "requestContext" / "questionContext" ! set[RequestContextQuestion](
372                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
373               )
374             )
375             .update(
376               "requestContext" / "languageContext" ! set[RequestContextLanguage](
377                 RequestContextLanguage.empty.copy(language = language)
378               )
379             )
380         }
381     )
382 
383   private val proposalQualifiedSerializer: JsonPersister[ProposalQualified, V5] =
384     persister[ProposalQualified, V5](
385       "proposal-qualified",
386       from[V1]
387         .to[V2](_.update("voteTrust" ! set[String]("trusted")))
388         .to[V3](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
389         .to[V4](
390           _.update(
391             "requestContext" ! modify[JsObject](
392               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
393             )
394           )
395         )
396         .to[V5] { json =>
397           val language = json.extract[Language]("requestContext" / "language".?)
398           val question = json.extract[String]("requestContext" / "question".?)
399           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
400           json
401             .update(
402               "requestContext" / "questionContext" ! set[RequestContextQuestion](
403                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
404               )
405             )
406             .update(
407               "requestContext" / "languageContext" ! set[RequestContextLanguage](
408                 RequestContextLanguage.empty.copy(language = language)
409               )
410             )
411         }
412     )
413 
414   private val proposalUnqualifiedSerializer: JsonPersister[ProposalUnqualified, V5] =
415     persister[ProposalUnqualified, V5](
416       "proposal-unqualified",
417       from[V1]
418         .to[V2](_.update("voteTrust" ! set[String]("trusted")))
419         .to[V3](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
420         .to[V4](
421           _.update(
422             "requestContext" ! modify[JsObject](
423               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
424             )
425           )
426         )
427         .to[V5] { json =>
428           val language = json.extract[Language]("requestContext" / "language".?)
429           val question = json.extract[String]("requestContext" / "question".?)
430           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
431           json
432             .update(
433               "requestContext" / "questionContext" ! set[RequestContextQuestion](
434                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
435               )
436             )
437             .update(
438               "requestContext" / "languageContext" ! set[RequestContextLanguage](
439                 RequestContextLanguage.empty.copy(language = language)
440               )
441             )
442         }
443     )
444 
445   private val similarProposalsAddedSerializer: JsonPersister[SimilarProposalsAdded, V4] =
446     persister[SimilarProposalsAdded, V4](
447       "similar-proposals-added",
448       from[V1]
449         .to[V2](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
450         .to[V3](
451           _.update(
452             "requestContext" ! modify[JsObject](
453               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
454             )
455           )
456         )
457         .to[V4] { json =>
458           val language = json.extract[Language]("requestContext" / "language".?)
459           val question = json.extract[String]("requestContext" / "question".?)
460           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
461           json
462             .update(
463               "requestContext" / "questionContext" ! set[RequestContextQuestion](
464                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
465               )
466             )
467             .update(
468               "requestContext" / "languageContext" ! set[RequestContextLanguage](
469                 RequestContextLanguage.empty.copy(language = language)
470               )
471             )
472         }
473     )
474 
475   private val proposalLockedSerializer: JsonPersister[ProposalLocked, V4] =
476     persister[ProposalLocked, V4](
477       "proposal-locked",
478       from[V1]
479         .to[V2](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
480         .to[V3](
481           _.update(
482             "requestContext" ! modify[JsObject](
483               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
484             )
485           )
486         )
487         .to[V4] { json =>
488           val language = json.extract[Language]("requestContext" / "language".?)
489           val question = json.extract[String]("requestContext" / "question".?)
490           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
491           json
492             .update(
493               "requestContext" / "questionContext" ! set[RequestContextQuestion](
494                 RequestContextQuestion.empty.copy(question = question, questionId = questionId)
495               )
496             )
497             .update(
498               "requestContext" / "languageContext" ! set[RequestContextLanguage](
499                 RequestContextLanguage.empty.copy(language = language)
500               )
501             )
502         }
503     )
504 
505   private[proposal] val proposalStateSerializer: JsonPersister[State, V16] = {
506     final case class QualificationV5(key: QualificationKey, count: Int)
507     implicit val qualificationV5Formatter: RootJsonFormat[QualificationV5] =
508       DefaultJsonProtocol.jsonFormat2(QualificationV5.apply)
509 
510     final case class VoteV5(key: VoteKey, count: Int, qualifications: Seq[QualificationV5])
511     implicit val voteV5Formatter: RootJsonFormat[VoteV5] =
512       DefaultJsonProtocol.jsonFormat3(VoteV5.apply)
513 
514     final case class QualificationV6(key: QualificationKey, count: Int, countVerified: Int)
515     implicit val qualificationV6formatter: RootJsonFormat[QualificationV6] =
516       DefaultJsonProtocol.jsonFormat3(QualificationV6.apply)
517 
518     final case class VoteV6(key: VoteKey, count: Int, countVerified: Int, qualifications: Seq[QualificationV6])
519     implicit val voteV6formatter: RootJsonFormat[VoteV6] =
520       DefaultJsonProtocol.jsonFormat4(VoteV6.apply)
521 
522     final case class QualificationV8(
523       key: QualificationKey,
524       count: Int,
525       countVerified: Int,
526       countSequence: Int,
527       countSegment: Int
528     )
529     implicit val qualificationV8formatter: RootJsonFormat[QualificationV8] =
530       DefaultJsonProtocol.jsonFormat5(QualificationV8.apply)
531 
532     final case class VoteV8(
533       key: VoteKey,
534       count: Int,
535       countVerified: Int,
536       countSequence: Int,
537       countSegment: Int,
538       qualifications: Seq[QualificationV8]
539     )
540 
541     implicit val voteV8formatter: RootJsonFormat[VoteV8] =
542       DefaultJsonProtocol.jsonFormat6(VoteV8.apply)
543 
544     persister[State, V16](
545       "proposalState",
546       from[V1]
547         .to[V2](
548           _.update("proposal" / "language" ! set[Option[String]](Some("fr")))
549             .update("proposal" / "country" ! set[Option[String]](Some("FR")))
550         )
551         .to[V3](_.update("proposal" / "organisations" ! set[Seq[OrganisationInfo]](Seq.empty)))
552         .to[V4] { json =>
553           val organisationInfos = json.extract[Seq[OrganisationInfo]]("proposal" / "organisations")
554           json.update("proposal" / "organisationIds" ! set[Seq[UserId]](organisationInfos.map(_.organisationId)))
555         }
556         .to[V5] {
557           _.update("proposal" / "initialProposal" ! set[Boolean](false))
558         }
559         .to[V6] { json =>
560           val votes: Seq[VoteV6] = json
561             .extract[Seq[VoteV5]]("proposal" / "votes")
562             .map(vote => {
563               val qualifications: Seq[QualificationV6] = vote.qualifications
564                 .map(qualification => QualificationV6(qualification.key, qualification.count, qualification.count))
565               VoteV6(vote.key, vote.count, vote.count, qualifications)
566             })
567           json.update("proposal" / "votes", votes)
568         }
569         .to[V7](_.update("proposal" / "creationContext" / "customData" ! set[Map[String, String]](Map.empty)))
570         .to[V8] { json =>
571           val votes: Seq[VoteV8] = json
572             .extract[Seq[VoteV6]]("proposal" / "votes")
573             .map(vote => {
574               val qualifications: Seq[QualificationV8] = vote.qualifications
575                 .map(
576                   qualification =>
577                     QualificationV8(
578                       key = qualification.key,
579                       count = qualification.count,
580                       countVerified = qualification.countVerified,
581                       countSequence = qualification.countVerified,
582                       countSegment = 0
583                     )
584                 )
585               VoteV8(
586                 key = vote.key,
587                 count = vote.count,
588                 countVerified = vote.countVerified,
589                 countSequence = vote.countVerified,
590                 countSegment = 0,
591                 qualifications = qualifications
592               )
593             })
594           json.update("proposal" / "votes", votes)
595         }
596         .to[V9] { json =>
597           json.update("proposal" / "keywords", Seq.empty[ProposalKeyword])
598         }
599         // format: off
600         .to[V10](
601           _.update(
602             "proposal" / "creationContext" ! modify[JsObject](
603               MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)
604             )
605           )
606         )
607         .to[V11] { json =>
608           json
609             .asJsObject.fields.get("proposal")
610             .fold(json)(
611               _
612                 .extract[Seq[VoteV8]]("votes")
613                 .map(vote =>
614                   Vote(
615                     key = vote.key,
616                     count = vote.count,
617                     countVerified = vote.countVerified,
618                     countSequence = vote.countSequence,
619                     countSegment = vote.countSegment,
620                     qualifications =
621                       vote.qualifications.map(q =>
622                         Qualification(
623                           key = q.key,
624                           count = q.count,
625                           countVerified = q.countVerified,
626                           countSequence = q.countSequence,
627                           countSegment = q.countSegment
628                         )
629                       )
630                   )
631                 )
632                 .pipe(LegacyVotesConverter.convertSeqToVotingOptions)
633                 .pipe(json.update("proposal" / "votes", _))
634             )
635         }
636         .to[V12] { json =>
637           json
638             .asJsObject.fields.get("proposal")
639             .fold(json)(
640               _.extract[Language]("creationContext" / "language".?)
641                 .pipe(json.update("proposal" / "submittedAsLanguage", _)
642                   .update("proposal" / "contentTranslations" ! set[Option[Multilingual[String]]](None)))
643             )
644         }
645         .to[V13] { json =>
646           json
647             .asJsObject.fields.get("proposal")
648             .fold(json) { j =>
649               (j.extract[Language]("creationContext" / "language".?),
650               j.extract[String]("creationContext" / "question".?),
651               j.extract[QuestionId]("creationContext" / "questionId".?)).pipe {
652                 case (language, question, questionId) =>
653                   json.update("proposal" / "creationContext" / "questionContext" ! set[RequestContextQuestion](RequestContextQuestion.empty.copy(question = question, questionId = questionId)))
654                     .update("proposal" / "creationContext" / "languageContext" ! set[RequestContextLanguage](RequestContextLanguage.empty.copy(language = language)))
655               }
656             }
657         }
658         .to[V14] { json =>
659           json
660             .asJsObject.fields.get("proposal")
661             .fold(json)(_ => json.update("proposal" / "isAnonymous" ! set[Boolean](false)))
662         }
663         .to[V15] {
664           _.update("proposal".? / "validatedAt" ! set[Option[ZonedDateTime]](None))
665             .update("proposal".? / "postponedAt" ! set[Option[ZonedDateTime]](None))
666         }
667         .to[V16] { json =>
668           json.asJsObject.fields.get("proposal").fold(json)(_ => {
669           val isInitial = json.extract[Boolean]("proposal" / "initialProposal")
670           if (isInitial) {
671             json.update("proposal" / "proposalType" ! set[ProposalType](ProposalType.ProposalTypeInitial))
672           } else {
673             json.update("proposal" / "proposalType" ! set[ProposalType](ProposalType.ProposalTypeSubmitted))
674           }})
675         }
676     )
677   }
678 
679   private val similarProposalRemovedSerializer: JsonPersister[SimilarProposalRemoved, V4] =
680     persister[SimilarProposalRemoved, V4](
681       "similar-proposal-removed",
682       from[V1].to[V2](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
683         .to[V3](_.update("requestContext" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))))
684         .to[V4] { json =>
685           val language = json.extract[Language]("requestContext" / "language".?)
686           val question = json.extract[String]("requestContext" / "question".?)
687           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
688           json.update("requestContext" / "questionContext" ! set[RequestContextQuestion](RequestContextQuestion.empty.copy(question = question, questionId = questionId)))
689             .update("requestContext" / "languageContext" ! set[RequestContextLanguage](RequestContextLanguage.empty.copy(language = language)))
690         }
691     )
692 
693   private val similarProposalsClearedSerializer: JsonPersister[SimilarProposalsCleared, V4] =
694     persister[SimilarProposalsCleared, V4](
695       "similar-proposals-cleared",
696       from[V1].to[V2](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
697         .to[V3](_.update("requestContext" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))))
698         .to[V4] { json =>
699           val language = json.extract[Language]("requestContext" / "language".?)
700           val question = json.extract[String]("requestContext" / "question".?)
701           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
702           json.update("requestContext" / "questionContext" ! set[RequestContextQuestion](RequestContextQuestion.empty.copy(question = question, questionId = questionId)))
703             .update("requestContext" / "languageContext" ! set[RequestContextLanguage](RequestContextLanguage.empty.copy(language = language)))
704         }
705     )
706 
707   private val proposalPatchedSerializer: JsonPersister[ProposalPatched, V14] = {
708 
709     final case class QualificationV4(key: QualificationKey, count: Int)
710     implicit val qualificationV4Formatter: RootJsonFormat[QualificationV4] =
711       DefaultJsonProtocol.jsonFormat2(QualificationV4.apply)
712 
713     final case class VoteV4(key: VoteKey, count: Int, qualifications: Seq[QualificationV4])
714     implicit val voteV4Formatter: RootJsonFormat[VoteV4] =
715       DefaultJsonProtocol.jsonFormat3(VoteV4.apply)
716 
717     final case class QualificationV5(key: QualificationKey, count: Int, countVerified: Int)
718     implicit val qualificationV5Formatter: RootJsonFormat[QualificationV5] =
719       DefaultJsonProtocol.jsonFormat3(QualificationV5.apply)
720 
721     final case class VoteV5(key: VoteKey, count: Int, countVerified: Int, qualifications: Seq[QualificationV5])
722     implicit val voteV5Formatter: RootJsonFormat[VoteV5] =
723       DefaultJsonProtocol.jsonFormat4(VoteV5.apply)
724 
725     final case class QualificationV7(
726       key: QualificationKey,
727       count: Int,
728       countVerified: Int,
729       countSequence: Int,
730       countSegment: Int
731     )
732     implicit val qualificationV7formatter: RootJsonFormat[QualificationV7] =
733       DefaultJsonProtocol.jsonFormat5(QualificationV7.apply)
734 
735     final case class VoteV7(
736       key: VoteKey,
737       count: Int,
738       countVerified: Int,
739       countSequence: Int,
740       countSegment: Int,
741       qualifications: Seq[QualificationV7]
742     )
743 
744     implicit val voteV7formatter: RootJsonFormat[VoteV7] =
745       DefaultJsonProtocol.jsonFormat6(VoteV7.apply)
746 
747     persister[ProposalPatched, V14](
748       "proposal-tags-updated",
749       from[V1]
750         .to[V2](_.update("proposal" / "organisations" ! set[Seq[OrganisationInfo]](Seq.empty)))
751         .to[V3] { json =>
752           val organisationInfos = json.extract[Seq[OrganisationInfo]]("proposal" / "organisations")
753           json.update("proposal" / "organisationIds" ! set[Seq[UserId]](organisationInfos.map(_.organisationId)))
754         }
755         .to[V4] {
756           _.update("proposal" / "initialProposal" ! set[Boolean](false))
757         }
758         .to[V5] { json =>
759           val votes: Seq[VoteV5] = json
760             .extract[Seq[VoteV4]]("proposal" / "votes")
761             .map(vote => {
762               val qualifications: Seq[QualificationV5] = vote.qualifications
763                 .map(qualification => QualificationV5(qualification.key, qualification.count, qualification.count))
764               VoteV5(vote.key, vote.count, vote.count, qualifications)
765             })
766           json.update("proposal" / "votes", votes)
767         }
768         .to[V6](
769           _.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty))
770             .update("proposal" / "creationContext" / "customData" ! set[Map[String, String]](Map.empty))
771         )
772         .to[V7] { json =>
773           val votes: Seq[VoteV7] = json
774             .extract[Seq[VoteV5]]("proposal" / "votes")
775             .map(vote => {
776               val qualifications: Seq[QualificationV7] = vote.qualifications
777                 .map(
778                   qualification =>
779                     QualificationV7(
780                       key = qualification.key,
781                       count = qualification.countVerified,
782                       countVerified = qualification.countVerified,
783                       countSequence = qualification.count,
784                       countSegment = 0
785                     )
786                 )
787               VoteV7(
788                 key = vote.key,
789                 count = vote.count,
790                 countVerified = vote.countVerified,
791                 countSequence = vote.countVerified,
792                 countSegment = 0,
793                 qualifications = qualifications
794               )
795             })
796           json.update("proposal" / "votes", votes)
797         }
798         .to[V8] { json =>
799           json.update("proposal" / "keywords", Seq.empty[ProposalKeyword])
800         }
801         .to[V9](_.update("requestContext" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)))
802           .update("proposal" / "creationContext" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt)))
803         )
804         .to[V10] { json =>
805           val language = json.extract[Language]("proposal" / "creationContext" / "language".?)
806           json.update("proposal" / "submittedAsLanguage" ! set[Option[Language]](language))
807             .update("proposal" / "contentTranslations" ! set[Option[Multilingual[String]]](None))
808         }
809         .to[V11] { json =>
810           val language = json.extract[Language]("proposal" / "creationContext" / "language".?)
811           val question = json.extract[String]("proposal" / "creationContext" / "question".?)
812           val questionId = json.extract[QuestionId]("proposal" / "creationContext" / "questionId".?)
813           json.update("proposal" / "creationContext" / "questionContext" ! set[RequestContextQuestion](RequestContextQuestion.empty.copy(question = question, questionId = questionId)))
814             .update("proposal" / "creationContext" / "languageContext" ! set[RequestContextLanguage](RequestContextLanguage.empty.copy(language = language)))
815             .update("requestContext" / "questionContext" ! set[RequestContextQuestion](RequestContextQuestion.empty.copy(question = question, questionId = questionId)))
816             .update("requestContext" / "languageContext" ! set[RequestContextLanguage](RequestContextLanguage.empty.copy(language = language)))
817         }
818         .to[V12] {
819           _.update("proposal" / "isAnonymous" ! set[Boolean](false))
820         }
821         .to[V13] {
822           _.update("proposal" / "validatedAt" ! set[Option[ZonedDateTime]](None))
823             .update("proposal" / "postponedAt" ! set[Option[ZonedDateTime]](None))
824         }
825         .to[V14] { json =>
826           val isInitial = json.extract[Boolean]("proposal" / "initialProposal")
827           if (isInitial) {
828             json.update("proposal" / "proposalType" ! set[ProposalType](ProposalType.ProposalTypeInitial))
829           } else {
830             json.update("proposal" / "proposalType" ! set[ProposalType](ProposalType.ProposalTypeSubmitted))
831           }
832         }
833     )
834   }
835 
836   private val proposalAnonymizedSerializer: JsonPersister[ProposalAnonymized, V4] =
837     persister[ProposalAnonymized, V4](
838       "proposal-anonymized",
839       from[V1].to[V2](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
840         .to[V3](_.update("requestContext" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))))
841         .to[V4] { json =>
842           val language = json.extract[Language]("requestContext" / "language".?)
843           val question = json.extract[String]("requestContext" / "question".?)
844           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
845           json.update("requestContext" / "questionContext" ! set[RequestContextQuestion](RequestContextQuestion.empty.copy(question = question, questionId = questionId)))
846             .update("requestContext" / "languageContext" ! set[RequestContextLanguage](RequestContextLanguage.empty.copy(language = language)))
847         }
848     )
849 
850   private val proposalAddedToOperationSerializer: JsonPersister[ProposalAddedToOperation, V4] =
851     persister[ProposalAddedToOperation, V4](
852       "proposal-added-to-operation",
853       from[V1].to[V2](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
854         .to[V3](_.update("requestContext" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))))
855         .to[V4] { json =>
856           val language = json.extract[Language]("requestContext" / "language".?)
857           val question = json.extract[String]("requestContext" / "question".?)
858           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
859           json.update("requestContext" / "questionContext" ! set[RequestContextQuestion](RequestContextQuestion.empty.copy(question = question, questionId = questionId)))
860             .update("requestContext" / "languageContext" ! set[RequestContextLanguage](RequestContextLanguage.empty.copy(language = language)))
861         }
862     )
863 
864   private val proposalRemovedFromOperationSerializer: JsonPersister[ProposalRemovedFromOperation, V4] =
865     persister[ProposalRemovedFromOperation, V4](
866       "proposal-removed-from-operation",
867       from[V1].to[V2](_.update("requestContext" / "customData" ! set[Map[String, String]](Map.empty)))
868         .to[V3](_.update("requestContext" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))))
869         .to[V4] { json =>
870           val language = json.extract[Language]("requestContext" / "language".?)
871           val question = json.extract[String]("requestContext" / "question".?)
872           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
873           json.update("requestContext" / "questionContext" ! set[RequestContextQuestion](RequestContextQuestion.empty.copy(question = question, questionId = questionId)))
874             .update("requestContext" / "languageContext" ! set[RequestContextLanguage](RequestContextLanguage.empty.copy(language = language)))
875         }
876     )
877 
878   private val proposalKeywordsSetSerializer: JsonPersister[ProposalKeywordsSet, V3] =
879     persister[ProposalKeywordsSet, V3]("proposal-keywords-set",
880       from[V1].to[V2](_.update("requestContext" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))))
881         .to[V3] { json =>
882           val language = json.extract[Language]("requestContext" / "language".?)
883           val question = json.extract[String]("requestContext" / "question".?)
884           val questionId = json.extract[QuestionId]("requestContext" / "questionId".?)
885           json.update("requestContext" / "questionContext" ! set[RequestContextQuestion](RequestContextQuestion.empty.copy(question = question, questionId = questionId)))
886             .update("requestContext" / "languageContext" ! set[RequestContextLanguage](RequestContextLanguage.empty.copy(language = language)))
887         }
888   )
889 
890   private val proposalSerializer: JsonPersister[Proposal, V8] =
891     persister[Proposal, V8]("proposal-entity", from[V1].to[V2](_.update("keywords", Seq.empty[ProposalKeyword]))
892       .to[V3](_.update("creationContext" ! modify[JsObject](MakeEventSerializer.setIpAddressAndHash(securityConfiguration.secureHashSalt))))
893       .to[V4] { json =>
894         val language = json.extract[Language]("creationContext" / "language".?)
895         json.update("submittedAsLanguage" ! set[Option[Language]](language))
896           .update("contentTranslations" ! set[Option[Multilingual[String]]](None))
897       }
898       .to[V5] { json =>
899         val language = json.extract[Language]("creationContext" / "language".?)
900         val question = json.extract[String]("creationContext" / "question".?)
901         val questionId = json.extract[QuestionId]("creationContext" / "questionId".?)
902         json.update("creationContext" / "questionContext" ! set[RequestContextQuestion](RequestContextQuestion.empty.copy(question = question, questionId = questionId)))
903           .update("creationContext" / "languageContext" ! set[RequestContextLanguage](RequestContextLanguage.empty.copy(language = language)))
904       }
905       .to[V6] {
906         _.update("isAnonymous" ! set[Boolean](false))
907       }
908       .to[V7] {
909         _.update("validatedAt" ! set[Option[ZonedDateTime]](None))
910           .update("postponedAt" ! set[Option[ZonedDateTime]](None))
911       }
912       .to[V8] { json =>
913         val isInitial = json.extract[Boolean]("initialProposal")
914         if (isInitial) {
915           json.update("proposalType" ! set[ProposalType](ProposalType.ProposalTypeInitial))
916         } else {
917           json.update("proposalType" ! set[ProposalType](ProposalType.ProposalTypeSubmitted))
918         }
919       }
920     )
921 
922   val serializers: Seq[JsonPersister[_, _]] =
923     Seq(
924       proposalProposedSerializer,
925       proposalViewedSerializer,
926       proposalUpdatedSerializer,
927       proposalAcceptedSerializer,
928       proposalRefusedSerializer,
929       proposalPostponedSerializer,
930       proposalVotesVerifiedUpdatedSerializer,
931       proposalVotesUpdatedSerializer,
932       proposalVotedSerializer,
933       proposalUnvotedSerializer,
934       proposalQualifiedSerializer,
935       proposalUnqualifiedSerializer,
936       proposalLockedSerializer,
937       proposalStateSerializer,
938       similarProposalsAddedSerializer,
939       similarProposalRemovedSerializer,
940       similarProposalsClearedSerializer,
941       proposalPatchedSerializer,
942       proposalAnonymizedSerializer,
943       proposalAddedToOperationSerializer,
944       proposalRemovedFromOperationSerializer,
945       proposalKeywordsSetSerializer,
946       proposalSerializer
947     )
948 }
949 
950 object ProposalSerializers {
951   def apply(securityConfiguration: SecurityConfiguration): ProposalSerializers =
952     new ProposalSerializers(securityConfiguration)
953 }