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 enumeratum.values.{StringCirceEnum, StringEnum, StringEnumEntry}
23 import cats.implicits._
24 import io.circe.Codec
25 import io.circe.generic.semiauto.deriveCodec
26 import io.swagger.annotations.{ApiModel, ApiModelProperty}
27 import org.make.api.proposal.ProposalActorResponse.{VoteActorResponse, VotesActorResponse}
28 import org.make.api.question.{SimpleQuestionResponse, SimpleQuestionWordingResponse}
29 import org.make.core.technical.Multilingual
30 import org.make.core.history.HistoryActions.VoteAndQualifications
31 import org.make.core.idea.IdeaId
32 import org.make.core.operation.OperationId
33 import org.make.core.proposal.VoteKey.{Agree, Disagree, Neutral}
34 import org.make.core.proposal._
35 import org.make.core.proposal.indexed._
36 import org.make.core.question.QuestionId
37 import org.make.core.reference._
38 import org.make.core.tag.{Tag, TagId, TagTypeId}
39 import org.make.core.user.{User, UserId, UserType}
40 import org.make.core.{CirceFormatters, RequestContext, SlugHelper}
41 
42 import java.time.temporal.ChronoUnit
43 import java.time.{LocalDate, ZonedDateTime}
44 import scala.annotation.meta.field
45 
46 final case class ModerationProposalAuthorResponse(
47   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
48   userId: UserId,
49   firstName: Option[String],
50   lastName: Option[String],
51   displayName: Option[String],
52   @(ApiModelProperty @field)(dataType = "string", example = "12345")
53   postalCode: Option[String],
54   @(ApiModelProperty @field)(dataType = "int")
55   age: Option[Int],
56   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/avatar.png")
57   avatarUrl: Option[String],
58   organisationName: Option[String],
59   organisationSlug: Option[String],
60   reachable: Boolean
61 )
62 
63 object ModerationProposalAuthorResponse {
64 
65   def apply(user: User): ModerationProposalAuthorResponse =
66     ModerationProposalAuthorResponse(
67       userId = user.userId,
68       firstName = user.firstName,
69       lastName = user.lastName,
70       displayName = user.displayName,
71       postalCode = user.profile.flatMap(_.postalCode),
72       age = user.profile
73         .flatMap(_.dateOfBirth)
74         .map(date => ChronoUnit.YEARS.between(date, LocalDate.now()).toInt),
75       avatarUrl = user.profile.flatMap(_.avatarUrl),
76       organisationName = user.organisationName,
77       organisationSlug = user.organisationName.map(SlugHelper.apply),
78       reachable = !user.isHardBounce
79     )
80 
81   implicit val codec: Codec[ModerationProposalAuthorResponse] = deriveCodec
82 }
83 
84 final case class ModerationAuthorResponse(
85   author: ModerationProposalAuthorResponse,
86   proposals: Seq[ModerationProposalResponse],
87   total: Int
88 )
89 
90 object ModerationAuthorResponse {
91   implicit val codec: Codec[ModerationAuthorResponse] = deriveCodec
92 }
93 
94 final case class ModerationProposalResponse(
95   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
96   id: ProposalId,
97   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
98   proposalId: ProposalId,
99   slug: String,
100   content: String,
101   contentTranslations: Option[Multilingual[String]],
102   submittedAsLanguage: Option[Language],
103   author: ModerationProposalAuthorResponse,
104   @(ApiModelProperty @field)(
105     dataType = "string",
106     required = true,
107     allowableValues = ProposalStatus.swaggerAllowableValues
108   )
109   status: ProposalStatus,
110   proposalType: ProposalType,
111   @(ApiModelProperty @field)(dataType = "string", example = "other")
112   refusalReason: Option[String] = None,
113   @(ApiModelProperty @field)(dataType = "list[string]", required = true)
114   tags: Seq[TagId] = Seq.empty,
115   votes: Seq[ModerationVoteResponse],
116   context: RequestContext,
117   createdAt: Option[ZonedDateTime],
118   updatedAt: Option[ZonedDateTime],
119   events: Seq[ProposalActionResponse],
120   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
121   idea: Option[IdeaId],
122   @(ApiModelProperty @field)(hidden = true)
123   ideaProposals: Seq[IndexedProposal],
124   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
125   questionId: Option[QuestionId],
126   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
127   operationId: Option[OperationId],
128   keywords: Seq[ProposalKeyword],
129   zone: Zone
130 )
131 
132 object ModerationProposalResponse extends CirceFormatters {
133   implicit val codec: Codec[ModerationProposalResponse] = deriveCodec
134 }
135 
136 final case class ModerationVoteResponse(
137   @(ApiModelProperty @field)(dataType = "string", required = true, allowableValues = VoteKey.swaggerAllowableValues)
138   voteKey: VoteKey,
139   score: Double,
140   qualifications: Seq[QualificationResponse]
141 )
142 
143 object ModerationVoteResponse {
144   implicit val codec: Codec[ModerationVoteResponse] = deriveCodec
145 
146   def apply(wrapper: VotingOptionWrapper, score: Double): ModerationVoteResponse =
147     ModerationVoteResponse(
148       voteKey = wrapper.vote.key,
149       score = score,
150       qualifications = wrapper.deprecatedQualificationsSeq.map(QualificationResponse.parseQualification(_, false))
151     )
152 }
153 
154 final case class ProposalActionResponse(
155   date: ZonedDateTime,
156   user: Option[ProposalActionAuthorResponse],
157   actionType: String,
158   arguments: Map[String, String]
159 )
160 
161 object ProposalActionResponse extends CirceFormatters {
162   implicit val codec: Codec[ProposalActionResponse] = deriveCodec
163 }
164 
165 final case class ProposalActionAuthorResponse(
166   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
167   id: UserId,
168   displayName: Option[String]
169 )
170 
171 object ProposalActionAuthorResponse {
172   implicit val codec: Codec[ProposalActionAuthorResponse] = deriveCodec
173 }
174 
175 @ApiModel
176 final case class ProposalIdResponse(
177   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
178   id: ProposalId,
179   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
180   proposalId: ProposalId
181 )
182 
183 object ProposalIdResponse {
184   implicit val codec: Codec[ProposalIdResponse] = deriveCodec
185 
186   def apply(id: ProposalId): ProposalIdResponse = ProposalIdResponse(id, id)
187 }
188 
189 final case class AuthorResponse(
190   userId: UserId,
191   firstName: Option[String],
192   displayName: Option[String],
193   organisationName: Option[String],
194   organisationSlug: Option[String],
195   @(ApiModelProperty @field)(dataType = "string", example = "12345")
196   postalCode: Option[String],
197   @(ApiModelProperty @field)(dataType = "int", example = "21")
198   age: Option[Int],
199   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/avatar.png")
200   avatarUrl: Option[String],
201   @(ApiModelProperty @field)(dataType = "string", allowableValues = UserType.swaggerAllowableValues)
202   userType: UserType
203 )
204 
205 object AuthorResponse {
206   implicit val codec: Codec[AuthorResponse] = deriveCodec
207 
208   def fromIndexedAuthor(author: IndexedAuthor): AuthorResponse =
209     AuthorResponse(
210       userId = author.userId,
211       firstName = author.firstName,
212       displayName = author.displayName,
213       organisationName = author.organisationName,
214       organisationSlug = author.organisationSlug,
215       postalCode = author.postalCode,
216       age = author.age,
217       avatarUrl = author.avatarUrl,
218       userType = author.userType
219     )
220 }
221 
222 final case class ProposalContextResponse(
223   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
224   operation: Option[OperationId],
225   source: Option[String],
226   location: Option[String],
227   questionSlug: Option[String],
228   @(ApiModelProperty @field)(dataType = "string", example = "FR")
229   country: Option[Country],
230   @(ApiModelProperty @field)(dataType = "string", example = "fr")
231   questionLanguage: Option[Language],
232   proposalLanguage: Option[Language],
233   clientLanguage: Option[Language],
234   getParameters: Seq[GetParameterResponse]
235 )
236 
237 object ProposalContextResponse {
238   implicit val codec: Codec[ProposalContextResponse] = deriveCodec
239 
240   def fromIndexedContext(context: IndexedContext): ProposalContextResponse = {
241     ProposalContextResponse(
242       context.operation,
243       context.source,
244       context.location,
245       context.questionSlug,
246       context.country,
247       context.questionLanguage,
248       context.proposalLanguage,
249       context.clientLanguage,
250       context.getParameters.map(GetParameterResponse.fromIndexedGetParameters)
251     )
252   }
253 }
254 
255 final case class GetParameterResponse(key: String, value: String)
256 
257 object GetParameterResponse {
258   implicit val codec: Codec[GetParameterResponse] = deriveCodec
259 
260   def fromIndexedGetParameters(parameter: IndexedGetParameters): GetParameterResponse = {
261     GetParameterResponse(key = parameter.key, value = parameter.value)
262   }
263 }
264 
265 final case class OrganisationInfoResponse(
266   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
267   organisationId: UserId,
268   organisationName: Option[String],
269   organisationSlug: Option[String]
270 )
271 
272 object OrganisationInfoResponse {
273   implicit val codec: Codec[OrganisationInfoResponse] = deriveCodec
274 
275   def fromIndexedOrganisationInfo(indexedOrganisationInfo: IndexedOrganisationInfo): OrganisationInfoResponse = {
276     OrganisationInfoResponse(
277       indexedOrganisationInfo.organisationId,
278       indexedOrganisationInfo.organisationName,
279       indexedOrganisationInfo.organisationSlug
280     )
281   }
282 }
283 
284 @ApiModel
285 final case class ProposalResponse(
286   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
287   id: ProposalId,
288   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
289   content: String,
290   contentLanguage: Language,
291   translatedContent: Option[String],
292   translatedLanguage: Option[Language],
293   slug: String,
294   @(ApiModelProperty @field)(
295     dataType = "string",
296     required = true,
297     allowableValues = ProposalStatus.swaggerAllowableValues
298   )
299   status: ProposalStatus,
300   createdAt: ZonedDateTime,
301   updatedAt: Option[ZonedDateTime],
302   votes: Seq[VoteResponse],
303   context: Option[ProposalContextResponse],
304   author: Option[AuthorResponse],
305   organisations: Seq[OrganisationInfoResponse],
306   tags: Seq[IndexedTag],
307   selectedStakeTag: Option[IndexedTag],
308   myProposal: Boolean,
309   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
310   idea: Option[IdeaId],
311   question: Option[SimpleQuestionResponse],
312   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
313   operationId: Option[OperationId],
314   proposalKey: String,
315   keywords: Seq[IndexedProposalKeyword]
316 )
317 
318 object ProposalResponse extends CirceFormatters {
319   implicit val codec: Codec[ProposalResponse] = deriveCodec
320 
321   def apply(
322     indexedProposal: IndexedProposal,
323     myProposal: Boolean,
324     voteAndQualifications: Option[VoteAndQualifications],
325     proposalKey: String,
326     newProposalsVoteThreshold: Int,
327     preferredLanguage: Option[Language],
328     questionDefaultLanguage: Option[Language]
329   ): ProposalResponse = {
330     val scores = VotingOptionsScores(indexedProposal.votes, newProposalsVoteThreshold)
331     val votesResponses =
332       indexedProposal.votes.wrappers.map(wrapper => {
333         val hasVoted =
334           voteAndQualifications match {
335             case Some(VoteAndQualifications(wrapper.vote.key, _, _, _)) => true
336             case _                                                      => false
337           }
338         val qualifications = wrapper.deprecatedQualificationsSeq
339         val score = scores.get(wrapper.vote.key)
340         VoteResponse.parseVote(wrapper.vote, qualifications, hasVoted, voteAndQualifications, score)
341       })
342     val mainLanguage =
343       indexedProposal.submittedAsLanguage
344       // When a legacy proposal does not have a submittedAsLanguage, we get the first one from the
345       // question. This is reasonably safe because legacy questions will not be multilingual.
346         .orElse(indexedProposal.question.map(_.languages.head))
347         .getOrElse(Language("fr"))
348 
349     // if preferredLanguage if not defined or is equal to the main language: no translations
350     // else translate with preferredLanguage if possible or with the question default language
351     // if this language is not equal to the main language
352     val (translatedContent, translatedLanguage) =
353       preferredLanguage
354         .filter(_ != mainLanguage)
355         .flatMap(
356           pl =>
357             indexedProposal.content
358               .getTranslation(pl)
359               .tupleRight(pl)
360               .orElse(
361                 questionDefaultLanguage
362                   .filter(_ != mainLanguage)
363                   .flatMap(qdl => indexedProposal.content.getTranslation(qdl).tupleRight(qdl))
364               )
365         )
366         .separate
367     val returnedLanguage = translatedLanguage.getOrElse(mainLanguage)
368     ProposalResponse(
369       id = indexedProposal.id,
370       content = indexedProposal.contentGeneral,
371       contentLanguage = mainLanguage,
372       translatedContent = translatedContent,
373       translatedLanguage = translatedLanguage,
374       slug = indexedProposal.slug,
375       status = indexedProposal.status,
376       createdAt = indexedProposal.createdAt,
377       updatedAt = indexedProposal.updatedAt,
378       votes = votesResponses,
379       context = indexedProposal.context.map(ProposalContextResponse.fromIndexedContext),
380       author = Option.unless(indexedProposal.isAnonymous)(AuthorResponse.fromIndexedAuthor(indexedProposal.author)),
381       organisations = indexedProposal.organisations.map(OrganisationInfoResponse.fromIndexedOrganisationInfo),
382       tags = indexedProposal.tags,
383       selectedStakeTag = indexedProposal.selectedStakeTag,
384       myProposal = myProposal,
385       idea = indexedProposal.ideaId,
386       question = indexedProposal.question.map { proposalQuestion =>
387         SimpleQuestionResponse(
388           questionId = proposalQuestion.questionId,
389           slug = proposalQuestion.slug,
390           wording = SimpleQuestionWordingResponse(
391             proposalQuestion.titles
392               .getTranslation(returnedLanguage)
393               .getOrElse(proposalQuestion.titles.getTranslationUnsafe(proposalQuestion.languages.head)),
394             proposalQuestion.questions
395               .getTranslation(returnedLanguage)
396               .getOrElse(proposalQuestion.questions.getTranslationUnsafe(proposalQuestion.languages.head))
397           ),
398           countries = proposalQuestion.countries,
399           preferredLanguage = preferredLanguage,
400           returnedLanguage = returnedLanguage,
401           startDate = proposalQuestion.startDate,
402           endDate = proposalQuestion.endDate
403         )
404       },
405       operationId = indexedProposal.operationId,
406       proposalKey = proposalKey,
407       keywords = indexedProposal.keywords
408     )
409   }
410 }
411 
412 @ApiModel
413 final case class ProposalsResultResponse(total: Long, results: Seq[ProposalResponse])
414 
415 object ProposalsResultResponse {
416   implicit val codec: Codec[ProposalsResultResponse] = deriveCodec
417 }
418 
419 final case class ProposalsResultSeededResponse(
420   total: Long,
421   results: Seq[ProposalResponse],
422   @(ApiModelProperty @field)(dataType = "int", example = "42") seed: Option[Int]
423 )
424 
425 object ProposalsResultSeededResponse {
426   implicit val codec: Codec[ProposalsResultSeededResponse] = deriveCodec
427 
428   val empty: ProposalsResultSeededResponse = ProposalsResultSeededResponse(0, Seq.empty, None)
429 }
430 
431 final case class ProposalResultWithUserVote(
432   proposal: ProposalResponse,
433   @(ApiModelProperty @field)(dataType = "string", required = true, allowableValues = VoteKey.swaggerAllowableValues)
434   vote: VoteKey,
435   voteDate: ZonedDateTime,
436   voteDetails: Option[VoteResponse]
437 )
438 object ProposalResultWithUserVote extends CirceFormatters {
439   implicit val codec: Codec[ProposalResultWithUserVote] = deriveCodec
440 }
441 
442 @ApiModel
443 final case class ProposalsResultWithUserVoteSeededResponse(
444   total: Long,
445   results: Seq[ProposalResultWithUserVote],
446   @(ApiModelProperty @field)(dataType = "int", example = "42")
447   seed: Option[Int]
448 )
449 
450 object ProposalsResultWithUserVoteSeededResponse {
451   implicit val codec: Codec[ProposalsResultWithUserVoteSeededResponse] = deriveCodec
452 }
453 
454 @ApiModel
455 final case class VotesResponse(
456   agree: VoteResponse,
457   disagree: VoteResponse,
458   neutral: VoteResponse,
459   @(ApiModelProperty @field)(dataType = "string", example = "agree")
460   voteKey: VoteKey,
461   score: Double,
462   qualifications: Seq[QualificationResponse],
463   hasVoted: Boolean
464 )
465 
466 object VotesResponse {
467 
468   implicit val codec: Codec[VotesResponse] = deriveCodec
469 
470   def parseVotes(votes: VotesActorResponse, hasVoted: Map[VoteKey, Boolean], votedKey: VoteKey): VotesResponse = {
471     val agree = VoteResponse.parseVote(votes.agree, hasVoted.getOrElse(Agree, false))
472     val disagree = VoteResponse.parseVote(votes.disagree, hasVoted.getOrElse(Disagree, false))
473     val neutral = VoteResponse.parseVote(votes.neutral, hasVoted.getOrElse(Neutral, false))
474     val voted = Seq(agree, disagree, neutral).find(vote => vote.voteKey == votedKey).getOrElse(agree)
475     VotesResponse(agree, disagree, neutral, voted.voteKey, voted.score, voted.qualifications, voted.hasVoted)
476   }
477 }
478 
479 @ApiModel
480 final case class VoteResponse(
481   @(ApiModelProperty @field)(dataType = "string", required = true, allowableValues = VoteKey.swaggerAllowableValues)
482   voteKey: VoteKey,
483   count: Int,
484   score: Double,
485   qualifications: Seq[QualificationResponse],
486   hasVoted: Boolean
487 )
488 
489 object VoteResponse {
490 
491   implicit val codec: Codec[VoteResponse] = deriveCodec
492 
493   def parseVote(vote: VoteActorResponse, hasVoted: Boolean): VoteResponse =
494     VoteResponse(
495       voteKey = vote.key,
496       count = vote.count,
497       score = vote.score,
498       qualifications = vote.qualifications
499         .map(qualification => QualificationResponse.parseQualification(qualification, hasQualified = false)),
500       hasVoted = hasVoted
501     )
502 
503   def parseVote(
504     vote: Vote,
505     qualifications: Seq[Qualification],
506     hasVoted: Boolean,
507     voteAndQualifications: Option[VoteAndQualifications],
508     score: Double
509   ): VoteResponse =
510     VoteResponse(
511       voteKey = vote.key,
512       count = vote.countVerified,
513       score = score,
514       qualifications = qualifications
515         .map(
516           qualification =>
517             QualificationResponse.parseQualification(qualification, hasQualified = voteAndQualifications match {
518               case Some(VoteAndQualifications(_, keys, _, _)) if keys.contains(qualification.key) => true
519               case _                                                                              => false
520             })
521         ),
522       hasVoted = hasVoted
523     )
524 }
525 
526 @ApiModel
527 final case class QualificationResponse(
528   @(ApiModelProperty @field)(
529     dataType = "string",
530     required = true,
531     allowableValues = QualificationKey.swaggerAllowableValues
532   )
533   qualificationKey: QualificationKey,
534   count: Int,
535   hasQualified: Boolean
536 )
537 
538 object QualificationResponse {
539   implicit val codec: Codec[QualificationResponse] = deriveCodec
540 
541   def parseQualification(qualification: Qualification, hasQualified: Boolean): QualificationResponse =
542     QualificationResponse(
543       qualificationKey = qualification.key,
544       count = qualification.count,
545       hasQualified = hasQualified
546     )
547 }
548 
549 final case class DuplicateResponse(
550   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
551   ideaId: IdeaId,
552   ideaName: String,
553   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
554   proposalId: ProposalId,
555   proposalContent: String,
556   score: Double
557 )
558 
559 object DuplicateResponse {
560   implicit val codec: Codec[DuplicateResponse] = deriveCodec
561 }
562 
563 @ApiModel
564 final case class TagForProposalResponse(
565   @(ApiModelProperty @field)(dataType = "string", example = "tag-slug", required = true) id: TagId,
566   label: String,
567   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
568   tagTypeId: TagTypeId,
569   weight: Float,
570   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
571   questionId: Option[QuestionId],
572   checked: Boolean,
573   predicted: Boolean
574 )
575 
576 object TagForProposalResponse {
577   implicit val codec: Codec[TagForProposalResponse] = deriveCodec
578 
579   def apply(tag: Tag, checked: Boolean, predicted: Boolean): TagForProposalResponse =
580     TagForProposalResponse(
581       id = tag.tagId,
582       label = tag.label,
583       tagTypeId = tag.tagTypeId,
584       weight = tag.weight,
585       questionId = tag.questionId,
586       checked = checked,
587       predicted = predicted
588     )
589 }
590 
591 final case class TagsForProposalResponse(
592   tags: Seq[TagForProposalResponse],
593   @(ApiModelProperty @field)(dataType = "string", example = "auto") modelName: String
594 )
595 
596 object TagsForProposalResponse {
597   implicit val codec: Codec[TagsForProposalResponse] = deriveCodec
598 
599   val empty: TagsForProposalResponse = TagsForProposalResponse(tags = Seq.empty, modelName = "")
600 }
601 
602 sealed abstract class ProposalKeywordsResponseStatus(val value: String) extends StringEnumEntry
603 
604 object ProposalKeywordsResponseStatus
605     extends StringEnum[ProposalKeywordsResponseStatus]
606     with StringCirceEnum[ProposalKeywordsResponseStatus] {
607 
608   case object Ok extends ProposalKeywordsResponseStatus("Ok")
609   case object Error extends ProposalKeywordsResponseStatus("Error")
610 
611   override val values: IndexedSeq[ProposalKeywordsResponseStatus] = findValues
612   final val swaggerAllowableValues = "Ok,Error"
613 }
614 
615 final case class ProposalKeywordsResponse(
616   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
617   proposalId: ProposalId,
618   @(ApiModelProperty @field)(
619     dataType = "string",
620     allowableValues = ProposalKeywordsResponseStatus.swaggerAllowableValues,
621     required = true
622   )
623   status: ProposalKeywordsResponseStatus,
624   message: Option[String]
625 )
626 
627 object ProposalKeywordsResponse {
628   implicit val codec: Codec[ProposalKeywordsResponse] = deriveCodec[ProposalKeywordsResponse]
629 }
630 
631 final case class BulkActionResponse(
632   @(ApiModelProperty @field)(dataType = "list[string]", required = true)
633   successes: Seq[ProposalId],
634   failures: Seq[SingleActionResponse]
635 )
636 
637 object BulkActionResponse {
638   implicit val codec: Codec[BulkActionResponse] = deriveCodec[BulkActionResponse]
639 }
640 
641 final case class SingleActionResponse(
642   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
643   proposalId: ProposalId,
644   @(ApiModelProperty @field)(dataType = "string", required = true, allowableValues = ActionKey.swaggerAllowableValues)
645   key: ActionKey,
646   message: Option[String]
647 )
648 
649 object SingleActionResponse extends CirceFormatters {
650   implicit val codec: Codec[SingleActionResponse] = deriveCodec[SingleActionResponse]
651 }
652 
653 sealed abstract class ActionKey(val value: String) extends StringEnumEntry
654 
655 object ActionKey extends StringEnum[ActionKey] with StringCirceEnum[ActionKey] {
656   final case class ValidationError(key: String) extends ActionKey(key)
657   case object NotFound extends ActionKey("not_found")
658   case object OK extends ActionKey("ok")
659   case object QuestionNotFound extends ActionKey("question_not_found")
660   case object Unknown extends ActionKey("unknown")
661 
662   override val values: IndexedSeq[ActionKey] = findValues
663   final val swaggerAllowableValues = "not_found,ok,question_not_found,unknown,other"
664 }