1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2018 Make.org
4  *
5  * This program is free software: you can redistribute it and/or modify
6  *  it under the terms of the GNU Affero General Public License as
7  *  published by the Free Software Foundation, either version 3 of the
8  *  License, or (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU Affero General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Affero General Public License
16  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
17  *
18  */
19 
20 package org.make.api.sessionhistory
21 
22 import org.make.api.userhistory._
23 import org.make.core.SprayJsonFormatters._
24 import org.make.core.history.HistoryActions.VoteTrust
25 import org.make.core.proposal.{ProposalId, QualificationKey, VoteKey}
26 import org.make.core.session._
27 import org.make.core.user.UserId
28 import org.make.core.{MakeSerializable, RequestContext}
29 import spray.json.DefaultJsonProtocol._
30 import spray.json._
31 
32 import java.time.ZonedDateTime
33 
34 final case class SessionAction[T](date: ZonedDateTime, actionType: String, arguments: T)
35 
36 object SessionAction {
37   implicit def sessionActionSessionRegisteredFormatted[T](
38     implicit formatter: JsonFormat[T]
39   ): RootJsonFormat[SessionAction[T]] =
40     DefaultJsonProtocol.jsonFormat3[ZonedDateTime, String, T, SessionAction[T]](
41       (date: ZonedDateTime, action: String, parameter: T) => SessionAction[T](date, action, parameter)
42     )
43 }
44 
45 sealed trait SessionHistoryEvent[T] extends MakeSerializable {
46   def sessionId: SessionId
47   def requestContext: RequestContext
48   def action: SessionAction[T]
49 }
50 
51 sealed trait LoggableHistoryEvent[T] extends SessionHistoryEvent[T] {
52   def toUserHistoryEvent(userId: UserId): TransactionalUserHistoryEvent[_]
53 }
54 
55 object SessionHistoryEvent {
56   implicit val format: RootJsonFormat[SessionHistoryEvent[_]] =
57     new RootJsonFormat[SessionHistoryEvent[_]] {
58       override def read(json: JsValue): SessionHistoryEvent[_] = {
59         json.asJsObject.getFields("type") match {
60           case Seq(JsString("SessionTransformed"))             => json.convertTo[SessionTransformed]
61           case Seq(JsString("SessionTransforming"))            => json.convertTo[SessionTransforming]
62           case Seq(JsString("SessionExpired"))                 => json.convertTo[SessionExpired]
63           case Seq(JsString("LogSessionSearchProposalsEvent")) => json.convertTo[LogSessionSearchProposalsEvent]
64           case Seq(JsString("LogSessionVoteEvent"))            => json.convertTo[LogSessionVoteEvent]
65           case Seq(JsString("LogSessionUnvoteEvent"))          => json.convertTo[LogSessionUnvoteEvent]
66           case Seq(JsString("LogSessionQualificationEvent"))   => json.convertTo[LogSessionQualificationEvent]
67           case Seq(JsString("LogSessionUnqualificationEvent")) => json.convertTo[LogSessionUnqualificationEvent]
68           case Seq(JsString("LogSessionStartSequenceEvent"))   => json.convertTo[LogSessionStartSequenceEvent]
69           case Seq(JsString("SaveLastEventDate"))              => json.convertTo[SaveLastEventDate]
70         }
71       }
72 
73       override def write(obj: SessionHistoryEvent[_]): JsObject = {
74         JsObject((obj match {
75           case event: SessionTransformed             => event.toJson
76           case event: SessionTransforming            => event.toJson
77           case event: SessionExpired                 => event.toJson
78           case event: LogSessionSearchProposalsEvent => event.toJson
79           case event: LogSessionVoteEvent            => event.toJson
80           case event: LogSessionUnvoteEvent          => event.toJson
81           case event: LogSessionQualificationEvent   => event.toJson
82           case event: LogSessionUnqualificationEvent => event.toJson
83           case event: LogSessionStartSequenceEvent   => event.toJson
84           case event: SaveLastEventDate              => event.toJson
85         }).asJsObject.fields + ("type" -> JsString(obj.productPrefix)))
86       }
87     }
88 }
89 
90 object LoggableHistoryEvent {
91   implicit val format: RootJsonFormat[LoggableHistoryEvent[_]] =
92     new RootJsonFormat[LoggableHistoryEvent[_]] {
93       override def read(json: JsValue): LoggableHistoryEvent[_] = {
94         json.asJsObject.getFields("type") match {
95           case Seq(JsString("LogSessionSearchProposalsEvent")) => json.convertTo[LogSessionSearchProposalsEvent]
96           case Seq(JsString("LogSessionVoteEvent"))            => json.convertTo[LogSessionVoteEvent]
97           case Seq(JsString("LogSessionUnvoteEvent"))          => json.convertTo[LogSessionUnvoteEvent]
98           case Seq(JsString("LogSessionQualificationEvent"))   => json.convertTo[LogSessionQualificationEvent]
99           case Seq(JsString("LogSessionUnqualificationEvent")) => json.convertTo[LogSessionUnqualificationEvent]
100           case Seq(JsString("LogSessionStartSequenceEvent"))   => json.convertTo[LogSessionStartSequenceEvent]
101         }
102       }
103 
104       override def write(obj: LoggableHistoryEvent[_]): JsObject = {
105         JsObject((obj match {
106           case event: LogSessionSearchProposalsEvent => event.toJson
107           case event: LogSessionVoteEvent            => event.toJson
108           case event: LogSessionUnvoteEvent          => event.toJson
109           case event: LogSessionQualificationEvent   => event.toJson
110           case event: LogSessionUnqualificationEvent => event.toJson
111           case event: LogSessionStartSequenceEvent   => event.toJson
112         }).asJsObject.fields + ("type" -> JsString(obj.productPrefix)))
113       }
114     }
115 }
116 
117 final case class SessionSearchParameters(term: String)
118 
119 object SessionSearchParameters {
120   implicit val format: RootJsonFormat[SessionSearchParameters] =
121     DefaultJsonProtocol.jsonFormat1(SessionSearchParameters.apply)
122 }
123 
124 final case class SessionVote(proposalId: ProposalId, voteKey: VoteKey, trust: VoteTrust)
125 
126 object SessionVote {
127   implicit val format: RootJsonFormat[SessionVote] =
128     DefaultJsonProtocol.jsonFormat3(SessionVote.apply)
129 }
130 
131 final case class SessionUnvote(proposalId: ProposalId, voteKey: VoteKey, trust: VoteTrust)
132 
133 object SessionUnvote {
134   implicit val format: RootJsonFormat[SessionUnvote] =
135     DefaultJsonProtocol.jsonFormat3(SessionUnvote.apply)
136 }
137 
138 final case class SessionQualification(proposalId: ProposalId, qualificationKey: QualificationKey, trust: VoteTrust)
139 
140 object SessionQualification {
141   implicit val format: RootJsonFormat[SessionQualification] =
142     DefaultJsonProtocol.jsonFormat3(SessionQualification.apply)
143 }
144 
145 final case class SessionUnqualification(proposalId: ProposalId, qualificationKey: QualificationKey, trust: VoteTrust)
146 
147 object SessionUnqualification {
148   implicit val format: RootJsonFormat[SessionUnqualification] =
149     DefaultJsonProtocol.jsonFormat3(SessionUnqualification.apply)
150 }
151 
152 final case class LogSessionVoteEvent(
153   sessionId: SessionId,
154   requestContext: RequestContext,
155   action: SessionAction[SessionVote]
156 ) extends LoggableHistoryEvent[SessionVote] {
157   override def toUserHistoryEvent(userId: UserId): LogUserVoteEvent = {
158     LogUserVoteEvent(
159       userId = userId,
160       requestContext = requestContext,
161       action = UserAction[UserVote](
162         date = action.date,
163         actionType = action.actionType,
164         arguments = UserVote(
165           proposalId = action.arguments.proposalId,
166           voteKey = action.arguments.voteKey,
167           trust = action.arguments.trust
168         )
169       )
170     )
171   }
172 }
173 
174 object LogSessionVoteEvent {
175   val action: String = "vote"
176 
177   implicit val format: RootJsonFormat[LogSessionVoteEvent] =
178     DefaultJsonProtocol.jsonFormat(LogSessionVoteEvent.apply, "sessionId", "context", "action")
179 }
180 
181 final case class LogSessionUnvoteEvent(
182   sessionId: SessionId,
183   requestContext: RequestContext,
184   action: SessionAction[SessionUnvote]
185 ) extends LoggableHistoryEvent[SessionUnvote] {
186   override def toUserHistoryEvent(userId: UserId): LogUserUnvoteEvent = {
187     LogUserUnvoteEvent(
188       userId = userId,
189       requestContext = requestContext,
190       action = UserAction[UserUnvote](
191         date = action.date,
192         actionType = action.actionType,
193         arguments = UserUnvote(
194           proposalId = action.arguments.proposalId,
195           voteKey = action.arguments.voteKey,
196           trust = action.arguments.trust
197         )
198       )
199     )
200   }
201 }
202 
203 object LogSessionUnvoteEvent {
204   val action: String = "unvote"
205 
206   implicit val format: RootJsonFormat[LogSessionUnvoteEvent] =
207     DefaultJsonProtocol.jsonFormat(LogSessionUnvoteEvent.apply, "sessionId", "context", "action")
208 }
209 
210 final case class LogSessionQualificationEvent(
211   sessionId: SessionId,
212   requestContext: RequestContext,
213   action: SessionAction[SessionQualification]
214 ) extends LoggableHistoryEvent[SessionQualification] {
215   override def toUserHistoryEvent(userId: UserId): LogUserQualificationEvent = {
216     LogUserQualificationEvent(
217       userId = userId,
218       requestContext = requestContext,
219       action = UserAction[UserQualification](
220         date = action.date,
221         actionType = action.actionType,
222         arguments = UserQualification(
223           proposalId = action.arguments.proposalId,
224           qualificationKey = action.arguments.qualificationKey,
225           trust = action.arguments.trust
226         )
227       )
228     )
229   }
230 }
231 
232 object LogSessionQualificationEvent {
233   val action: String = "qualification"
234 
235   implicit val format: RootJsonFormat[LogSessionQualificationEvent] =
236     DefaultJsonProtocol.jsonFormat(LogSessionQualificationEvent.apply, "sessionId", "context", "action")
237 }
238 
239 final case class LogSessionUnqualificationEvent(
240   sessionId: SessionId,
241   requestContext: RequestContext,
242   action: SessionAction[SessionUnqualification]
243 ) extends LoggableHistoryEvent[SessionUnqualification] {
244   override def toUserHistoryEvent(userId: UserId): LogUserUnqualificationEvent = {
245     LogUserUnqualificationEvent(
246       userId = userId,
247       requestContext = requestContext,
248       action = UserAction[UserUnqualification](
249         date = action.date,
250         actionType = action.actionType,
251         arguments = UserUnqualification(
252           proposalId = action.arguments.proposalId,
253           qualificationKey = action.arguments.qualificationKey,
254           trust = action.arguments.trust
255         )
256       )
257     )
258   }
259 }
260 
261 object LogSessionUnqualificationEvent {
262   val action: String = "unqualification"
263 
264   implicit val format: RootJsonFormat[LogSessionUnqualificationEvent] =
265     DefaultJsonProtocol.jsonFormat(LogSessionUnqualificationEvent.apply, "sessionId", "context", "action")
266 }
267 
268 final case class LogSessionSearchProposalsEvent(
269   sessionId: SessionId,
270   requestContext: RequestContext,
271   action: SessionAction[SessionSearchParameters]
272 ) extends LoggableHistoryEvent[SessionSearchParameters] {
273   override def toUserHistoryEvent(userId: UserId): LogUserSearchProposalsEvent = {
274     LogUserSearchProposalsEvent(
275       userId = userId,
276       requestContext = requestContext,
277       action = UserAction[UserSearchParameters](
278         date = action.date,
279         actionType = action.actionType,
280         arguments = UserSearchParameters(term = action.arguments.term)
281       )
282     )
283   }
284 
285 }
286 
287 object LogSessionSearchProposalsEvent {
288   val action: String = "search"
289 
290   implicit val format: RootJsonFormat[LogSessionSearchProposalsEvent] =
291     DefaultJsonProtocol.jsonFormat(LogSessionSearchProposalsEvent.apply, "sessionId", "context", "action")
292 
293 }
294 
295 final case class SessionExpired(sessionId: SessionId, requestContext: RequestContext, action: SessionAction[SessionId])
296     extends SessionHistoryEvent[SessionId]
297 
298 object SessionExpired {
299   implicit val format: RootJsonFormat[SessionExpired] =
300     DefaultJsonProtocol.jsonFormat(SessionExpired.apply, "sessionId", "context", "action")
301 }
302 
303 final case class SessionTransforming(
304   sessionId: SessionId,
305   requestContext: RequestContext,
306   action: SessionAction[UserId]
307 ) extends SessionHistoryEvent[UserId]
308 
309 object SessionTransforming {
310   implicit val format: RootJsonFormat[SessionTransforming] =
311     DefaultJsonProtocol.jsonFormat(SessionTransforming.apply, "sessionId", "context", "action")
312 }
313 
314 final case class SessionTransformed(sessionId: SessionId, requestContext: RequestContext, action: SessionAction[UserId])
315     extends SessionHistoryEvent[UserId]
316 
317 object SessionTransformed {
318   implicit val format: RootJsonFormat[SessionTransformed] =
319     DefaultJsonProtocol.jsonFormat(SessionTransformed.apply, "sessionId", "context", "action")
320 }
321 
322 final case class SaveLastEventDate(
323   sessionId: SessionId,
324   requestContext: RequestContext,
325   action: SessionAction[Option[ZonedDateTime]]
326 ) extends SessionHistoryEvent[Option[ZonedDateTime]]
327 
328 object SaveLastEventDate {
329   implicit val format: RootJsonFormat[SaveLastEventDate] =
330     DefaultJsonProtocol.jsonFormat(SaveLastEventDate.apply, "sessionId", "context", "action")
331 }
332 
333 final case class LogSessionStartSequenceEvent(
334   sessionId: SessionId,
335   requestContext: RequestContext,
336   action: SessionAction[StartSequenceParameters]
337 ) extends LoggableHistoryEvent[StartSequenceParameters] {
338   override def toUserHistoryEvent(userId: UserId): LogUserStartSequenceEvent =
339     LogUserStartSequenceEvent(
340       userId,
341       requestContext,
342       UserAction(date = action.date, actionType = LogUserStartSequenceEvent.action, arguments = action.arguments)
343     )
344 }
345 
346 object LogSessionStartSequenceEvent {
347   val action: String = "start-sequence"
348 
349   implicit val logSessionStartSequenceEventFormatted: RootJsonFormat[LogSessionStartSequenceEvent] =
350     DefaultJsonProtocol.jsonFormat(LogSessionStartSequenceEvent.apply, "sessionId", "context", "action")
351 }