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.userhistory
21 
22 import org.make.api.proposal.PublishedProposalEvent.{
23   ProposalAccepted,
24   ProposalLocked,
25   ProposalPostponed,
26   ProposalRefused
27 }
28 import org.make.api.user.Anonymization
29 import org.make.core.SprayJsonFormatters._
30 import org.make.core.history.HistoryActions.VoteTrust
31 import org.make.core.operation.OperationId
32 import org.make.core.proposal.{ProposalId, QualificationKey, VoteKey}
33 import org.make.core.question.QuestionId
34 import org.make.core.reference.{Country, ThemeId}
35 import org.make.core.user._
36 import org.make.core.{MakeSerializable, RequestContext}
37 import spray.json.DefaultJsonProtocol._
38 import spray.json._
39 
40 import java.time.ZonedDateTime
41 
42 final case class UserAction[T](date: ZonedDateTime, actionType: String, arguments: T)
43 
44 object UserAction {
45   implicit def userActionUserRegisteredFormatted[T](implicit formatter: JsonFormat[T]): RootJsonFormat[UserAction[T]] =
46     DefaultJsonProtocol.jsonFormat3[ZonedDateTime, String, T, UserAction[T]](
47       (date: ZonedDateTime, action: String, parameter: T) => UserAction[T](date, action, parameter)
48     )
49 
50 }
51 
52 sealed trait Protagonist
53 
54 case object Moderator extends Protagonist
55 case object Citizen extends Protagonist
56 
57 sealed trait UserHistoryEvent[T] extends UserPersistentEvent with MakeSerializable {
58   def requestContext: RequestContext
59   def action: UserAction[T]
60   def protagonist: Protagonist
61 }
62 
63 sealed trait TransactionalUserHistoryEvent[T] extends UserHistoryEvent[T]
64 
65 object UserHistoryEvent {
66   implicit val format: RootJsonFormat[UserHistoryEvent[_]] =
67     new RootJsonFormat[UserHistoryEvent[_]] {
68       override def read(json: JsValue): UserHistoryEvent[_] = {
69         json.asJsObject.getFields("type") match {
70           case Seq(JsString("LogUserSearchProposalsEvent"))      => json.convertTo[LogUserSearchProposalsEvent]
71           case Seq(JsString("LogUserVoteEvent"))                 => json.convertTo[LogUserVoteEvent]
72           case Seq(JsString("LogUserUnvoteEvent"))               => json.convertTo[LogUserUnvoteEvent]
73           case Seq(JsString("LogUserQualificationEvent"))        => json.convertTo[LogUserQualificationEvent]
74           case Seq(JsString("LogUserUnqualificationEvent"))      => json.convertTo[LogUserUnqualificationEvent]
75           case Seq(JsString("LogRegisterCitizenEvent"))          => json.convertTo[LogRegisterCitizenEvent]
76           case Seq(JsString("LogUserProposalEvent"))             => json.convertTo[LogUserProposalEvent]
77           case Seq(JsString("LogAcceptProposalEvent"))           => json.convertTo[LogAcceptProposalEvent]
78           case Seq(JsString("LogRefuseProposalEvent"))           => json.convertTo[LogRefuseProposalEvent]
79           case Seq(JsString("LogPostponeProposalEvent"))         => json.convertTo[LogPostponeProposalEvent]
80           case Seq(JsString("LogLockProposalEvent"))             => json.convertTo[LogLockProposalEvent]
81           case Seq(JsString("LogGetProposalDuplicatesEvent"))    => json.convertTo[LogGetProposalDuplicatesEvent]
82           case Seq(JsString("LogUserAddProposalsSequenceEvent")) => json.convertTo[LogUserAddProposalsSequenceEvent]
83           case Seq(JsString("LogUserCreateSequenceEvent"))       => json.convertTo[LogUserCreateSequenceEvent]
84           case Seq(JsString("LogUserRemoveProposalsSequenceEvent")) =>
85             json.convertTo[LogUserRemoveProposalsSequenceEvent]
86           case Seq(JsString("LogUserUpdateSequenceEvent"))       => json.convertTo[LogUserUpdateSequenceEvent]
87           case Seq(JsString("LogUserStartSequenceEvent"))        => json.convertTo[LogUserStartSequenceEvent]
88           case Seq(JsString("LogUserAnonymizedEvent"))           => json.convertTo[LogUserAnonymizedEvent]
89           case Seq(JsString("LogUserOptInNewsletterEvent"))      => json.convertTo[LogUserOptInNewsletterEvent]
90           case Seq(JsString("LogUserOptOutNewsletterEvent"))     => json.convertTo[LogUserOptOutNewsletterEvent]
91           case Seq(JsString("LogUserConnectedEvent"))            => json.convertTo[LogUserConnectedEvent]
92           case Seq(JsString("LogUserUploadedAvatarEvent"))       => json.convertTo[LogUserUploadedAvatarEvent]
93           case Seq(JsString("LogOrganisationEmailChangedEvent")) => json.convertTo[LogOrganisationEmailChangedEvent]
94           case Seq(JsString("LogPersonalityEmailChangedEvent"))  => json.convertTo[LogPersonalityEmailChangedEvent]
95         }
96       }
97 
98       override def write(obj: UserHistoryEvent[_]): JsObject = {
99         JsObject((obj match {
100           case event: LogUserSearchProposalsEvent         => event.toJson
101           case event: LogUserVoteEvent                    => event.toJson
102           case event: LogUserUnvoteEvent                  => event.toJson
103           case event: LogUserQualificationEvent           => event.toJson
104           case event: LogUserUnqualificationEvent         => event.toJson
105           case event: LogRegisterCitizenEvent             => event.toJson
106           case event: LogUserProposalEvent                => event.toJson
107           case event: LogAcceptProposalEvent              => event.toJson
108           case event: LogRefuseProposalEvent              => event.toJson
109           case event: LogPostponeProposalEvent            => event.toJson
110           case event: LogLockProposalEvent                => event.toJson
111           case event: LogGetProposalDuplicatesEvent       => event.toJson
112           case event: LogUserAddProposalsSequenceEvent    => event.toJson
113           case event: LogUserCreateSequenceEvent          => event.toJson
114           case event: LogUserRemoveProposalsSequenceEvent => event.toJson
115           case event: LogUserUpdateSequenceEvent          => event.toJson
116           case event: LogUserStartSequenceEvent           => event.toJson
117           case event: LogUserAnonymizedEvent              => event.toJson
118           case event: LogUserOptInNewsletterEvent         => event.toJson
119           case event: LogUserOptOutNewsletterEvent        => event.toJson
120           case event: LogUserConnectedEvent               => event.toJson
121           case event: LogUserUploadedAvatarEvent          => event.toJson
122           case event: LogOrganisationEmailChangedEvent    => event.toJson
123           case event: LogPersonalityEmailChangedEvent     => event.toJson
124         }).asJsObject.fields + ("type" -> JsString(obj.productPrefix)))
125       }
126     }
127 
128 }
129 
130 final case class UserSearchParameters(term: String)
131 
132 object UserSearchParameters {
133   implicit val searchParametersFormatted: RootJsonFormat[UserSearchParameters] =
134     DefaultJsonProtocol.jsonFormat1(UserSearchParameters.apply)
135 }
136 
137 final case class StartSequenceParameters(
138   slug: Option[String],
139   questionId: Option[QuestionId],
140   includedProposals: Seq[ProposalId] = Seq.empty
141 )
142 object StartSequenceParameters {
143   implicit val searchParametersFormatted: RootJsonFormat[StartSequenceParameters] =
144     DefaultJsonProtocol.jsonFormat3(StartSequenceParameters.apply)
145 }
146 
147 final case class UserRegistered(firstName: Option[String], country: Country = Country("FR"))
148 
149 object UserRegistered {
150   implicit val userRegisteredFormatted: RootJsonFormat[UserRegistered] =
151     DefaultJsonProtocol.jsonFormat2(UserRegistered.apply)
152 
153 }
154 
155 final case class UserProposal(content: String)
156 
157 object UserProposal {
158   implicit val userProposalFormatted: RootJsonFormat[UserProposal] =
159     DefaultJsonProtocol.jsonFormat1(UserProposal.apply)
160 
161 }
162 
163 final case class UserVote(proposalId: ProposalId, voteKey: VoteKey, trust: VoteTrust)
164 
165 object UserVote {
166   implicit val userVoteFormatted: RootJsonFormat[UserVote] =
167     DefaultJsonProtocol.jsonFormat3(UserVote.apply)
168 
169 }
170 
171 final case class UserUnvote(proposalId: ProposalId, voteKey: VoteKey, trust: VoteTrust)
172 
173 object UserUnvote {
174   implicit val userUnvoteFormatted: RootJsonFormat[UserUnvote] =
175     DefaultJsonProtocol.jsonFormat3(UserUnvote.apply)
176 
177 }
178 
179 final case class UserQualification(proposalId: ProposalId, qualificationKey: QualificationKey, trust: VoteTrust)
180 
181 object UserQualification {
182   implicit val userQualificationFormatted: RootJsonFormat[UserQualification] =
183     DefaultJsonProtocol.jsonFormat3(UserQualification.apply)
184 
185 }
186 
187 final case class UserUnqualification(proposalId: ProposalId, qualificationKey: QualificationKey, trust: VoteTrust)
188 
189 object UserUnqualification {
190   implicit val userUnqualificationFormatted: RootJsonFormat[UserUnqualification] =
191     DefaultJsonProtocol.jsonFormat3(UserUnqualification.apply)
192 
193 }
194 
195 final case class LogUserSearchProposalsEvent(
196   userId: UserId,
197   requestContext: RequestContext,
198   action: UserAction[UserSearchParameters]
199 ) extends TransactionalUserHistoryEvent[UserSearchParameters] {
200   override val protagonist: Protagonist = Citizen
201 }
202 
203 // User actions
204 object LogUserSearchProposalsEvent {
205   val action: String = "search"
206 
207   implicit val logUserSearchProposalsEventFormatted: RootJsonFormat[LogUserSearchProposalsEvent] =
208     DefaultJsonProtocol.jsonFormat(LogUserSearchProposalsEvent.apply, "userId", "context", "action")
209 
210 }
211 
212 final case class LogGetProposalDuplicatesEvent(
213   userId: UserId,
214   requestContext: RequestContext,
215   action: UserAction[ProposalId]
216 ) extends UserHistoryEvent[ProposalId] {
217   override val protagonist: Protagonist = Moderator
218 }
219 
220 object LogGetProposalDuplicatesEvent {
221   val action: String = "duplicates"
222 
223   implicit val format: RootJsonFormat[LogGetProposalDuplicatesEvent] =
224     DefaultJsonProtocol.jsonFormat(LogGetProposalDuplicatesEvent.apply, "userId", "context", "action")
225 }
226 
227 final case class LogAcceptProposalEvent(
228   userId: UserId,
229   requestContext: RequestContext,
230   action: UserAction[ProposalAccepted]
231 ) extends UserHistoryEvent[ProposalAccepted] {
232   override val protagonist: Protagonist = Moderator
233 }
234 
235 object LogAcceptProposalEvent {
236   val action: String = "accept-proposal"
237 
238   implicit val logAcceptProposalEventFormatted: RootJsonFormat[LogAcceptProposalEvent] =
239     DefaultJsonProtocol.jsonFormat(LogAcceptProposalEvent.apply, "userId", "context", "action")
240 
241 }
242 
243 final case class LogRefuseProposalEvent(
244   userId: UserId,
245   requestContext: RequestContext,
246   action: UserAction[ProposalRefused]
247 ) extends UserHistoryEvent[ProposalRefused] {
248   override val protagonist: Protagonist = Moderator
249 }
250 
251 object LogRefuseProposalEvent {
252   val action: String = "refuse-proposal"
253 
254   implicit val logRefuseProposalEventFormatted: RootJsonFormat[LogRefuseProposalEvent] =
255     DefaultJsonProtocol.jsonFormat(LogRefuseProposalEvent.apply, "userId", "context", "action")
256 
257 }
258 
259 final case class LogPostponeProposalEvent(
260   userId: UserId,
261   requestContext: RequestContext,
262   action: UserAction[ProposalPostponed]
263 ) extends UserHistoryEvent[ProposalPostponed] {
264   override val protagonist: Protagonist = Moderator
265 }
266 
267 object LogPostponeProposalEvent {
268   val action: String = "postpone-proposal"
269 
270   implicit val logPostponeProposalEventFormatted: RootJsonFormat[LogPostponeProposalEvent] =
271     DefaultJsonProtocol.jsonFormat(LogPostponeProposalEvent.apply, "userId", "context", "action")
272 }
273 
274 final case class LogLockProposalEvent(
275   userId: UserId,
276   moderatorName: Option[String],
277   requestContext: RequestContext,
278   action: UserAction[ProposalLocked]
279 ) extends UserHistoryEvent[ProposalLocked] {
280   override val protagonist: Protagonist = Moderator
281 }
282 
283 object LogLockProposalEvent {
284   val action: String = "lock-proposal"
285 
286   implicit val logLockProposalEventFormatted: RootJsonFormat[LogLockProposalEvent] =
287     DefaultJsonProtocol.jsonFormat(LogLockProposalEvent.apply, "userId", "moderatorName", "context", "action")
288 
289 }
290 
291 object LogRegisterCitizenEvent {
292   val action: String = "register"
293 
294   implicit val logRegisterCitizenEventFormatted: RootJsonFormat[LogRegisterCitizenEvent] =
295     DefaultJsonProtocol.jsonFormat(LogRegisterCitizenEvent.apply, "userId", "context", "action")
296 
297 }
298 
299 final case class LogUserProposalEvent(userId: UserId, requestContext: RequestContext, action: UserAction[UserProposal])
300     extends UserHistoryEvent[UserProposal] {
301   override val protagonist: Protagonist = Citizen
302 }
303 
304 object LogUserProposalEvent {
305   val action: String = "propose"
306   implicit val logUserProposalEventFormatted: RootJsonFormat[LogUserProposalEvent] =
307     DefaultJsonProtocol.jsonFormat(LogUserProposalEvent.apply, "userId", "context", "action")
308 
309 }
310 
311 final case class LogUserVoteEvent(userId: UserId, requestContext: RequestContext, action: UserAction[UserVote])
312     extends TransactionalUserHistoryEvent[UserVote] {
313   override val protagonist: Protagonist = Citizen
314 }
315 
316 object LogUserVoteEvent {
317   val action: String = "vote"
318 
319   implicit val logUserVoteEventFormatted: RootJsonFormat[LogUserVoteEvent] =
320     DefaultJsonProtocol.jsonFormat(LogUserVoteEvent.apply, "userId", "context", "action")
321 
322 }
323 
324 final case class LogUserUnvoteEvent(userId: UserId, requestContext: RequestContext, action: UserAction[UserUnvote])
325     extends TransactionalUserHistoryEvent[UserUnvote] {
326   override val protagonist: Protagonist = Citizen
327 }
328 
329 object LogUserUnvoteEvent {
330   val action: String = "unvote"
331 
332   implicit val logUserUnvoteEventFormatted: RootJsonFormat[LogUserUnvoteEvent] =
333     DefaultJsonProtocol.jsonFormat(LogUserUnvoteEvent.apply, "userId", "context", "action")
334 
335 }
336 
337 final case class LogUserQualificationEvent(
338   userId: UserId,
339   requestContext: RequestContext,
340   action: UserAction[UserQualification]
341 ) extends TransactionalUserHistoryEvent[UserQualification] {
342   override val protagonist: Protagonist = Citizen
343 }
344 
345 object LogUserQualificationEvent {
346   val action: String = "qualification"
347 
348   implicit val logUserQualifEventFormatted: RootJsonFormat[LogUserQualificationEvent] =
349     DefaultJsonProtocol.jsonFormat(LogUserQualificationEvent.apply, "userId", "context", "action")
350 
351 }
352 
353 final case class LogUserUnqualificationEvent(
354   userId: UserId,
355   requestContext: RequestContext,
356   action: UserAction[UserUnqualification]
357 ) extends TransactionalUserHistoryEvent[UserUnqualification] {
358   override val protagonist: Protagonist = Citizen
359 }
360 
361 object LogUserUnqualificationEvent {
362   val action: String = "unqualification"
363 
364   implicit val logUserUnqualifEventFormatted: RootJsonFormat[LogUserUnqualificationEvent] =
365     DefaultJsonProtocol.jsonFormat(LogUserUnqualificationEvent.apply, "userId", "context", "action")
366 
367 }
368 
369 final case class LogRegisterCitizenEvent(
370   userId: UserId,
371   requestContext: RequestContext,
372   action: UserAction[UserRegistered]
373 ) extends UserHistoryEvent[UserRegistered] {
374   override val protagonist: Protagonist = Citizen
375 }
376 
377 final case class LogUserCreateSequenceEvent(
378   userId: UserId,
379   requestContext: RequestContext,
380   action: UserAction[SequenceCreated]
381 ) extends UserHistoryEvent[SequenceCreated] {
382   override val protagonist: Protagonist = Moderator
383 }
384 
385 object LogUserCreateSequenceEvent {
386   val action: String = "create-sequence"
387 
388   implicit val logUserCreateSequenceEventFormatted: RootJsonFormat[LogUserCreateSequenceEvent] =
389     DefaultJsonProtocol.jsonFormat(LogUserCreateSequenceEvent.apply, "userId", "context", "action")
390 }
391 
392 final case class LogUserAddProposalsSequenceEvent(
393   userId: UserId,
394   requestContext: RequestContext,
395   action: UserAction[SequenceProposalsAdded]
396 ) extends UserHistoryEvent[SequenceProposalsAdded] {
397   override val protagonist: Protagonist = Moderator
398 }
399 
400 object LogUserAddProposalsSequenceEvent {
401   val action: String = "add-proposals-sequence"
402 
403   implicit val logUserAddProposalsSequenceEventFormatted: RootJsonFormat[LogUserAddProposalsSequenceEvent] =
404     DefaultJsonProtocol.jsonFormat(LogUserAddProposalsSequenceEvent.apply, "userId", "context", "action")
405 }
406 
407 final case class LogUserRemoveProposalsSequenceEvent(
408   userId: UserId,
409   requestContext: RequestContext,
410   action: UserAction[SequenceProposalsRemoved]
411 ) extends UserHistoryEvent[SequenceProposalsRemoved] {
412   override val protagonist: Protagonist = Moderator
413 }
414 object LogUserRemoveProposalsSequenceEvent {
415   val action: String = "remove-proposals-sequence"
416 
417   implicit val logUserRemoveProposalsSequenceEvent: RootJsonFormat[LogUserRemoveProposalsSequenceEvent] =
418     DefaultJsonProtocol.jsonFormat(LogUserRemoveProposalsSequenceEvent.apply, "userId", "context", "action")
419 }
420 
421 final case class LogUserUpdateSequenceEvent(
422   userId: UserId,
423   requestContext: RequestContext,
424   action: UserAction[SequenceUpdated]
425 ) extends UserHistoryEvent[SequenceUpdated] {
426   override val protagonist: Protagonist = Moderator
427 }
428 object LogUserUpdateSequenceEvent {
429   val action: String = "update-sequence"
430 
431   implicit val logUserUpdateSequenceEventFormatted: RootJsonFormat[LogUserUpdateSequenceEvent] =
432     DefaultJsonProtocol.jsonFormat(LogUserUpdateSequenceEvent.apply, "userId", "context", "action")
433 }
434 
435 final case class LogUserStartSequenceEvent(
436   userId: UserId,
437   requestContext: RequestContext,
438   action: UserAction[StartSequenceParameters]
439 ) extends TransactionalUserHistoryEvent[StartSequenceParameters] {
440   override val protagonist: Protagonist = Citizen
441 }
442 
443 object LogUserStartSequenceEvent {
444   val action: String = "start-sequence"
445 
446   implicit val logUserStartSequenceEventFormatted: RootJsonFormat[LogUserStartSequenceEvent] =
447     DefaultJsonProtocol.jsonFormat(LogUserStartSequenceEvent.apply, "userId", "context", "action")
448 
449 }
450 
451 final case class SequenceProposalsAdded(
452   proposalIds: Seq[ProposalId],
453   requestContext: RequestContext,
454   eventDate: ZonedDateTime,
455   userId: UserId
456 ) {
457 
458   def version(): Int = MakeSerializable.V1
459 }
460 
461 object SequenceProposalsAdded {
462   val actionType: String = "sequence-proposal-added"
463 
464   implicit val sequenceProposalsAddedFormatter: RootJsonFormat[SequenceProposalsAdded] =
465     DefaultJsonProtocol.jsonFormat4(SequenceProposalsAdded.apply)
466 }
467 
468 final case class SequenceProposalsRemoved(
469   proposalIds: Seq[ProposalId],
470   requestContext: RequestContext,
471   eventDate: ZonedDateTime,
472   userId: UserId
473 ) {
474 
475   def version(): Int = MakeSerializable.V1
476 }
477 
478 object SequenceProposalsRemoved {
479   val actionType: String = "sequence-proposal-added"
480 
481   implicit val sequenceProposalsRemovedFormatter: RootJsonFormat[SequenceProposalsRemoved] =
482     DefaultJsonProtocol.jsonFormat4(SequenceProposalsRemoved.apply)
483 
484 }
485 
486 final case class SequenceCreated(
487   slug: String,
488   requestContext: RequestContext,
489   userId: UserId,
490   eventDate: ZonedDateTime,
491   title: String,
492   themeIds: Seq[ThemeId] = Seq.empty,
493   operationId: Option[OperationId] = None,
494   searchable: Boolean
495 ) {
496   def version(): Int = MakeSerializable.V2
497 }
498 
499 object SequenceCreated {
500   val actionType: String = "sequence-created"
501 
502   implicit val sequenceCreatedFormatter: RootJsonFormat[SequenceCreated] =
503     DefaultJsonProtocol.jsonFormat8(SequenceCreated.apply)
504 }
505 
506 final case class SequenceUpdated(
507   userId: UserId,
508   eventDate: ZonedDateTime,
509   requestContext: RequestContext,
510   title: Option[String],
511   @Deprecated operation: Option[String] = None,
512   operationId: Option[OperationId] = None,
513   themeIds: Seq[ThemeId] = Seq.empty
514 ) {
515   def version(): Int = MakeSerializable.V2
516 }
517 
518 object SequenceUpdated {
519   val actionType: String = "sequence-updated"
520 
521   implicit val sequenceUpdated: RootJsonFormat[SequenceUpdated] =
522     DefaultJsonProtocol.jsonFormat7(SequenceUpdated.apply)
523 }
524 
525 final case class LogUserAnonymizedEvent(
526   userId: UserId,
527   requestContext: RequestContext,
528   action: UserAction[UserAnonymized]
529 ) extends UserHistoryEvent[UserAnonymized] {
530   override val protagonist: Protagonist = Citizen
531 }
532 
533 object LogUserAnonymizedEvent {
534   val action: String = "anonymize-user"
535 
536   implicit val logUserAnonymizedEventFormatted: RootJsonFormat[LogUserAnonymizedEvent] =
537     DefaultJsonProtocol.jsonFormat(LogUserAnonymizedEvent.apply, "userId", "context", "action")
538 
539 }
540 
541 final case class UserAnonymized(userId: UserId, adminId: UserId, mode: Anonymization) {
542   def version(): Int = MakeSerializable.V2
543 }
544 
545 object UserAnonymized {
546   val actionType: String = "user-anonymized"
547 
548   implicit val userAnonymized: RootJsonFormat[UserAnonymized] =
549     DefaultJsonProtocol.jsonFormat3(UserAnonymized.apply)
550 }
551 
552 final case class LogUserOptInNewsletterEvent(
553   userId: UserId,
554   requestContext: RequestContext,
555   action: UserAction[UserUpdatedOptIn]
556 ) extends UserHistoryEvent[UserUpdatedOptIn] {
557   override val protagonist: Protagonist = Citizen
558 }
559 
560 object LogUserOptInNewsletterEvent {
561   val action: String = "opt-in-user"
562 
563   implicit val logUserOptInNewsletterEventFormatted: RootJsonFormat[LogUserOptInNewsletterEvent] =
564     DefaultJsonProtocol.jsonFormat(LogUserOptInNewsletterEvent.apply, "userId", "context", "action")
565 
566 }
567 
568 final case class LogUserOptOutNewsletterEvent(
569   userId: UserId,
570   requestContext: RequestContext,
571   action: UserAction[UserUpdatedOptIn]
572 ) extends UserHistoryEvent[UserUpdatedOptIn] {
573   override val protagonist: Protagonist = Citizen
574 }
575 
576 object LogUserOptOutNewsletterEvent {
577   val action: String = "opt-out-user"
578 
579   implicit val logUserOptOutNewsletterEventFormatted: RootJsonFormat[LogUserOptOutNewsletterEvent] =
580     DefaultJsonProtocol.jsonFormat(LogUserOptOutNewsletterEvent.apply, "userId", "context", "action")
581 
582 }
583 
584 final case class UserUpdatedOptIn(newOptIn: Boolean) {
585   def version(): Int = MakeSerializable.V1
586 }
587 
588 object UserUpdatedOptIn {
589   val actionType: String = "user-updated-opt-in"
590 
591   implicit val userUpdatedOptIn: RootJsonFormat[UserUpdatedOptIn] =
592     DefaultJsonProtocol.jsonFormat1(UserUpdatedOptIn.apply)
593 }
594 
595 final case class LogUserConnectedEvent(
596   userId: UserId,
597   requestContext: RequestContext,
598   action: UserAction[UserHasConnected]
599 ) extends UserHistoryEvent[UserHasConnected] {
600   override val protagonist: Protagonist = Citizen
601 }
602 
603 object LogUserConnectedEvent {
604   val action: String = "connect-user"
605 
606   implicit val logUserConnectedEventFormatted: RootJsonFormat[LogUserConnectedEvent] =
607     DefaultJsonProtocol.jsonFormat(LogUserConnectedEvent.apply, "userId", "context", "action")
608 
609 }
610 
611 final case class UserHasConnected() {
612   def version(): Int = MakeSerializable.V1
613 }
614 
615 case object UserHasConnected {
616   val actionType: String = "user-connected"
617 
618   implicit val userHasConnected: RootJsonFormat[UserHasConnected] =
619     DefaultJsonProtocol.jsonFormat0(UserHasConnected.apply _)
620 }
621 
622 final case class LogUserUploadedAvatarEvent(
623   userId: UserId,
624   requestContext: RequestContext,
625   action: UserAction[UploadedAvatar]
626 ) extends UserHistoryEvent[UploadedAvatar] {
627   override val protagonist: Protagonist = Citizen
628 }
629 
630 object LogUserUploadedAvatarEvent {
631   val action: String = "user-upload-avatar"
632 
633   implicit val logUserUploadedAvatarEventFormatted: RootJsonFormat[LogUserUploadedAvatarEvent] =
634     DefaultJsonProtocol.jsonFormat(LogUserUploadedAvatarEvent.apply, "userId", "context", "action")
635 
636 }
637 
638 final case class UploadedAvatar(avatarUrl: String) {
639   def version(): Int = MakeSerializable.V1
640 }
641 
642 case object UploadedAvatar {
643   val actionType: String = "uploaded-avatar"
644 
645   implicit val uploadedAvatar: RootJsonFormat[UploadedAvatar] =
646     DefaultJsonProtocol.jsonFormat1(UploadedAvatar.apply)
647 }
648 
649 final case class LogOrganisationEmailChangedEvent(
650   userId: UserId,
651   requestContext: RequestContext,
652   action: UserAction[OrganisationEmailChanged]
653 ) extends UserHistoryEvent[OrganisationEmailChanged] {
654   override val protagonist: Protagonist = Citizen
655 }
656 
657 object LogOrganisationEmailChangedEvent {
658   val action: String = "organisation-email-changed"
659 
660   implicit val logOrganisationEmailChangedEvent: RootJsonFormat[LogOrganisationEmailChangedEvent] =
661     DefaultJsonProtocol.jsonFormat(LogOrganisationEmailChangedEvent.apply, "userId", "context", "action")
662 
663 }
664 
665 final case class LogPersonalityEmailChangedEvent(
666   userId: UserId,
667   requestContext: RequestContext,
668   action: UserAction[PersonalityEmailChanged]
669 ) extends UserHistoryEvent[PersonalityEmailChanged] {
670   override val protagonist: Protagonist = Citizen
671 }
672 
673 object LogPersonalityEmailChangedEvent {
674   val action: String = "organisation-email-changed"
675 
676   implicit val logPersonalityEmailChangedEvent: RootJsonFormat[LogPersonalityEmailChangedEvent] =
677     DefaultJsonProtocol.jsonFormat(LogPersonalityEmailChangedEvent.apply, "userId", "context", "action")
678 
679 }
680 
681 final case class OrganisationEmailChanged(oldEmail: String, newEmail: String) {
682   def version(): Int = MakeSerializable.V1
683 }
684 
685 case object OrganisationEmailChanged {
686   val actionType: String = "email-changed"
687 
688   implicit val organisationEmailChanged: RootJsonFormat[OrganisationEmailChanged] =
689     DefaultJsonProtocol.jsonFormat2(OrganisationEmailChanged.apply)
690 }
691 
692 final case class PersonalityEmailChanged(oldEmail: String, newEmail: String) {
693   def version(): Int = MakeSerializable.V1
694 }
695 
696 case object PersonalityEmailChanged {
697   val actionType: String = "email-changed"
698 
699   implicit val personalityEmailChanged: RootJsonFormat[PersonalityEmailChanged] =
700     DefaultJsonProtocol.jsonFormat2(PersonalityEmailChanged.apply)
701 }