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.operation
21 
22 import java.time.{LocalDate, ZonedDateTime}
23 import scala.concurrent.Future
24 import scala.concurrent.ExecutionContext.Implicits.global
25 import cats.implicits._
26 import cats.data.NonEmptyList
27 import cats.data.ValidatedNec
28 import akka.http.scaladsl.model.StatusCodes
29 import akka.http.scaladsl.server.{Directives, PathMatcher1, Route}
30 import eu.timepit.refined.refineV
31 import eu.timepit.refined.auto._
32 import eu.timepit.refined.api.Refined
33 import eu.timepit.refined.string.Url
34 import eu.timepit.refined.collection._
35 import eu.timepit.refined.boolean.And
36 import eu.timepit.refined.string.StartsWith
37 import grizzled.slf4j.Logging
38 import io.circe.{Codec, Decoder, Encoder, HCursor}
39 import io.circe.refined._
40 import io.circe.generic.semiauto._
41 import io.swagger.annotations._
42 
43 import javax.ws.rs.Path
44 import org.make.api.question.QuestionServiceComponent
45 import org.make.api.technical.{`X-Total-Count`, EventBusServiceComponent, MakeAuthenticationDirectives}
46 import org.make.api.technical.CsvReceptacle._
47 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
48 import org.make.api.technical.directives.FutureDirectivesExtensions._
49 import org.make.api.userhistory.{VoteOnlyEvent, VoteOnlyTestEvent}
50 import org.make.api.widget.WidgetServiceComponent
51 import org.make.core.Validation
52 import org.make.core.Validation._
53 import org.make.core.technical.{Multilingual, MultilingualUtils, Pagination}
54 import org.make.core.technical.ValidatedUtils.ValidatedNecWithUtils
55 import org.make.core._
56 import org.make.core.auth.UserRights
57 import org.make.core.operation.OperationKind.GreatCause
58 import org.make.core.operation.OperationOfQuestion.{Status => QuestionStatus}
59 import org.make.core.operation._
60 import org.make.core.operation.indexed.{
61   IndexedOperationOfQuestion,
62   OperationOfQuestionElasticsearchFieldName,
63   OperationOfQuestionSearchResult
64 }
65 import org.make.core.question.{Question, QuestionId}
66 import org.make.core.reference.{Country, Language}
67 import org.make.core.technical.RefinedTypes
68 import org.make.core.user.Role.RoleAdmin
69 import scalaoauth2.provider.AuthInfo
70 import org.make.api.demographics.DemographicsCardServiceComponent
71 import org.make.api.operation.DefaultModerationOperationOfQuestionApiComponent._
72 import org.make.api.operation.DefaultPersistentOperationOfQuestionServiceComponent.PersistentOperationOfQuestion
73 import org.make.api.technical.crm.PersistentCrmUserServiceComponent
74 
75 import scala.annotation.meta.field
76 
77 @Api(value = "Moderation Operation of question")
78 @Path(value = "/moderation/operations-of-questions")
79 trait ModerationOperationOfQuestionApi extends Directives {
80 
81   @ApiOperation(
82     value = "get-operations-of-questions-for-operation",
83     httpMethod = "GET",
84     code = HttpCodes.OK,
85     authorizations = Array(
86       new Authorization(
87         value = "MakeApi",
88         scopes = Array(
89           new AuthorizationScope(scope = "admin", description = "BO Admin"),
90           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
91         )
92       )
93     )
94   )
95   @ApiResponses(
96     value = Array(
97       new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[OperationOfQuestionResponse]])
98     )
99   )
100   @ApiImplicitParams(
101     value = Array(
102       new ApiImplicitParam(
103         name = "_start",
104         paramType = "query",
105         dataType = "int",
106         allowableValues = "range[0, infinity]"
107       ),
108       new ApiImplicitParam(
109         name = "_end",
110         paramType = "query",
111         dataType = "int",
112         allowableValues = "range[0, infinity]"
113       ),
114       new ApiImplicitParam(
115         name = "_sort",
116         paramType = "query",
117         dataType = "string",
118         allowableValues = PersistentOperationOfQuestion.swaggerAllowableValues
119       ),
120       new ApiImplicitParam(
121         name = "_order",
122         paramType = "query",
123         dataType = "string",
124         allowableValues = Order.swaggerAllowableValues
125       ),
126       new ApiImplicitParam(name = "id", paramType = "query", dataType = "string", allowMultiple = true),
127       new ApiImplicitParam(name = "questionId", paramType = "query", dataType = "string", allowMultiple = true),
128       new ApiImplicitParam(name = "operationId", paramType = "query", dataType = "string"),
129       new ApiImplicitParam(
130         name = "operationKind",
131         paramType = "query",
132         dataType = "string",
133         allowableValues = OperationKind.swaggerAllowableValues,
134         allowMultiple = true
135       ),
136       new ApiImplicitParam(name = "openAt", paramType = "query", dataType = "dateTime"),
137       new ApiImplicitParam(name = "endAfter", paramType = "query", dataType = "dateTime"),
138       new ApiImplicitParam(name = "slug", paramType = "query", dataType = "string")
139     )
140   )
141   @Path(value = "/")
142   def listOperationOfQuestions: Route
143 
144   @ApiOperation(
145     value = "get-operation-of-question",
146     httpMethod = "GET",
147     code = HttpCodes.OK,
148     authorizations = Array(
149       new Authorization(
150         value = "MakeApi",
151         scopes = Array(
152           new AuthorizationScope(scope = "admin", description = "BO Admin"),
153           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
154         )
155       )
156     )
157   )
158   @ApiResponses(
159     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[OperationOfQuestionResponse]))
160   )
161   @ApiImplicitParams(
162     value = Array(new ApiImplicitParam(name = "questionId", paramType = "path", required = true, dataType = "string"))
163   )
164   @Path(value = "/{questionId}")
165   def getOperationOfQuestion: Route
166 
167   @ApiOperation(
168     value = "modify-operation-of-question",
169     httpMethod = "PUT",
170     code = HttpCodes.OK,
171     authorizations = Array(
172       new Authorization(
173         value = "MakeApi",
174         scopes = Array(
175           new AuthorizationScope(scope = "admin", description = "BO Admin"),
176           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
177         )
178       )
179     )
180   )
181   @ApiResponses(
182     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[OperationOfQuestionResponse]))
183   )
184   @ApiImplicitParams(
185     value = Array(
186       new ApiImplicitParam(name = "questionId", paramType = "path", required = true, dataType = "string"),
187       new ApiImplicitParam(
188         value = "body",
189         paramType = "body",
190         required = true,
191         dataType = "org.make.api.operation.ModifyOperationOfQuestionRequest"
192       )
193     )
194   )
195   @Path(value = "/{questionId}")
196   def modifyOperationOfQuestion: Route
197 
198   @ApiOperation(
199     value = "delete-operation-of-question",
200     httpMethod = "DELETE",
201     code = HttpCodes.NoContent,
202     authorizations = Array(
203       new Authorization(
204         value = "MakeApi",
205         scopes = Array(
206           new AuthorizationScope(scope = "admin", description = "BO Admin"),
207           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
208         )
209       )
210     )
211   )
212   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
213   @ApiImplicitParams(
214     value = Array(new ApiImplicitParam(name = "questionId", paramType = "path", required = true, dataType = "string"))
215   )
216   @Path(value = "/{questionId}")
217   def deleteOperationOfQuestionAndQuestion: Route
218 
219   @ApiOperation(
220     value = "create-operation-of-question",
221     httpMethod = "POST",
222     code = HttpCodes.OK,
223     authorizations = Array(
224       new Authorization(
225         value = "MakeApi",
226         scopes = Array(
227           new AuthorizationScope(scope = "admin", description = "BO Admin"),
228           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
229         )
230       )
231     )
232   )
233   @ApiResponses(
234     value =
235       Array(new ApiResponse(code = HttpCodes.Created, message = "Ok", response = classOf[OperationOfQuestionResponse]))
236   )
237   @ApiImplicitParams(
238     value = Array(
239       new ApiImplicitParam(
240         value = "body",
241         paramType = "body",
242         required = true,
243         dataType = "org.make.api.operation.CreateOperationOfQuestionRequest"
244       )
245     )
246   )
247   @Path(value = "/")
248   def createOperationOfQuestionAndQuestion: Route
249 
250   @ApiOperation(
251     value = "search-operations-of-questions",
252     httpMethod = "GET",
253     code = HttpCodes.OK,
254     authorizations = Array(
255       new Authorization(
256         value = "MakeApi",
257         scopes = Array(
258           new AuthorizationScope(scope = "admin", description = "BO Admin"),
259           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
260         )
261       )
262     )
263   )
264   @ApiResponses(
265     value = Array(
266       new ApiResponse(
267         code = HttpCodes.OK,
268         message = "Ok",
269         response = classOf[Array[ModerationOperationOfQuestionSearchResult]]
270       )
271     )
272   )
273   @ApiImplicitParams(
274     value = Array(
275       new ApiImplicitParam(
276         name = "_start",
277         paramType = "query",
278         dataType = "int",
279         allowableValues = "range[0, infinity]"
280       ),
281       new ApiImplicitParam(
282         name = "_end",
283         paramType = "query",
284         dataType = "int",
285         allowableValues = "range[0, infinity]"
286       ),
287       new ApiImplicitParam(
288         name = "_sort",
289         paramType = "query",
290         dataType = "string",
291         allowableValues = OperationOfQuestionElasticsearchFieldName.swaggerAllowableValues
292       ),
293       new ApiImplicitParam(
294         name = "_order",
295         paramType = "query",
296         dataType = "string",
297         allowableValues = Order.swaggerAllowableValues
298       ),
299       new ApiImplicitParam(name = "slug", paramType = "query", dataType = "string")
300     )
301   )
302   @Path(value = "/search")
303   def searchOperationsOfQuestions: Route
304 
305   @ApiOperation(
306     value = "operations-of-questions-infos",
307     httpMethod = "GET",
308     code = HttpCodes.OK,
309     authorizations = Array(
310       new Authorization(
311         value = "MakeApi",
312         scopes = Array(
313           new AuthorizationScope(scope = "admin", description = "BO Admin"),
314           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
315         )
316       )
317     )
318   )
319   @ApiResponses(
320     value = Array(
321       new ApiResponse(
322         code = HttpCodes.OK,
323         message = "Ok",
324         response = classOf[Array[ModerationOperationOfQuestionInfosResponse]]
325       )
326     )
327   )
328   @ApiImplicitParams(
329     value =
330       Array(new ApiImplicitParam(name = "moderationMode", paramType = "query", required = true, dataType = "string"))
331   )
332   @Path(value = "/infos")
333   def infosOperationsOfQuestions: Route
334 
335   @ApiOperation(
336     value = "send-vote-only-test",
337     httpMethod = "POST",
338     code = HttpCodes.OK,
339     authorizations = Array(
340       new Authorization(
341         value = "MakeApi",
342         scopes = Array(
343           new AuthorizationScope(scope = "admin", description = "BO Admin"),
344           new AuthorizationScope(scope = "moderator", description = "BO Moderator")
345         )
346       )
347     )
348   )
349   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok")))
350   @ApiImplicitParams(
351     value = Array(new ApiImplicitParam(name = "questionId", paramType = "path", required = true, dataType = "string"))
352   )
353   @Path(value = "/{questionId}/vote-only-test")
354   def sendVoteOnlyTest: Route
355 
356   def routes: Route =
357     listOperationOfQuestions ~
358       infosOperationsOfQuestions ~
359       searchOperationsOfQuestions ~
360       getOperationOfQuestion ~
361       modifyOperationOfQuestion ~
362       deleteOperationOfQuestionAndQuestion ~
363       createOperationOfQuestionAndQuestion ~
364       sendVoteOnlyTest
365 }
366 
367 trait ModerationOperationOfQuestionApiComponent {
368   def moderationOperationOfQuestionApi: ModerationOperationOfQuestionApi
369 }
370 
371 trait DefaultModerationOperationOfQuestionApiComponent
372     extends ModerationOperationOfQuestionApiComponent
373     with MakeAuthenticationDirectives
374     with Logging
375     with ParameterExtractors {
376 
377   this: MakeDirectivesDependencies
378     with EventBusServiceComponent
379     with OperationOfQuestionServiceComponent
380     with QuestionServiceComponent
381     with WidgetServiceComponent
382     with OperationServiceComponent
383     with DemographicsCardServiceComponent
384     with PersistentCrmUserServiceComponent =>
385 
386   private val moderationQuestionId: PathMatcher1[QuestionId] = Segment.map(id => QuestionId(id))
387 
388   override lazy val moderationOperationOfQuestionApi: DefaultModerationOperationOfQuestionApi =
389     new DefaultModerationOperationOfQuestionApi
390 
391   class DefaultModerationOperationOfQuestionApi extends ModerationOperationOfQuestionApi {
392 
393     override def listOperationOfQuestions: Route = get {
394       path("moderation" / "operations-of-questions") {
395         makeOperation("ListOperationsOfQuestions") { _ =>
396           makeOAuth2 { auth: AuthInfo[UserRights] =>
397             requireModerationRole(auth.user) {
398               parameters(
399                 "_start".as[Pagination.Offset].?,
400                 "_end".as[Pagination.End].?,
401                 "_sort".?,
402                 "_order".as[Order].?,
403                 "id".csv[QuestionId],
404                 "questionId".csv[QuestionId],
405                 "operationId".as[OperationId].?,
406                 "operationKind".csv[OperationKind],
407                 "openAt".as[ZonedDateTime].?,
408                 "endAfter".as[ZonedDateTime].?,
409                 "slug".as[String].?
410               ) {
411                 (
412                   offset: Option[Pagination.Offset],
413                   end: Option[Pagination.End],
414                   sort: Option[String],
415                   order: Option[Order],
416                   ids,
417                   questionIds,
418                   operationId,
419                   operationKinds,
420                   openAt,
421                   endAfter,
422                   slug
423                 ) =>
424                   val resolvedQuestions: Option[Seq[QuestionId]] = {
425                     if (auth.user.roles.contains(RoleAdmin)) {
426                       questionIds.plusDistinct(ids)
427                     } else {
428                       questionIds
429                         .plusDistinct(ids)
430                         .map(_.filter(auth.user.availableQuestions.contains))
431                         .orElse(Some(auth.user.availableQuestions))
432                     }
433                   }
434                   (
435                     operationOfQuestionService
436                       .find(
437                         offset.orZero,
438                         end,
439                         sort,
440                         order,
441                         SearchOperationsOfQuestions(
442                           questionIds = resolvedQuestions,
443                           operationIds = operationId.map(opId => Seq(opId)),
444                           operationKind = operationKinds,
445                           openAt = openAt,
446                           endAfter = endAfter,
447                           slug = slug
448                         )
449                       )
450                       .asDirective,
451                     operationOfQuestionService
452                       .count(
453                         SearchOperationsOfQuestions(
454                           questionIds = resolvedQuestions,
455                           operationIds = operationId.map(opId => Seq(opId)),
456                           operationKind = operationKinds,
457                           openAt = openAt,
458                           endAfter = endAfter,
459                           slug = slug
460                         )
461                       )
462                       .asDirective
463                   ).tupled.apply({
464                     case (result, count) =>
465                       questionService.getQuestions(result.map(_.questionId)).asDirective { questions =>
466                         val questionsAsMap = questions.map(q => q.questionId -> q).toMap
467                         complete(
468                           (
469                             StatusCodes.OK,
470                             List(`X-Total-Count`(count.toString)),
471                             result
472                               .map(
473                                 operationOfQuestion =>
474                                   OperationOfQuestionResponse(
475                                     operationOfQuestion,
476                                     questionsAsMap(operationOfQuestion.questionId)
477                                   )
478                               )
479                           )
480                         )
481                       }
482                   })
483               }
484             }
485           }
486         }
487       }
488     }
489 
490     override def getOperationOfQuestion: Route = get {
491       path("moderation" / "operations-of-questions" / moderationQuestionId) { questionId =>
492         makeOperation("GetOperationsOfQuestions") { _ =>
493           makeOAuth2 { auth: AuthInfo[UserRights] =>
494             requireModerationRole(auth.user) {
495               (
496                 operationOfQuestionService.findByQuestionId(questionId).asDirectiveOrNotFound,
497                 questionService.getQuestion(questionId).asDirectiveOrNotFound
498               ).tupled.apply({
499                 case (operationOfQuestion, question) =>
500                   persistentCrmUserService.getActiveConsultationUsersCount(question.slug).asDirective {
501                     activesUsersCount =>
502                       complete(OperationOfQuestionResponse(operationOfQuestion, question, Some(activesUsersCount)))
503                   }
504               })
505             }
506           }
507         }
508       }
509     }
510 
511     @SuppressWarnings(Array("org.wartremover.warts.Throw"))
512     private def validateModifyRequest(
513       request: ModifyOperationOfQuestionRequest,
514       question: Question,
515       operationOfQuestion: OperationOfQuestion,
516       widgetsCount: Int,
517       activeCardCount: Int
518     ): ValidatedNec[ValidationError, Unit] = {
519       val countriesValidated: ValidatedNec[ValidationError, Unit] =
520         if (operationOfQuestion.proposalsCount > 0) {
521           val deletedCountries = question.countries.toList.toSet -- request.countries.toList
522           if (deletedCountries.isEmpty) ().validNec
523           else
524             ValidationError(
525               "countries",
526               "removal_forbidden",
527               Some(s"You cannot remove existing countries: ${deletedCountries.mkString(", ")}")
528             ).invalidNec
529         } else ().validNec
530       val languagesRemoved = question.languages.toList.toSet -- request.languages.toList
531       val languagesRemovedValidated =
532         if (languagesRemoved.nonEmpty) {
533           if (operationOfQuestion.proposalsCount > 0)
534             ValidationError(
535               "languages",
536               "has_proposition",
537               Some("Cannot remove languages from a consultation that already has had proposals made on it")
538             ).invalidNec
539           else if (widgetsCount > 0)
540             ValidationError(
541               "languages",
542               "has_widget",
543               Some("Cannot remove languages from a consultation that has a widget attached to it")
544             ).invalidNec
545           else ().validNec
546         } else ().validNec
547       val languagesAdded = request.languages.toList.toSet -- question.languages.toList
548       val languagesAddedValidated =
549         if (languagesAdded.nonEmpty && operationOfQuestion.proposalsCount > 0) {
550           ValidationError(
551             "languages",
552             "has_proposition",
553             Some("Cannot add a language on a consultation that already has had proposals made on it")
554           ).invalidNec
555         } else ().validNec
556       val activeCardsCountValidated =
557         if (languagesAdded.nonEmpty && activeCardCount > 0) {
558           ValidationError(
559             "languages",
560             "has_demographics_cards",
561             Some("Cannot add languages from a consultation that has demographics cards attached to it")
562           ).invalidNec
563         } else ().validNec
564       val reportUrlValidated =
565         request.reportUrl match {
566           case None => ().validNec
567           case Some(value) =>
568             refineV[Url](value)
569               .leftMap(
570                 err =>
571                   ValidationError("report_url", "valid_report_url", Some(s"$value is not a valid report url: $err"))
572               )
573               .toValidatedNec
574               .void
575         }
576       val actionsUrlValidated =
577         request.actionsUrl match {
578           case None => ().validNec
579           case Some(value) =>
580             refineV[Url](value)
581               .leftMap(
582                 err =>
583                   ValidationError("actions_url", "valid_actions_url", Some(s"$value is not a valid actions url: $err"))
584               )
585               .toValidatedNec
586               .void
587         }
588       val proposalPrefixesSizeValidated =
589         if (operationOfQuestion.proposalsCount > 0
590             && operationOfQuestion.proposalPrefixes.toMap.sizeIs != request.proposalPrefixes.toMap.size) {
591           ValidationError(
592             "proposalPrefixes",
593             "has_proposition",
594             Some("Cannot add or delete proposal prefixes on a consultation that already has had proposals made on it")
595           ).invalidNec
596         } else ().validNec
597       val proposalPrefixesMerged = (operationOfQuestion.proposalPrefixes.toMap.toSeq ++
598         request.proposalPrefixes.mapTranslations(_.value).toMap.toSeq).groupMap(_._1)(_._2)
599       val proposalPrefixesValidated =
600         if (operationOfQuestion.proposalsCount > 0
601             && proposalPrefixesMerged.view.values.exists(v => v.headOption != v.lastOption)) {
602           ValidationError(
603             "proposalPrefixes",
604             "has_proposition",
605             Some("Cannot update proposal prefixes on a consultation that already has had proposals made on it")
606           ).invalidNec
607         } else ().validNec
608       (
609         countriesValidated,
610         languagesRemovedValidated,
611         languagesAddedValidated,
612         activeCardsCountValidated,
613         reportUrlValidated,
614         actionsUrlValidated,
615         proposalPrefixesSizeValidated,
616         proposalPrefixesValidated
617       ).tupled.void
618     }
619 
620     override def sendVoteOnlyTest: Route = post {
621       path("moderation" / "operations-of-questions" / moderationQuestionId / "vote-only-test") { questionId =>
622         makeOperation("SendVoteOnlyTest") { requestContext =>
623           makeOAuth2 { auth: AuthInfo[UserRights] =>
624             requireAdminRole(auth.user) {
625               Future {
626                 eventBusService.publish(
627                   VoteOnlyTestEvent(
628                     eventId = Some(idGenerator.nextEventId()),
629                     eventDate = DateHelper.now(),
630                     userId = auth.user.userId,
631                     requestContext = requestContext
632                       .copy(questionContext = RequestContextQuestion(questionId = Some(questionId)))
633                   )
634                 )
635               }.asDirective.apply(complete(_))
636             }
637           }
638         }
639       }
640     }
641 
642     override def modifyOperationOfQuestion: Route = put {
643       path("moderation" / "operations-of-questions" / moderationQuestionId) { questionId =>
644         makeOperation("ModifyOperationsOfQuestions") { requestContext =>
645           makeOAuth2 { auth: AuthInfo[UserRights] =>
646             requireAdminRole(auth.user) {
647               decodeRequest {
648                 entity(as[ModifyOperationOfQuestionRequest]) { request =>
649                   (
650                     questionService.getQuestion(questionId).asDirectiveOrNotFound,
651                     operationOfQuestionService.findByQuestionId(questionId).asDirectiveOrNotFound,
652                     widgetService.count(questionId).asDirective,
653                     demographicsCardService.count(questionId = Some(questionId)).asDirective
654                   ).tupled
655                     .flatMap({
656                       case (question, operationOfQuestion, widgetsCount, demographicsCardCount) =>
657                         validateModifyRequest(
658                           request,
659                           question,
660                           operationOfQuestion,
661                           widgetsCount,
662                           demographicsCardCount
663                         ).throwIfInvalid()
664                         val updatedQuestion = question.copy(
665                           countries = request.countries,
666                           defaultLanguage = request.defaultLanguage,
667                           languages = request.languages,
668                           questions = request.questions.mapTranslations(RefinedTypes.cast(_)),
669                           shortTitles = request.shortTitles
670                             .map(_.mapTranslations(title => refineV[NonEmpty].unsafeFrom(title.value)))
671                         )
672                         val updatedSequenceCardsConfiguration =
673                           request.sequenceCardsConfiguration.copy(
674                             introCard = request.sequenceCardsConfiguration.introCard
675                               .copy(titles = if (request.sequenceCardsConfiguration.introCard.enabled) {
676                                 request.sequenceCardsConfiguration.introCard.titles
677                               } else {
678                                 None
679                               }, descriptions = if (request.sequenceCardsConfiguration.introCard.enabled) {
680                                 request.sequenceCardsConfiguration.introCard.descriptions
681                               } else {
682                                 None
683                               }),
684                             pushProposalCard = PushProposalCard(enabled = request.canPropose &&
685                               request.sequenceCardsConfiguration.pushProposalCard.enabled
686                             ),
687                             finalCard = request.sequenceCardsConfiguration.finalCard
688                               .copy(sharingEnabled = request.sequenceCardsConfiguration.finalCard.enabled &&
689                                 request.sequenceCardsConfiguration.finalCard.sharingEnabled
690                               )
691                           )
692 
693                         val closingQuestion = operationOfQuestion.canPropose && !request.canPropose
694                         if (closingQuestion) {
695                           eventBusService.publish(
696                             VoteOnlyEvent(
697                               eventId = Some(idGenerator.nextEventId()),
698                               eventDate = DateHelper.now(),
699                               userId = auth.user.userId,
700                               requestContext = requestContext
701                                 .copy(questionContext = RequestContextQuestion(questionId = Some(questionId)))
702                             )
703                           )
704                         }
705 
706                         operationOfQuestionService
707                           .updateWithQuestion(
708                             operationOfQuestion
709                               .copy(
710                                 startDate = request.startDate,
711                                 endDate = request.endDate,
712                                 operationTitles = request.operationTitles.mapTranslations(_.value),
713                                 proposalPrefixes = request.proposalPrefixes.mapTranslations(_.value),
714                                 canPropose = request.canPropose,
715                                 sequenceCardsConfiguration = updatedSequenceCardsConfiguration,
716                                 aboutUrls = request.aboutUrls.map(_.mapTranslations(_.value)),
717                                 metas = request.metas,
718                                 theme = request.theme,
719                                 descriptions = request.descriptions.map(_.mapTranslations(_.value)),
720                                 consultationImages = request.consultationImages.map(_.mapTranslations(_.value)),
721                                 consultationImageAlts = request.consultationImageAlts,
722                                 descriptionImages = request.descriptionImages.map(_.mapTranslations(_.value)),
723                                 descriptionImageAlts = request.descriptionImageAlts,
724                                 partnersLogos = request.partnersLogos.map(_.value),
725                                 partnersLogosAlt = request.partnersLogosAlt,
726                                 initiatorsLogos = request.initiatorsLogos.map(_.value),
727                                 initiatorsLogosAlt = request.initiatorsLogosAlt,
728                                 consultationHeader = request.consultationHeader.map(_.value),
729                                 consultationHeaderAlts = request.consultationHeaderAlts,
730                                 cobrandingLogo = request.cobrandingLogo.map(_.value),
731                                 cobrandingLogoAlt = request.cobrandingLogoAlt,
732                                 resultsLink = Option
733                                   .when(request.displayResults)(request.resultsLink.flatMap(_.resultsLink))
734                                   .flatten,
735                                 actions = request.actions,
736                                 featured = request.featured,
737                                 votesTarget = request.votesTarget,
738                                 timeline = request.timeline.toOOQTimeline,
739                                 sessionBindingMode = request.sessionBindingMode,
740                                 reportUrl = request.reportUrl,
741                                 actionsUrl = request.actionsUrl
742                               ),
743                             updatedQuestion
744                           )
745                           .asDirective
746                           .map(result => StatusCodes.OK -> OperationOfQuestionResponse(result, updatedQuestion))
747                     })
748                     .apply(complete(_))
749                 }
750               }
751             }
752           }
753         }
754       }
755     }
756 
757     override def deleteOperationOfQuestionAndQuestion: Route = delete {
758       path("moderation" / "operations-of-questions" / moderationQuestionId) { questionId =>
759         makeOperation("DeleteOperationsOfQuestions") { _ =>
760           makeOAuth2 { auth: AuthInfo[UserRights] =>
761             requireAdminRole(auth.user) {
762               operationOfQuestionService.delete(questionId).asDirective { _ =>
763                 complete(StatusCodes.NoContent)
764               }
765             }
766           }
767         }
768       }
769     }
770 
771     override def createOperationOfQuestionAndQuestion: Route = post {
772       path("moderation" / "operations-of-questions") {
773         makeOperation("CreateOperationsOfQuestions") { _ =>
774           makeOAuth2 { auth: AuthInfo[UserRights] =>
775             requireAdminRole(auth.user) {
776               decodeRequest {
777                 entity(as[CreateOperationOfQuestionRequest]) { body =>
778                   (
779                     operationService.findOneSimple(body.operationId).asDirective,
780                     operationOfQuestionService.findByQuestionSlug(body.questionSlug).asDirective
781                   ).mapN((maybeOperation, maybeQuestion) => {
782                       (
783                         body.operationTitle.toSanitizedInput("operationTitle"),
784                         body.question.value.toSanitizedInput("question"),
785                         body.questionSlug.toSanitizedInput("questionSlug"),
786                         maybeQuestion.toEmpty("slug", Some(s"Slug '${body.questionSlug}' already exists")),
787                         maybeOperation
788                           .toNonEmpty("operationId", Some(s"Operation '${body.operationId}' does not exists"))
789                       ).tupled.throwIfInvalid()
790                       operationOfQuestionService
791                         .create(
792                           CreateOperationOfQuestion(
793                             operationId = body.operationId,
794                             startDate = body.startDate,
795                             endDate = body.endDate,
796                             operationTitle = body.operationTitle,
797                             slug = body.questionSlug,
798                             countries = body.countries,
799                             defaultLanguage = body.defaultLanguage,
800                             question = body.question,
801                             proposalPrefix = body.proposalPrefix.value,
802                             featured = maybeOperation.exists(_.operationKind == GreatCause)
803                           )
804                         )
805                         .asDirective
806                     })
807                     .flatten
808                     .apply(
809                       operationOfQuestion =>
810                         questionService
811                           .getQuestion(operationOfQuestion.questionId)
812                           .asDirectiveOrNotFound
813                           .apply(
814                             question =>
815                               complete(
816                                 StatusCodes.Created -> OperationOfQuestionResponse(operationOfQuestion, question)
817                               )
818                           )
819                     )
820                 }
821               }
822             }
823           }
824         }
825       }
826     }
827 
828     override def searchOperationsOfQuestions: Route = get {
829       path("moderation" / "operations-of-questions" / "search") {
830         makeOperation("SearchOperationsOfQuestions") { _ =>
831           makeOAuth2 { auth: AuthInfo[UserRights] =>
832             requireModerationRole(auth.user) {
833               parameters(
834                 "_start".as[Pagination.Offset].?,
835                 "_end".as[Pagination.End].?,
836                 "_sort".as[OperationOfQuestionElasticsearchFieldName].?,
837                 "_order".as[Order].?,
838                 "slug".as[String].?
839               ) {
840                 (
841                   offset: Option[Pagination.Offset],
842                   end: Option[Pagination.End],
843                   sort: Option[OperationOfQuestionElasticsearchFieldName],
844                   order: Option[Order],
845                   slug
846                 ) =>
847                   Validation.validate(sort.map(Validation.validateSort("_sort")).toList: _*)
848                   val questions: Option[Seq[QuestionId]] =
849                     Option.unless(auth.user.roles.contains(RoleAdmin))(auth.user.availableQuestions)
850                   operationOfQuestionService
851                     .search(
852                       OperationOfQuestionSearchQuery(
853                         filters = Some(
854                           OperationOfQuestionSearchFilters(
855                             questionIds = questions.map(QuestionIdsSearchFilter),
856                             slug = slug.map(SlugSearchFilter),
857                             operationKinds = Some(OperationKindsSearchFilter(OperationKind.values))
858                           )
859                         ),
860                         limit = end.map(_.toLimit(offset.orZero)),
861                         offset = offset,
862                         sort = sort,
863                         order = order
864                       )
865                     )
866                     .asDirective
867                     .apply { result: OperationOfQuestionSearchResult =>
868                       complete(
869                         (
870                           StatusCodes.OK,
871                           List(`X-Total-Count`(result.total.toString)),
872                           result.results.map(ModerationOperationOfQuestionSearchResult.apply)
873                         )
874                       )
875                     }
876               }
877             }
878           }
879         }
880       }
881     }
882 
883     override def infosOperationsOfQuestions: Route = get {
884       path("moderation" / "operations-of-questions" / "infos") {
885         makeOperation("InfosOperationsOfQuestions") { _ =>
886           makeOAuth2 { auth: AuthInfo[UserRights] =>
887             requireModerationRole(auth.user) {
888               parameters("moderationMode".as[ModerationMode], "minVotesCount".as[Int].?, "minScore".as[Double].?) {
889                 (moderationMode: ModerationMode, minVotesCount: Option[Int], minScore: Option[Double]) =>
890                   val questionIds: Option[Seq[QuestionId]] =
891                     Option.unless(auth.user.roles.contains(RoleAdmin))(auth.user.availableQuestions)
892                   operationOfQuestionService
893                     .getQuestionsInfos(questionIds, moderationMode, minVotesCount, minScore)
894                     .asDirective { infos =>
895                       complete((StatusCodes.OK, List(`X-Total-Count`(infos.size.toString)), infos))
896                     }
897               }
898             }
899           }
900         }
901       }
902     }
903 
904   }
905 
906 }
907 
908 object DefaultModerationOperationOfQuestionApiComponent {
909   implicit class PlusDistinctRichOptionSeq[T](val self: Option[Seq[T]]) extends AnyVal {
910     def plusDistinct(other: Option[Seq[T]]): Option[Seq[T]] =
911       Option.when(self.orElse(other).isDefined) {
912         (self.getOrElse(Seq.empty) ++ other.getOrElse(Seq.empty)).distinct
913       }
914   }
915 }
916 
917 @ApiModel
918 final case class ModifyOperationOfQuestionRequest(
919   val defaultLanguage: Language,
920   val languages: NonEmptyList[Language],
921   startDate: ZonedDateTime,
922   endDate: ZonedDateTime,
923   operationTitles: Multilingual[String Refined ValidHtml],
924   proposalPrefixes: Multilingual[String Refined (NonEmpty And ValidHtml And MaxSize[15])],
925   @(ApiModelProperty @field)(dataType = "list[string]", required = true)
926   countries: NonEmptyList[Country],
927   questions: Multilingual[String Refined (NonEmpty And ValidHtml)],
928   @(ApiModelProperty @field)(dataType = "string")
929   shortTitles: Option[Multilingual[String Refined (NonEmpty And MaxSize[30] And ValidHtml)]],
930   canPropose: Boolean,
931   sequenceCardsConfiguration: SequenceCardsConfiguration,
932   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/about")
933   aboutUrls: Option[Multilingual[String Refined Url]],
934   metas: Metas,
935   theme: QuestionTheme,
936   descriptions: Option[Multilingual[String Refined ValidHtml]],
937   displayResults: Boolean,
938   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/consultation-image.png")
939   consultationImages: Option[Multilingual[String Refined (Url And StartsWith["https://"])]],
940   @(ApiModelProperty @field)(dataType = "string", example = "consultation image alternative")
941   consultationImageAlts: Option[Multilingual[String Refined MaxSize[130]]],
942   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/description-image.png")
943   descriptionImages: Option[Multilingual[String Refined (Url And StartsWith["https://"])]],
944   @(ApiModelProperty @field)(dataType = "string", example = "description image alternative")
945   descriptionImageAlts: Option[Multilingual[String Refined MaxSize[130]]],
946   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/partners-logos.png")
947   partnersLogos: Option[String Refined (Url And StartsWith["https://"])],
948   @(ApiModelProperty @field)(dataType = "string", example = "partners logos alternative")
949   partnersLogosAlt: Option[String Refined MaxSize[130]],
950   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/initiators-logos.png")
951   initiatorsLogos: Option[String Refined (Url And StartsWith["https://"])],
952   @(ApiModelProperty @field)(dataType = "string", example = "initiators logos alternative")
953   initiatorsLogosAlt: Option[String Refined MaxSize[130]],
954   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/consultation-header.png")
955   consultationHeader: Option[String Refined (Url And StartsWith["https://"])],
956   @(ApiModelProperty @field)(dataType = "string", example = "consultation header alternative")
957   consultationHeaderAlts: Option[Multilingual[String Refined MaxSize[130]]],
958   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/cobranding-logo.png")
959   cobrandingLogo: Option[String Refined (Url And StartsWith["https://"])],
960   @(ApiModelProperty @field)(dataType = "string", example = "cobranding logo alternative")
961   cobrandingLogoAlt: Option[String Refined MaxSize[130]],
962   resultsLink: Option[ResultsLinkRequest],
963   actions: Option[String],
964   featured: Boolean,
965   votesTarget: Int,
966   timeline: OperationOfQuestionTimelineContract,
967   sessionBindingMode: Boolean,
968   reportUrl: Option[String],
969   actionsUrl: Option[String]
970 )
971 
972 object ModifyOperationOfQuestionRequest extends CirceFormatters {
973   implicit val decoder: Decoder[ModifyOperationOfQuestionRequest] =
974     MultilingualUtils.genDecoder(deriveDecoder[ModifyOperationOfQuestionRequest], _.languages.toList.toSet)
975 
976   implicit val codec: Codec[ModifyOperationOfQuestionRequest] = deriveCodec
977 }
978 
979 @ApiModel
980 final case class CreateOperationOfQuestionRequest(
981   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
982   operationId: OperationId,
983   startDate: ZonedDateTime,
984   endDate: ZonedDateTime,
985   operationTitle: String,
986   proposalPrefix: String Refined (NonEmpty And ValidHtml And MaxSize[15]),
987   @(ApiModelProperty @field)(dataType = "list[string]", required = true)
988   countries: NonEmptyList[Country],
989   @(ApiModelProperty @field)(dataType = "string", example = "fr", required = true)
990   defaultLanguage: Language,
991   question: String Refined NonEmpty,
992   questionSlug: String
993 )
994 
995 object CreateOperationOfQuestionRequest extends CirceFormatters {
996 
997   implicit val codec: Codec[CreateOperationOfQuestionRequest] = deriveCodec
998 }
999 
1000 final case class OperationOfQuestionTimelineContract(
1001   action: TimelineElementContract,
1002   result: TimelineElementContract,
1003   workshop: TimelineElementContract
1004 ) {
1005   def toOOQTimeline: OperationOfQuestionTimeline = OperationOfQuestionTimeline(
1006     action = action.toTimelineElement,
1007     result = result.toTimelineElement,
1008     workshop = workshop.toTimelineElement
1009   )
1010 }
1011 
1012 object OperationOfQuestionTimelineContract extends CirceFormatters {
1013   implicit val codec: Codec[OperationOfQuestionTimelineContract] =
1014     deriveCodec[OperationOfQuestionTimelineContract]
1015 
1016   def apply(timeline: OperationOfQuestionTimeline): OperationOfQuestionTimelineContract =
1017     OperationOfQuestionTimelineContract(
1018       action = TimelineElementContract(timeline.action),
1019       result = TimelineElementContract(timeline.result),
1020       workshop = TimelineElementContract(timeline.workshop)
1021     )
1022 }
1023 
1024 final case class TimelineElementContract(
1025   defined: Boolean,
1026   date: Option[LocalDate],
1027   @(ApiModelProperty @field)(dataType = "string", required = true)
1028   dateTexts: Multilingual[String Refined MaxSize[20]],
1029   @(ApiModelProperty @field)(dataType = "string", required = true)
1030   descriptions: Multilingual[String Refined MaxSize[150]]
1031 ) {
1032   @SuppressWarnings(Array("org.wartremover.warts.OptionPartial"))
1033   def toTimelineElement: Option[TimelineElement] =
1034     if (!defined) {
1035       None
1036     } else {
1037       (
1038         date.getValidated("timeline.date"),
1039         dateTexts.toNonEmpty("timeline.dateTexts"),
1040         descriptions.toNonEmpty("timeline.descriptions")
1041       ).tupled.throwIfInvalid()
1042 
1043       date.map(d => TimelineElement(date = d, dateTexts = dateTexts, descriptions = descriptions))
1044     }
1045 }
1046 
1047 object TimelineElementContract extends CirceFormatters {
1048 
1049   implicit val encoder: Encoder[TimelineElementContract] = deriveEncoder
1050 
1051   implicit val decoder: Decoder[TimelineElementContract] = new Decoder[TimelineElementContract] {
1052     final def apply(c: HCursor): Decoder.Result[TimelineElementContract] =
1053       c.downField("defined")
1054         .as[Boolean]
1055         .flatMap({
1056           case true =>
1057             for {
1058               date         <- c.downField("date").as[Option[LocalDate]]
1059               dateTexts    <- c.downField("dateTexts").as[Multilingual[String Refined MaxSize[20]]]
1060               descriptions <- c.downField("descriptions").as[Multilingual[String Refined MaxSize[150]]]
1061             } yield TimelineElementContract(true, date, dateTexts, descriptions)
1062           case false =>
1063             Either.right(TimelineElementContract(false, None, Multilingual.empty, Multilingual.empty))
1064         })
1065   }
1066 
1067   def apply(timelineElement: Option[TimelineElement]): TimelineElementContract = TimelineElementContract(
1068     defined = timelineElement.isDefined,
1069     date = timelineElement.map(_.date),
1070     dateTexts = timelineElement.fold(Multilingual.empty[String Refined MaxSize[20]])(_.dateTexts),
1071     descriptions = timelineElement.fold(Multilingual.empty[String Refined MaxSize[150]])(_.descriptions)
1072   )
1073 }
1074 
1075 @ApiModel
1076 final case class OperationOfQuestionResponse(
1077   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
1078   id: QuestionId,
1079   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
1080   operationId: OperationId,
1081   startDate: ZonedDateTime,
1082   endDate: ZonedDateTime,
1083   operationTitles: Multilingual[String],
1084   proposalPrefixes: Multilingual[String],
1085   slug: String,
1086   questions: Multilingual[String Refined NonEmpty],
1087   shortTitles: Option[Multilingual[String Refined NonEmpty]],
1088   @(ApiModelProperty @field)(dataType = "list[string]", required = true)
1089   countries: NonEmptyList[Country],
1090   @(ApiModelProperty @field)(dataType = "string", example = "fr", required = true)
1091   defaultLanguage: Language,
1092   languages: NonEmptyList[Language],
1093   canPropose: Boolean,
1094   sequenceCardsConfiguration: SequenceCardsConfiguration,
1095   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/about")
1096   aboutUrls: Option[Multilingual[String]],
1097   metas: Metas,
1098   theme: QuestionTheme,
1099   descriptions: Option[Multilingual[String]],
1100   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/consultation-image.png")
1101   consultationImages: Option[Multilingual[String]],
1102   @(ApiModelProperty @field)(dataType = "string", example = "consultation image alternative")
1103   consultationImageAlts: Option[Multilingual[String Refined MaxSize[130]]],
1104   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/description-image.png")
1105   descriptionImages: Option[Multilingual[String]],
1106   @(ApiModelProperty @field)(dataType = "string", example = "description image alternative")
1107   descriptionImageAlts: Option[Multilingual[String Refined MaxSize[130]]],
1108   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/partners-logos.png")
1109   partnersLogos: Option[String],
1110   @(ApiModelProperty @field)(dataType = "string", example = "partners logos alternative")
1111   partnersLogosAlt: Option[String Refined MaxSize[130]],
1112   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/initiators-logos.png")
1113   initiatorsLogos: Option[String],
1114   @(ApiModelProperty @field)(dataType = "string", example = "initiators logos alternative")
1115   initiatorsLogosAlt: Option[String Refined MaxSize[130]],
1116   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/consultation-header.png")
1117   consultationHeader: Option[String],
1118   @(ApiModelProperty @field)(dataType = "string", example = "consultation header alternative")
1119   consultationHeaderAlts: Option[Multilingual[String Refined MaxSize[130]]],
1120   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/cobranding-logo.png")
1121   cobrandingLogo: Option[String],
1122   @(ApiModelProperty @field)(dataType = "string", example = "cobranding logo alternative")
1123   cobrandingLogoAlt: Option[String Refined MaxSize[130]],
1124   displayResults: Boolean,
1125   resultsLink: Option[ResultsLinkResponse],
1126   actions: Option[String],
1127   featured: Boolean,
1128   @(ApiModelProperty @field)(
1129     dataType = "string",
1130     allowableValues = QuestionStatus.swaggerAllowableValues,
1131     required = true
1132   )
1133   status: QuestionStatus,
1134   votesTarget: Int,
1135   timeline: OperationOfQuestionTimelineContract,
1136   createdAt: ZonedDateTime,
1137   sessionBindingMode: Boolean,
1138   activesUsersCount: Option[Int],
1139   reportUrl: Option[String],
1140   actionsUrl: Option[String]
1141 )
1142 
1143 object OperationOfQuestionResponse extends CirceFormatters {
1144 
1145   implicit val codec: Codec[OperationOfQuestionResponse] = deriveCodec
1146 
1147   def apply(
1148     operationOfQuestion: OperationOfQuestion,
1149     question: Question,
1150     activesUsersCount: Option[Int] = None
1151   ): OperationOfQuestionResponse = {
1152     OperationOfQuestionResponse(
1153       id = operationOfQuestion.questionId,
1154       operationId = operationOfQuestion.operationId,
1155       operationTitles = operationOfQuestion.operationTitles,
1156       proposalPrefixes = operationOfQuestion.proposalPrefixes,
1157       startDate = operationOfQuestion.startDate,
1158       endDate = operationOfQuestion.endDate,
1159       slug = question.slug,
1160       questions = question.questions,
1161       shortTitles = question.shortTitles,
1162       countries = question.countries,
1163       defaultLanguage = question.defaultLanguage,
1164       languages = question.languages,
1165       canPropose = operationOfQuestion.canPropose,
1166       sequenceCardsConfiguration = operationOfQuestion.sequenceCardsConfiguration,
1167       aboutUrls = operationOfQuestion.aboutUrls,
1168       metas = operationOfQuestion.metas,
1169       theme = operationOfQuestion.theme,
1170       descriptions = operationOfQuestion.descriptions,
1171       consultationImages = operationOfQuestion.consultationImages,
1172       consultationImageAlts = operationOfQuestion.consultationImageAlts,
1173       descriptionImages = operationOfQuestion.descriptionImages,
1174       descriptionImageAlts = operationOfQuestion.descriptionImageAlts,
1175       partnersLogos = operationOfQuestion.partnersLogos,
1176       partnersLogosAlt = operationOfQuestion.partnersLogosAlt,
1177       initiatorsLogos = operationOfQuestion.initiatorsLogos,
1178       initiatorsLogosAlt = operationOfQuestion.initiatorsLogosAlt,
1179       consultationHeader = operationOfQuestion.consultationHeader,
1180       consultationHeaderAlts = operationOfQuestion.consultationHeaderAlts,
1181       cobrandingLogo = operationOfQuestion.cobrandingLogo,
1182       cobrandingLogoAlt = operationOfQuestion.cobrandingLogoAlt,
1183       displayResults = operationOfQuestion.resultsLink.isDefined,
1184       resultsLink = operationOfQuestion.resultsLink.map(ResultsLinkResponse.apply),
1185       actions = operationOfQuestion.actions,
1186       featured = operationOfQuestion.featured,
1187       status = operationOfQuestion.status,
1188       votesTarget = operationOfQuestion.votesTarget,
1189       timeline = OperationOfQuestionTimelineContract(operationOfQuestion.timeline),
1190       createdAt = operationOfQuestion.createdAt,
1191       sessionBindingMode = operationOfQuestion.sessionBindingMode,
1192       activesUsersCount = activesUsersCount,
1193       reportUrl = operationOfQuestion.reportUrl,
1194       actionsUrl = operationOfQuestion.actionsUrl
1195     )
1196   }
1197 }
1198 
1199 @ApiModel
1200 final case class ModerationOperationOfQuestionSearchResult(
1201   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555") id: QuestionId,
1202   slug: String
1203 )
1204 
1205 object ModerationOperationOfQuestionSearchResult {
1206 
1207   def apply(ooq: IndexedOperationOfQuestion): ModerationOperationOfQuestionSearchResult =
1208     ModerationOperationOfQuestionSearchResult(ooq.questionId, ooq.slug)
1209 
1210   implicit val codec: Codec[ModerationOperationOfQuestionSearchResult] = deriveCodec
1211 }