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 akka.http.scaladsl.model.StatusCodes
23 import akka.http.scaladsl.server.{Directives, PathMatcher1, Route}
24 import cats.implicits._
25 import grizzled.slf4j.Logging
26 import io.circe.Codec
27 import io.circe.generic.semiauto.deriveCodec
28 import io.swagger.annotations._
29 import org.make.api.ConfigComponent
30 import org.make.api.idea.IdeaServiceComponent
31 import org.make.api.operation.OperationServiceComponent
32 import org.make.api.question.QuestionServiceComponent
33 import org.make.api.tag.TagServiceComponent
34 import org.make.api.technical.Futures._
35 import org.make.api.technical.CsvReceptacle._
36 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
37 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
38 import org.make.api.technical.directives.FutureDirectivesExtensions._
39 import org.make.api.user.UserServiceComponent
40 import org.make.core.technical.{Multilingual, MultilingualUtils, Pagination}
41 import org.make.core.technical.ValidatedUtils.ValidatedNecWithUtils
42 import org.make.core.auth.UserRights
43 import org.make.core.proposal.indexed.{IndexedContext, IndexedProposal, IndexedTag, ProposalElasticsearchFieldName}
44 import org.make.core.proposal.{
45   Proposal,
46   ProposalId,
47   ProposalStatus,
48   ProposalType,
49   QualificationKey,
50   SearchQuery,
51   VoteKey,
52   Qualification => ProposalQualification,
53   Vote          => ProposalVote
54 }
55 import org.make.core.question.{Question, QuestionId}
56 import org.make.core.reference.{Country, Language}
57 import org.make.core.tag.TagId
58 import org.make.core.user.{UserId, UserType}
59 import org.make.core.{CirceFormatters, DateHelper, HttpCodes, Order, ParameterExtractors, Validation}
60 import scalaoauth2.provider.AuthInfo
61 
62 import java.time.ZonedDateTime
63 import javax.ws.rs.Path
64 import scala.annotation.meta.field
65 import scala.concurrent.ExecutionContext.Implicits.global
66 import scala.concurrent.Future
67 import scala.concurrent.duration._
68 
69 @Api(value = "AdminProposal")
70 @Path(value = "/admin/proposals")
71 trait AdminProposalApi extends Directives {
72 
73   @ApiOperation(
74     value = "admin-search-proposals",
75     httpMethod = "GET",
76     code = HttpCodes.OK,
77     authorizations = Array(
78       new Authorization(
79         value = "MakeApi",
80         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
81       )
82     )
83   )
84   @ApiResponses(
85     value =
86       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[AdminProposalResponse]]))
87   )
88   @ApiImplicitParams(
89     value = Array(
90       new ApiImplicitParam(name = "id", paramType = "query", dataType = "string", allowMultiple = true),
91       new ApiImplicitParam(name = "questionId", paramType = "query", dataType = "string", allowMultiple = true),
92       new ApiImplicitParam(
93         name = "status",
94         paramType = "query",
95         dataType = "string",
96         allowableValues = ProposalStatus.swaggerAllowableValues,
97         allowMultiple = true
98       ),
99       new ApiImplicitParam(name = "content", paramType = "query", dataType = "string"),
100       new ApiImplicitParam(
101         name = "userType",
102         paramType = "query",
103         dataType = "string",
104         allowableValues = UserType.swaggerAllowableValues,
105         allowMultiple = true
106       ),
107       new ApiImplicitParam(name = "initialProposal", paramType = "query", dataType = "boolean"),
108       new ApiImplicitParam(name = "tagId", paramType = "query", dataType = "string", allowMultiple = true),
109       new ApiImplicitParam(
110         name = "_start",
111         paramType = "query",
112         dataType = "int",
113         allowableValues = "range[0, infinity]"
114       ),
115       new ApiImplicitParam(
116         name = "_end",
117         paramType = "query",
118         dataType = "int",
119         allowableValues = "range[0, infinity]"
120       ),
121       new ApiImplicitParam(
122         name = "_sort",
123         paramType = "query",
124         dataType = "string",
125         allowableValues = ProposalElasticsearchFieldName.swaggerAllowableValues
126       ),
127       new ApiImplicitParam(
128         name = "_order",
129         paramType = "query",
130         dataType = "string",
131         allowableValues = Order.swaggerAllowableValues
132       )
133     )
134   )
135   def search: Route
136 
137   @ApiOperation(
138     value = "fix-trolled-proposal",
139     httpMethod = "PUT",
140     code = HttpCodes.OK,
141     authorizations = Array(
142       new Authorization(
143         value = "MakeApi",
144         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
145       )
146     )
147   )
148   @ApiImplicitParams(
149     value = Array(
150       new ApiImplicitParam(
151         value = "body",
152         paramType = "body",
153         dataType = "org.make.api.proposal.UpdateProposalVotesRequest"
154       ),
155       new ApiImplicitParam(name = "proposalId", paramType = "path", required = true, value = "", dataType = "string")
156     )
157   )
158   @ApiResponses(
159     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ModerationProposalResponse]))
160   )
161   @Path(value = "/{proposalId}/fix-trolled-proposal")
162   def updateProposalVotes: Route
163 
164   @ApiOperation(
165     value = "reset-unverified-proposal-votes",
166     httpMethod = "POST",
167     code = HttpCodes.Accepted,
168     authorizations = Array(
169       new Authorization(
170         value = "MakeApi",
171         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
172       )
173     )
174   )
175   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.Accepted, message = "Accepted")))
176   @Path(value = "/reset-votes")
177   def resetVotes: Route
178 
179   @ApiOperation(
180     value = "patch-proposal",
181     httpMethod = "PATCH",
182     code = HttpCodes.OK,
183     authorizations = Array(
184       new Authorization(
185         value = "MakeApi",
186         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
187       )
188     )
189   )
190   @ApiResponses(
191     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ModerationProposalResponse]))
192   )
193   @ApiImplicitParams(
194     value = Array(
195       new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string"),
196       new ApiImplicitParam(name = "body", paramType = "body", dataType = "org.make.api.proposal.PatchProposalRequest")
197     )
198   )
199   @Path(value = "/{proposalId}")
200   def patchProposal: Route
201 
202   @ApiOperation(
203     value = "add-keywords",
204     httpMethod = "POST",
205     code = HttpCodes.OK,
206     authorizations = Array(
207       new Authorization(
208         value = "MakeApi",
209         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
210       )
211     )
212   )
213   @ApiResponses(
214     value =
215       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[ProposalKeywordsResponse]]))
216   )
217   @ApiImplicitParams(
218     value = Array(
219       new ApiImplicitParam(name = "body", paramType = "body", dataType = "org.make.api.proposal.ProposalKeywordRequest")
220     )
221   )
222   @Path(value = "/keywords")
223   def setProposalKeywords: Route
224 
225   @ApiOperation(
226     value = "bulk-refuse-proposal",
227     httpMethod = "POST",
228     code = HttpCodes.OK,
229     authorizations = Array(
230       new Authorization(
231         value = "MakeApi",
232         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
233       )
234     )
235   )
236   @ApiImplicitParams(
237     value = Array(
238       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.proposal.BulkRefuseProposal")
239     )
240   )
241   @ApiResponses(
242     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[BulkActionResponse]))
243   )
244   @Path(value = "/refuse-initials-proposals")
245   def bulkRefuseInitialsProposals: Route
246 
247   @ApiOperation(
248     value = "bulk-tag-proposal",
249     httpMethod = "POST",
250     code = HttpCodes.OK,
251     authorizations = Array(
252       new Authorization(
253         value = "MakeApi",
254         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
255       )
256     )
257   )
258   @ApiImplicitParams(
259     value = Array(
260       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.proposal.BulkTagProposal")
261     )
262   )
263   @ApiResponses(
264     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[BulkActionResponse]))
265   )
266   @Path(value = "/tag")
267   def bulkTagProposal: Route
268 
269   @ApiOperation(
270     value = "bulk-delete-tag-proposal",
271     httpMethod = "DELETE",
272     code = HttpCodes.OK,
273     authorizations = Array(
274       new Authorization(
275         value = "MakeApi",
276         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
277       )
278     )
279   )
280   @ApiImplicitParams(
281     value = Array(
282       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.proposal.BulkDeleteTagProposal")
283     )
284   )
285   @ApiResponses(
286     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[BulkActionResponse]))
287   )
288   @Path(value = "/tag")
289   def bulkDeleteTagProposal: Route
290 
291   @ApiOperation(
292     value = "get-proposal-history",
293     httpMethod = "GET",
294     code = HttpCodes.OK,
295     authorizations = Array(
296       new Authorization(
297         value = "MakeApi",
298         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
299       )
300     )
301   )
302   @ApiResponses(
303     value =
304       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[ProposalActionResponse]]))
305   )
306   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "proposalId", paramType = "path", dataType = "string")))
307   @Path(value = "/{proposalId}/history")
308   def getProposalHistory: Route
309 
310   @ApiOperation(
311     value = "submitted-as-language-patch-script",
312     httpMethod = "POST",
313     code = HttpCodes.OK,
314     authorizations = Array(
315       new Authorization(
316         value = "MakeApi",
317         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
318       )
319     )
320   )
321   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok")))
322   @ApiImplicitParams(
323     value = Array(
324       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
325       new ApiImplicitParam(name = "dry-run", paramType = "query", dataType = "boolean")
326     )
327   )
328   @Path(value = "/submitted-as-language-patch-script/{questionId}")
329   def submittedAsLanguagePatchScript: Route
330 
331   def routes: Route =
332     search ~ patchProposal ~ updateProposalVotes ~ resetVotes ~ setProposalKeywords ~
333       bulkTagProposal ~ bulkDeleteTagProposal ~ getProposalHistory ~ bulkRefuseInitialsProposals ~
334       submittedAsLanguagePatchScript
335 }
336 
337 trait AdminProposalApiComponent {
338   def adminProposalApi: AdminProposalApi
339 }
340 
341 trait DefaultAdminProposalApiComponent
342     extends AdminProposalApiComponent
343     with MakeAuthenticationDirectives
344     with Logging
345     with ParameterExtractors {
346 
347   this: MakeDirectivesDependencies
348     with ConfigComponent
349     with ProposalServiceComponent
350     with ProposalCoordinatorServiceComponent
351     with QuestionServiceComponent
352     with IdeaServiceComponent
353     with OperationServiceComponent
354     with UserServiceComponent
355     with TagServiceComponent =>
356 
357   override lazy val adminProposalApi: AdminProposalApi = new DefaultAdminProposalApi
358 
359   class DefaultAdminProposalApi extends AdminProposalApi {
360     val adminProposalId: PathMatcher1[ProposalId] = Segment.map(id => ProposalId(id))
361 
362     @Deprecated
363     override def search: Route = get {
364       path("admin" / "proposals") {
365         makeOperation("AdminSearchProposals") { requestContext =>
366           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
367             requireAdminRole(userAuth.user) {
368               parameters(
369                 "id".csv[ProposalId],
370                 "questionId".csv[QuestionId],
371                 "content".?,
372                 "status".csv[ProposalStatus],
373                 "userType".csv[UserType],
374                 "proposalType".csv[ProposalType],
375                 "tagId".csv[TagId],
376                 "_start".as[Pagination.Offset].?,
377                 "_end".as[Pagination.End].?,
378                 "_sort".as[ProposalElasticsearchFieldName].?,
379                 "_order".as[Order].?
380               ) {
381                 (
382                   proposalIds: Option[Seq[ProposalId]],
383                   questionIds: Option[Seq[QuestionId]],
384                   content: Option[String],
385                   status: Option[Seq[ProposalStatus]],
386                   userTypes: Option[Seq[UserType]],
387                   proposalTypes: Option[Seq[ProposalType]],
388                   tagIds: Option[Seq[TagId]],
389                   offset: Option[Pagination.Offset],
390                   end: Option[Pagination.End],
391                   sort: Option[ProposalElasticsearchFieldName],
392                   order: Option[Order]
393                 ) =>
394                   Validation.validate(sort.map(Validation.validateSort("_sort")).toList: _*)
395 
396                   val exhaustiveSearchRequest: ExhaustiveSearchRequest = ExhaustiveSearchRequest(
397                     proposalIds = proposalIds,
398                     proposalTypes = proposalTypes,
399                     tagsIds = tagIds,
400                     questionIds = questionIds,
401                     content = content,
402                     status = status,
403                     sort = sort.map(_.field),
404                     order = order,
405                     limit = end.map(_.toLimit(offset.orZero)),
406                     offset = offset,
407                     userTypes = userTypes
408                   )
409                   val query: SearchQuery = exhaustiveSearchRequest.toSearchQuery(requestContext)
410                   proposalService
411                     .searchInIndex(query, requestContext)
412                     .asDirective
413                     .apply(
414                       proposals =>
415                         complete(
416                           (
417                             StatusCodes.OK,
418                             List(`X-Total-Count`(proposals.total.toString)),
419                             proposals.results.map(AdminProposalResponse.apply)
420                           )
421                         )
422                     )
423               }
424             }
425           }
426         }
427       }
428     }
429 
430     def updateProposalVotes: Route = put {
431       path("admin" / "proposals" / adminProposalId / "fix-trolled-proposal") { proposalId =>
432         makeOperation("EditProposalVotesVerified") { requestContext =>
433           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
434             requireAdminRole(userAuth.user) {
435               decodeRequest {
436                 entity(as[UpdateProposalVotesRequest]) { request =>
437                   retrieveProposalQuestion(proposalId).asDirectiveOrNotFound { _ =>
438                     proposalService
439                       .updateVotes(
440                         proposalId = proposalId,
441                         moderator = userAuth.user.userId,
442                         requestContext = requestContext,
443                         updatedAt = DateHelper.now(),
444                         votes = request.votes
445                       )
446                       .asDirectiveOrNotFound
447                       .apply(complete(_))
448                   }
449                 }
450               }
451             }
452           }
453         }
454       }
455     }
456 
457     override def patchProposal: Route = {
458       patch {
459         path("admin" / "proposals" / adminProposalId) { id =>
460           makeOperation("PatchProposal") { context =>
461             makeOAuth2 { auth =>
462               requireAdminRole(auth.user) {
463                 decodeRequest {
464                   entity(as[PatchProposalRequest]) { patch =>
465                     (
466                       proposalService.getProposalById(id, context).flattenOrFail("Proposal not found"),
467                       patch.author.traverse(userService.getUser(_)).map(_.flatten),
468                       patch.ideaId.traverse(ideaService.fetchOne(_)).map(_.flatten),
469                       patch.operation.traverse(operationService.findOneSimple(_)).map(_.flatten),
470                       patch.questionId.traverse(questionService.getQuestion(_)).map(_.flatten),
471                       patch.tags.traverse(tagService.findByTagIds(_).map(_.map(_.tagId)))
472                     ).tupled.asDirective
473                       .flatMap({
474                         case (proposal, maybeAuthor, maybeIdea, maybeOperation, maybeQuestion, maybeTags) =>
475                           Validation.validateOptional(
476                             patch.author.map(_ => {
477                               Validation.validateField(
478                                 field = "author",
479                                 key = "invalid_value",
480                                 condition = maybeAuthor.isDefined,
481                                 message = s"UserId ${patch.author} does not exist."
482                               )
483                             }),
484                             patch.ideaId.map(_ => {
485                               Validation.validateField(
486                                 field = "ideaId",
487                                 key = "invalid_value",
488                                 condition = maybeIdea.isDefined,
489                                 message = s"Idea ${patch.ideaId} does not exist."
490                               )
491                             }),
492                             patch.operation.map(_ => {
493                               Validation.validateField(
494                                 field = "operation",
495                                 key = "invalid_value",
496                                 condition = maybeOperation.isDefined,
497                                 message = s"Operation ${patch.operation} does not exist."
498                               )
499                             }),
500                             patch.questionId.map(_ => {
501                               Validation.validateField(
502                                 field = "questionId",
503                                 key = "invalid_value",
504                                 condition = maybeQuestion.isDefined,
505                                 message = s"Question ${patch.questionId} does not exist."
506                               )
507                             })
508                           )
509                           (maybeQuestion, patch.contentTranslations).tupled.foreach({
510                             case (question, translations) =>
511                               MultilingualUtils
512                                 .hasRequiredTranslations(
513                                   question.languages.toList.toSet - proposal.submittedAsLanguage
514                                     .getOrElse(Language("fr")),
515                                   List((translations, "proposal_translations"))
516                                 )
517                                 .throwIfInvalid()
518                           })
519 
520                           proposalService
521                             .patchProposal(id, auth.user.userId, context, patch.copy(tags = maybeTags))
522                             .asDirectiveOrNotFound
523                       })
524                       .apply(complete(_))
525                   }
526                 }
527               }
528             }
529           }
530         }
531       }
532     }
533 
534     private def retrieveProposalQuestion(proposalId: ProposalId): Future[Option[Question]] = {
535       proposalCoordinatorService.getProposal(proposalId).flatMap {
536         case Some(proposal) =>
537           proposal.questionId
538             .map(questionService.getQuestion)
539             .getOrElse(Future.successful(None))
540         case None =>
541           Future.successful(None)
542       }
543     }
544 
545     override def resetVotes: Route = post {
546       path("admin" / "proposals" / "reset-votes") {
547         withoutRequestTimeout {
548           makeOperation("ResetVotes") { requestContext =>
549             makeOAuth2 { userAuth =>
550               requireAdminRole(userAuth.user) {
551                 proposalService.resetVotes(userAuth.user.userId, requestContext)
552                 complete(StatusCodes.Accepted)
553               }
554             }
555           }
556         }
557       }
558     }
559 
560     override def setProposalKeywords: Route = post {
561       path("admin" / "proposals" / "keywords") {
562         makeOperation("SetProposalKeywords") { requestContext =>
563           makeOAuth2 { userAuth =>
564             requireAdminRole(userAuth.user) {
565               decodeRequest {
566                 entity(as[Seq[ProposalKeywordRequest]]) { request =>
567                   proposalService
568                     .setKeywords(request, requestContext)
569                     .asDirective
570                     .apply(complete(_))
571                 }
572               }
573             }
574           }
575         }
576       }
577     }
578 
579     @Deprecated
580     override def bulkRefuseInitialsProposals: Route = post {
581       path("admin" / "proposals" / "refuse-initials-proposals") {
582         makeOperation("BulkRefuseInitialsProposals") { requestContext =>
583           makeOAuth2 { userAuth =>
584             requireAdminRole(userAuth.user) {
585               decodeRequest {
586                 entity(as[BulkRefuseProposal]) { request =>
587                   proposalService
588                     .refuseAll(request.proposalIds, userAuth.user.userId, requestContext)
589                     .asDirective
590                     .apply(complete(_))
591                 }
592               }
593             }
594           }
595         }
596       }
597     }
598 
599     @Deprecated
600     override def bulkTagProposal: Route = post {
601       path("admin" / "proposals" / "tag") {
602         makeOperation("BulkTagProposal") { requestContext =>
603           makeOAuth2 { userAuth =>
604             requireAdminRole(userAuth.user) {
605               decodeRequest {
606                 entity(as[BulkTagProposal]) { request =>
607                   tagService.findByTagIds(request.tagIds).asDirective { foundTags =>
608                     Validation.validate(request.tagIds.diff(foundTags.map(_.tagId)).map { tagId =>
609                       Validation.validateField(
610                         field = "tagId",
611                         key = "invalid_value",
612                         condition = false,
613                         message = s"Tag $tagId does not exist."
614                       )
615                     }: _*)
616                     proposalService
617                       .addTagsToAll(request.proposalIds, request.tagIds, userAuth.user.userId, requestContext)
618                       .asDirective
619                       .apply(complete(_))
620                   }
621                 }
622               }
623             }
624           }
625         }
626       }
627     }
628 
629     @Deprecated
630     override def bulkDeleteTagProposal: Route = delete {
631       path("admin" / "proposals" / "tag") {
632         makeOperation("BulkDeleteTagProposal") { requestContext =>
633           makeOAuth2 { userAuth =>
634             requireAdminRole(userAuth.user) {
635               decodeRequest {
636                 entity(as[BulkDeleteTagProposal]) { request =>
637                   tagService.getTag(request.tagId).asDirective { maybeTag =>
638                     Validation.validate(
639                       Validation.validateField(
640                         field = "tagId",
641                         key = "invalid_value",
642                         condition = maybeTag.isDefined,
643                         message = s"Tag ${request.tagId} does not exist."
644                       )
645                     )
646                     proposalService
647                       .deleteTagFromAll(request.proposalIds, request.tagId, userAuth.user.userId, requestContext)
648                       .asDirective
649                       .apply(complete(_))
650                   }
651                 }
652               }
653             }
654           }
655         }
656       }
657     }
658 
659     private val questionId: PathMatcher1[QuestionId] = Segment.map(QuestionId.apply)
660 
661     private val userId = config.getString("make-api.environment") match {
662       case "production" => UserId("98c4cc66-d0fd-466b-bf84-e345c1851fcb")
663       case _            => UserId("61568b62-2f92-4620-8408-0d22d9d263e2")
664     }
665 
666     override def submittedAsLanguagePatchScript: Route = post {
667       path("admin" / "proposals" / "submitted-as-language-patch-script" / questionId) { questionId =>
668         withRequestTimeout(5.minutes) {
669           makeOperation("SubmittedAsLanguagePatchScript") { requestContext =>
670             parameters("dry-run".as[Boolean].?)(
671               dryRun =>
672                 makeOAuth2 { userAuth =>
673                   requireAdminRole(userAuth.user) {
674                     questionService
675                       .getQuestion(questionId)
676                       .flattenOrFail(s"Could not find question $questionId")
677                       .map(question => {
678                         def modifyFn(p: Proposal): Future[Unit] = {
679                           val questionLanguages = question.languages.toList
680                           val canPatch = questionLanguages.size === 1
681                           val mustPatch = p.submittedAsLanguage.fold(true)(!questionLanguages.contains(_))
682                           if (canPatch && mustPatch) {
683                             logger.info(s"Patching ${p.proposalId} from question ${question.questionId}")
684                             if (dryRun.getOrElse(true)) Future.unit
685                             else {
686                               val patch = PatchProposalRequest(submittedAsLanguage = Some(question.defaultLanguage))
687                               proposalService.patchProposal(p.proposalId, userId, requestContext, patch).void
688                             }
689                           } else Future.unit
690                         }
691 
692                         proposalService.modifyForQuestion(questionId, modifyFn, requestContext)
693                       })
694                       .asDirective
695                       .apply(_ => complete(StatusCodes.OK))
696                   }
697                 }
698             )
699           }
700         }
701       }
702     }
703 
704     override def getProposalHistory: Route = get {
705       path("admin" / "proposals" / adminProposalId / "history") { id =>
706         makeOperation("GetProposalHistory") { _ =>
707           makeOAuth2 { userAuth =>
708             requireAdminRole(userAuth.user) {
709               proposalService.getHistory(id).asDirectiveOrNotFound.apply(complete(_))
710             }
711           }
712         }
713       }
714     }
715   }
716 
717 }
718 
719 final case class UpdateProposalVotesRequest(votes: Seq[UpdateVoteRequest])
720 
721 object UpdateProposalVotesRequest {
722   implicit val codec: Codec[UpdateProposalVotesRequest] = deriveCodec
723 }
724 
725 final case class AdminProposalResponse(
726   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true) id: ProposalId,
727   author: AdminProposalResponse.Author,
728   content: String,
729   contentTranslations: Multilingual[String],
730   submittedAsLanguage: Option[Language],
731   @(ApiModelProperty @field)(
732     dataType = "string",
733     required = true,
734     allowableValues = ProposalStatus.swaggerAllowableValues
735   ) status: ProposalStatus,
736   proposalType: ProposalType,
737   tags: Seq[IndexedTag] = Seq.empty,
738   createdAt: ZonedDateTime,
739   agreementRate: Double,
740   context: AdminProposalResponse.Context,
741   votes: Seq[AdminProposalResponse.Vote],
742   votesCount: Int
743 )
744 
745 object AdminProposalResponse extends CirceFormatters {
746 
747   def apply(proposal: IndexedProposal): AdminProposalResponse =
748     AdminProposalResponse(
749       id = proposal.id,
750       author = Author(proposal),
751       content = proposal.contentGeneral,
752       contentTranslations = proposal.content,
753       submittedAsLanguage = proposal.submittedAsLanguage,
754       status = proposal.status,
755       proposalType = proposal.proposalType,
756       tags = proposal.tags,
757       createdAt = proposal.createdAt,
758       agreementRate = proposal.agreementRate,
759       context = Context(proposal.context),
760       votes = proposal.votes.deprecatedVotesSeq.map(Vote.apply),
761       votesCount = proposal.votesCount
762     )
763 
764   final case class Author(
765     @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true) id: UserId,
766     @(ApiModelProperty @field)(dataType = "string", required = true, allowableValues = UserType.swaggerAllowableValues) userType: UserType,
767     displayName: Option[String],
768     postalCode: Option[String],
769     @(ApiModelProperty @field)(dataType = "int", example = "42") age: Option[Int],
770     profession: Option[String]
771   )
772 
773   object Author {
774     def apply(proposal: IndexedProposal): Author =
775       Author(
776         id = proposal.author.userId,
777         userType = proposal.author.userType,
778         displayName = proposal.author.displayName,
779         postalCode = proposal.author.postalCode,
780         age = proposal.author.age,
781         profession = proposal.author.profession
782       )
783     implicit val codec: Codec[Author] = deriveCodec
784   }
785 
786   final case class Context(
787     source: Option[String],
788     questionSlug: Option[String],
789     @(ApiModelProperty @field)(dataType = "string", example = "FR") country: Option[Country],
790     @(ApiModelProperty @field)(dataType = "string", example = "fr") questionLanguage: Option[Language],
791     @(ApiModelProperty @field)(dataType = "string", example = "fr") proposalLanguage: Option[Language],
792     @(ApiModelProperty @field)(dataType = "string", example = "fr") clientLanguage: Option[Language]
793   )
794 
795   object Context {
796     def apply(context: Option[IndexedContext]): Context =
797       Context(
798         source = context.flatMap(_.source),
799         questionSlug = context.flatMap(_.questionSlug),
800         country = context.flatMap(_.country),
801         questionLanguage = context.flatMap(_.questionLanguage),
802         proposalLanguage = context.flatMap(_.proposalLanguage),
803         clientLanguage = context.flatMap(_.clientLanguage)
804       )
805     implicit val codec: Codec[Context] = deriveCodec
806   }
807 
808   final case class Vote(
809     @(ApiModelProperty @field)(dataType = "string", required = true, allowableValues = VoteKey.swaggerAllowableValues)
810     key: VoteKey,
811     count: Int,
812     qualifications: Seq[Qualification]
813   )
814 
815   object Vote {
816     def apply(vote: ProposalVote): Vote =
817       Vote(key = vote.key, count = vote.count, qualifications = vote.qualifications.map(Qualification.apply))
818     implicit val codec: Codec[Vote] = deriveCodec
819   }
820 
821   final case class Qualification(
822     @(ApiModelProperty @field)(
823       dataType = "string",
824       required = true,
825       allowableValues = QualificationKey.swaggerAllowableValues
826     )
827     key: QualificationKey,
828     count: Int
829   )
830 
831   object Qualification {
832     def apply(qualification: ProposalQualification): Qualification =
833       Qualification(key = qualification.key, count = qualification.count)
834     implicit val codec: Codec[Qualification] = deriveCodec
835   }
836 
837   implicit val codec: Codec[AdminProposalResponse] = deriveCodec
838 
839 }