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.operation
21 
22 import enumeratum.values.{StringCirceEnum, StringEnum, StringEnumEntry}
23 import enumeratum.{Circe, Enum, EnumEntry}
24 import eu.timepit.refined.api.Refined
25 import eu.timepit.refined.collection.MaxSize
26 import io.circe.generic.semiauto._
27 import io.circe.{Codec, Decoder, Encoder, Json, KeyDecoder, KeyEncoder}
28 import io.circe.parser.decode
29 import io.circe.refined._
30 import io.circe.syntax.EncoderOps
31 import io.swagger.annotations.ApiModelProperty
32 import org.make.core.SprayJsonFormatters._
33 import org.make.core._
34 import org.make.core.Validation._
35 import org.make.core.technical.Multilingual
36 import org.make.core.technical.enumeratum.EnumKeys.StringEnumKeys
37 import org.make.core.question.{Question, QuestionId}
38 import org.make.core.user.UserId
39 import org.make.core.jsoniter.JsoniterEnum
40 import com.github.plokhotnyuk.jsoniter_scala.core._
41 import scalikejdbc.Binders
42 import spray.json.DefaultJsonProtocol._
43 import spray.json.{DefaultJsonProtocol, JsonFormat, RootJsonFormat}
44 
45 import java.time.{LocalDate, ZonedDateTime}
46 import scala.annotation.meta.field
47 
48 final case class QuestionWithDetails(question: Question, details: OperationOfQuestion)
49 
50 final case class Operation(
51   operationId: OperationId,
52   slug: String,
53   events: List[OperationAction],
54   questions: Seq[QuestionWithDetails],
55   operationKind: OperationKind,
56   operationAuthentication: Option[OperationAuthentication],
57   override val createdAt: Option[ZonedDateTime],
58   override val updatedAt: Option[ZonedDateTime]
59 ) extends MakeSerializable
60     with Timestamped {
61   def simple: SimpleOperation =
62     SimpleOperation(operationId, slug, operationKind, operationAuthentication, createdAt, updatedAt)
63 }
64 
65 final case class OperationId(value: String) extends StringValue
66 
67 object OperationId {
68 
69   implicit val operationIdKeyEncoder: KeyEncoder[OperationId] = KeyEncoder.encodeKeyString.contramap(_.value)
70   implicit val operationIdKeyDecoder: KeyDecoder[OperationId] = KeyDecoder.decodeKeyString.map(OperationId(_))
71 
72   implicit lazy val operationIdEncoder: Encoder[OperationId] =
73     (a: OperationId) => Json.fromString(a.value)
74   implicit lazy val operationIdDecoder: Decoder[OperationId] =
75     Decoder.decodeString.map(OperationId(_))
76 
77   implicit val operationIdFormatter: JsonFormat[OperationId] = SprayJsonFormatters.forStringValue(OperationId.apply)
78 
79   implicit val operationIdCodec: JsonValueCodec[OperationId] =
80     StringValue.makeCodec(OperationId.apply)
81 }
82 
83 final case class IntroCard(
84   enabled: Boolean,
85   titles: Option[Multilingual[String]],
86   descriptions: Option[Multilingual[String]]
87 )
88 
89 object IntroCard extends CirceFormatters {
90 
91   implicit val codec: Codec[IntroCard] = deriveCodec
92 }
93 
94 final case class PushProposalCard(enabled: Boolean)
95 
96 object PushProposalCard extends CirceFormatters {
97 
98   implicit val codec: Codec[PushProposalCard] = deriveCodec
99 }
100 
101 final case class FinalCard(
102   enabled: Boolean,
103   sharingEnabled: Boolean,
104   titles: Option[Multilingual[String]],
105   shareDescriptions: Option[Multilingual[String]],
106   learnMoreTitles: Option[Multilingual[String]],
107   learnMoreTextButtons: Option[Multilingual[String]],
108   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/link")
109   linkUrl: Option[String]
110 )
111 
112 object FinalCard extends CirceFormatters {
113 
114   implicit val codec: Codec[FinalCard] = deriveCodec
115 }
116 
117 final case class SequenceCardsConfiguration(
118   introCard: IntroCard,
119   pushProposalCard: PushProposalCard,
120   finalCard: FinalCard
121 )
122 
123 object SequenceCardsConfiguration extends CirceFormatters {
124 
125   implicit val codec: Codec[SequenceCardsConfiguration] = deriveCodec
126 
127   val default: SequenceCardsConfiguration = SequenceCardsConfiguration(
128     introCard = IntroCard(enabled = true, titles = None, descriptions = None),
129     pushProposalCard = PushProposalCard(enabled = true),
130     finalCard = FinalCard(
131       enabled = true,
132       sharingEnabled = true,
133       titles = None,
134       shareDescriptions = None,
135       learnMoreTitles = None,
136       learnMoreTextButtons = None,
137       linkUrl = None
138     )
139   )
140 }
141 
142 final case class Metas(
143   titles: Option[Multilingual[String]],
144   descriptions: Option[Multilingual[String]],
145   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/picture.png")
146   picture: Option[String]
147 )
148 
149 object Metas extends CirceFormatters {
150 
151   implicit val codec: Codec[Metas] = deriveCodec
152 }
153 
154 final case class QuestionTheme(
155   @(ApiModelProperty @field)(dataType = "string", example = "#842142", required = true)
156   color: String Refined Colour,
157   @(ApiModelProperty @field)(dataType = "string", example = "#ff0000", required = true)
158   fontColor: String Refined Colour
159 )
160 
161 object QuestionTheme {
162 
163   implicit val codec: Codec[QuestionTheme] = deriveCodec
164 
165   val default: QuestionTheme = QuestionTheme(color = Colour.black, fontColor = Colour.black)
166 }
167 
168 final case class OperationOfQuestion(
169   questionId: QuestionId,
170   operationId: OperationId,
171   startDate: ZonedDateTime,
172   endDate: ZonedDateTime,
173   operationTitles: Multilingual[String],
174   proposalPrefixes: Multilingual[String],
175   canPropose: Boolean,
176   sequenceCardsConfiguration: SequenceCardsConfiguration,
177   aboutUrls: Option[Multilingual[String]],
178   metas: Metas,
179   theme: QuestionTheme,
180   descriptions: Option[Multilingual[String]],
181   consultationImages: Option[Multilingual[String]],
182   consultationImageAlts: Option[Multilingual[String Refined MaxSize[130]]],
183   descriptionImages: Option[Multilingual[String]],
184   descriptionImageAlts: Option[Multilingual[String Refined MaxSize[130]]],
185   partnersLogos: Option[String],
186   partnersLogosAlt: Option[String Refined MaxSize[130]],
187   initiatorsLogos: Option[String],
188   initiatorsLogosAlt: Option[String Refined MaxSize[130]],
189   consultationHeader: Option[String],
190   consultationHeaderAlts: Option[Multilingual[String Refined MaxSize[130]]],
191   cobrandingLogo: Option[String],
192   cobrandingLogoAlt: Option[String Refined MaxSize[130]],
193   resultsLink: Option[ResultsLink],
194   proposalsCount: Int,
195   participantsCount: Int,
196   actions: Option[String],
197   featured: Boolean,
198   votesCount: Int,
199   votesTarget: Int,
200   timeline: OperationOfQuestionTimeline,
201   createdAt: ZonedDateTime,
202   sessionBindingMode: Boolean,
203   reportUrl: Option[String],
204   actionsUrl: Option[String]
205 ) {
206 
207   def status: OperationOfQuestion.Status = {
208     val now = DateHelper.now()
209     if (startDate.isAfter(now)) {
210       OperationOfQuestion.Status.Upcoming
211     } else if (endDate.isBefore(now)) {
212       OperationOfQuestion.Status.Finished
213     } else {
214       OperationOfQuestion.Status.Open
215     }
216   }
217 }
218 
219 object OperationOfQuestion {
220   sealed abstract class Status extends EnumEntry
221   object Status extends Enum[Status] {
222     final case object Upcoming extends Status
223     final case object Open extends Status
224     final case object Finished extends Status
225     override val values: IndexedSeq[Status] = findValues
226     final val swaggerAllowableValues = "upcoming,open,finished"
227     implicit val decoder: Decoder[Status] = Circe.decodeCaseInsensitive(this)
228     implicit val encoder: Encoder[Status] = Circe.encoderLowercase(this)
229   }
230 }
231 
232 final case class OperationAction(
233   date: ZonedDateTime = DateHelper.now(),
234   makeUserId: UserId,
235   actionType: String,
236   arguments: Map[String, String] = Map.empty
237 )
238 
239 object OperationAction {
240 
241   implicit val operationActionFormatter: RootJsonFormat[OperationAction] =
242     DefaultJsonProtocol.jsonFormat4(OperationAction.apply)
243 }
244 
245 sealed abstract class OperationActionType(val value: String) extends StringEnumEntry
246 
247 object OperationActionType extends StringEnum[OperationActionType] {
248 
249   final case object OperationCreateAction extends OperationActionType("create")
250   final case object OperationUpdateAction extends OperationActionType("update")
251 
252   override val values: IndexedSeq[OperationActionType] = findValues
253 
254 }
255 
256 final case class SimpleOperation(
257   operationId: OperationId,
258   slug: String,
259   operationKind: OperationKind,
260   operationAuthentication: Option[OperationAuthentication],
261   createdAt: Option[ZonedDateTime],
262   updatedAt: Option[ZonedDateTime]
263 )
264 
265 object SimpleOperation extends CirceFormatters {
266 
267   implicit val codec: Codec[SimpleOperation] = deriveCodec
268 }
269 
270 sealed abstract class OperationKind(val value: String) extends StringEnumEntry with Product with Serializable
271 
272 object OperationKind
273     extends StringEnum[OperationKind]
274     with StringCirceEnum[OperationKind]
275     with StringEnumKeys[OperationKind]
276     with JsoniterEnum[OperationKind] {
277 
278   final case object GreatCause extends OperationKind("GREAT_CAUSE")
279   final case object PrivateConsultation extends OperationKind("PRIVATE_CONSULTATION")
280   final case object BusinessConsultation extends OperationKind("BUSINESS_CONSULTATION")
281   final case object SecuredConsultation extends OperationKind("SECURED_CONSULTATION")
282 
283   override def values: IndexedSeq[OperationKind] = findValues
284   final val swaggerAllowableValues = "GREAT_CAUSE,PRIVATE_CONSULTATION,BUSINESS_CONSULTATION,SECURED_CONSULTATION"
285 
286   val publicKinds: Seq[OperationKind] = Seq(OperationKind.GreatCause, OperationKind.BusinessConsultation)
287 
288   val unsecuredKinds: Seq[OperationKind] =
289     Seq(OperationKind.GreatCause, OperationKind.PrivateConsultation, OperationKind.BusinessConsultation)
290 }
291 
292 final case class OperationOfQuestionTimeline(
293   action: Option[TimelineElement],
294   result: Option[TimelineElement],
295   workshop: Option[TimelineElement]
296 )
297 
298 object OperationOfQuestionTimeline extends CirceFormatters {
299 
300   implicit val codec: Codec[OperationOfQuestionTimeline] = deriveCodec
301 }
302 
303 final case class TimelineElement(
304   date: LocalDate,
305   dateTexts: Multilingual[String Refined MaxSize[20]] = Multilingual.empty,
306   descriptions: Multilingual[String Refined MaxSize[150]] = Multilingual.empty
307 )
308 
309 object TimelineElement extends CirceFormatters {
310 
311   implicit val codec: Codec[TimelineElement] = deriveCodec
312 }
313 
314 final case class OidcConfiguration(
315   @ApiModelProperty(dataType = "string", example = "https://example.com/auth")
316   authorizationEndpoint: String,
317   @ApiModelProperty(dataType = "string", example = "https://example.com/token")
318   tokenEndpoint: String,
319   @ApiModelProperty(dataType = "string", example = "https://example.com/userinfo")
320   userInfoEndpoint: Option[String],
321   @ApiModelProperty(dataType = "string", example = "openid profile email")
322   scope: String,
323   @ApiModelProperty(dataType = "string", example = "client_id")
324   clientId: String,
325   @ApiModelProperty(dataType = "string", example = "client_id")
326   clientSecret: Option[String],
327   @ApiModelProperty(dataType = "string", example = "code")
328   responseType: String = "code",
329   @ApiModelProperty(dataType = "string", example = "sn")
330   jwtUserIdAltField: Option[String] = None,
331   @ApiModelProperty(dataType = "string", example = "email")
332   jwtEmailAltField: Option[String] = None,
333   @ApiModelProperty(dataType = "string", example = "givenname")
334   jwtGivenNameAltField: Option[String] = None
335 ) {
336   def simple(questionId: QuestionId): SimpleOidcConfiguration =
337     SimpleOidcConfiguration(authorizationEndpoint, scope, clientId, responseType, questionId)
338 }
339 
340 object OidcConfiguration {
341   implicit val codec: Codec[OidcConfiguration] = deriveCodec
342 
343 }
344 
345 final case class SimpleOidcConfiguration(
346   @ApiModelProperty(dataType = "string", example = "https://example.com/auth")
347   authorizationEndpoint: String,
348   @ApiModelProperty(dataType = "string", example = "openid profile email")
349   scope: String,
350   @ApiModelProperty(dataType = "string", example = "client_id")
351   clientId: String,
352   @ApiModelProperty(dataType = "string", example = "code")
353   responseType: String = "code",
354   @ApiModelProperty(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
355   questionId: QuestionId
356 )
357 
358 object SimpleOidcConfiguration {
359   implicit val codec: Codec[SimpleOidcConfiguration] = deriveCodec
360 
361 }
362 
363 final case class OperationAuthentication(oidc: Option[OidcConfiguration])
364 
365 object OperationAuthentication extends CirceFormatters {
366   implicit val codec: Codec[OperationAuthentication] = deriveCodec
367 
368   implicit val operationAuthenticationBinder: Binders[Option[OperationAuthentication]] =
369     Binders.string
370       .xmap(str => decode[Option[OperationAuthentication]](str).fold(_ => None, identity), _.asJson.noSpaces)
371 }