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 cats.data.NonEmptyList
23 import io.circe.generic.auto._
24 import io.circe.generic.semiauto.{deriveCodec, deriveDecoder, deriveEncoder}
25 import io.circe.{Codec, Decoder, Encoder}
26 import io.swagger.annotations.{ApiModel, ApiModelProperty}
27 import org.make.api.technical.MakeRandom
28 import org.make.core.technical.{Multilingual, Pagination}
29 import org.make.core.common.indexed.Sort
30 import org.make.core.idea.IdeaId
31 import org.make.core.operation.{OperationId, OperationKind}
32 import org.make.core.proposal._
33 import org.make.core.question.QuestionId
34 import org.make.core.reference.{Country, LabelId, Language}
35 import org.make.core.tag.TagId
36 import org.make.core.user.{UserId, UserType}
37 import org.make.core._
38 import org.make.core.Validation._
39 
40 import java.time.ZonedDateTime
41 import scala.annotation.meta.field
42 import org.make.core.technical.ValidatedUtils.ValidatedNecWithUtils
43 import org.make.core.technical.Pagination.{Limit, Offset}
44 
45 @ApiModel
46 final case class ProposeProposalRequest(
47   content: String,
48   @(ApiModelProperty @field)(dataType = "boolean", example = "false", required = true)
49   isAnonymous: Boolean,
50   @(ApiModelProperty @field)(dataType = "string", example = "fr", required = true)
51   language: Language,
52   @(ApiModelProperty @field)(dataType = "string", example = "FR", required = true)
53   country: Country
54 )
55 
56 object ProposeProposalRequest {
57   implicit val decoder: Decoder[ProposeProposalRequest] = deriveDecoder
58 }
59 
60 final case class UpdateProposalRequest(
61   newContent: Option[String],
62   newContentTranslations: Option[Multilingual[String]],
63   @(ApiModelProperty @field)(dataType = "list[string]", required = true)
64   tags: Seq[TagId],
65   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
66   questionId: Option[QuestionId],
67   @(ApiModelProperty @field)(dataType = "list[string]")
68   predictedTags: Option[Seq[TagId]],
69   @(ApiModelProperty @field)(dataType = "string", example = "auto")
70   predictedTagsModelName: Option[String]
71 )
72 
73 object UpdateProposalRequest {
74   implicit val decoder: Decoder[UpdateProposalRequest] = deriveDecoder
75 }
76 
77 final case class ValidateProposalRequest(
78   newContent: Option[String],
79   newContentTranslations: Option[Multilingual[String]],
80   sendNotificationEmail: Boolean,
81   @(ApiModelProperty @field)(dataType = "list[string]", required = true)
82   tags: Seq[TagId],
83   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
84   questionId: Option[QuestionId],
85   @(ApiModelProperty @field)(dataType = "list[string]")
86   predictedTags: Option[Seq[TagId]],
87   @(ApiModelProperty @field)(dataType = "string", example = "auto")
88   predictedTagsModelName: Option[String]
89 )
90 
91 object ValidateProposalRequest {
92   implicit val decoder: Decoder[ValidateProposalRequest] = deriveDecoder[ValidateProposalRequest]
93   implicit val encoder: Encoder[ValidateProposalRequest] = deriveEncoder[ValidateProposalRequest]
94 }
95 
96 final case class RefuseProposalRequest(
97   sendNotificationEmail: Boolean,
98   @(ApiModelProperty @field)(dataType = "string", example = "other")
99   refusalReason: Option[String]
100 ) {
101 
102   refusalReason
103     .getValidated("refusalReason", None)
104     .map(_.toSanitizedInput("refusalReason").throwIfInvalid())
105     .throwIfInvalid()
106 }
107 
108 object RefuseProposalRequest {
109   implicit val codec: Codec[RefuseProposalRequest] = deriveCodec[RefuseProposalRequest]
110 }
111 
112 final case class ContextFilterRequest(
113   operation: Option[OperationId] = None,
114   source: Option[String] = None,
115   location: Option[String] = None,
116   question: Option[String] = None
117 ) {
118   def toContext: ContextSearchFilter = {
119     ContextSearchFilter(operation, source, location, question)
120   }
121 }
122 
123 object ContextFilterRequest {
124   def parse(
125     operationId: Option[OperationId],
126     source: Option[String],
127     location: Option[String],
128     question: Option[String]
129   ): Option[ContextFilterRequest] = {
130     (operationId, source, location, question) match {
131       case (None, None, None, None) => None
132       case _                        => Some(ContextFilterRequest(operationId, source, location, question))
133     }
134   }
135 
136   implicit val decoder: Decoder[ContextFilterRequest] = deriveDecoder[ContextFilterRequest]
137 }
138 
139 final case class SearchRequest(
140   proposalIds: Option[Seq[ProposalId]] = None,
141   proposalTypes: Option[Seq[ProposalType]] = None,
142   tagsIds: Option[Seq[TagId]] = None,
143   labelsIds: Option[Seq[LabelId]] = None,
144   operationId: Option[OperationId] = None,
145   questionIds: Option[Seq[QuestionId]] = None,
146   content: Option[String] = None,
147   slug: Option[String] = None,
148   seed: Option[Int] = None,
149   context: Option[ContextFilterRequest] = None,
150   language: Option[Language] = None,
151   country: Option[Country] = None,
152   sort: Option[String] = None,
153   order: Option[Order] = None,
154   limit: Option[Pagination.Limit] = None,
155   offset: Option[Pagination.Offset] = None,
156   sortAlgorithm: Option[String] = None,
157   operationKinds: Option[Seq[OperationKind]] = None,
158   userTypes: Option[Seq[UserType]] = None,
159   ideaIds: Option[Seq[IdeaId]] = None,
160   keywords: Option[Seq[ProposalKeywordKey]] = None,
161   excludedProposalIds: Option[Seq[ProposalId]] = None
162 ) {
163 
164   def toSearchQuery(requestContext: RequestContext): SearchQuery = {
165     val filters: Option[SearchFilters] =
166       SearchFilters.parse(
167         proposals = proposalIds.map(ProposalSearchFilter.apply),
168         proposalTypes = proposalTypes.map(ProposalTypesSearchFilter.apply),
169         tags = tagsIds.map(TagsSearchFilter.apply),
170         labels = labelsIds.map(LabelsSearchFilter.apply),
171         operation = operationId.map(opId => OperationSearchFilter(Seq(opId))),
172         question = questionIds.map(QuestionSearchFilter.apply),
173         content = content.map(ContentSearchFilter.apply),
174         slug = slug.map(value => SlugSearchFilter(value)),
175         context = context.map(_.toContext),
176         languages = language.map(l => NonEmptyList.of(LanguageSearchFilter(l))),
177         country = country.map(CountrySearchFilter.apply),
178         operationKinds = operationKinds.map(OperationKindsSearchFilter.apply),
179         userTypes = userTypes.map(UserTypesSearchFilter.apply),
180         idea = ideaIds.map(IdeaSearchFilter.apply),
181         keywords = keywords.map(KeywordsSearchFilter)
182       )
183     val excludesFilter: Option[SearchFilters] =
184       SearchFilters.parse(proposals = excludedProposalIds.map(ProposalSearchFilter.apply))
185 
186     val randomSeed: Int = seed.getOrElse(MakeRandom.nextInt())
187     val searchSortAlgorithm: Option[SortAlgorithm] = AlgorithmSelector.select(sortAlgorithm, randomSeed)
188     SearchQuery(
189       filters = filters,
190       excludes = excludesFilter,
191       sort = Sort.parse(sort, order),
192       limit = limit,
193       offset = offset,
194       language = requestContext.languageContext.language,
195       sortAlgorithm = searchSortAlgorithm
196     )
197   }
198 }
199 
200 object SearchRequest {
201   implicit val decoder: Decoder[SearchRequest] = deriveDecoder[SearchRequest]
202 }
203 
204 final case class ExhaustiveSearchRequest(
205   proposalIds: Option[Seq[ProposalId]] = None,
206   proposalTypes: Option[Seq[ProposalType]] = None,
207   tagsIds: Option[Seq[TagId]] = None,
208   labelsIds: Option[Seq[LabelId]] = None,
209   operationId: Option[OperationId] = None,
210   questionIds: Option[Seq[QuestionId]] = None,
211   ideaIds: Option[Seq[IdeaId]] = None,
212   content: Option[String] = None,
213   context: Option[ContextFilterRequest] = None,
214   status: Option[Seq[ProposalStatus]] = None,
215   minVotesCount: Option[Int] = None,
216   toEnrich: Option[Boolean] = None,
217   minScore: Option[Double] = None,
218   language: Option[Language] = None,
219   country: Option[Country] = None,
220   sort: Option[String] = None,
221   order: Option[Order] = None,
222   limit: Option[Limit] = None,
223   offset: Option[Offset] = None,
224   createdBefore: Option[ZonedDateTime] = None,
225   userTypes: Option[Seq[UserType]] = None,
226   keywords: Option[Seq[ProposalKeywordKey]] = None,
227   userId: Option[UserId] = None,
228   submittedAsLanguages: Option[Seq[Language]] = None
229 ) {
230   def toSearchQuery(requestContext: RequestContext): SearchQuery = {
231     val filters: Option[SearchFilters] =
232       SearchFilters.parse(
233         proposals = proposalIds.map(ProposalSearchFilter.apply),
234         proposalTypes = proposalTypes.map(ProposalTypesSearchFilter.apply),
235         tags = tagsIds.map(TagsSearchFilter.apply),
236         labels = labelsIds.map(LabelsSearchFilter.apply),
237         operation = operationId.map(opId => OperationSearchFilter(Seq(opId))),
238         question = questionIds.map(QuestionSearchFilter.apply),
239         idea = ideaIds.map(IdeaSearchFilter.apply),
240         content = content.map(ContentSearchFilter.apply),
241         context = context.map(_.toContext),
242         status = status.map(StatusSearchFilter.apply),
243         minVotesCount = minVotesCount.map(MinVotesCountSearchFilter.apply),
244         toEnrich = toEnrich.map(ToEnrichSearchFilter.apply),
245         minScore = minScore.map(MinScoreSearchFilter.apply),
246         languages = language.map(l => NonEmptyList.of(LanguageSearchFilter(l))),
247         country = country.map(CountrySearchFilter.apply),
248         createdAt = createdBefore.map(createdBeforeDate => CreatedAtSearchFilter(Some(createdBeforeDate), None)),
249         userTypes = userTypes.map(UserTypesSearchFilter.apply),
250         user = userId.map(userId => UserSearchFilter(Seq(userId))),
251         keywords = keywords.map(KeywordsSearchFilter),
252         submittedAsLanguages = submittedAsLanguages.map(SubmittedAsLanguagesFilter)
253       )
254 
255     SearchQuery(
256       filters = filters,
257       sort = Sort.parse(sort, order),
258       limit = limit,
259       offset = offset,
260       language = requestContext.languageContext.language
261     )
262   }
263 }
264 
265 object ExhaustiveSearchRequest extends CirceFormatters {
266 
267   implicit val decoder: Decoder[ExhaustiveSearchRequest] = deriveDecoder[ExhaustiveSearchRequest]
268 }
269 
270 @ApiModel
271 final case class VoteProposalRequest(
272   @(ApiModelProperty @field)(dataType = "string", allowableValues = VoteKey.swaggerAllowableValues, required = true)
273   voteKey: VoteKey,
274   proposalKey: Option[String]
275 )
276 
277 object VoteProposalRequest {
278   implicit val decoder: Decoder[VoteProposalRequest] = deriveDecoder[VoteProposalRequest]
279 }
280 
281 @ApiModel
282 final case class QualificationProposalRequest(
283   @(ApiModelProperty @field)(
284     dataType = "string",
285     allowableValues = QualificationKey.swaggerAllowableValues,
286     required = true
287   )
288   qualificationKey: QualificationKey,
289   @(ApiModelProperty @field)(dataType = "string", allowableValues = VoteKey.swaggerAllowableValues, required = true)
290   voteKey: VoteKey,
291   proposalKey: Option[String]
292 )
293 
294 object QualificationProposalRequest {
295   implicit val decoder: Decoder[QualificationProposalRequest] = deriveDecoder[QualificationProposalRequest]
296 }
297 
298 @ApiModel
299 final case class PatchProposalsIdeaRequest(
300   @(ApiModelProperty @field)(dataType = "list[string]", required = true) proposalIds: Seq[ProposalId],
301   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true) ideaId: IdeaId
302 )
303 
304 object PatchProposalsIdeaRequest {
305   implicit val decoder: Decoder[PatchProposalsIdeaRequest] = deriveDecoder[PatchProposalsIdeaRequest]
306 }
307 
308 final case class NextProposalToModerateRequest(
309   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
310   questionId: Option[QuestionId],
311   toEnrich: Boolean,
312   languages: Option[NonEmptyList[Language]],
313   @(ApiModelProperty @field)(dataType = "int") minVotesCount: Option[Int],
314   @(ApiModelProperty @field)(dataType = "double") minScore: Option[Double]
315 ) {
316   validate(requirePresent("questionId", questionId, Some("Next proposal needs a question")))
317 }
318 
319 object NextProposalToModerateRequest {
320   implicit val decoder: Decoder[NextProposalToModerateRequest] = deriveDecoder[NextProposalToModerateRequest]
321 }
322 
323 final case class ProposalKeywordRequest(
324   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
325   proposalId: ProposalId,
326   keywords: Seq[ProposalKeyword]
327 )
328 
329 object ProposalKeywordRequest {
330   implicit val decoder: Decoder[ProposalKeywordRequest] = deriveDecoder[ProposalKeywordRequest]
331 }
332 
333 final case class BulkRefuseProposal(
334   @(ApiModelProperty @field)(dataType = "list[string]", required = true) proposalIds: Seq[ProposalId]
335 )
336 
337 object BulkRefuseProposal {
338   implicit val codec: Codec[BulkRefuseProposal] = deriveCodec[BulkRefuseProposal]
339 }
340 
341 final case class BulkTagProposal(
342   @(ApiModelProperty @field)(dataType = "list[string]", required = true) proposalIds: Seq[ProposalId],
343   @(ApiModelProperty @field)(dataType = "list[string]", required = true) tagIds: Seq[TagId]
344 )
345 
346 object BulkTagProposal {
347   implicit val codec: Codec[BulkTagProposal] = deriveCodec[BulkTagProposal]
348 }
349 
350 final case class BulkDeleteTagProposal(
351   @(ApiModelProperty @field)(dataType = "list[string]", required = true) proposalIds: Seq[ProposalId],
352   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
353   tagId: TagId
354 )
355 
356 object BulkDeleteTagProposal {
357   implicit val codec: Codec[BulkDeleteTagProposal] = deriveCodec[BulkDeleteTagProposal]
358 }
359 
360 final case class LockProposalsRequest(
361   @(ApiModelProperty @field)(dataType = "list[string]", required = true) proposalIds: Set[ProposalId]
362 )
363 
364 object LockProposalsRequest {
365   implicit val codec: Codec[LockProposalsRequest] = deriveCodec[LockProposalsRequest]
366 }
367 
368 @ApiModel
369 final case class ReportProposalRequest(
370   @(ApiModelProperty @field)(dataType = "string", example = "fr", required = true)
371   proposalLanguage: Language,
372   @(ApiModelProperty @field)(dataType = "string", example = "FR", required = true)
373   reason: ProposalReportReason
374 )
375 
376 object ReportProposalRequest {
377 
378   implicit val codec: Codec[ReportProposalRequest] = deriveCodec
379 }