1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2018 Make.org
4  *
5  * This program is free software: you can redistribute it and/or modify
6  *  it under the terms of the GNU Affero General Public License as
7  *  published by the Free Software Foundation, either version 3 of the
8  *  License, or (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU Affero General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Affero General Public License
16  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
17  *
18  */
19 
20 package org.make.api.sessionhistory
21 
22 import akka.actor.typed.scaladsl.Behaviors
23 import akka.actor.typed.{ActorRef, Behavior}
24 import akka.persistence.typed.scaladsl._
25 import akka.persistence.typed.{PersistenceId, SnapshotAdapter}
26 import grizzled.slf4j.Logging
27 import org.make.api.extensions.MakeSettings
28 import org.make.api.technical.TimeSettings
29 import org.make.api.userhistory._
30 import org.make.core.proposal.{ProposalId, QualificationKey}
31 import org.make.core.session._
32 import org.make.core.technical.IdGenerator
33 
34 import scala.concurrent.duration.{Deadline, FiniteDuration}
35 
36 object SessionHistoryActor extends Logging {
37 
38   val JournalPluginId: String = "make-api.event-sourcing.sessions.journal"
39   val SnapshotPluginId: String = "make-api.event-sourcing.sessions.snapshot"
40   val QueryJournalPluginId: String = "make-api.event-sourcing.sessions.query"
41 
42   sealed trait LockVoteAction
43 
44   case object Vote extends LockVoteAction
45   final case class ChangeQualifications(key: Seq[QualificationKey]) extends LockVoteAction
46 
47   class LockHandler(lockDuration: FiniteDuration) {
48     private var locks: Map[ProposalId, LockVoteAction] = Map.empty
49     private var deadline = Deadline.now
50 
51     def add(lock: (ProposalId, LockVoteAction)): Unit = {
52       locks += lock
53       deadline = Deadline.now + lockDuration
54     }
55 
56     def getOrExpire(id: ProposalId): Option[LockVoteAction] = {
57       if (deadline.isOverdue()) {
58         locks = Map.empty
59       }
60       locks.get(id)
61     }
62 
63     def release(id: ProposalId): Unit = {
64       locks -= id
65     }
66   }
67 
68   def apply(
69     userHistoryCoordinator: ActorRef[UserHistoryCommand],
70     lockDuration: FiniteDuration,
71     idGenerator: IdGenerator,
72     settings: MakeSettings
73   ): Behavior[SessionHistoryCommand] = {
74     Behaviors.setup { implicit context =>
75       val timeout = TimeSettings.defaultTimeout
76       val id: SessionId = SessionId(context.self.path.name)
77       val persistenceId: PersistenceId = PersistenceId.ofUniqueId(id.value)
78       val lockHandler = new LockHandler(lockDuration)
79       EventSourcedBehavior[SessionHistoryCommand, SessionHistoryEvent[_], State](
80         persistenceId,
81         emptyState = Active(SessionHistory(Nil), None),
82         _.handleCommand(userHistoryCoordinator, lockHandler, settings, idGenerator)(context, timeout)(_),
83         _.handleEvent(settings)(_)
84       ).withJournalPluginId(JournalPluginId)
85         .withSnapshotPluginId(SnapshotPluginId)
86         .withRetention(
87           RetentionCriteria.snapshotEvery(numberOfEvents = 10, keepNSnapshots = 2).withDeleteEventsOnSnapshot
88         )
89         .snapshotAdapter(snapshotAdapter)
90     }
91   }
92 
93   val snapshotAdapter: SnapshotAdapter[State] = new SnapshotAdapter[State] {
94     override def toJournal(state: State): Any = state
95 
96     @SuppressWarnings(Array("org.wartremover.warts.Throw"))
97     override def fromJournal(from: Any): State = {
98       from match {
99         case sessionHistory: SessionHistory =>
100           val allEvents: Seq[SessionHistoryEvent[_]] =
101             sessionHistory.events.sortWith((e1, e2) => e2.action.date.isBefore(e1.action.date))
102 
103           allEvents.collectFirst {
104             case event: SessionExpired     => Expired(event.action.arguments, Some(event.action.date))
105             case event: SessionTransformed => Closed(event.action.arguments, Some(event.action.date))
106             case event: SessionTransforming =>
107               Transforming(sessionHistory, event.requestContext, Some(event.action.date))
108           }.getOrElse(Active(sessionHistory, allEvents.headOption.map(_.action.date)))
109         case state: State => state
110         case other        => throw new IllegalStateException(s"$other with class ${other.getClass} is not a recoverable state")
111       }
112     }
113   }
114 }