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.core.proposal
21 
22 import cats.implicits._
23 import com.github.plokhotnyuk.jsoniter_scala.core._
24 import com.github.plokhotnyuk.jsoniter_scala.macros._
25 import com.sksamuel.avro4s.AvroSortPriority
26 import enumeratum.values.{StringCirceEnum, StringEnum, StringEnumEntry}
27 import io.circe.generic.extras.JsonKey
28 import io.circe.generic.extras.semiauto.{
29   deriveConfiguredCodec   => deriveCodec,
30   deriveConfiguredDecoder => deriveDecoder,
31   deriveConfiguredEncoder => deriveEncoder
32 }
33 import io.circe.{Codec, Decoder, Encoder}
34 import io.swagger.annotations.ApiModelProperty
35 import org.make.api.proposal.ProposalScorer
36 import org.make.api.proposal.ProposalScorer.VotesCounter
37 import org.make.core._
38 import org.make.core.idea.IdeaId
39 import org.make.core.jsoniter.JsoniterEnum
40 import org.make.core.operation.OperationId
41 import org.make.core.proposal.ProposalStatus.Accepted
42 import org.make.core.proposal.QualificationKey.{
43   DoNotCare,
44   DoNotUnderstand,
45   Doable,
46   Impossible,
47   LikeIt,
48   NoOpinion,
49   NoWay,
50   PlatitudeAgree,
51   PlatitudeDisagree
52 }
53 import org.make.core.proposal.VoteKey.{Agree, Disagree, Neutral}
54 import org.make.core.proposal.indexed.Zone
55 import org.make.core.question.QuestionId
56 import org.make.core.reference.Language
57 import org.make.core.sequence.ExplorationSequenceConfiguration.SequenceThresholds
58 import org.make.core.tag.{TagId, TagType, TagTypeId}
59 import org.make.core.technical.Multilingual
60 import org.make.core.user.UserId
61 import spray.json.RootJsonFormat
62 
63 import java.time.ZonedDateTime
64 import scala.annotation.meta.field
65 
66 final case class Proposal(
67   proposalId: ProposalId,
68   slug: String,
69   content: String,
70   submittedAsLanguage: Option[Language] = None,
71   contentTranslations: Option[Multilingual[String]] = None,
72   author: UserId,
73   status: ProposalStatus = ProposalStatus.Pending,
74   refusalReason: Option[String] = None,
75   tags: Seq[TagId] = Seq.empty,
76   @JsonKey("votes") votingOptions: Option[VotingOptions] = None,
77   isAnonymous: Boolean = false,
78   organisationIds: Seq[UserId] = Seq.empty,
79   questionId: Option[QuestionId] = None,
80   creationContext: RequestContext,
81   idea: Option[IdeaId] = None,
82   operation: Option[OperationId] = None,
83   proposalType: ProposalType = ProposalType.ProposalTypeSubmitted,
84   override val createdAt: Option[ZonedDateTime],
85   override val updatedAt: Option[ZonedDateTime],
86   validatedAt: Option[ZonedDateTime] = None,
87   postponedAt: Option[ZonedDateTime] = None,
88   events: List[ProposalAction],
89   initialProposal: Boolean = false,
90   keywords: Seq[ProposalKeyword] = Nil
91 ) extends Timestamped
92     with MakeSerializable {
93 
94   def getZone(threshold: SequenceThresholds): Zone =
95     votingOptions
96       .map(ProposalScorer(_, VotesCounter.VerifiedVotesVotesCounter, 0.5).zone(threshold))
97       .getOrElse(Zone.Limbo)
98 }
99 
100 object Proposal extends CirceFormatters {
101   implicit val encoder: Encoder[Proposal] = deriveEncoder
102   implicit val decoder: Decoder[Proposal] = deriveDecoder
103   implicit val writer: RootJsonFormat[Proposal] = circeCodec2sprayFormatter
104 
105   def needsEnrichment(status: ProposalStatus, tagTypes: Seq[TagType], proposalTagTypes: Seq[TagTypeId]): Boolean = {
106     val proposalTypesSet = proposalTagTypes.toSet
107     status == Accepted && !tagTypes.filter(_.requiredForEnrichment).map(_.tagTypeId).forall(proposalTypesSet.contains)
108   }
109 
110 }
111 
112 final case class ProposalId(value: String) extends StringValue
113 
114 object ProposalId extends CirceFormatters {
115   implicit lazy val proposalIdEncoder: Encoder[ProposalId] =
116     Encoder.encodeString.contramap(_.value)
117   implicit lazy val proposalIdDecoder: Decoder[ProposalId] =
118     Decoder.decodeString.map(ProposalId(_))
119   implicit lazy val proposalFormat: RootJsonFormat[ProposalId] =
120     circeCodec2sprayFormatter
121 
122   implicit val proposalIdCodec: JsonValueCodec[ProposalId] =
123     StringValue.makeCodec(ProposalId.apply)
124 }
125 
126 final case class OrganisationInfo(organisationId: UserId, organisationName: Option[String])
127 
128 object OrganisationInfo extends CirceFormatters {
129   implicit val encoder: Encoder[OrganisationInfo] = deriveEncoder[OrganisationInfo]
130   implicit val decoder: Decoder[OrganisationInfo] = deriveDecoder[OrganisationInfo]
131   implicit lazy val organisationInfoFormat: RootJsonFormat[OrganisationInfo] =
132     circeCodec2sprayFormatter
133 }
134 
135 final case class ProposalAction(date: ZonedDateTime, user: UserId, actionType: String, arguments: Map[String, String])
136 
137 object ProposalAction extends CirceFormatters {
138   implicit val codec: Codec[ProposalAction] = deriveCodec
139   implicit val proposalActionFormat: RootJsonFormat[ProposalAction] =
140     circeCodec2sprayFormatter
141 }
142 
143 sealed abstract class ProposalActionType(val value: String) extends StringEnumEntry
144 
145 object ProposalActionType extends StringEnum[ProposalActionType] {
146 
147   final case object ProposalProposeAction extends ProposalActionType("propose")
148   final case object ProposalUpdateAction extends ProposalActionType("update")
149   final case object ProposalUpdateVoteVerifiedAction extends ProposalActionType("update-votes-verified")
150   final case object ProposalAcceptAction extends ProposalActionType("accept")
151   final case object ProposalVoteAction extends ProposalActionType("vote")
152   final case object ProposalUnvoteAction extends ProposalActionType("unvote")
153   final case object ProposalQualifyAction extends ProposalActionType("qualify")
154   final case object ProposalUnqualifyAction extends ProposalActionType("unqualify")
155 
156   override val values: IndexedSeq[ProposalActionType] = findValues
157 
158 }
159 
160 sealed abstract class QualificationKey(val value: String) extends StringEnumEntry with Key
161 
162 object QualificationKey
163     extends StringEnum[QualificationKey]
164     with StringCirceEnum[QualificationKey]
165     with JsoniterEnum[QualificationKey] {
166 
167   final case object LikeIt extends QualificationKey("likeIt")
168   final case object Doable extends QualificationKey("doable")
169   final case object PlatitudeAgree extends QualificationKey("platitudeAgree")
170   final case object NoWay extends QualificationKey("noWay")
171   final case object Impossible extends QualificationKey("impossible")
172   final case object PlatitudeDisagree extends QualificationKey("platitudeDisagree")
173   final case object DoNotUnderstand extends QualificationKey("doNotUnderstand")
174   final case object NoOpinion extends QualificationKey("noOpinion")
175   final case object DoNotCare extends QualificationKey("doNotCare")
176 
177   override def values: IndexedSeq[QualificationKey] = findValues
178   final val swaggerAllowableValues =
179     "likeIt,doable,platitudeAgree,noWay,impossible,platitudeDisagree,doNotUnderstand,noOpinion,doNotCare"
180 }
181 
182 trait BaseQualification extends BaseVoteOrQualification[QualificationKey]
183 
184 final case class Qualification(
185   @(ApiModelProperty @field)(dataType = "string", example = "likeIt") override val key: QualificationKey,
186   override val count: Int,
187   override val countVerified: Int,
188   override val countSequence: Int,
189   override val countSegment: Int
190 ) extends BaseQualification
191 
192 object Qualification extends CirceFormatters {
193   implicit val encoder: Encoder[Qualification] = deriveEncoder[Qualification]
194   implicit val decoder: Decoder[Qualification] = deriveDecoder[Qualification]
195   implicit val qualificationFormat: RootJsonFormat[Qualification] = circeCodec2sprayFormatter
196 }
197 
198 trait BaseVoteOrQualification[KeyType <: Key] {
199   def key: KeyType
200   def count: Int
201   def countVerified: Int
202   def countSequence: Int
203   def countSegment: Int
204 }
205 
206 trait BaseVote extends BaseVoteOrQualification[VoteKey]
207 
208 object BaseVote {
209 
210   def rate(votingOptions: VotingOptions, key: VoteKey): Double = {
211     val total = votingOptions.counts.totalVotes
212     if (total === 0) 0
213     else votingOptions.getVote(key).count.toDouble / total
214   }
215 }
216 
217 final case class Vote(
218   @(ApiModelProperty @field)(dataType = "string", example = "agree")
219   override val key: VoteKey,
220   override val count: Int,
221   override val countVerified: Int,
222   override val countSequence: Int,
223   override val countSegment: Int,
224   qualifications: Seq[Qualification] = Seq.empty
225 ) extends BaseVote
226 
227 object Vote extends CirceFormatters {
228 
229   implicit val encoder: Encoder[Vote] = deriveEncoder[Vote]
230   implicit val decoder: Decoder[Vote] = deriveDecoder[Vote]
231   implicit val voteFormat: RootJsonFormat[Vote] = circeCodec2sprayFormatter
232 
233   def empty(key: VoteKey): Vote = Vote(key, 0, 0, 0, 0)
234 }
235 
236 sealed abstract class ProposalType(val value: String) extends StringEnumEntry with Product with Serializable
237 
238 object ProposalType
239     extends StringEnum[ProposalType]
240     with StringCirceEnum[ProposalType]
241     with JsoniterEnum[ProposalType] {
242 
243   final case object ProposalTypeSubmitted extends ProposalType("SUBMITTED")
244   final case object ProposalTypeExternal extends ProposalType("EXTERNAL")
245   final case object ProposalTypeInitial extends ProposalType("INITIAL")
246 
247   override def values: IndexedSeq[ProposalType] = findValues
248 
249 }
250 
251 sealed trait Key
252 
253 object Key {
254   implicit class CountOps[T <: Key](val key: T) extends AnyVal {
255     def count(voteCounts: VoteCounts)(implicit c: HasCount[T]): Int = c.keyCount(voteCounts)
256   }
257 
258   implicit class SmoothingOps[T <: Key](val key: T) extends AnyVal {
259     def smoothing(implicit s: HasSmoothing[T]): Double = s.smoothing()
260   }
261 }
262 
263 trait HasCount[T] {
264   def keyCount(voteCounts: VoteCounts): Int
265 }
266 
267 object HasCount {
268   implicit val agreeCount: HasCount[Agree.type] = _.agreeVote
269   implicit val disagreeCount: HasCount[Disagree.type] = _.disagreeVote
270   implicit val neutralCount: HasCount[Neutral.type] = _.neutralVote
271   implicit val doNotCareCount: HasCount[DoNotCare.type] = _.doNotCare
272   implicit val doNotUnderstandCount: HasCount[DoNotUnderstand.type] = _.doNotUnderstand
273   implicit val doableCount: HasCount[Doable.type] = _.doable
274   implicit val impossibleCount: HasCount[Impossible.type] = _.impossible
275   implicit val likeItCount: HasCount[LikeIt.type] = _.likeIt
276   implicit val noOpinionCount: HasCount[NoOpinion.type] = _.noOpinion
277   implicit val noWayCount: HasCount[NoWay.type] = _.noWay
278   implicit val platitudeAgreeCount: HasCount[PlatitudeAgree.type] = _.platitudeAgree
279   implicit val platitudeDisagreeCount: HasCount[PlatitudeDisagree.type] = _.platitudeDisagree
280 }
281 
282 trait HasSmoothing[T <: Key] {
283   def smoothing(): Double
284 }
285 
286 object HasSmoothing {
287   implicit def voteSmoothing[T <: VoteKey]: HasSmoothing[T] = new HasSmoothing[T] {
288     override def smoothing(): Double = ProposalScorer.votesSmoothing
289   }
290 
291   implicit def qualificationSmoothing[T <: QualificationKey]: HasSmoothing[T] = new HasSmoothing[T] {
292     override def smoothing(): Double = ProposalScorer.qualificationsSmoothing
293   }
294 }
295 sealed abstract class VoteKey(val value: String) extends StringEnumEntry with Key with Product with Serializable
296 
297 object VoteKey extends StringEnum[VoteKey] with StringCirceEnum[VoteKey] with JsoniterEnum[VoteKey] {
298 
299   final case object Agree extends VoteKey("agree")
300   final case object Disagree extends VoteKey("disagree")
301   final case object Neutral extends VoteKey("neutral")
302 
303   override def values: IndexedSeq[VoteKey] = findValues
304   final val swaggerAllowableValues = "agree,disagree,neutral"
305 }
306 
307 sealed abstract class ProposalStatus(val value: String) extends StringEnumEntry with Product with Serializable
308 
309 object ProposalStatus
310     extends StringEnum[ProposalStatus]
311     with StringCirceEnum[ProposalStatus]
312     with JsoniterEnum[ProposalStatus] {
313 
314   @AvroSortPriority(5)
315   final case object Pending extends ProposalStatus("Pending")
316 
317   @AvroSortPriority(1)
318   final case object Accepted extends ProposalStatus("Accepted")
319 
320   @AvroSortPriority(3)
321   final case object Refused extends ProposalStatus("Refused")
322 
323   @AvroSortPriority(4)
324   final case object Postponed extends ProposalStatus("Postponed")
325 
326   @AvroSortPriority(2)
327   final case object Archived extends ProposalStatus("Archived")
328 
329   override def values: IndexedSeq[ProposalStatus] = findValues
330   final val swaggerAllowableValues = "Pending,Accepted,Refused,Postponed,Archived"
331 }
332 
333 final case class ProposalKeyword(
334   @(ApiModelProperty @field)(dataType = "string", required = true)
335   key: ProposalKeywordKey,
336   label: String
337 )
338 
339 object ProposalKeyword extends CirceFormatters {
340   implicit val codec: Codec[ProposalKeyword] = deriveCodec[ProposalKeyword]
341   implicit val format: RootJsonFormat[ProposalKeyword] = circeCodec2sprayFormatter
342 
343   implicit val proposalKeywordCodec: JsonValueCodec[ProposalKeyword] =
344     JsonCodecMaker.makeWithRequiredCollectionFields
345 }
346 
347 final case class ProposalKeywordKey(value: String) extends StringValue
348 
349 object ProposalKeywordKey extends CirceFormatters {
350 
351   implicit val codec: Codec[ProposalKeywordKey] =
352     Codec.from(Decoder[String].map(ProposalKeywordKey.apply), Encoder[String].contramap(_.value))
353   implicit val format: RootJsonFormat[ProposalKeywordKey] = circeCodec2sprayFormatter
354 
355   implicit val proposalKeywordKeycodec: JsonValueCodec[ProposalKeywordKey] =
356     StringValue.makeCodec(ProposalKeywordKey.apply)
357 }
358 
359 sealed abstract class ProposalReportReason(val value: String) extends StringEnumEntry
360 
361 object ProposalReportReason extends StringEnum[ProposalReportReason] with StringCirceEnum[ProposalReportReason] {
362 
363   final case object Inintelligible extends ProposalReportReason("Inintelligible")
364   final case object BadTranslation extends ProposalReportReason("BadTranslation")
365   final case object IncorrectInformation extends ProposalReportReason("IncorrectInformation")
366   final case object Offensive extends ProposalReportReason("Offensive")
367 
368   override val values: IndexedSeq[ProposalReportReason] = findValues
369   final val swaggerAllowableValues = "Inintelligible,BadTranslation,IncorrectInformation,Offensive"
370 }