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 akka.actor.typed.scaladsl.Behaviors
23 import akka.actor.typed.{ActorRef, Behavior}
24 import akka.persistence.typed.scaladsl.{Effect, EventSourcedBehavior, ReplyEffect, RetentionCriteria}
25 import akka.persistence.typed.{PersistenceId, SnapshotAdapter}
26 import cats.implicits._
27 import grizzled.slf4j.Logging
28 import org.make.api.proposal.ProposalActorResponse.Error._
29 import org.make.api.proposal.ProposalActorResponse._
30 import org.make.api.proposal.ProposalEvent._
31 import org.make.api.proposal.PublishedProposalEvent._
32 import org.make.api.sessionhistory._
33 import org.make.api.technical.EffectBuilderHelper._
34 import org.make.core._
35 import org.make.core.history.HistoryActions.VoteTrust
36 import org.make.core.proposal.ProposalActionType._
37 import org.make.core.proposal.ProposalStatus.{Accepted, Postponed, Refused}
38 import org.make.core.proposal.QualificationKey._
39 import org.make.core.proposal.VoteKey._
40 import org.make.core.proposal._
41 import org.make.core.technical.IdGenerator
42 import org.make.core.user.UserId
43 import spray.json.DefaultJsonProtocol._
44 import spray.json.{DefaultJsonProtocol, RootJsonFormat}
45 
46 import java.time.temporal.ChronoUnit
47 import java.time.{LocalDate, ZoneOffset}
48 import scala.concurrent.ExecutionContext.Implicits.global
49 import scala.concurrent.Future
50 import scala.concurrent.duration.{Deadline, FiniteDuration}
51 import scala.util.{Failure, Success}
52 
53 object ProposalActor extends Logging {
54 
55   val JournalPluginId: String = "make-api.event-sourcing.proposals.journal"
56   val SnapshotPluginId: String = "make-api.event-sourcing.proposals.snapshot"
57   val QueryJournalPluginId: String = "make-api.event-sourcing.proposals.query"
58 
59   final case class State(proposal: Option[Proposal]) extends MakeSerializable {
60 
61     def getProposal: ProposalActorResponse[ProposalNotFound, Proposal] = proposal match {
62       case Some(proposal) => Envelope(proposal)
63       case _              => ProposalNotFound
64     }
65 
66     def getVotes(newProposalsVoteThreshold: Int): ProposalActorResponse[VoteError, VotesActorResponse] =
67       getProposal.flatMap(_.votingOptions match {
68         case Some(votingOptions) =>
69           val scores = VotingOptionsScores(votingOptions, newProposalsVoteThreshold)
70           val agree = VoteActorResponse(votingOptions.agreeVote, scores.agree)
71           val neutral = VoteActorResponse(votingOptions.neutralVote, scores.neutral)
72           val disagree = VoteActorResponse(votingOptions.disagreeVote, scores.disagree)
73           Envelope(VotesActorResponse(agree, disagree, neutral))
74         case None => VoteNotFound
75       })
76 
77     def getQualification(key: QualificationKey): ProposalActorResponse[QualificationError, Qualification] =
78       getProposal.flatMap(_.votingOptions match {
79         case Some(votingOptions) => Envelope(votingOptions.getQualification(key))
80         case None                => QualificationNotFound
81       })
82   }
83 
84   object State {
85     implicit val stateFormatter: RootJsonFormat[State] = DefaultJsonProtocol.jsonFormat1(State.apply)
86   }
87 
88   final case class ProposalLock(moderatorId: UserId, moderatorName: String, deadline: Deadline)
89 
90   class LockHandler(duration: FiniteDuration) {
91     var lock: Option[ProposalLock] = None
92     def take(id: UserId, name: Option[String]): Unit = {
93       lock = Some(ProposalLock(id, name.getOrElse("<unknown>"), duration.fromNow))
94     }
95   }
96 
97   def apply(
98     sessionHistoryCoordinatorService: SessionHistoryCoordinatorService,
99     lockDuration: FiniteDuration,
100     idGenerator: IdGenerator
101   ): Behavior[ProposalCommand] = {
102 
103     Behaviors.setup { implicit context =>
104       def commandHandler(lockHandler: LockHandler): (State, ProposalCommand) => ReplyEffect[ProposalEvent, State] = {
105         case (state, GetProposal(_, _, replyTo)) => Effect.reply(replyTo)(state.getProposal)
106         case (_, ViewProposalCommand(proposalId, requestContext, replyTo)) =>
107           onViewProposalCommand(proposalId, requestContext, replyTo)
108         case (_, command: ProposeCommand)                 => onProposeCommand(command)
109         case (state, command: UpdateProposalCommand)      => onUpdateProposalCommand(state, command)
110         case (state, command: UpdateProposalVotesCommand) => onUpdateProposalVotesCommand(state, command)
111         case (state, command: AcceptProposalCommand)      => onAcceptProposalCommand(state, command)
112         case (state, command: RefuseProposalCommand)      => onRefuseProposalCommand(state, command)
113         case (state, command: PostponeProposalCommand)    => onPostponeProposalCommand(state, command)
114         case (state, command: VoteProposalCommand)        => onVoteProposalCommand(state, command)
115         case (state, command: UnvoteProposalCommand)      => onUnvoteProposalCommand(state, command)
116         case (state, command: QualifyVoteCommand)         => onQualificationProposalCommand(state, command)
117         case (state, command: UnqualifyVoteCommand)       => onUnqualificationProposalCommand(state, command)
118         case (state, command: LockProposalCommand)        => onLockProposalCommand(state, command, lockHandler)
119         case (state, command: PatchProposalCommand)       => onPatchProposalCommand(state, command)
120         case (_, command: SetKeywordsCommand)             => onSetKeywordsCommand(command)
121         case (_, Stop(_, _, replyTo))                     => Effect.stop().thenReply(replyTo)(_ => Envelope(()))
122       }
123 
124       def onPatchProposalCommand(state: State, command: PatchProposalCommand): ReplyEffect[ProposalEvent, State] = {
125         state.proposal match {
126           case None => Effect.reply(command.replyTo)(ProposalNotFound)
127           case Some(proposal) =>
128             val changes = command.changes
129             val modifiedContext =
130               changes.creationContext.fold(proposal.creationContext) { contextChanges =>
131                 proposal.creationContext.copy(
132                   requestId = contextChanges.requestId.getOrElse(proposal.creationContext.requestId),
133                   sessionId = contextChanges.sessionId.getOrElse(proposal.creationContext.sessionId),
134                   visitorId = contextChanges.visitorId.orElse(proposal.creationContext.visitorId),
135                   visitorCreatedAt = contextChanges.visitorCreatedAt.orElse(proposal.creationContext.visitorCreatedAt),
136                   externalId = contextChanges.externalId.getOrElse(proposal.creationContext.externalId),
137                   country = contextChanges.country.orElse(proposal.creationContext.country),
138                   detectedCountry = contextChanges.detectedCountry.orElse(proposal.creationContext.detectedCountry),
139                   languageContext = proposal.creationContext.languageContext
140                     .copy(language = contextChanges.language.orElse(proposal.creationContext.languageContext.language)),
141                   operationId = contextChanges.operation.orElse(proposal.creationContext.operationId),
142                   source = contextChanges.source.orElse(proposal.creationContext.source),
143                   location = contextChanges.location.orElse(proposal.creationContext.location),
144                   questionContext = proposal.creationContext.questionContext.copy(
145                     question = contextChanges.question.orElse(proposal.creationContext.questionContext.question),
146                     questionId = contextChanges.questionId.orElse(proposal.creationContext.questionContext.questionId)
147                   ),
148                   hostname = contextChanges.hostname.orElse(proposal.creationContext.hostname),
149                   ipAddress = contextChanges.ipAddress.orElse(proposal.creationContext.ipAddress),
150                   ipAddressHash = contextChanges.ipAddressHash.orElse(proposal.creationContext.ipAddressHash),
151                   getParameters = contextChanges.getParameters.orElse(proposal.creationContext.getParameters),
152                   userAgent = contextChanges.userAgent.orElse(proposal.creationContext.userAgent),
153                   applicationName = contextChanges.applicationName.orElse(proposal.creationContext.applicationName),
154                   referrer = contextChanges.referrer.orElse(proposal.creationContext.referrer),
155                   customData = contextChanges.customData.getOrElse(proposal.creationContext.customData)
156                 )
157               }
158 
159             val modifiedProposal =
160               proposal.copy(
161                 slug = changes.slug.getOrElse(proposal.slug),
162                 content = changes.content.getOrElse(proposal.content),
163                 contentTranslations = changes.contentTranslations.orElse(proposal.contentTranslations),
164                 submittedAsLanguage = changes.submittedAsLanguage.orElse(proposal.submittedAsLanguage),
165                 author = changes.author.getOrElse(proposal.author),
166                 status = changes.status.getOrElse(proposal.status),
167                 refusalReason = changes.refusalReason.orElse(proposal.refusalReason),
168                 isAnonymous = changes.isAnonymous.getOrElse(proposal.isAnonymous),
169                 tags = changes.tags.getOrElse(proposal.tags),
170                 questionId = changes.questionId.orElse(proposal.questionId),
171                 creationContext = modifiedContext,
172                 idea = changes.ideaId.orElse(proposal.idea),
173                 operation = changes.operation.orElse(proposal.operation),
174                 updatedAt = Some(DateHelper.now()),
175                 initialProposal = changes.initialProposal.getOrElse(proposal.initialProposal),
176                 keywords = changes.keywords.getOrElse(proposal.keywords)
177               )
178 
179             val event = ProposalPatched(
180               id = command.proposalId,
181               requestContext = command.requestContext,
182               proposal = modifiedProposal,
183               eventDate = DateHelper.now(),
184               eventId = Some(idGenerator.nextEventId())
185             )
186             Effect
187               .persist[ProposalPatched, State](event)
188               .thenPublish(event)
189               .thenReply(command.replyTo)(_.getProposal)
190         }
191       }
192 
193       def onVoteProposalCommand(state: State, command: VoteProposalCommand): ReplyEffect[ProposalEvent, State] = {
194         state.proposal match {
195           case None => Effect.reply(command.replyTo)(ProposalNotFound)
196           case _ =>
197             command.vote match {
198               // User hasn't voted on proposal yet
199               case None =>
200                 val event = ProposalVoted(
201                   id = command.proposalId,
202                   maybeUserId = command.maybeUserId,
203                   eventDate = DateHelper.now(),
204                   maybeOrganisationId = command.maybeOrganisationId,
205                   requestContext = command.requestContext,
206                   voteKey = command.voteKey,
207                   voteTrust = command.voteTrust,
208                   eventId = Some(idGenerator.nextEventId())
209                 )
210                 Effect
211                   .persist[ProposalVoted, State](event)
212                   .thenPublish(event)
213                   .thenRun { s =>
214                     logVoteEvent(event).onComplete {
215                       case Success(_) => command.replyTo ! s.getVotes(command.newProposalsVoteThreshold)
216                       case Failure(e) => command.replyTo ! HistoryError(e)
217                     }
218                   }
219                   .thenNoReply()
220               // User has already voted on this proposal with this vote key (e.g.: double click)
221               case Some(vote) if vote.voteKey == command.voteKey =>
222                 Effect.reply(command.replyTo)(state.getVotes(command.newProposalsVoteThreshold))
223               // User has already voted with another key. Behaviour: first, unvote previous vote then, revote with new key
224               case Some(vote) =>
225                 val unvoteEvent = ProposalUnvoted(
226                   id = command.proposalId,
227                   maybeUserId = command.maybeUserId,
228                   eventDate = DateHelper.now(),
229                   requestContext = command.requestContext,
230                   voteKey = vote.voteKey,
231                   maybeOrganisationId = command.maybeOrganisationId,
232                   voteTrust = vote.trust,
233                   selectedQualifications = vote.qualificationKeys.keys.toSeq,
234                   eventId = Some(idGenerator.nextEventId())
235                 )
236                 val voteEvent = ProposalVoted(
237                   id = command.proposalId,
238                   maybeUserId = command.maybeUserId,
239                   eventDate = DateHelper.now(),
240                   maybeOrganisationId = command.maybeOrganisationId,
241                   requestContext = command.requestContext,
242                   voteKey = command.voteKey,
243                   voteTrust = command.voteTrust,
244                   eventId = Some(idGenerator.nextEventId())
245                 )
246                 Effect
247                   .persist[ProposalEvent, State](Seq(unvoteEvent, voteEvent))
248                   .thenPublish(unvoteEvent)
249                   .thenPublish(voteEvent)
250                   .thenRun { s =>
251                     (logUnvoteEvent(unvoteEvent) >> logVoteEvent(voteEvent)).onComplete {
252                       case Success(_) => command.replyTo ! s.getVotes(command.newProposalsVoteThreshold)
253                       case Failure(e) => command.replyTo ! HistoryError(e)
254                     }
255                   }
256                   .thenNoReply()
257             }
258         }
259       }
260 
261       def logVoteEvent(event: ProposalVoted): Future[_] = {
262         sessionHistoryCoordinatorService.logTransactionalHistory(
263           LogSessionVoteEvent(
264             sessionId = event.requestContext.sessionId,
265             requestContext = event.requestContext,
266             action = SessionAction(
267               date = event.eventDate,
268               actionType = ProposalVoteAction.value,
269               SessionVote(proposalId = event.id, voteKey = event.voteKey, trust = event.voteTrust)
270             )
271           )
272         )
273       }
274 
275       def logUnvoteEvent(event: ProposalUnvoted): Future[_] = {
276         sessionHistoryCoordinatorService.logTransactionalHistory(
277           LogSessionUnvoteEvent(
278             sessionId = event.requestContext.sessionId,
279             requestContext = event.requestContext,
280             action = SessionAction(
281               date = event.eventDate,
282               actionType = ProposalUnvoteAction.value,
283               SessionUnvote(proposalId = event.id, voteKey = event.voteKey, trust = event.voteTrust)
284             )
285           )
286         )
287       }
288 
289       def logQualifyVoteEvent(event: ProposalQualified): Future[_] = {
290         sessionHistoryCoordinatorService.logTransactionalHistory(
291           LogSessionQualificationEvent(
292             sessionId = event.requestContext.sessionId,
293             requestContext = event.requestContext,
294             action = SessionAction(
295               date = event.eventDate,
296               actionType = ProposalQualifyAction.value,
297               SessionQualification(
298                 proposalId = event.id,
299                 qualificationKey = event.qualificationKey,
300                 trust = event.voteTrust
301               )
302             )
303           )
304         )
305       }
306 
307       def logRemoveVoteQualificationEvent(event: ProposalUnqualified): Future[_] = {
308         sessionHistoryCoordinatorService.logTransactionalHistory(
309           LogSessionUnqualificationEvent(
310             sessionId = event.requestContext.sessionId,
311             requestContext = event.requestContext,
312             action = SessionAction(
313               date = event.eventDate,
314               actionType = ProposalUnqualifyAction.value,
315               SessionUnqualification(
316                 proposalId = event.id,
317                 qualificationKey = event.qualificationKey,
318                 trust = event.voteTrust
319               )
320             )
321           )
322         )
323       }
324 
325       def onUnvoteProposalCommand(state: State, command: UnvoteProposalCommand): ReplyEffect[ProposalEvent, State] = {
326         state.proposal match {
327           case None => Effect.reply(command.replyTo)(ProposalNotFound)
328           case _ =>
329             command.vote match {
330               // User hasn't voted on proposal yet
331               case None =>
332                 Effect.reply(command.replyTo)(state.getVotes(command.newProposalsVoteThreshold))
333               // User voted on this proposal so we unvote whatever voted key
334               case Some(vote) =>
335                 val event = ProposalUnvoted(
336                   id = command.proposalId,
337                   maybeUserId = command.maybeUserId,
338                   eventDate = DateHelper.now(),
339                   requestContext = command.requestContext,
340                   voteKey = vote.voteKey,
341                   maybeOrganisationId = command.maybeOrganisationId,
342                   selectedQualifications = vote.qualificationKeys.keys.toSeq,
343                   voteTrust = vote.trust,
344                   eventId = Some(idGenerator.nextEventId())
345                 )
346                 Effect
347                   .persist[ProposalUnvoted, State](event)
348                   .thenPublish(event)
349                   .thenRun { s =>
350                     logUnvoteEvent(event).flatMap { _ =>
351                       Future.traverse(event.selectedQualifications) { qualification =>
352                         logRemoveVoteQualificationEvent(
353                           ProposalUnqualified(
354                             event.id,
355                             maybeUserId = event.maybeUserId,
356                             eventDate = event.eventDate,
357                             requestContext = event.requestContext,
358                             voteKey = event.voteKey,
359                             qualificationKey = qualification,
360                             voteTrust = vote.qualificationKeys.getOrElse(qualification, event.voteTrust),
361                             eventId = Some(idGenerator.nextEventId())
362                           )
363                         )
364                       }
365                     }.onComplete { result =>
366                       command.replyTo ! (result match {
367                         case Success(_) => s.getVotes(command.newProposalsVoteThreshold)
368                         case Failure(e) => HistoryError(e)
369                       })
370                     }
371                   }
372                   .thenNoReply()
373             }
374         }
375       }
376 
377       def checkQualification(voteKey: VoteKey, commandVoteKey: VoteKey, qualificationKey: QualificationKey): Boolean = {
378         voteKey match {
379           case key if key != commandVoteKey => false
380           case Agree =>
381             qualificationKey == LikeIt || qualificationKey == Doable || qualificationKey == PlatitudeAgree
382           case Disagree =>
383             qualificationKey == NoWay || qualificationKey == Impossible || qualificationKey == PlatitudeDisagree
384           case Neutral =>
385             qualificationKey == DoNotCare || qualificationKey == DoNotUnderstand || qualificationKey == NoOpinion
386           case _ => false
387         }
388       }
389 
390       def onQualificationProposalCommand(
391         state: State,
392         command: QualifyVoteCommand
393       ): ReplyEffect[ProposalEvent, State] = {
394         state.proposal match {
395           case None => Effect.reply(command.replyTo)(ProposalNotFound)
396           case _ =>
397             command.vote match {
398               // User hasn't voted on proposal yet
399               case None =>
400                 Effect.reply(command.replyTo)(state.getQualification(command.qualificationKey))
401               // User already qualified this qualification key on this proposal (e.g.: double click)
402               case Some(vote) if vote.qualificationKeys.contains(command.qualificationKey) =>
403                 Effect.reply(command.replyTo)(state.getQualification(command.qualificationKey))
404               // Qualificication doesn't belong to user's vote.
405               case Some(vote) if !checkQualification(vote.voteKey, command.voteKey, command.qualificationKey) =>
406                 Effect.reply(command.replyTo)(state.getQualification(command.qualificationKey))
407               // User qualifies correctly
408               case Some(vote) =>
409                 val resolvedTrust = if (!vote.trust.isTrusted) {
410                   vote.trust
411                 } else {
412                   command.voteTrust
413                 }
414                 val event = ProposalQualified(
415                   id = command.proposalId,
416                   maybeUserId = command.maybeUserId,
417                   eventDate = DateHelper.now(),
418                   requestContext = command.requestContext,
419                   voteKey = command.voteKey,
420                   qualificationKey = command.qualificationKey,
421                   voteTrust = resolvedTrust,
422                   eventId = Some(idGenerator.nextEventId())
423                 )
424                 Effect
425                   .persist[ProposalQualified, State](event)
426                   .thenPublish(event)
427                   .thenRun { s =>
428                     logQualifyVoteEvent(event).onComplete { result =>
429                       command.replyTo ! (result match {
430                         case Success(_) =>
431                           s.getQualification(command.qualificationKey)
432                         case Failure(e) => HistoryError(e)
433                       })
434                     }
435                   }
436                   .thenNoReply()
437             }
438         }
439       }
440 
441       def onUnqualificationProposalCommand(
442         state: State,
443         command: UnqualifyVoteCommand
444       ): ReplyEffect[ProposalEvent, State] = {
445         state.proposal match {
446           case None => Effect.reply(command.replyTo)(ProposalNotFound)
447           case _ =>
448             command.vote match {
449               // User hasn't voted on proposal yet
450               case None =>
451                 Effect.reply(command.replyTo)(state.getQualification(command.qualificationKey))
452 
453               // User has voted and qualified this proposal
454               case Some(vote) if vote.qualificationKeys.contains(command.qualificationKey) =>
455                 val event = ProposalUnqualified(
456                   id = command.proposalId,
457                   maybeUserId = command.maybeUserId,
458                   eventDate = DateHelper.now(),
459                   requestContext = command.requestContext,
460                   voteKey = command.voteKey,
461                   qualificationKey = command.qualificationKey,
462                   voteTrust = vote.qualificationKeys.getOrElse(command.qualificationKey, command.voteTrust),
463                   eventId = Some(idGenerator.nextEventId())
464                 )
465                 Effect
466                   .persist[ProposalUnqualified, State](event)
467                   .thenPublish(event)
468                   .thenRun { s =>
469                     logRemoveVoteQualificationEvent(event).onComplete { result =>
470                       command.replyTo ! (result match {
471                         case Success(_) => s.getQualification(command.qualificationKey)
472                         case Failure(e) => HistoryError(e)
473                       })
474                     }
475                   }
476                   .thenNoReply()
477               // User has voted on this proposal but hasn't qualified with the unqualify key
478               case _ =>
479                 Effect.reply(command.replyTo)(state.getQualification(command.qualificationKey))
480 
481             }
482         }
483 
484       }
485 
486       def onViewProposalCommand(
487         proposalId: ProposalId,
488         requestContext: RequestContext,
489         replyTo: ActorRef[ProposalActorResponse[ProposalNotFound, Proposal]]
490       ): ReplyEffect[ProposalEvent, State] = {
491         Effect
492           .persist(
493             ProposalViewed(
494               id = proposalId,
495               eventDate = DateHelper.now(),
496               requestContext = requestContext,
497               eventId = Some(idGenerator.nextEventId())
498             )
499           )
500           .thenReply(replyTo)(_.getProposal)
501       }
502 
503       def onProposeCommand(command: ProposeCommand): ReplyEffect[ProposalEvent, State] = {
504         val user = command.user
505         val event = ProposalProposed(
506           id = command.proposalId,
507           author = ProposalAuthorInfo(
508             user.userId,
509             user.organisationName.orElse(user.firstName),
510             user.profile.flatMap(_.postalCode),
511             user.profile.flatMap(_.dateOfBirth).map { date =>
512               ChronoUnit.YEARS.between(date, LocalDate.now(ZoneOffset.UTC)).toInt
513             }
514           ),
515           slug = SlugHelper(command.content),
516           requestContext = command.requestContext,
517           userId = user.userId,
518           eventDate = command.createdAt,
519           content = command.content,
520           submittedAsLanguage = Some(command.submittedAsLanguage),
521           operation = command.question.operationId,
522           language = Some(command.question.defaultLanguage),
523           country = command.requestContext.country,
524           isAnonymous = command.isAnonymous,
525           question = Some(command.question.questionId),
526           initialProposal = command.initialProposal,
527           proposalType = command.proposalType,
528           eventId = Some(idGenerator.nextEventId())
529         )
530         Effect
531           .persist[ProposalProposed, State](event)
532           .thenPublish(event)
533           .thenReply(command.replyTo)(_ => Envelope(command.proposalId))
534 
535       }
536 
537       def onUpdateProposalCommand(state: State, command: UpdateProposalCommand): ReplyEffect[ProposalEvent, State] = {
538         state.proposal match {
539           case None => Effect.reply(command.replyTo)(ProposalNotFound)
540           case Some(proposal) if proposal.status != ProposalStatus.Accepted =>
541             Effect.reply(command.replyTo)(
542               InvalidStateError(s"Proposal ${command.proposalId.value} is not accepted and cannot be updated")
543             )
544           case Some(proposal) =>
545             val event =
546               ProposalUpdated(
547                 id = proposal.proposalId,
548                 eventDate = DateHelper.now(),
549                 requestContext = command.requestContext,
550                 updatedAt = command.updatedAt,
551                 moderator = Some(command.moderator),
552                 edition = (command.newContent, command.newTranslations) match {
553                   case (None, None) => None
554                   case (newContent, newTranslations) =>
555                     Some(ProposalEdition(proposal.content, newContent, proposal.contentTranslations, newTranslations))
556                 },
557                 tags = command.tags,
558                 similarProposals = Seq.empty,
559                 operation = command.question.operationId.orElse(proposal.operation),
560                 question = Some(command.question.questionId),
561                 idea = proposal.idea,
562                 eventId = Some(idGenerator.nextEventId())
563               )
564             Effect
565               .persist[ProposalUpdated, State](event)
566               .thenPublish(event)
567               .thenReply(command.replyTo)(_.getProposal)
568         }
569       }
570 
571       def onUpdateProposalVotesCommand(
572         state: State,
573         command: UpdateProposalVotesCommand
574       ): ReplyEffect[ProposalEvent, State] = {
575         state.proposal match {
576           case None => Effect.reply(command.replyTo)(ProposalNotFound)
577           case Some(proposal)
578               if !Seq(ProposalStatus.Accepted, ProposalStatus.Archived, ProposalStatus.Refused).contains(
579                 proposal.status
580               ) =>
581             Effect.reply(command.replyTo)(
582               InvalidStateError(
583                 s"Proposal ${command.proposalId.value} is not accepted/archived/refused and cannot be updated"
584               )
585             )
586           case Some(proposal) =>
587             val event = ProposalVotesUpdated(
588               id = command.proposalId,
589               eventDate = DateHelper.now(),
590               requestContext = command.requestContext,
591               updatedAt = command.updatedAt,
592               moderator = Some(command.moderator),
593               updatedVotes = proposal.votingOptions.map(mergeVotes(_, command.votes)),
594               eventId = Some(idGenerator.nextEventId())
595             )
596             Effect
597               .persist[ProposalVotesUpdated, State](event)
598               .thenPublish(event)
599               .thenReply(command.replyTo)(_.getProposal)
600         }
601       }
602 
603       def onAcceptProposalCommand(state: State, command: AcceptProposalCommand): ReplyEffect[ProposalEvent, State] = {
604         state.proposal match {
605           case None => Effect.reply(command.replyTo)(ProposalNotFound)
606           case Some(proposal) if proposal.status == ProposalStatus.Archived =>
607             Effect.reply(command.replyTo)(
608               InvalidStateError(s"Proposal ${command.proposalId.value} is archived and cannot be validated")
609             )
610           case Some(proposal) if proposal.status == ProposalStatus.Accepted =>
611             // possible double request, ignore.
612             // other modifications should use the proposal update method
613             Effect.reply(command.replyTo)(
614               InvalidStateError(s"Proposal ${command.proposalId.value} is already validated")
615             )
616           case Some(proposal) =>
617             val event = ProposalAccepted(
618               id = command.proposalId,
619               eventDate = DateHelper.now(),
620               requestContext = command.requestContext,
621               moderator = command.moderator,
622               edition = (command.newContent, command.newTranslations) match {
623                 case (None, None) => None
624                 case (newContent, newTranslations) =>
625                   Some(ProposalEdition(proposal.content, newContent, proposal.contentTranslations, newTranslations))
626               },
627               sendValidationEmail = command.sendNotificationEmail,
628               tags = command.tags,
629               similarProposals = Seq.empty,
630               idea = proposal.idea,
631               operation = command.question.operationId.orElse(proposal.operation),
632               question = Some(command.question.questionId),
633               eventId = Some(idGenerator.nextEventId())
634             )
635             Effect
636               .persist[ProposalAccepted, State](event)
637               .thenPublish(event)
638               .thenReply(command.replyTo)(_.getProposal)
639         }
640       }
641 
642       def onRefuseProposalCommand(state: State, command: RefuseProposalCommand): ReplyEffect[ProposalEvent, State] = {
643         state.proposal match {
644           case None => Effect.reply(command.replyTo)(ProposalNotFound)
645           case Some(proposal) if proposal.status == ProposalStatus.Archived =>
646             Effect.reply(command.replyTo)(
647               InvalidStateError(s"Proposal ${command.proposalId.value} is archived and cannot be refused")
648             )
649           case Some(proposal) if proposal.status == ProposalStatus.Refused =>
650             // possible double request, ignore.
651             // other modifications should use the proposal update command
652             Effect.reply(command.replyTo)(InvalidStateError(s"Proposal ${command.proposalId.value} is already refused"))
653           case Some(proposal) =>
654             val event = ProposalRefused(
655               id = command.proposalId,
656               eventDate = DateHelper.now(),
657               requestContext = command.requestContext,
658               moderator = command.moderator,
659               sendRefuseEmail = command.sendNotificationEmail,
660               refusalReason = command.refusalReason,
661               operation = proposal.operation,
662               eventId = Some(idGenerator.nextEventId())
663             )
664             Effect
665               .persist[ProposalRefused, State](event)
666               .thenPublish(event)
667               .thenReply(command.replyTo)(_.getProposal)
668         }
669       }
670 
671       def onPostponeProposalCommand(
672         state: State,
673         command: PostponeProposalCommand
674       ): ReplyEffect[ProposalEvent, State] = {
675         state.proposal match {
676           case None => Effect.reply(command.replyTo)(ProposalNotFound)
677           case Some(proposal) if proposal.status == ProposalStatus.Archived =>
678             Effect.reply(command.replyTo)(
679               InvalidStateError(s"Proposal ${command.proposalId.value} is archived and cannot be postponed")
680             )
681           case Some(proposal)
682               if proposal.status == ProposalStatus.Accepted || proposal.status == ProposalStatus.Refused =>
683             Effect.reply(command.replyTo)(
684               InvalidStateError(s"Proposal ${command.proposalId.value} is already moderated and cannot be postponed")
685             )
686           case Some(proposal) if proposal.status == ProposalStatus.Postponed =>
687             Effect.reply(command.replyTo)(
688               InvalidStateError(s"Proposal ${command.proposalId.value} is already postponed")
689             )
690           case Some(_) =>
691             val event =
692               ProposalPostponed(
693                 id = command.proposalId,
694                 requestContext = command.requestContext,
695                 moderator = command.moderator,
696                 eventDate = DateHelper.now(),
697                 eventId = Some(idGenerator.nextEventId())
698               )
699             Effect
700               .persist[ProposalPostponed, State](event)
701               .thenPublish(event)
702               .thenReply(command.replyTo)(_.getProposal)
703         }
704       }
705 
706       def onLockProposalCommand(
707         state: State,
708         command: LockProposalCommand,
709         lockHandler: LockHandler
710       ): ReplyEffect[ProposalEvent, State] = {
711         state.proposal match {
712           case None => Effect.reply(command.replyTo)(ProposalNotFound)
713           case _ =>
714             lockHandler.lock match {
715               case Some(ProposalLock(moderatorId, moderatorName, deadline))
716                   if moderatorId != command.moderatorId && deadline.hasTimeLeft() =>
717                 Effect.reply(command.replyTo)(AlreadyLockedBy(moderatorName))
718 
719               case maybeLock if maybeLock.forall(_.deadline.isOverdue()) =>
720                 val event = ProposalLocked(
721                   id = command.proposalId,
722                   moderatorId = command.moderatorId,
723                   moderatorName = command.moderatorName,
724                   eventDate = DateHelper.now(),
725                   requestContext = command.requestContext,
726                   eventId = Some(idGenerator.nextEventId())
727                 )
728                 lockHandler.take(event.moderatorId, event.moderatorName)
729                 Effect
730                   .persist[ProposalLocked, State](event)
731                   .thenPublish(event)
732                   .thenReply(command.replyTo)(_ => Envelope(event.moderatorId))
733               case _ =>
734                 lockHandler.take(command.moderatorId, command.moderatorName)
735                 Effect.reply(command.replyTo)(Envelope(command.moderatorId))
736             }
737         }
738       }
739 
740       def mergeVotes(proposalVotes: VotingOptions, commandVotes: Seq[UpdateVoteRequest]): VotingOptions = {
741         def mergeQualification(qualification: Qualification): Qualification =
742           commandVotes.flatMap(_.qualifications).find(_.key == qualification.key) match {
743             case None => qualification
744             case Some(updatedQualification) =>
745               qualification.copy(
746                 count = updatedQualification.count.getOrElse(qualification.count),
747                 countVerified = updatedQualification.countVerified.getOrElse(qualification.countVerified),
748                 countSequence = updatedQualification.countSequence.getOrElse(qualification.countSequence),
749                 countSegment = updatedQualification.countSegment.getOrElse(qualification.countSegment)
750               )
751           }
752         def mergeVote(vote: Vote): Vote =
753           commandVotes.find(_.key == vote.key) match {
754             case None => vote
755             case Some(updatedVote) =>
756               vote.copy(
757                 count = updatedVote.count.getOrElse(vote.count),
758                 countVerified = updatedVote.countVerified.getOrElse(vote.countVerified),
759                 countSequence = updatedVote.countSequence.getOrElse(vote.countSequence),
760                 countSegment = updatedVote.countSegment.getOrElse(vote.countSegment)
761               )
762           }
763 
764         proposalVotes.mapVotes(mergeVote).mapQualifications(mergeQualification)
765       }
766 
767       def onSetKeywordsCommand(command: SetKeywordsCommand): ReplyEffect[ProposalEvent, State] = {
768         val event = ProposalKeywordsSet(
769           command.proposalId,
770           eventDate = DateHelper.now(),
771           keywords = command.keywords,
772           requestContext = command.requestContext,
773           eventId = Some(idGenerator.nextEventId())
774         )
775         Effect.persist[ProposalKeywordsSet, State](event).thenPublish(event).thenReply(command.replyTo)(_.getProposal)
776       }
777 
778       def applyProposalUpdated(state: Proposal, event: ProposalUpdated): Proposal = {
779 
780         val arguments: Map[String, String] = Map(
781           "oldQuestion" -> state.questionId.filterNot(event.question.contains).fold("")(_.value),
782           "newQuestion" -> event.question.filterNot(state.questionId.contains).fold("")(_.value),
783           "oldOperation" -> state.operation.filterNot(event.operation.contains).fold("")(_.value),
784           "newOperation" -> event.operation.filterNot(state.operation.contains).fold("")(_.value),
785           "oldContent" -> event.edition.fold("")(_.oldVersion),
786           "newContent" -> event.edition.flatMap(_.newVersion).getOrElse(""),
787           "oldTranslations" -> event.edition.flatMap(_.oldContentTranslations.map(_.toString)).getOrElse(""),
788           "newTranslations" -> event.edition.flatMap(_.newContentTranslations.map(_.toString)).getOrElse(""),
789           "submittedAsLanguage" -> event.submittedAsLanguage.fold("")(_.value),
790           "removedTags" -> state.tags.diff(event.tags).map(_.value).mkString(","),
791           "addedTags" -> event.tags.diff(state.tags).map(_.value).mkString(",")
792         ).filter {
793           case (_, value) => value.nonEmpty
794         }
795         @SuppressWarnings(Array("org.wartremover.warts.Throw"))
796         val moderator: UserId = event.moderator match {
797           case Some(userId) => userId
798           case _            => throw new IllegalStateException("moderator required")
799         }
800         val action =
801           ProposalAction(
802             date = event.eventDate,
803             user = moderator,
804             actionType = ProposalUpdateAction.value,
805             arguments = arguments
806           )
807         val proposal =
808           state.copy(
809             tags = event.tags,
810             events = action :: state.events,
811             updatedAt = Some(event.eventDate),
812             idea = event.idea,
813             operation = event.operation,
814             questionId = event.question
815           )
816 
817         event.edition match {
818           case None => proposal
819           case Some(ProposalEdition(_, Some(newVersion), _, newContentTranslations)) =>
820             proposal.copy(
821               content = newVersion,
822               slug = SlugHelper(newVersion),
823               contentTranslations = newContentTranslations
824             )
825           case Some(ProposalEdition(_, None, _, newContentTranslations)) =>
826             proposal.copy(contentTranslations = newContentTranslations)
827         }
828       }
829 
830       def applyProposalVotesVerifiedUpdated(state: Proposal, event: ProposalVotesVerifiedUpdated): Proposal =
831         state.copy(votingOptions = event.updatedVerifiedVotes)
832 
833       def applyProposalVotesUpdated(state: Proposal, event: ProposalVotesUpdated): Proposal =
834         state.copy(votingOptions = event.updatedVotes)
835 
836       def applyProposalAccepted(state: Proposal, event: ProposalAccepted): Proposal = {
837         val arguments: Map[String, String] = Map(
838           "initialContent" -> event.edition.map(_.oldVersion).getOrElse(""),
839           "moderatedContent" -> event.edition.flatMap(_.newVersion).getOrElse(""),
840           "initialTranslations" -> event.edition.flatMap(_.oldContentTranslations.map(_.toString)).getOrElse(""),
841           "moderatedTranslations" -> event.edition.flatMap(_.newContentTranslations.map(_.toString)).getOrElse(""),
842           "tags" -> event.tags.map(_.value).mkString(","),
843           "userNotified" -> event.sendValidationEmail.toString
844         ).filter {
845           case (_, value) => value.nonEmpty
846         }
847         val action =
848           ProposalAction(
849             date = event.eventDate,
850             user = event.moderator,
851             actionType = ProposalAcceptAction.value,
852             arguments = arguments
853           )
854         val proposal =
855           state.copy(
856             tags = event.tags,
857             events = action :: state.events,
858             status = Accepted,
859             updatedAt = Some(event.eventDate),
860             validatedAt = Some(event.eventDate),
861             idea = event.idea,
862             operation = event.operation,
863             questionId = event.question
864           )
865 
866         event.edition match {
867           case None => proposal
868           case Some(ProposalEdition(_, Some(newVersion), _, newContentTranslations)) =>
869             proposal.copy(
870               content = newVersion,
871               slug = SlugHelper(newVersion),
872               contentTranslations = newContentTranslations
873             )
874           case Some(ProposalEdition(_, None, _, newContentTranslations)) =>
875             proposal.copy(contentTranslations = newContentTranslations)
876         }
877       }
878 
879       def applyProposalRefused(state: Proposal, event: ProposalRefused): Proposal = {
880         val arguments: Map[String, String] = Map(
881           "refusalReason" -> event.refusalReason.getOrElse(""),
882           "userNotified" -> event.sendRefuseEmail.toString
883         ).filter {
884           case (_, value) => value.nonEmpty
885         }
886         val action =
887           ProposalAction(date = event.eventDate, user = event.moderator, actionType = "refuse", arguments = arguments)
888         state.copy(
889           events = action :: state.events,
890           status = Refused,
891           refusalReason = event.refusalReason,
892           updatedAt = Some(event.eventDate),
893           validatedAt = Some(event.eventDate)
894         )
895       }
896 
897       def applyProposalPostponed(state: Proposal, event: ProposalPostponed): Proposal = {
898         val action =
899           ProposalAction(date = event.eventDate, user = event.moderator, actionType = "postpone", arguments = Map.empty)
900         state.copy(
901           events = action :: state.events,
902           status = Postponed,
903           updatedAt = Some(event.eventDate),
904           postponedAt = Some(event.eventDate)
905         )
906       }
907 
908       val increaseCountIf: (Int, Boolean) => Int = {
909         case (newCount, true) => newCount + 1
910         case (newCount, _)    => newCount
911       }
912 
913       def decreaseCountIf(logError: () => Unit): (Int, Boolean) => Int = {
914         case (0, true) =>
915           logError()
916           0
917         case (newCount, true) => newCount - 1
918         case (newCount, _)    => newCount
919       }
920 
921       def incrementWithVoteTrust(vote: Vote, voteTrust: VoteTrust): Vote =
922         vote.copy(
923           count = increaseCountIf(vote.count, true),
924           countSegment = increaseCountIf(vote.countSegment, voteTrust.isInSegment),
925           countSequence = increaseCountIf(vote.countSequence, voteTrust.isInSequence),
926           countVerified = increaseCountIf(vote.countVerified, voteTrust.isTrusted)
927         )
928 
929       def decrementWithVoteTrust(vote: Vote, proposal: Proposal, event: ProposalUnvoted): Vote = {
930         def genLogFunction(voteType: String): () => Unit =
931           () =>
932             logger.error(
933               s"Prevented $voteType [${event.voteKey}] count to be set to -1 for proposal: $proposal. Caused by event: $event"
934             )
935         vote.copy(
936           count = decreaseCountIf(genLogFunction("count"))(vote.count, true),
937           countSegment = decreaseCountIf(genLogFunction("countSegment"))(vote.countSegment, event.voteTrust.isInSegment),
938           countSequence =
939             decreaseCountIf(genLogFunction("countSequence"))(vote.countSequence, event.voteTrust.isInSequence),
940           countVerified =
941             decreaseCountIf(genLogFunction("countVerified"))(vote.countVerified, event.voteTrust.isTrusted)
942         )
943       }
944 
945       def applyProposalVoted(state: Proposal, event: ProposalVoted): Proposal = {
946         state.copy(
947           votingOptions =
948             state.votingOptions.map(_.updateVote(event.voteKey, incrementWithVoteTrust(_, event.voteTrust))),
949           organisationIds = event.maybeOrganisationId match {
950             case Some(organisationId)
951                 if !state.organisationIds
952                   .exists(_.value == organisationId.value) =>
953               state.organisationIds :+ organisationId
954             case _ => state.organisationIds
955           }
956         )
957       }
958 
959       def applyProposalUnvoted(state: Proposal, event: ProposalUnvoted): Proposal = {
960         state.copy(
961           votingOptions = state.votingOptions
962             .map(
963               _.updateVote(event.voteKey, decrementWithVoteTrust(_, state, event))
964                 .mapQualifications(
965                   qualification =>
966                     event.selectedQualifications
967                       .find(_ == qualification.key)
968                       .fold(qualification)(_ => applyUnqualifVote(state, qualification, event))
969                 )
970             ),
971           organisationIds = event.maybeOrganisationId match {
972             case Some(organisationId) =>
973               state.organisationIds.filterNot(_.value == organisationId.value)
974             case _ => state.organisationIds
975           }
976         )
977       }
978 
979       def applyUnqualifVote[T: Unvoted](state: Proposal, qualification: Qualification, event: T): Qualification = {
980         if (event.selectedQualifications.contains(qualification.key)) {
981           def logError(qualifType: String): () => Unit =
982             () =>
983               logger.error(
984                 s"Prevented $qualifType [${qualification.key}] count to be set to -1 for proposal: $state. Caused by event: $event"
985               )
986           Qualification(
987             key = qualification.key,
988             count = decreaseCountIf(logError("count"))(qualification.count, true),
989             countVerified =
990               decreaseCountIf(logError("countVerified"))(qualification.countVerified, event.voteTrust.isTrusted),
991             countSequence =
992               decreaseCountIf(logError("countSequence"))(qualification.countSequence, event.voteTrust.isInSequence),
993             countSegment =
994               decreaseCountIf(logError("countSegment"))(qualification.countSegment, event.voteTrust.isInSegment)
995           )
996         } else {
997           qualification
998         }
999       }
1000 
1001       def applyVoteTrustToQualification(qualification: Qualification, voteTrust: VoteTrust): Qualification =
1002         Qualification(
1003           key = qualification.key,
1004           count = increaseCountIf(qualification.count, true),
1005           countVerified = increaseCountIf(qualification.countVerified, voteTrust.isTrusted),
1006           countSequence = increaseCountIf(qualification.countSequence, voteTrust.isInSequence),
1007           countSegment = increaseCountIf(qualification.countSegment, voteTrust.isInSegment)
1008         )
1009 
1010       def applyProposalQualified(state: Proposal, event: ProposalQualified): Proposal =
1011         state.copy(votingOptions = state.votingOptions.map(
1012           _.updateQualification(event.qualificationKey, applyVoteTrustToQualification(_, event.voteTrust))
1013         )
1014         )
1015 
1016       def applyProposalUnqualified(state: Proposal, event: ProposalUnqualified): Proposal =
1017         state.copy(votingOptions =
1018           state.votingOptions.map(_.updateQualification(event.qualificationKey, applyUnqualifVote(state, _, event)))
1019         )
1020 
1021       def applyProposalLocked(state: Proposal, event: ProposalLocked): Proposal = {
1022         val arguments: Map[String, String] =
1023           Map("moderatorName" -> event.moderatorName.getOrElse("<unknown>")).filter {
1024             case (_, value) => value.nonEmpty
1025           }
1026         val action =
1027           ProposalAction(date = event.eventDate, user = event.moderatorId, actionType = "lock", arguments = arguments)
1028         state.copy(events = action :: state.events, updatedAt = Some(event.eventDate))
1029       }
1030 
1031       def applyProposalKeywordsSet(state: Proposal, event: ProposalKeywordsSet): Proposal = {
1032         state.copy(keywords = event.keywords, updatedAt = Some(event.eventDate))
1033       }
1034 
1035       val eventHandler: (State, ProposalEvent) => State = {
1036         case (_, e: ProposalProposed) =>
1037           State(
1038             Some(
1039               Proposal(
1040                 proposalId = e.id,
1041                 slug = e.slug,
1042                 author = e.userId,
1043                 createdAt = Some(e.eventDate),
1044                 updatedAt = None,
1045                 validatedAt = None,
1046                 postponedAt = None,
1047                 content = e.content,
1048                 submittedAsLanguage = e.submittedAsLanguage,
1049                 contentTranslations = None,
1050                 status = ProposalStatus.Pending,
1051                 questionId = e.question,
1052                 creationContext = e.requestContext,
1053                 votingOptions = Some(VotingOptions.empty),
1054                 isAnonymous = e.isAnonymous,
1055                 operation = e.operation,
1056                 proposalType = e.proposalType,
1057                 events = List(
1058                   ProposalAction(
1059                     date = e.eventDate,
1060                     user = e.userId,
1061                     actionType = ProposalProposeAction.value,
1062                     arguments = Map("content" -> e.content)
1063                   )
1064                 ),
1065                 initialProposal = e.initialProposal,
1066                 keywords = Seq.empty
1067               )
1068             )
1069           )
1070         case (state, e: ProposalUpdated) => State(state.proposal.map(applyProposalUpdated(_, e)))
1071         case (state, e: ProposalVotesVerifiedUpdated) =>
1072           State(state.proposal.map(applyProposalVotesVerifiedUpdated(_, e)))
1073         case (state, e: ProposalVotesUpdated) => State(state.proposal.map(applyProposalVotesUpdated(_, e)))
1074         case (state, e: ProposalAccepted)     => State(state.proposal.map(applyProposalAccepted(_, e)))
1075         case (state, e: ProposalRefused)      => State(state.proposal.map(applyProposalRefused(_, e)))
1076         case (state, e: ProposalPostponed)    => State(state.proposal.map(applyProposalPostponed(_, e)))
1077         case (state, e: ProposalVoted)        => State(state.proposal.map(applyProposalVoted(_, e)))
1078         case (state, e: ProposalUnvoted)      => State(state.proposal.map(applyProposalUnvoted(_, e)))
1079         case (state, e: ProposalQualified)    => State(state.proposal.map(applyProposalQualified(_, e)))
1080         case (state, e: ProposalUnqualified)  => State(state.proposal.map(applyProposalUnqualified(_, e)))
1081         case (state, e: ProposalLocked)       => State(state.proposal.map(applyProposalLocked(_, e)))
1082         case (_, e: ProposalPatched)          => State(Some(e.proposal))
1083         case (state, e: ProposalKeywordsSet)  => State(state.proposal.map(applyProposalKeywordsSet(_, e)))
1084         case (state, _: DeprecatedEvent)      => state
1085         case (state, _)                       => state
1086       }
1087 
1088       val snapshotAdapter = new SnapshotAdapter[State] {
1089         override def toJournal(state: State): Any = state
1090 
1091         @SuppressWarnings(Array("org.wartremover.warts.Throw"))
1092         override def fromJournal(from: Any): State = from match {
1093           case proposal: Proposal => State(Some(proposal))
1094           case state: State       => state
1095           case other =>
1096             throw new IllegalStateException(s"$other with class ${other.getClass} is not a recoverable state")
1097         }
1098       }
1099 
1100       EventSourcedBehavior
1101         .withEnforcedReplies[ProposalCommand, ProposalEvent, State](
1102           persistenceId = PersistenceId.ofUniqueId(context.self.path.name),
1103           emptyState = State(proposal = None),
1104           commandHandler(new LockHandler(lockDuration)),
1105           eventHandler
1106         )
1107         .withJournalPluginId(JournalPluginId)
1108         .withSnapshotPluginId(SnapshotPluginId)
1109         .withRetention(RetentionCriteria.snapshotEvery(numberOfEvents = 10, keepNSnapshots = 50))
1110         .snapshotAdapter(snapshotAdapter)
1111         .snapshotWhen {
1112           case (_, _: ProposalPatched, _) => true
1113           case _                          => false
1114         }
1115     }
1116   }
1117 
1118   implicit class UnvotedOps[T](val event: T) extends AnyVal {
1119     def selectedQualifications(implicit unvoted: Unvoted[T]): Seq[QualificationKey] = unvoted.qualifications(event)
1120     def voteTrust(implicit unvoted: Unvoted[T]): VoteTrust = unvoted.trust(event)
1121   }
1122 }
1123 
1124 trait Unvoted[T] {
1125   def qualifications(event: T): Seq[QualificationKey]
1126   def trust(event: T): VoteTrust
1127 }
1128 
1129 object Unvoted {
1130   implicit val qualification: Unvoted[ProposalUnqualified] = new Unvoted[ProposalUnqualified] {
1131     def qualifications(event: ProposalUnqualified): Seq[QualificationKey] =
1132       Seq(event.qualificationKey)
1133     def trust(event: ProposalUnqualified): VoteTrust =
1134       event.voteTrust
1135   }
1136 
1137   implicit val vote: Unvoted[ProposalUnvoted] = new Unvoted[ProposalUnvoted] {
1138     def qualifications(event: ProposalUnvoted): Seq[QualificationKey] =
1139       event.selectedQualifications
1140     def trust(event: ProposalUnvoted): VoteTrust =
1141       event.voteTrust
1142   }
1143 }