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 com.sksamuel.avro4s.{AvroDefault, AvroSortPriority}
23 import org.make.api.proposal.ProposalEvent.DeprecatedEvent
24 import org.make.core.SprayJsonFormatters._
25 import org.make.core._
26 import org.make.core.history.HistoryActions.VoteTrust
27 import org.make.core.history.HistoryActions.VoteTrust.Trusted
28 import org.make.core.idea.IdeaId
29 import org.make.core.operation.OperationId
30 import org.make.core.proposal._
31 import org.make.core.question.QuestionId
32 import org.make.core.reference.{Country, Language}
33 import org.make.core.tag.TagId
34 import org.make.core.technical.Multilingual
35 import org.make.core.user.UserId
36 import spray.json.DefaultJsonProtocol._
37 import spray.json.{DefaultJsonProtocol, RootJsonFormat}
38 
39 import java.time.ZonedDateTime
40 
41 sealed trait ProposalEvent extends MakeSerializable {
42   def id: ProposalId
43   def requestContext: RequestContext
44   def eventDate: ZonedDateTime
45 }
46 
47 object ProposalEvent {
48 
49   trait DeprecatedEvent
50 
51   private val defaultDate: ZonedDateTime = ZonedDateTime.parse("2017-11-01T09:00:00Z")
52 
53   final case class SimilarProposalsCleared(
54     id: ProposalId,
55     eventDate: ZonedDateTime = defaultDate,
56     requestContext: RequestContext
57   ) extends ProposalEvent
58       with DeprecatedEvent
59 
60   object SimilarProposalsCleared {
61 
62     implicit val formatter: RootJsonFormat[SimilarProposalsCleared] =
63       DefaultJsonProtocol.jsonFormat3(SimilarProposalsCleared.apply)
64   }
65 
66   // This event isn't published and so doesn't need to be in the coproduct
67   final case class SimilarProposalRemoved(
68     id: ProposalId,
69     proposalToRemove: ProposalId,
70     eventDate: ZonedDateTime = defaultDate,
71     requestContext: RequestContext
72   ) extends ProposalEvent
73       with DeprecatedEvent
74 
75   object SimilarProposalRemoved {
76 
77     implicit val formatter: RootJsonFormat[SimilarProposalRemoved] =
78       DefaultJsonProtocol.jsonFormat4(SimilarProposalRemoved.apply)
79   }
80 }
81 
82 sealed trait PublishedProposalEvent extends ProposalEvent {
83   def version(): Int
84   def eventId: Option[EventId]
85 }
86 
87 object PublishedProposalEvent {
88 
89   @AvroSortPriority(15)
90   final case class ProposalReportedNotice(
91     override val id: ProposalId,
92     proposalLanguage: Language,
93     reason: ProposalReportReason,
94     override val eventDate: ZonedDateTime,
95     override val requestContext: RequestContext,
96     override val eventId: Option[EventId] = None
97   ) extends PublishedProposalEvent {
98 
99     override def version(): Int = MakeSerializable.V1
100   }
101 
102   object ProposalReportedNotice {
103 
104     val actionType: String = "proposal-reported"
105 
106     implicit val formatter: RootJsonFormat[ProposalReportedNotice] =
107       DefaultJsonProtocol.jsonFormat6(ProposalReportedNotice.apply)
108 
109   }
110 
111   private val defaultDate: ZonedDateTime = ZonedDateTime.parse("2017-11-01T09:00:00Z")
112 
113   @AvroSortPriority(6)
114   final case class ProposalPatched(
115     id: ProposalId,
116     @AvroDefault("2017-11-01T09:00Z") eventDate: ZonedDateTime = defaultDate,
117     requestContext: RequestContext,
118     proposal: Proposal,
119     eventId: Option[EventId] = None
120   ) extends PublishedProposalEvent {
121     override def version(): Int = MakeSerializable.V4
122   }
123 
124   object ProposalPatched {
125 
126     implicit val formatter: RootJsonFormat[ProposalPatched] =
127       DefaultJsonProtocol.jsonFormat5(ProposalPatched.apply)
128   }
129 
130   @AvroSortPriority(20)
131   final case class ProposalProposed(
132     id: ProposalId,
133     slug: String,
134     requestContext: RequestContext,
135     author: ProposalAuthorInfo,
136     userId: UserId,
137     eventDate: ZonedDateTime,
138     content: String,
139     submittedAsLanguage: Option[Language] = None,
140     isAnonymous: Boolean = false,
141     operation: Option[OperationId] = None,
142     language: Option[Language] = None,
143     country: Option[Country] = None,
144     question: Option[QuestionId] = None,
145     initialProposal: Boolean = false,
146     proposalType: ProposalType = ProposalType.ProposalTypeSubmitted,
147     eventId: Option[EventId] = None
148   ) extends PublishedProposalEvent {
149 
150     override def version(): Int = MakeSerializable.V4
151   }
152 
153   object ProposalProposed {
154 
155     implicit val formatter: RootJsonFormat[ProposalProposed] =
156       DefaultJsonProtocol.jsonFormat16(ProposalProposed.apply)
157 
158   }
159 
160   final case class ProposalAuthorInfo(
161     userId: UserId,
162     firstName: Option[String],
163     postalCode: Option[String],
164     age: Option[Int]
165   )
166 
167   object ProposalAuthorInfo {
168     val version: Int = MakeSerializable.V1
169 
170     implicit val formatter: RootJsonFormat[ProposalAuthorInfo] =
171       DefaultJsonProtocol.jsonFormat4(ProposalAuthorInfo.apply)
172 
173   }
174 
175   @AvroSortPriority(16)
176   final case class ProposalViewed(
177     id: ProposalId,
178     eventDate: ZonedDateTime,
179     requestContext: RequestContext,
180     eventId: Option[EventId] = None
181   ) extends PublishedProposalEvent {
182 
183     override def version(): Int = MakeSerializable.V1
184   }
185 
186   object ProposalViewed {
187 
188     implicit val formatter: RootJsonFormat[ProposalViewed] =
189       DefaultJsonProtocol.jsonFormat4(ProposalViewed.apply)
190 
191   }
192 
193   @AvroSortPriority(15)
194   final case class ProposalUpdated(
195     id: ProposalId,
196     eventDate: ZonedDateTime,
197     requestContext: RequestContext,
198     updatedAt: ZonedDateTime,
199     moderator: Option[UserId] = None,
200     edition: Option[ProposalEdition] = None,
201     tags: Seq[TagId] = Seq.empty,
202     similarProposals: Seq[ProposalId] = Seq.empty,
203     idea: Option[IdeaId] = None,
204     operation: Option[OperationId] = None,
205     submittedAsLanguage: Option[Language] = None,
206     question: Option[QuestionId] = None,
207     eventId: Option[EventId] = None
208   ) extends PublishedProposalEvent {
209 
210     override def version(): Int = MakeSerializable.V1
211   }
212 
213   object ProposalUpdated {
214 
215     val actionType: String = "proposal-updated"
216 
217     implicit val formatter: RootJsonFormat[ProposalUpdated] =
218       DefaultJsonProtocol.jsonFormat13(ProposalUpdated.apply)
219 
220   }
221 
222   @AvroSortPriority(14)
223   @Deprecated
224   final case class ProposalVotesVerifiedUpdated(
225     id: ProposalId,
226     eventDate: ZonedDateTime,
227     requestContext: RequestContext,
228     updatedAt: ZonedDateTime,
229     moderator: Option[UserId] = None,
230     question: Option[QuestionId] = None,
231     updatedVerifiedVotes: Option[VotingOptions] = None,
232     eventId: Option[EventId] = None
233   ) extends PublishedProposalEvent {
234 
235     override def version(): Int = MakeSerializable.V1
236   }
237 
238   object ProposalVotesVerifiedUpdated {
239 
240     val actionType: String = "proposal-votes-verified-updated"
241 
242     implicit val formatter: RootJsonFormat[ProposalVotesVerifiedUpdated] =
243       DefaultJsonProtocol.jsonFormat8(ProposalVotesVerifiedUpdated.apply)
244   }
245 
246   @AvroSortPriority(2)
247   final case class ProposalVotesUpdated(
248     id: ProposalId,
249     eventDate: ZonedDateTime,
250     requestContext: RequestContext,
251     updatedAt: ZonedDateTime,
252     moderator: Option[UserId] = None,
253     updatedVotes: Option[VotingOptions] = None,
254     eventId: Option[EventId] = None
255   ) extends PublishedProposalEvent {
256 
257     override def version(): Int = MakeSerializable.V1
258   }
259 
260   object ProposalVotesUpdated {
261 
262     val actionType: String = "proposal-votes-updated"
263 
264     implicit val formatter: RootJsonFormat[ProposalVotesUpdated] =
265       DefaultJsonProtocol.jsonFormat7(ProposalVotesUpdated.apply)
266   }
267 
268   @AvroSortPriority(13)
269   final case class ReindexProposal(
270     id: ProposalId,
271     eventDate: ZonedDateTime,
272     requestContext: RequestContext,
273     eventId: Option[EventId] = None
274   ) extends PublishedProposalEvent {
275     override def version(): Int = MakeSerializable.V1
276   }
277 
278   object ReindexProposal {
279 
280     val actionType: String = "proposals-tags-updated"
281 
282     implicit val formatter: RootJsonFormat[ReindexProposal] =
283       DefaultJsonProtocol.jsonFormat4(ReindexProposal.apply)
284   }
285 
286   @AvroSortPriority(19)
287   final case class ProposalAccepted(
288     id: ProposalId,
289     eventDate: ZonedDateTime,
290     requestContext: RequestContext,
291     moderator: UserId,
292     edition: Option[ProposalEdition],
293     sendValidationEmail: Boolean,
294     tags: Seq[TagId],
295     similarProposals: Seq[ProposalId],
296     idea: Option[IdeaId] = None,
297     operation: Option[OperationId] = None,
298     question: Option[QuestionId] = None,
299     eventId: Option[EventId] = None
300   ) extends PublishedProposalEvent {
301 
302     override def version(): Int = MakeSerializable.V1
303   }
304 
305   object ProposalAccepted {
306 
307     val actionType: String = "proposal-accepted"
308 
309     implicit val formatter: RootJsonFormat[ProposalAccepted] =
310       DefaultJsonProtocol.jsonFormat12(ProposalAccepted.apply)
311 
312   }
313 
314   @AvroSortPriority(18)
315   final case class ProposalRefused(
316     id: ProposalId,
317     eventDate: ZonedDateTime,
318     requestContext: RequestContext,
319     moderator: UserId,
320     sendRefuseEmail: Boolean,
321     refusalReason: Option[String],
322     operation: Option[OperationId] = None,
323     eventId: Option[EventId] = None
324   ) extends PublishedProposalEvent {
325 
326     override def version(): Int = MakeSerializable.V1
327   }
328 
329   object ProposalRefused {
330 
331     val actionType: String = "proposal-refused"
332 
333     implicit val formatter: RootJsonFormat[ProposalRefused] =
334       DefaultJsonProtocol.jsonFormat8(ProposalRefused.apply)
335 
336   }
337 
338   @AvroSortPriority(17)
339   final case class ProposalPostponed(
340     id: ProposalId,
341     @AvroDefault("2017-11-01T09:00Z") eventDate: ZonedDateTime = defaultDate,
342     requestContext: RequestContext,
343     moderator: UserId,
344     eventId: Option[EventId] = None
345   ) extends PublishedProposalEvent {
346 
347     override def version(): Int = MakeSerializable.V1
348   }
349 
350   object ProposalPostponed {
351 
352     val actionType: String = "proposal-postponed"
353 
354     implicit val formatter: RootJsonFormat[ProposalPostponed] =
355       DefaultJsonProtocol.jsonFormat5(ProposalPostponed.apply)
356 
357   }
358 
359   @AvroSortPriority(12)
360   final case class ProposalVoted(
361     id: ProposalId,
362     maybeUserId: Option[UserId],
363     eventDate: ZonedDateTime,
364     //@Deprecated(since = "05/09/2018. Use the maybeOrganisationId field instead")
365     organisationInfo: Option[OrganisationInfo] = None,
366     maybeOrganisationId: Option[UserId],
367     requestContext: RequestContext,
368     voteKey: VoteKey,
369     @AvroDefault("trusted") voteTrust: VoteTrust = Trusted,
370     eventId: Option[EventId] = None
371   ) extends PublishedProposalEvent {
372 
373     override def version(): Int = MakeSerializable.V4
374   }
375 
376   object ProposalVoted {
377 
378     implicit val formatter: RootJsonFormat[ProposalVoted] =
379       DefaultJsonProtocol.jsonFormat9(ProposalVoted.apply)
380 
381   }
382 
383   @AvroSortPriority(11)
384   final case class ProposalUnvoted(
385     id: ProposalId,
386     maybeUserId: Option[UserId],
387     eventDate: ZonedDateTime,
388     //@Deprecated(since = "05/09/2018. Use the maybeOrganisationId field instead")
389     organisationInfo: Option[OrganisationInfo] = None,
390     maybeOrganisationId: Option[UserId],
391     requestContext: RequestContext,
392     voteKey: VoteKey,
393     selectedQualifications: Seq[QualificationKey],
394     @AvroDefault("trusted") voteTrust: VoteTrust = Trusted,
395     eventId: Option[EventId] = None
396   ) extends PublishedProposalEvent {
397 
398     override def version(): Int = MakeSerializable.V4
399   }
400 
401   object ProposalUnvoted {
402 
403     implicit val formatter: RootJsonFormat[ProposalUnvoted] =
404       DefaultJsonProtocol.jsonFormat10(ProposalUnvoted.apply)
405   }
406 
407   @AvroSortPriority(10)
408   final case class ProposalQualified(
409     id: ProposalId,
410     maybeUserId: Option[UserId],
411     eventDate: ZonedDateTime,
412     requestContext: RequestContext,
413     voteKey: VoteKey,
414     qualificationKey: QualificationKey,
415     @AvroDefault("trusted") voteTrust: VoteTrust = Trusted,
416     eventId: Option[EventId] = None
417   ) extends PublishedProposalEvent {
418 
419     override def version(): Int = MakeSerializable.V2
420   }
421 
422   object ProposalQualified {
423 
424     implicit val formatter: RootJsonFormat[ProposalQualified] =
425       DefaultJsonProtocol.jsonFormat8(ProposalQualified.apply)
426 
427   }
428 
429   @AvroSortPriority(9)
430   final case class ProposalUnqualified(
431     id: ProposalId,
432     maybeUserId: Option[UserId],
433     eventDate: ZonedDateTime,
434     requestContext: RequestContext,
435     voteKey: VoteKey,
436     qualificationKey: QualificationKey,
437     @AvroDefault("trusted") voteTrust: VoteTrust = Trusted,
438     eventId: Option[EventId] = None
439   ) extends PublishedProposalEvent {
440 
441     override def version(): Int = MakeSerializable.V2
442   }
443 
444   object ProposalUnqualified {
445 
446     implicit val formatter: RootJsonFormat[ProposalUnqualified] =
447       DefaultJsonProtocol.jsonFormat8(ProposalUnqualified.apply)
448 
449   }
450 
451   final case class ProposalEdition(
452     oldVersion: String,
453     newVersion: Option[String] = None,
454     oldContentTranslations: Option[Multilingual[String]] = None,
455     newContentTranslations: Option[Multilingual[String]] = None
456   )
457 
458   object ProposalEdition {
459     implicit val formatter: RootJsonFormat[ProposalEdition] =
460       DefaultJsonProtocol.jsonFormat4(ProposalEdition.apply)
461 
462   }
463 
464   @AvroSortPriority(8)
465   final case class SimilarProposalsAdded(
466     id: ProposalId,
467     similarProposals: Set[ProposalId],
468     requestContext: RequestContext,
469     eventDate: ZonedDateTime,
470     eventId: Option[EventId] = None
471   ) extends PublishedProposalEvent
472       with DeprecatedEvent {
473 
474     override def version(): Int = MakeSerializable.V1
475   }
476 
477   object SimilarProposalsAdded {
478 
479     implicit val formatter: RootJsonFormat[SimilarProposalsAdded] =
480       DefaultJsonProtocol.jsonFormat5(SimilarProposalsAdded.apply)
481   }
482 
483   @AvroSortPriority(7)
484   final case class ProposalLocked(
485     id: ProposalId,
486     moderatorId: UserId,
487     moderatorName: Option[String] = None,
488     @AvroDefault("2017-11-01T09:00Z") eventDate: ZonedDateTime = defaultDate,
489     requestContext: RequestContext,
490     eventId: Option[EventId] = None
491   ) extends PublishedProposalEvent {
492 
493     override def version(): Int = MakeSerializable.V1
494   }
495 
496   object ProposalLocked {
497 
498     val actionType: String = "proposal-locked"
499 
500     implicit val formatter: RootJsonFormat[ProposalLocked] =
501       DefaultJsonProtocol.jsonFormat6(ProposalLocked.apply)
502 
503   }
504 
505   @AvroSortPriority(5)
506   final case class ProposalAddedToOperation(
507     id: ProposalId,
508     operationId: OperationId,
509     moderatorId: UserId,
510     @AvroDefault("2017-11-01T09:00Z") eventDate: ZonedDateTime = defaultDate,
511     requestContext: RequestContext,
512     eventId: Option[EventId] = None
513   ) extends PublishedProposalEvent {
514 
515     override def version(): Int = MakeSerializable.V1
516   }
517 
518   object ProposalAddedToOperation {
519 
520     implicit val formatter: RootJsonFormat[ProposalAddedToOperation] =
521       DefaultJsonProtocol.jsonFormat6(ProposalAddedToOperation.apply)
522   }
523 
524   @AvroSortPriority(4)
525   final case class ProposalRemovedFromOperation(
526     id: ProposalId,
527     operationId: OperationId,
528     moderatorId: UserId,
529     @AvroDefault("2017-11-01T09:00Z") eventDate: ZonedDateTime = defaultDate,
530     requestContext: RequestContext,
531     eventId: Option[EventId] = None
532   ) extends PublishedProposalEvent {
533 
534     override def version(): Int = MakeSerializable.V1
535   }
536   object ProposalRemovedFromOperation {
537 
538     implicit val formatter: RootJsonFormat[ProposalRemovedFromOperation] =
539       DefaultJsonProtocol.jsonFormat6(ProposalRemovedFromOperation.apply)
540   }
541 
542   @AvroSortPriority(3)
543   final case class ProposalAnonymized(
544     id: ProposalId,
545     @AvroDefault("2017-11-01T09:00Z") eventDate: ZonedDateTime = defaultDate,
546     requestContext: RequestContext,
547     eventId: Option[EventId] = None
548   ) extends PublishedProposalEvent {
549     override def version(): Int = MakeSerializable.V1
550   }
551 
552   object ProposalAnonymized {
553 
554     implicit val formatter: RootJsonFormat[ProposalAnonymized] =
555       DefaultJsonProtocol.jsonFormat4(ProposalAnonymized.apply)
556   }
557 
558   @AvroSortPriority(1)
559   final case class ProposalKeywordsSet(
560     id: ProposalId,
561     eventDate: ZonedDateTime,
562     keywords: Seq[ProposalKeyword],
563     requestContext: RequestContext,
564     eventId: Option[EventId] = None
565   ) extends PublishedProposalEvent {
566     override def version(): Int = MakeSerializable.V1
567   }
568 
569   object ProposalKeywordsSet {
570     implicit val formatter: RootJsonFormat[ProposalKeywordsSet] =
571       DefaultJsonProtocol.jsonFormat5(ProposalKeywordsSet.apply)
572   }
573 
574 }