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.Done
23 import akka.stream.scaladsl.{Sink, Source}
24 import cats.data.NonEmptyList
25 import cats.implicits._
26 import com.sksamuel.elastic4s.requests.searches.sort.SortOrder
27 import grizzled.slf4j.Logging
28 import kamon.Kamon
29 import kamon.tag.TagSet
30 import org.make.api.idea.IdeaServiceComponent
31 import org.make.api.partner.PartnerServiceComponent
32 import org.make.api.proposal.ProposalActorResponse.VotesActorResponse
33 import org.make.api.question.{AuthorRequest, QuestionServiceComponent}
34 import org.make.api.segment.SegmentServiceComponent
35 import org.make.api.sequence.SequenceConfigurationComponent
36 import org.make.api.sessionhistory._
37 import org.make.api.tag.TagServiceComponent
38 import org.make.api.tagtype.TagTypeServiceComponent
39 import org.make.api.technical.crm.QuestionResolver
40 import org.make.api.technical.job.JobCoordinatorServiceComponent
41 import org.make.api.technical.security.{SecurityConfigurationComponent, SecurityHelper}
42 import org.make.api.technical._
43 import org.make.api.user.UserServiceComponent
44 import org.make.api.userhistory._
45 import org.make.core._
46 import org.make.core.common.indexed.Sort
47 import org.make.core.history.HistoryActions.VoteTrust._
48 import org.make.core.history.HistoryActions.{VoteAndQualifications, VoteTrust}
49 import org.make.core.idea.IdeaId
50 import org.make.core.job.Job.JobId.SubmittedAsLanguagePatch
51 import org.make.core.partner.Partner
52 import org.make.core.proposal.ProposalStatus.Pending
53 import org.make.core.proposal._
54 import org.make.core.proposal.indexed.{IndexedProposal, ProposalElasticsearchFieldName, ProposalsSearchResult}
55 import org.make.core.question.TopProposalsMode.IdeaMode
56 import org.make.core.question.{Question, QuestionId, TopProposalsMode}
57 import org.make.core.reference.{Country, Language}
58 import org.make.core.sequence.SequenceConfiguration
59 import org.make.core.session.SessionId
60 import org.make.core.tag.{Tag, TagId, TagType}
61 import org.make.core.technical.Pagination.Offset
62 import org.make.core.technical.{Multilingual, Pagination}
63 import org.make.core.user._
64 
65 import java.time.ZonedDateTime
66 import scala.collection.mutable
67 import scala.concurrent.ExecutionContext.Implicits.global
68 import scala.concurrent.Future
69 import scala.util.{Failure, Success}
70 
71 trait DefaultProposalServiceComponent extends ProposalServiceComponent with CirceFormatters with Logging {
72   this: ProposalServiceComponent
73     with ActorSystemComponent
74     with EventBusServiceComponent
75     with IdeaServiceComponent
76     with IdGeneratorComponent
77     with PartnerServiceComponent
78     with ProposalCoordinatorServiceComponent
79     with ProposalSearchEngineComponent
80     with QuestionServiceComponent
81     with ReadJournalComponent
82     with SecurityConfigurationComponent
83     with SegmentServiceComponent
84     with SequenceConfigurationComponent
85     with SessionHistoryCoordinatorServiceComponent
86     with JobCoordinatorServiceComponent
87     with TagServiceComponent
88     with TagTypeServiceComponent
89     with UserHistoryCoordinatorServiceComponent
90     with UserServiceComponent =>
91 
92   override lazy val proposalService: DefaultProposalService = new DefaultProposalService
93 
94   class DefaultProposalService extends ProposalService {
95 
96     override def createInitialProposal(
97       content: String,
98       contentTranslations: Option[Multilingual[String]],
99       question: Question,
100       country: Country,
101       submittedAsLanguage: Language,
102       isAnonymous: Boolean,
103       tags: Seq[TagId],
104       author: AuthorRequest,
105       moderator: UserId,
106       moderatorRequestContext: RequestContext
107     ): Future[ProposalId] = {
108 
109       for {
110         user           <- userService.retrieveOrCreateVirtualUser(author, country)
111         requestContext <- buildRequestContext(user, country, question, moderatorRequestContext)
112         proposalId <- propose(
113           user,
114           requestContext,
115           DateHelper.now(),
116           content,
117           question,
118           isAnonymous,
119           initialProposal = true,
120           submittedAsLanguage = submittedAsLanguage,
121           proposalType = ProposalType.ProposalTypeInitial
122         )
123         _ <- validateProposal(
124           proposalId = proposalId,
125           moderator = moderator,
126           requestContext = moderatorRequestContext,
127           question = question,
128           newContent = None,
129           newContentTranslations = contentTranslations,
130           sendNotificationEmail = false,
131           tags = tags
132         )
133       } yield proposalId
134     }
135 
136     override def createExternalProposal(
137       content: String,
138       contentTranslations: Option[Multilingual[String]],
139       question: Question,
140       country: Country,
141       submittedAsLanguage: Language,
142       isAnonymous: Boolean,
143       externalUserId: String,
144       author: AuthorRequest,
145       moderator: UserId,
146       moderatorRequestContext: RequestContext,
147       lineNumber: Int
148     ): Future[ProposalId] = {
149       val email = s"${question.questionId.value}-$externalUserId@example.com"
150 
151       for {
152         user           <- userService.retrieveOrCreateExternalUser(email, author, country, lineNumber)
153         requestContext <- buildRequestContext(user, country, question, moderatorRequestContext)
154         proposalId <- propose(
155           user,
156           requestContext,
157           DateHelper.now(),
158           content,
159           question,
160           isAnonymous,
161           initialProposal = false,
162           submittedAsLanguage = submittedAsLanguage,
163           proposalType = ProposalType.ProposalTypeExternal
164         )
165         _ <- validateProposal(
166           proposalId = proposalId,
167           moderator = moderator,
168           requestContext = moderatorRequestContext,
169           question = question,
170           newContent = None,
171           newContentTranslations = contentTranslations,
172           sendNotificationEmail = false,
173           tags = Seq.empty
174         )
175       } yield proposalId
176     }
177 
178     private def buildRequestContext(
179       user: User,
180       country: Country,
181       question: Question,
182       requestContext: RequestContext
183     ): Future[RequestContext] = Future.successful(
184       RequestContext.empty.copy(
185         userId = Some(user.userId),
186         country = Some(country),
187         questionContext = RequestContextQuestion(questionId = Some(question.questionId)),
188         languageContext = RequestContextLanguage(language = BusinessConfig.supportedCountries.collectFirst {
189           case CountryConfiguration(`country`, language, _) => language
190         }),
191         operationId = question.operationId,
192         applicationName = requestContext.applicationName
193       )
194     )
195 
196     override def searchProposalsVotedByUser(
197       userId: UserId,
198       filterVotes: Option[Seq[VoteKey]],
199       filterQualifications: Option[Seq[QualificationKey]],
200       preferredLanguage: Option[Language],
201       sort: Option[Sort],
202       limit: Option[Pagination.Limit],
203       offset: Option[Pagination.Offset],
204       requestContext: RequestContext
205     ): Future[ProposalsResultResponse] = {
206       val votedProposals: Future[Map[ProposalId, VoteAndQualifications]] =
207         for {
208           proposalIds <- userHistoryCoordinatorService.retrieveVotedProposals(
209             RequestUserVotedProposals(userId = userId, filterVotes, filterQualifications)
210           )
211           withVote <- userHistoryCoordinatorService.retrieveVoteAndQualifications(userId, proposalIds)
212         } yield withVote
213 
214       votedProposals.flatMap {
215         case proposalIdsWithVotes if proposalIdsWithVotes.isEmpty =>
216           Future.successful((0L, Seq.empty))
217         case proposalIdsWithVotes =>
218           val proposalIds: Seq[ProposalId] = proposalIdsWithVotes.toSeq.sortWith {
219             case ((_, firstVotesAndQualifications), (_, nextVotesAndQualifications)) =>
220               firstVotesAndQualifications.date.isAfter(nextVotesAndQualifications.date)
221           }.map {
222             case (proposalId, _) => proposalId
223           }
224           proposalService
225             .searchForUser(
226               Some(userId),
227               SearchQuery(
228                 filters = Some(SearchFilters(proposal = Some(ProposalSearchFilter(proposalIds = proposalIds)))),
229                 sort = sort,
230                 limit = limit,
231                 offset = offset
232               ),
233               requestContext,
234               preferredLanguage,
235               questionDefaultLanguage = None
236             )
237             .map { proposalResultSeededResponse =>
238               val proposalResult = proposalResultSeededResponse.results.sortWith {
239                 case (first, next) => proposalIds.indexOf(first.id) < proposalIds.indexOf(next.id)
240               }
241               (proposalResultSeededResponse.total, proposalResult)
242             }
243       }.map {
244         case (total, proposalResult) =>
245           ProposalsResultResponse(total = total, results = proposalResult)
246       }
247     }
248 
249     override def getProposalById(
250       proposalId: ProposalId,
251       requestContext: RequestContext
252     ): Future[Option[IndexedProposal]] = {
253       proposalCoordinatorService.viewProposal(proposalId, requestContext)
254       elasticsearchProposalAPI.findProposalById(proposalId)
255     }
256 
257     override def getProposalsById(
258       proposalIds: Seq[ProposalId],
259       requestContext: RequestContext
260     ): Future[Seq[IndexedProposal]] = {
261       Source(proposalIds).mapAsync(5)(id => getProposalById(id, requestContext)).runWith(Sink.seq).map(_.flatten)
262     }
263 
264     override def getModerationProposalById(proposalId: ProposalId): Future[Option[ModerationProposalResponse]] = {
265       toModerationProposalResponse(proposalCoordinatorService.getProposal(proposalId))
266     }
267 
268     override def getEventSourcingProposal(
269       proposalId: ProposalId,
270       requestContext: RequestContext
271     ): Future[Option[Proposal]] = {
272       proposalCoordinatorService.viewProposal(proposalId, requestContext)
273     }
274 
275     override def searchInIndex(query: SearchQuery, requestContext: RequestContext): Future[ProposalsSearchResult] = {
276       val logSearchContent: Future[Unit] = query.filters.flatMap(_.content) match {
277         case Some(contentFilter) =>
278           sessionHistoryCoordinatorService.logTransactionalHistory(
279             LogSessionSearchProposalsEvent(
280               requestContext.sessionId,
281               requestContext,
282               SessionAction(
283                 DateHelper.now(),
284                 LogSessionSearchProposalsEvent.action,
285                 SessionSearchParameters(contentFilter.text)
286               )
287             )
288           )
289         case _ => Future.unit
290       }
291       logSearchContent >> elasticsearchProposalAPI.searchProposals(query)
292     }
293 
294     override def modifyForQuestion(
295       questionId: QuestionId,
296       modifyFn: Proposal => Future[Unit],
297       requestContext: RequestContext
298     ): Unit = {
299       val startTime: Long = System.currentTimeMillis()
300 
301       jobCoordinatorService.start(SubmittedAsLanguagePatch) { _ =>
302         val batchSize = 200
303         val applyChanges = StreamUtils.asyncPageToPageSource { offset =>
304           val searchQuery =
305             SearchQuery(
306               filters = Some(
307                 SearchFilters(
308                   question = Some(QuestionSearchFilter(Seq(questionId))),
309                   status = Some(StatusSearchFilter(ProposalStatus.values))
310                 )
311               ),
312               offset = Some(Pagination.Offset(offset)),
313               limit = Some(Pagination.Limit(offset + batchSize))
314             )
315 
316           this
317             .searchInIndex(searchQuery, requestContext)
318             .map(_.results.map(_.id))
319         }.mapAsync(3) {
320             _.traverse_(
321               this
322                 .getEventSourcingProposal(_, requestContext)
323                 .flatMap(_.fold(Future.unit)(modifyFn)) // Ignoring proposals that can't be retrieved
324             )
325           }
326           .run()
327           .void
328         applyChanges.onComplete {
329           case Failure(exception) =>
330             logger.error("submittedAsLanguage patching script failed with:", exception)
331           case Success(_) =>
332             val elapsed = System.currentTimeMillis() - startTime
333             logger.info(s"submittedAsLanguage patching script succeeded in ${elapsed.toString}ms")
334         }
335 
336         applyChanges
337       }
338     }
339 
340     private def enrich(
341       searchFn: (RequestContext) => Future[ProposalsSearchResult],
342       maybeUserId: Option[UserId],
343       requestContext: RequestContext,
344       preferredLanguage: Option[Language],
345       questionDefaultLanguage: Option[Language]
346     ): Future[ProposalsResultResponse] = {
347       searchFn(requestContext).flatMap { searchResult =>
348         maybeUserId
349           .fold(
350             sessionHistoryCoordinatorService
351               .retrieveVoteAndQualifications(sessionId = requestContext.sessionId, searchResult.results.map(_.id))
352           ) { userId =>
353             userHistoryCoordinatorService.retrieveVoteAndQualifications(userId = userId, searchResult.results.map(_.id))
354           }
355           .flatMap { votes =>
356             val questionIds: Seq[QuestionId] = searchResult.results.flatMap(_.question.map(_.questionId)).distinct
357             Future.traverse(questionIds)(sequenceConfigurationService.getSequenceConfigurationByQuestionId).map {
358               configs =>
359                 val proposals = searchResult.results.map { indexedProposal =>
360                   val newProposalsVoteThreshold = configs
361                     .find(config => indexedProposal.question.map(_.questionId).contains(config.questionId))
362                     .fold(0)(_.newProposalsVoteThreshold)
363                   val proposalKey =
364                     generateProposalKeyHash(
365                       indexedProposal.id,
366                       requestContext.sessionId,
367                       requestContext.location,
368                       securityConfiguration.secureVoteSalt
369                     )
370                   ProposalResponse(
371                     indexedProposal,
372                     myProposal = maybeUserId.contains(indexedProposal.author.userId),
373                     votes.get(indexedProposal.id),
374                     proposalKey,
375                     newProposalsVoteThreshold,
376                     preferredLanguage,
377                     questionDefaultLanguage
378                   )
379                 }
380                 ProposalsResultResponse(searchResult.total, proposals)
381             }
382           }
383       }
384     }
385 
386     override def searchForUser(
387       maybeUserId: Option[UserId],
388       query: SearchQuery,
389       requestContext: RequestContext,
390       preferredLanguage: Option[Language] = None,
391       questionDefaultLanguage: Option[Language]
392     ): Future[ProposalsResultSeededResponse] = {
393       enrich(searchInIndex(query, _), maybeUserId, requestContext, preferredLanguage, questionDefaultLanguage).map(
394         proposalResultResponse =>
395           ProposalsResultSeededResponse(proposalResultResponse.total, proposalResultResponse.results, query.getSeed)
396       )
397     }
398 
399     override def getTopProposals(
400       maybeUserId: Option[UserId],
401       questionId: QuestionId,
402       size: Int,
403       mode: Option[TopProposalsMode],
404       requestContext: RequestContext
405     ): Future[ProposalsResultResponse] = {
406       val search = mode match {
407         case Some(IdeaMode) =>
408           elasticsearchProposalAPI.getTopProposals(questionId, size, ProposalElasticsearchFieldName.ideaId)
409         case _ =>
410           elasticsearchProposalAPI.getTopProposals(questionId, size, ProposalElasticsearchFieldName.selectedStakeTagId)
411       }
412       enrich(
413         _ => search.map(results => ProposalsSearchResult(results.size, results)),
414         maybeUserId,
415         requestContext,
416         preferredLanguage = None,
417         questionDefaultLanguage = None
418       ).map(
419         proposalResultResponse => ProposalsResultResponse(proposalResultResponse.total, proposalResultResponse.results)
420       )
421     }
422 
423     override def propose(
424       user: User,
425       requestContext: RequestContext,
426       createdAt: ZonedDateTime,
427       content: String,
428       question: Question,
429       isAnonymous: Boolean,
430       initialProposal: Boolean,
431       submittedAsLanguage: Language,
432       proposalType: ProposalType
433     ): Future[ProposalId] = {
434 
435       proposalCoordinatorService.propose(
436         proposalId = idGenerator.nextProposalId(),
437         requestContext = requestContext,
438         user = user,
439         createdAt = createdAt,
440         content = content,
441         submittedAsLanguage = submittedAsLanguage,
442         question = question,
443         isAnonymous = isAnonymous,
444         initialProposal = initialProposal,
445         proposalType = proposalType
446       )
447     }
448 
449     override def update(
450       proposalId: ProposalId,
451       moderator: UserId,
452       requestContext: RequestContext,
453       updatedAt: ZonedDateTime,
454       newContent: Option[String],
455       newContentTranslations: Option[Multilingual[String]],
456       question: Question,
457       tags: Seq[TagId]
458     ): Future[Option[ModerationProposalResponse]] = {
459       toModerationProposalResponse(
460         proposalCoordinatorService.update(
461           moderator = moderator,
462           proposalId = proposalId,
463           requestContext = requestContext,
464           updatedAt = updatedAt,
465           newContent = newContent,
466           newTranslations = newContentTranslations,
467           question = question,
468           tags = tags
469         )
470       )
471     }
472 
473     private def getEvents(proposal: Proposal): Future[Seq[ProposalActionResponse]] = {
474       val eventsUserIds: Seq[UserId] = proposal.events.map(_.user).distinct
475       val futureEventsUsers: Future[Seq[User]] = userService.getUsersByUserIds(eventsUserIds)
476 
477       futureEventsUsers.map { eventsUsers =>
478         val userById = eventsUsers.map(u => u.userId -> u.displayName).toMap
479         proposal.events.map { action =>
480           ProposalActionResponse(
481             date = action.date,
482             user = userById.get(action.user).map(name => ProposalActionAuthorResponse(action.user, name)),
483             actionType = action.actionType,
484             arguments = action.arguments
485           )
486         }
487       }
488     }
489 
490     private def toModerationProposalResponse(
491       futureProposal: Future[Option[Proposal]]
492     ): Future[Option[ModerationProposalResponse]] = {
493       def getSequenceConfiguration(questionId: Option[QuestionId]): Future[Option[SequenceConfiguration]] = {
494         questionId match {
495           case None => Future.successful(None)
496           case Some(qId) =>
497             sequenceConfigurationService
498               .getSequenceConfigurationByQuestionId(qId)
499               .map(config => Some(config))
500         }
501       }
502       def getLanguage(questionId: Option[QuestionId]): Future[Option[Language]] =
503         questionId.fold(Future.successful(Option(Language("fr"))))(
504           questionService.getQuestion(_).map(_.map(_.defaultLanguage))
505         )
506 
507       futureProposal.flatMap({
508         case None => Future.successful(None)
509         case Some(proposal) =>
510           (
511             userService.getUser(proposal.author),
512             getLanguage(proposal.questionId),
513             getSequenceConfiguration(proposal.questionId),
514             getEvents(proposal)
515           ).tupled.map({
516             case (Some(author), Some(language), Some(conf), events) =>
517               val votes = proposal.votingOptions.map { votingOptions =>
518                 val scores = VotingOptionsScores(votingOptions, conf.newProposalsVoteThreshold)
519                 votingOptions.wrappers.map(wrapper => ModerationVoteResponse(wrapper, scores.get(wrapper.vote.key)))
520               }.getOrElse(Seq.empty)
521               Some(
522                 ModerationProposalResponse(
523                   id = proposal.proposalId,
524                   proposalId = proposal.proposalId,
525                   slug = proposal.slug,
526                   content = proposal.content,
527                   contentTranslations = proposal.contentTranslations,
528                   submittedAsLanguage = Some(proposal.submittedAsLanguage.getOrElse(language)),
529                   author = ModerationProposalAuthorResponse(author),
530                   status = proposal.status,
531                   proposalType = proposal.proposalType,
532                   refusalReason = proposal.refusalReason,
533                   tags = proposal.tags,
534                   votes = votes,
535                   context = proposal.creationContext,
536                   createdAt = proposal.createdAt,
537                   updatedAt = proposal.updatedAt,
538                   events = events,
539                   idea = proposal.idea,
540                   ideaProposals = Seq.empty,
541                   operationId = proposal.operation,
542                   questionId = proposal.questionId,
543                   keywords = proposal.keywords,
544                   zone = proposal.getZone(conf.mainSequence.sequenceThresholds)
545                 )
546               )
547             case _ => None
548           })
549       })
550     }
551 
552     override def updateVotes(
553       proposalId: ProposalId,
554       moderator: UserId,
555       requestContext: RequestContext,
556       updatedAt: ZonedDateTime,
557       votes: Seq[UpdateVoteRequest]
558     ): Future[Option[ModerationProposalResponse]] = {
559       toModerationProposalResponse(
560         proposalCoordinatorService.updateVotes(
561           moderator = moderator,
562           proposalId = proposalId,
563           requestContext = requestContext,
564           updatedAt = updatedAt,
565           votes = votes
566         )
567       )
568     }
569 
570     override def validateProposal(
571       proposalId: ProposalId,
572       moderator: UserId,
573       requestContext: RequestContext,
574       question: Question,
575       newContent: Option[String],
576       newContentTranslations: Option[Multilingual[String]],
577       sendNotificationEmail: Boolean,
578       tags: Seq[TagId]
579     ): Future[Option[ModerationProposalResponse]] = {
580       toModerationProposalResponse(
581         proposalCoordinatorService.accept(
582           proposalId = proposalId,
583           moderator = moderator,
584           requestContext = requestContext,
585           sendNotificationEmail = sendNotificationEmail,
586           newContent = newContent,
587           newTranslations = newContentTranslations,
588           question = question,
589           tags = tags
590         )
591       )
592     }
593 
594     override def refuseProposal(
595       proposalId: ProposalId,
596       moderator: UserId,
597       requestContext: RequestContext,
598       request: RefuseProposalRequest
599     ): Future[Option[ModerationProposalResponse]] = {
600       toModerationProposalResponse(
601         proposalCoordinatorService.refuse(
602           proposalId = proposalId,
603           moderator = moderator,
604           requestContext = requestContext,
605           sendNotificationEmail = request.sendNotificationEmail,
606           refusalReason = request.refusalReason
607         )
608       )
609     }
610 
611     override def postponeProposal(
612       proposalId: ProposalId,
613       moderator: UserId,
614       requestContext: RequestContext
615     ): Future[Option[ModerationProposalResponse]] = {
616 
617       toModerationProposalResponse(
618         proposalCoordinatorService
619           .postpone(proposalId = proposalId, moderator = moderator, requestContext = requestContext)
620       )
621     }
622 
623     private def retrieveVoteHistory(
624       proposalId: ProposalId,
625       maybeUserId: Option[UserId],
626       sessionId: SessionId
627     ): Future[Map[ProposalId, VoteAndQualifications]] = {
628       val votesHistory = maybeUserId match {
629         case Some(userId) =>
630           userHistoryCoordinatorService.retrieveVoteAndQualifications(userId, Seq(proposalId))
631         case None =>
632           sessionHistoryCoordinatorService
633             .retrieveVoteAndQualifications(sessionId = sessionId, proposalIds = Seq(proposalId))
634       }
635       votesHistory
636     }
637 
638     private def retrieveUser(maybeUserId: Option[UserId]): Future[Option[User]] = {
639       maybeUserId.map { userId =>
640         userService.getUser(userId)
641       }.getOrElse(Future.successful(None))
642     }
643 
644     private def incrementTrollCounter(requestContext: RequestContext) = {
645       Kamon
646         .counter("vote_trolls")
647         .withTags(
648           TagSet.from(
649             Map(
650               "application" -> requestContext.applicationName.fold("unknown")(_.value),
651               "location" -> requestContext.location.flatMap(_.split(" ").headOption).getOrElse("unknown")
652             )
653           )
654         )
655         .increment()
656     }
657 
658     private val sequenceLocations: Set[String] = Set("sequence", "widget", "sequence-popular", "sequence-controversial")
659 
660     def resolveVoteTrust(
661       proposalKey: Option[String],
662       proposalId: ProposalId,
663       maybeUserSegment: Option[String],
664       maybeProposalSegment: Option[String],
665       requestContext: RequestContext
666     ): VoteTrust = {
667 
668       val newHash =
669         generateProposalKeyHash(
670           proposalId,
671           requestContext.sessionId,
672           requestContext.location,
673           securityConfiguration.secureVoteSalt
674         )
675       val page = requestContext.location.flatMap(_.split(" ").headOption)
676 
677       val isInSegment = (
678         for {
679           userSegment     <- maybeUserSegment
680           proposalSegment <- maybeProposalSegment
681         } yield userSegment == proposalSegment
682       ).exists(identity)
683 
684       val inSequence = page.exists(sequenceLocations.contains)
685       (proposalKey, proposalKey.contains(newHash), inSequence, isInSegment) match {
686         case (None, _, _, _) =>
687           logger.warn(s"No proposal key for proposal ${proposalId.value}, on context ${requestContext.toString}")
688           incrementTrollCounter(requestContext)
689           Troll
690         case (Some(_), false, _, _) =>
691           logger.warn(s"Bad proposal key found for proposal ${proposalId.value}, on context ${requestContext.toString}")
692           incrementTrollCounter(requestContext)
693           Troll
694         case (Some(_), true, true, true) => Segment
695         case (Some(_), true, true, _)    => Sequence
696         case (Some(_), true, _, _)       => Trusted
697       }
698     }
699 
700     private def getSegmentForProposal(proposalId: ProposalId): Future[Option[String]] = {
701       proposalCoordinatorService.getProposal(proposalId).flatMap {
702         case None           => Future.successful(None)
703         case Some(proposal) => segmentService.resolveSegment(proposal.creationContext)
704       }
705     }
706 
707     private def fVoteProposal(
708       proposalId: ProposalId,
709       maybeUserId: Option[UserId],
710       requestContext: RequestContext,
711       voteKey: VoteKey,
712       proposalKey: Option[String],
713       fVote: VoteProposalParams => Future[Option[VotesActorResponse]]
714     ): Future[Option[VotesActorResponse]] = {
715 
716       def runVote: Future[Option[VotesActorResponse]] = {
717         val futureVotes = retrieveVoteHistory(proposalId, maybeUserId, requestContext.sessionId)
718         val futureUser = retrieveUser(maybeUserId)
719         val futureProposalSegment = getSegmentForProposal(proposalId)
720         val futureUserSegment = segmentService.resolveSegment(requestContext)
721 
722         proposalCoordinatorService.getProposal(proposalId).flatMap {
723           case None => Future.successful(None)
724           case Some(proposal) =>
725             proposal.questionId match {
726               case None => Future.successful(None)
727               case Some(questionId) =>
728                 for {
729                   votes                <- futureVotes
730                   user                 <- futureUser
731                   maybeProposalSegment <- futureProposalSegment
732                   maybeUserSegment     <- futureUserSegment
733                   config               <- sequenceConfigurationService.getSequenceConfigurationByQuestionId(questionId)
734                   vote <- fVote(
735                     VoteProposalParams(
736                       proposalId = proposalId,
737                       maybeUserId = maybeUserId,
738                       requestContext = requestContext,
739                       voteKey = voteKey,
740                       maybeOrganisationId = user.filter(_.userType == UserType.UserTypeOrganisation).map(_.userId),
741                       vote = votes.get(proposalId),
742                       voteTrust = resolveVoteTrust(
743                         proposalKey,
744                         proposalId,
745                         maybeUserSegment,
746                         maybeProposalSegment,
747                         requestContext
748                       ),
749                       newProposalsVoteThreshold = config.newProposalsVoteThreshold
750                     )
751                   )
752                 } yield vote
753             }
754         }
755       }
756 
757       val result = for {
758         _    <- sessionHistoryCoordinatorService.lockSessionForVote(requestContext.sessionId, proposalId)
759         vote <- runVote
760         _    <- sessionHistoryCoordinatorService.unlockSessionForVote(requestContext.sessionId, proposalId)
761       } yield vote
762 
763       result.recoverWith {
764         case e: ConcurrentModification => Future.failed(e)
765         case other =>
766           sessionHistoryCoordinatorService.unlockSessionForVote(requestContext.sessionId, proposalId).flatMap { _ =>
767             Future.failed(other)
768           }
769       }
770 
771     }
772 
773     override def voteProposal(
774       proposalId: ProposalId,
775       maybeUserId: Option[UserId],
776       requestContext: RequestContext,
777       voteKey: VoteKey,
778       proposalKey: Option[String]
779     ): Future[Option[VotesActorResponse]] =
780       fVoteProposal(proposalId, maybeUserId, requestContext, voteKey, proposalKey, proposalCoordinatorService.vote)
781 
782     override def unvoteProposal(
783       proposalId: ProposalId,
784       maybeUserId: Option[UserId],
785       requestContext: RequestContext,
786       voteKey: VoteKey,
787       proposalKey: Option[String]
788     ): Future[Option[VotesActorResponse]] =
789       fVoteProposal(proposalId, maybeUserId, requestContext, voteKey, proposalKey, proposalCoordinatorService.unvote)
790 
791     override def qualifyVote(
792       proposalId: ProposalId,
793       maybeUserId: Option[UserId],
794       requestContext: RequestContext,
795       voteKey: VoteKey,
796       qualificationKey: QualificationKey,
797       proposalKey: Option[String]
798     ): Future[Option[Qualification]] = {
799 
800       val result = for {
801         _ <- sessionHistoryCoordinatorService.lockSessionForQualification(
802           requestContext.sessionId,
803           proposalId,
804           qualificationKey
805         )
806         votes                <- retrieveVoteHistory(proposalId, maybeUserId, requestContext.sessionId)
807         maybeUserSegment     <- segmentService.resolveSegment(requestContext)
808         maybeProposalSegment <- getSegmentForProposal(proposalId)
809         qualify <- proposalCoordinatorService.qualification(
810           proposalId = proposalId,
811           maybeUserId = maybeUserId,
812           requestContext = requestContext,
813           voteKey = voteKey,
814           qualificationKey = qualificationKey,
815           vote = votes.get(proposalId),
816           voteTrust = resolveVoteTrust(proposalKey, proposalId, maybeUserSegment, maybeProposalSegment, requestContext)
817         )
818         _ <- sessionHistoryCoordinatorService.unlockSessionForQualification(
819           requestContext.sessionId,
820           proposalId,
821           qualificationKey
822         )
823       } yield qualify
824 
825       result.recoverWith {
826         case e: ConcurrentModification => Future.failed(e)
827         case other =>
828           sessionHistoryCoordinatorService
829             .unlockSessionForQualification(requestContext.sessionId, proposalId, qualificationKey)
830             .flatMap { _ =>
831               Future.failed(other)
832             }
833       }
834 
835     }
836 
837     override def unqualifyVote(
838       proposalId: ProposalId,
839       maybeUserId: Option[UserId],
840       requestContext: RequestContext,
841       voteKey: VoteKey,
842       qualificationKey: QualificationKey,
843       proposalKey: Option[String]
844     ): Future[Option[Qualification]] = {
845 
846       val result = for {
847         _ <- sessionHistoryCoordinatorService.lockSessionForQualification(
848           requestContext.sessionId,
849           proposalId,
850           qualificationKey
851         )
852         votes                <- retrieveVoteHistory(proposalId, maybeUserId, requestContext.sessionId)
853         maybeUserSegment     <- segmentService.resolveSegment(requestContext)
854         maybeProposalSegment <- getSegmentForProposal(proposalId)
855         removeQualification <- proposalCoordinatorService.unqualification(
856           proposalId = proposalId,
857           maybeUserId = maybeUserId,
858           requestContext = requestContext,
859           voteKey = voteKey,
860           qualificationKey = qualificationKey,
861           vote = votes.get(proposalId),
862           voteTrust = resolveVoteTrust(proposalKey, proposalId, maybeUserSegment, maybeProposalSegment, requestContext)
863         )
864         _ <- sessionHistoryCoordinatorService.unlockSessionForQualification(
865           requestContext.sessionId,
866           proposalId,
867           qualificationKey
868         )
869       } yield removeQualification
870 
871       result.recoverWith {
872         case e: ConcurrentModification => Future.failed(e)
873         case other =>
874           sessionHistoryCoordinatorService
875             .unlockSessionForQualification(requestContext.sessionId, proposalId, qualificationKey)
876             .flatMap { _ =>
877               Future.failed(other)
878             }
879       }
880 
881     }
882 
883     override def lockProposal(
884       proposalId: ProposalId,
885       moderatorId: UserId,
886       moderatorFullName: Option[String],
887       requestContext: RequestContext
888     ): Future[Unit] = {
889       proposalCoordinatorService
890         .lock(
891           proposalId = proposalId,
892           moderatorId = moderatorId,
893           moderatorName = moderatorFullName,
894           requestContext = requestContext
895         )
896         .void
897     }
898 
899     override def lockProposals(
900       proposalIds: Seq[ProposalId],
901       moderatorId: UserId,
902       moderatorFullName: Option[String],
903       requestContext: RequestContext
904     ): Future[Unit] = {
905       Source(proposalIds)
906         .mapAsync(5)(
907           id =>
908             proposalCoordinatorService.lock(
909               proposalId = id,
910               moderatorId = moderatorId,
911               moderatorName = moderatorFullName,
912               requestContext = requestContext
913             )
914         )
915         .runWith(Sink.seq)
916         .void
917     }
918 
919     // Very permissive (no event generated etc), use carefully and only for one shot migrations.
920     override def patchProposal(
921       proposalId: ProposalId,
922       userId: UserId,
923       requestContext: RequestContext,
924       changes: PatchProposalRequest
925     ): Future[Option[ModerationProposalResponse]] = {
926       toModerationProposalResponse(
927         proposalCoordinatorService
928           .patch(proposalId = proposalId, userId = userId, changes = changes, requestContext = requestContext)
929       )
930     }
931 
932     override def changeProposalsIdea(
933       proposalIds: Seq[ProposalId],
934       moderatorId: UserId,
935       ideaId: IdeaId
936     ): Future[Seq[Proposal]] = {
937       Future
938         .sequence(proposalIds.map { proposalId =>
939           proposalCoordinatorService.patch(
940             proposalId = proposalId,
941             userId = moderatorId,
942             changes = PatchProposalRequest(ideaId = Some(ideaId)),
943             requestContext = RequestContext.empty
944           )
945         })
946         .map(_.flatten)
947     }
948 
949     private def getSearchFilters(
950       questionId: QuestionId,
951       languages: Option[NonEmptyList[Language]],
952       toEnrich: Boolean,
953       minVotesCount: Option[Int],
954       minScore: Option[Double]
955     ): SearchFilters = {
956       if (toEnrich) {
957         SearchFilters(
958           question = Some(QuestionSearchFilter(Seq(questionId))),
959           languages = languages.map(_.map(org.make.core.proposal.LanguageSearchFilter)),
960           status = Some(StatusSearchFilter(Seq(ProposalStatus.Accepted))),
961           toEnrich = Some(ToEnrichSearchFilter(toEnrich)),
962           minVotesCount = minVotesCount.map(MinVotesCountSearchFilter.apply),
963           minScore = minScore.map(MinScoreSearchFilter.apply)
964         )
965       } else {
966         SearchFilters(
967           question = Some(QuestionSearchFilter(Seq(questionId))),
968           languages = languages.map(_.map(org.make.core.proposal.LanguageSearchFilter)),
969           status = Some(StatusSearchFilter(Seq(ProposalStatus.Pending)))
970         )
971       }
972     }
973 
974     override def searchAndLockAuthorToModerate(
975       questionId: QuestionId,
976       moderatorId: UserId,
977       moderatorFullName: Option[String],
978       languages: Option[NonEmptyList[Language]],
979       requestContext: RequestContext,
980       toEnrich: Boolean,
981       minVotesCount: Option[Int],
982       minScore: Option[Double]
983     ): Future[Option[ModerationAuthorResponse]] = {
984       val searchFilters = getSearchFilters(questionId, languages, toEnrich, minVotesCount, minScore)
985       searchInIndex(
986         requestContext = requestContext,
987         query = SearchQuery(
988           filters = Some(searchFilters),
989           sort = Some(Sort(Some(ProposalElasticsearchFieldName.createdAt.field), Some(SortOrder.ASC))),
990           limit = Some(Pagination.Limit(1000)),
991           language = None,
992           sortAlgorithm = Some(B2BFirstAlgorithm)
993         )
994       ).flatMap { searchResults =>
995         // Group proposals to moderate by author, in a LinkedHashMap to transfer proposal search sort order to authors
996         @SuppressWarnings(Array("org.wartremover.warts.MutableDataStructures"))
997         val candidates =
998           searchResults.results.foldLeft(mutable.LinkedHashMap.empty[UserId, NonEmptyList[IndexedProposal]]) {
999             case (map, proposal) =>
1000               val list = map.get(proposal.author.userId).fold(NonEmptyList.of(proposal))(_ :+ proposal)
1001               map.put(proposal.author.userId, list)
1002               map
1003           }
1004 
1005         // For current author candidate, try to lock and turn every proposal into a moderation response
1006         def futureMaybeSuccessfulLocks(
1007           indexedProposals: NonEmptyList[IndexedProposal],
1008           tags: Seq[Tag],
1009           tagTypes: Seq[TagType]
1010         ): Future[NonEmptyList[Option[ModerationProposalResponse]]] = {
1011           indexedProposals.traverse { proposal =>
1012             getModerationProposalById(proposal.id).flatMap {
1013               case None => Future.successful(None)
1014               case Some(proposal) =>
1015                 val isValid: Boolean = if (toEnrich) {
1016                   val proposalTags = tags.filter(tag => proposal.tags.contains(tag.tagId))
1017                   Proposal.needsEnrichment(proposal.status, tagTypes, proposalTags.map(_.tagTypeId))
1018                 } else {
1019                   proposal.status == Pending
1020                 }
1021 
1022                 if (!isValid) {
1023                   // Current proposal was moderated in the meantime, do nothing
1024                   Future.successful(None)
1025                 } else {
1026                   proposalCoordinatorService
1027                     .lock(proposal.proposalId, moderatorId, moderatorFullName, requestContext)
1028                     .map { _ =>
1029                       searchFilters.status.foreach(
1030                         filter =>
1031                           if (!filter.status.contains(proposal.status)) {
1032                             logger.error(
1033                               s"Proposal id=${proposal.proposalId.value} with status=${proposal.status} incorrectly candidate for moderation, questionId=${questionId.value} moderator=${moderatorId.value} toEnrich=$toEnrich searchFilters=$searchFilters requestContext=$requestContext"
1034                             )
1035                           }
1036                       )
1037                       Some(proposal)
1038                     }
1039                     .recoverWith { case _ => Future.successful(None) }
1040                 }
1041             }
1042           }
1043         }
1044 
1045         def getAndLockFirstAuthor(tags: Seq[Tag], tagTypes: Seq[TagType]) =
1046           Source(candidates.view.values.toSeq)
1047             .foldAsync[Option[NonEmptyList[ModerationProposalResponse]]](None) {
1048               case (None, indexedProposals) =>
1049                 // For current author entry, build a future list of options of locked proposals, each element being
1050                 // a moderation response defined if corresponding proposal was still valid and could be locked.
1051                 // Then turn it into a future option of a list of locks if every one succeeded.
1052                 futureMaybeSuccessfulLocks(indexedProposals, tags, tagTypes).map(_.sequence)
1053               case (Some(list), _) =>
1054                 Future.successful(Some(list))
1055             }
1056             // Find the first author for which all proposals could be locked and were turned into a list of moderation responses
1057             .collect { case Some(list) => list }
1058             .runWith(Sink.headOption)
1059             .map(_.map { list =>
1060               ModerationAuthorResponse(list.head.author, list.toList, searchResults.total.toInt)
1061             })
1062 
1063         for {
1064           tags           <- tagService.findByQuestionId(questionId)
1065           tagTypes       <- tagTypeService.findAll(requiredForEnrichmentFilter = Some(true))
1066           authorResponse <- getAndLockFirstAuthor(tags, tagTypes)
1067         } yield authorResponse
1068 
1069       }
1070     }
1071 
1072     override def searchAndLockProposalToModerate(
1073       questionId: QuestionId,
1074       moderator: UserId,
1075       moderatorFullName: Option[String],
1076       languages: Option[NonEmptyList[Language]] = None,
1077       requestContext: RequestContext,
1078       toEnrich: Boolean,
1079       minVotesCount: Option[Int],
1080       minScore: Option[Double]
1081     ): Future[Option[ModerationProposalResponse]] = {
1082       val defaultNumberOfProposals = 50
1083       val searchFilters = getSearchFilters(questionId, None, toEnrich, minVotesCount, minScore)
1084       searchInIndex(
1085         requestContext = requestContext,
1086         query = SearchQuery(
1087           filters = Some(searchFilters),
1088           sort = Some(Sort(Some(ProposalElasticsearchFieldName.createdAt.field), Some(SortOrder.ASC))),
1089           limit = Some(Pagination.Limit(defaultNumberOfProposals)),
1090           language = None,
1091           sortAlgorithm = Some(B2BFirstAlgorithm)
1092         )
1093       ).flatMap { results =>
1094         @SuppressWarnings(Array("org.wartremover.warts.Recursion"))
1095         def recursiveLock(availableProposals: List[ProposalId]): Future[Option[ModerationProposalResponse]] = {
1096           availableProposals match {
1097             case Nil => Future.successful(None)
1098             case currentProposalId :: otherProposalIds =>
1099               getModerationProposalById(currentProposalId).flatMap {
1100                 // If, for some reason, the proposal is not found in event sourcing, ignore it
1101                 case None => recursiveLock(otherProposalIds)
1102                 case Some(proposal) =>
1103                   val isValid: Future[Boolean] = if (toEnrich) {
1104                     for {
1105                       tags     <- tagService.findByTagIds(proposal.tags)
1106                       tagTypes <- tagTypeService.findAll(requiredForEnrichmentFilter = Some(true))
1107                     } yield {
1108                       Proposal.needsEnrichment(proposal.status, tagTypes, tags.map(_.tagTypeId))
1109                     }
1110                   } else {
1111                     Future.successful(proposal.status == Pending)
1112                   }
1113 
1114                   isValid.flatMap {
1115                     case false => recursiveLock(otherProposalIds)
1116                     case true =>
1117                       proposalCoordinatorService
1118                         .lock(proposal.proposalId, moderator, moderatorFullName, requestContext)
1119                         .map { _ =>
1120                           searchFilters.status.foreach(
1121                             filter =>
1122                               if (!filter.status.contains(proposal.status)) {
1123                                 logger.error(
1124                                   s"Proposal id=${proposal.proposalId.value} with status=${proposal.status} incorrectly candidate for moderation, questionId=${questionId.value} moderator=${moderator.value} toEnrich=$toEnrich searchFilters=$searchFilters requestContext=$requestContext"
1125                                 )
1126                               }
1127                           )
1128                           Some(proposal)
1129                         }
1130                         .recoverWith { case _ => recursiveLock(otherProposalIds) }
1131                   }
1132               }
1133           }
1134         }
1135         recursiveLock(results.results.map(_.id).toList)
1136       }
1137     }
1138 
1139     override def getTagsForProposal(proposal: Proposal): Future[TagsForProposalResponse] = {
1140       proposal.questionId.fold(Future.successful(TagsForProposalResponse.empty)) { questionId =>
1141         val futureTags: Future[Seq[Tag]] = tagService.findByQuestionId(questionId)
1142         futureTags.map { questionTags =>
1143           val tags = questionTags.map { tag =>
1144             val checked = proposal.tags.contains(tag.tagId)
1145             TagForProposalResponse(tag = tag, checked = checked, predicted = false)
1146           }
1147           TagsForProposalResponse(tags = tags, modelName = "none")
1148         }
1149       }
1150     }
1151 
1152     private def trolledQualification(qualification: Qualification): Boolean =
1153       qualification.count != qualification.countVerified
1154 
1155     private def trolledVote(voteWrapper: VotingOptionWrapper): Boolean =
1156       voteWrapper.vote.count != voteWrapper.vote.countVerified ||
1157         voteWrapper.deprecatedQualificationsSeq.exists(trolledQualification)
1158 
1159     def needVoteReset(proposal: Proposal): Boolean =
1160       proposal.status == ProposalStatus.Accepted &&
1161         proposal.votingOptions.exists { votingOptions =>
1162           trolledVote(votingOptions.agreeVote) ||
1163           trolledVote(votingOptions.neutralVote) ||
1164           trolledVote(votingOptions.disagreeVote)
1165         }
1166 
1167     override def resetVotes(adminUserId: UserId, requestContext: RequestContext): Future[Done] = {
1168       val start = System.currentTimeMillis()
1169 
1170       proposalJournal
1171         .currentPersistenceIds()
1172         .mapAsync(4) { id =>
1173           proposalCoordinatorService.getProposal(ProposalId(id))
1174         }
1175         .collect {
1176           case Some(proposal) if needVoteReset(proposal) => proposal
1177         }
1178         .mapAsync(4) { proposal =>
1179           val voteWrappers = proposal.votingOptions.fold(Seq.empty[VotingOptionWrapper])(_.wrappers)
1180           proposalCoordinatorService.updateVotes(
1181             moderator = adminUserId,
1182             proposalId = proposal.proposalId,
1183             requestContext = requestContext,
1184             updatedAt = DateHelper.now(),
1185             votes = voteWrappers
1186               .filter(trolledVote)
1187               .map(
1188                 voteWrapper =>
1189                   UpdateVoteRequest(
1190                     key = voteWrapper.vote.key,
1191                     count = Some(voteWrapper.vote.countVerified),
1192                     countVerified = None,
1193                     countSequence = None,
1194                     countSegment = None,
1195                     qualifications = voteWrapper.deprecatedQualificationsSeq.collect {
1196                       case qualification if trolledQualification(qualification) =>
1197                         UpdateQualificationRequest(
1198                           key = qualification.key,
1199                           count = Some(qualification.countVerified),
1200                           countVerified = None,
1201                           countSequence = None,
1202                           countSegment = None
1203                         )
1204                     }
1205                   )
1206               )
1207           )
1208         }
1209         .runWith(Sink.ignore)
1210         .map { res =>
1211           val time = System.currentTimeMillis() - start
1212           logger.info(s"ResetVotes ended in $time ms")
1213           res
1214         }
1215     }
1216 
1217     override def resolveQuestionFromVoteEvent(
1218       resolver: QuestionResolver,
1219       context: RequestContext,
1220       proposalId: ProposalId
1221     ): Future[Option[Question]] = {
1222       resolver
1223         .extractQuestionWithOperationFromRequestContext(context) match {
1224         case Some(question) => Future.successful(Some(question))
1225         case None =>
1226           proposalCoordinatorService
1227             .getProposal(proposalId)
1228             .map { maybeProposal =>
1229               resolver.findQuestionWithOperation { question =>
1230                 maybeProposal.flatMap(_.questionId).contains(question.questionId)
1231               }
1232             }
1233       }
1234     }
1235 
1236     private def searchUserProposals(userId: UserId): Future[ProposalsSearchResult] = {
1237       val filters =
1238         SearchFilters(
1239           users = Some(UserSearchFilter(Seq(userId))),
1240           status = Some(StatusSearchFilter(ProposalStatus.values))
1241         )
1242       elasticsearchProposalAPI
1243         .countProposals(SearchQuery(filters = Some(filters)))
1244         .flatMap { count =>
1245           if (count == 0) {
1246             Future.successful(ProposalsSearchResult(0L, Seq.empty))
1247           } else {
1248             elasticsearchProposalAPI
1249               .searchProposals(SearchQuery(filters = Some(filters), limit = Some(Pagination.Limit(count.intValue()))))
1250           }
1251         }
1252     }
1253 
1254     override def resolveQuestionFromUserProposal(
1255       questionResolver: QuestionResolver,
1256       requestContext: RequestContext,
1257       userId: UserId,
1258       eventDate: ZonedDateTime
1259     ): Future[Option[Question]] = {
1260       questionResolver
1261         .extractQuestionWithOperationFromRequestContext(requestContext) match {
1262         case Some(question) => Future.successful(Some(question))
1263         case None           =>
1264           // If we can't resolve the question, retrieve the user proposals,
1265           // and search for the one proposed at the event date
1266           searchUserProposals(userId).map { proposalResult =>
1267             proposalResult.results
1268               .find(_.createdAt == eventDate)
1269               .flatMap(_.question)
1270               .map(_.questionId)
1271               .flatMap { questionId =>
1272                 questionResolver
1273                   .findQuestionWithOperation(question => questionId == question.questionId)
1274               }
1275           }
1276       }
1277     }
1278 
1279     override def questionFeaturedProposals(
1280       questionId: QuestionId,
1281       maxPartnerProposals: Int,
1282       preferredLanguage: Option[Language],
1283       questionDefaultLanguage: Option[Language],
1284       limit: Pagination.Limit,
1285       seed: Option[Int],
1286       maybeUserId: Option[UserId],
1287       requestContext: RequestContext
1288     ): Future[ProposalsResultSeededResponse] = {
1289       val randomSeed: Int = seed.getOrElse(MakeRandom.nextInt())
1290       val futurePartnerProposals: Future[ProposalsResultSeededResponse] =
1291         Math.min(maxPartnerProposals, limit.extractInt) match {
1292           case 0 => Future.successful(ProposalsResultSeededResponse.empty)
1293           case posInt =>
1294             partnerService
1295               .find(
1296                 offset = Offset.zero,
1297                 end = None,
1298                 sort = None,
1299                 order = None,
1300                 questionId = Some(questionId),
1301                 organisationId = None,
1302                 partnerKind = None
1303               )
1304               .flatMap { partners =>
1305                 partners.collect {
1306                   case Partner(_, _, _, _, Some(orgaId), _, _, _) => orgaId
1307                 } match {
1308                   case Seq() => Future.successful(ProposalsResultSeededResponse.empty)
1309                   case orgaIds =>
1310                     searchForUser(
1311                       maybeUserId,
1312                       query = SearchQuery(
1313                         filters = Some(
1314                           SearchFilters(
1315                             question = Some(QuestionSearchFilter(Seq(questionId))),
1316                             users = Some(UserSearchFilter(orgaIds))
1317                           )
1318                         ),
1319                         sortAlgorithm = Some(RandomAlgorithm(randomSeed)),
1320                         limit = Some(Pagination.Limit(posInt))
1321                       ),
1322                       requestContext = requestContext,
1323                       preferredLanguage = preferredLanguage,
1324                       questionDefaultLanguage = questionDefaultLanguage
1325                     )
1326                 }
1327               }
1328         }
1329       val futureProposalsRest: Future[ProposalsResultSeededResponse] = {
1330         enrich(
1331           _ =>
1332             elasticsearchProposalAPI.getFeaturedProposals(
1333               SearchQuery(
1334                 filters = Some(
1335                   SearchFilters(
1336                     question = Some(QuestionSearchFilter(Seq(questionId))),
1337                     userTypes = Some(UserTypesSearchFilter(Seq(UserType.UserTypeUser)))
1338                   )
1339                 ),
1340                 limit = Some(limit)
1341               )
1342             ),
1343           maybeUserId,
1344           requestContext,
1345           preferredLanguage,
1346           questionDefaultLanguage
1347         ).map(r => ProposalsResultSeededResponse(r.total, r.results, None))
1348       }
1349       for {
1350         partnerProposals <- futurePartnerProposals
1351         rest             <- futureProposalsRest
1352       } yield ProposalsResultSeededResponse(
1353         partnerProposals.total + rest.total,
1354         partnerProposals.results ++ rest.results.take(limit.extractInt - partnerProposals.results.size),
1355         Some(randomSeed)
1356       )
1357 
1358     }
1359 
1360     private def setProposalKeywords(
1361       proposalId: ProposalId,
1362       keywords: Seq[ProposalKeyword],
1363       requestContext: RequestContext
1364     ): Future[ProposalKeywordsResponse] = {
1365       proposalCoordinatorService.setKeywords(proposalId, keywords, requestContext).map {
1366         case Some(proposal) =>
1367           ProposalKeywordsResponse(proposal.proposalId, status = ProposalKeywordsResponseStatus.Ok, message = None)
1368         case None =>
1369           ProposalKeywordsResponse(
1370             proposalId,
1371             status = ProposalKeywordsResponseStatus.Error,
1372             message = Some(s"Proposal ${proposalId.value} not found")
1373           )
1374       }
1375     }
1376 
1377     override def setKeywords(
1378       proposalKeywordsList: Seq[ProposalKeywordRequest],
1379       requestContext: RequestContext
1380     ): Future[Seq[ProposalKeywordsResponse]] = {
1381       Source(proposalKeywordsList)
1382         .mapAsync(3) { proposalKeywords =>
1383           setProposalKeywords(proposalKeywords.proposalId, proposalKeywords.keywords, requestContext)
1384         }
1385         .runWith(Sink.seq)
1386     }
1387 
1388     override def refuseAll(
1389       proposalIds: Seq[ProposalId],
1390       moderator: UserId,
1391       requestContext: RequestContext
1392     ): Future[BulkActionResponse] = {
1393       bulkAction(refuseAction(moderator, requestContext), proposalIds)
1394     }
1395 
1396     override def addTagsToAll(
1397       proposalIds: Seq[ProposalId],
1398       tagIds: Seq[TagId],
1399       moderator: UserId,
1400       requestContext: RequestContext
1401     ): Future[BulkActionResponse] = {
1402       bulkAction(updateTagsAction(moderator, requestContext, current => (current ++ tagIds).distinct), proposalIds)
1403     }
1404 
1405     override def deleteTagFromAll(
1406       proposalIds: Seq[ProposalId],
1407       tagId: TagId,
1408       moderator: UserId,
1409       requestContext: RequestContext
1410     ): Future[BulkActionResponse] = {
1411       bulkAction(updateTagsAction(moderator, requestContext, _.filterNot(_ == tagId)), proposalIds)
1412     }
1413 
1414     private def refuseAction(
1415       moderator: UserId,
1416       requestContext: RequestContext
1417     )(proposal: IndexedProposal, question: Question): Future[Option[Proposal]] =
1418       if (proposal.initialProposal) {
1419         proposalCoordinatorService
1420           .refuse(
1421             proposalId = proposal.id,
1422             moderator = moderator,
1423             requestContext = requestContext,
1424             sendNotificationEmail = false,
1425             refusalReason = Some("other")
1426           )
1427       } else {
1428         Future.failed(
1429           ValidationFailedError(
1430             Seq(ValidationError(field = "initial", key = "not-initial", message = Some("The proposal is not initial")))
1431           )
1432         )
1433       }
1434 
1435     private def updateTagsAction(
1436       moderator: UserId,
1437       requestContext: RequestContext,
1438       transformTags: Seq[TagId] => Seq[TagId]
1439     )(proposal: IndexedProposal, question: Question): Future[Option[Proposal]] =
1440       proposalCoordinatorService
1441         .update(
1442           moderator = moderator,
1443           proposalId = proposal.id,
1444           requestContext = requestContext,
1445           updatedAt = DateHelper.now(),
1446           newContent = None,
1447           newTranslations = None,
1448           tags = transformTags(proposal.tags.map(_.tagId)),
1449           question = question
1450         )
1451 
1452     private def bulkAction(
1453       action: (IndexedProposal, Question) => Future[Option[Proposal]],
1454       proposalIds: Seq[ProposalId]
1455     ): Future[BulkActionResponse] = {
1456       val getProposals: Future[Map[ProposalId, (IndexedProposal, Option[QuestionId])]] =
1457         elasticsearchProposalAPI
1458           .searchProposals(
1459             SearchQuery(
1460               filters = Some(
1461                 SearchFilters(
1462                   proposal = Some(ProposalSearchFilter(proposalIds)),
1463                   status = Some(StatusSearchFilter(ProposalStatus.values))
1464                 )
1465               ),
1466               limit = Some(Pagination.Limit(proposalIds.size + 1))
1467             )
1468           )
1469           .map(_.results.map(p => (p.id, (p, p.question.map(_.questionId)))).toMap)
1470 
1471       def getQuestions(proposalMap: Map[ProposalId, (IndexedProposal, Option[QuestionId])]): Future[Seq[Question]] =
1472         questionService.getQuestions(proposalMap.values.collect { case (_, Some(id)) => id }.toSeq.distinct)
1473 
1474       def runActionOnAll(
1475         action: (IndexedProposal, Question) => Future[Option[Proposal]],
1476         proposalIds: Seq[ProposalId],
1477         proposals: Map[ProposalId, (IndexedProposal, Option[QuestionId])],
1478         questions: Seq[Question]
1479       ): Future[Seq[SingleActionResponse]] = {
1480         Source(proposalIds).map { id =>
1481           proposals.get(id) match {
1482             case Some((p, Some(qId))) => (id, Some(p), questions.find(_.questionId == qId), Some(qId))
1483             case Some((p, None))      => (id, Some(p), None, None)
1484             case None                 => (id, None, None, None)
1485           }
1486         }.mapAsync(5) {
1487             case (_, Some(proposal), Some(question), _) => runAction(proposal.id, action(proposal, question))
1488             case (id, None, _, _) =>
1489               Future.successful(SingleActionResponse(id, ActionKey.NotFound, Some("Proposal not found")))
1490             case (id, Some(_), _, qId) =>
1491               Future.successful(
1492                 SingleActionResponse(id, ActionKey.QuestionNotFound, Some(s"Question not found from id $qId"))
1493               )
1494           }
1495           .runWith(Sink.seq)
1496       }
1497 
1498       def runAction(id: ProposalId, action: Future[Option[Proposal]]): Future[SingleActionResponse] = {
1499         action.map {
1500           case None => SingleActionResponse(id, ActionKey.NotFound, Some(s"Proposal not found"))
1501           case _    => SingleActionResponse(id, ActionKey.OK, None)
1502         }.recover {
1503           case ValidationFailedError(Seq(error)) =>
1504             SingleActionResponse(id, ActionKey.ValidationError(error.key), error.message)
1505           case e =>
1506             SingleActionResponse(id, ActionKey.Unknown, Some(e.getMessage))
1507         }
1508       }
1509 
1510       for {
1511         proposalMap <- getProposals
1512         questions   <- getQuestions(proposalMap)
1513         actions     <- runActionOnAll(action, proposalIds, proposalMap, questions)
1514       } yield {
1515         val (successes, failures) = actions.partition(_.key == ActionKey.OK)
1516         BulkActionResponse(successes.map(_.proposalId), failures)
1517       }
1518     }
1519 
1520     override def getHistory(proposalId: ProposalId): Future[Option[Seq[ProposalActionResponse]]] = {
1521       for {
1522         proposal <- proposalCoordinatorService.getProposal(proposalId)
1523         events   <- proposal.traverse(getEvents)
1524       } yield events
1525     }
1526 
1527     override def generateProposalKeyHash(
1528       proposalId: ProposalId,
1529       sessionId: SessionId,
1530       location: Option[String],
1531       salt: String
1532     ): String = {
1533       val rawString: String = s"${proposalId.value}${sessionId.value}${location.getOrElse("")}"
1534       SecurityHelper.generateHash(value = rawString, salt = salt)
1535     }
1536   }
1537 }