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.sequence
21 
22 import cats.implicits._
23 import eu.timepit.refined.auto._
24 import grizzled.slf4j.Logging
25 import org.make.api.demographics._
26 import org.make.api.operation._
27 import org.make.api.proposal._
28 import org.make.api.segment.SegmentServiceComponent
29 import org.make.api.sessionhistory._
30 import org.make.api.technical.security.SecurityConfigurationComponent
31 import org.make.api.userhistory._
32 import org.make.core.session.SessionId
33 import org.make.core.history.HistoryActions.VoteAndQualifications
34 import org.make.core.proposal._
35 import org.make.core.reference.Language
36 import org.make.core.proposal.indexed.{IndexedProposal, SequencePool}
37 import org.make.core.question.{Question, QuestionId}
38 import org.make.core.user._
39 import org.make.core.{proposal, DateHelper, RequestContext}
40 import org.make.core.technical.Pagination
41 import org.make.core.demographics.DemographicsCardId
42 import org.make.core.sequence.SequenceConfiguration
43 
44 import scala.concurrent.ExecutionContext.Implicits.global
45 import scala.concurrent.Future
46 
47 trait DefaultSequenceServiceComponent extends SequenceServiceComponent {
48   this: DemographicsCardServiceComponent
49     with OperationOfQuestionSearchEngineComponent
50     with ProposalSearchEngineComponent
51     with ProposalServiceComponent
52     with OperationOfQuestionServiceComponent
53     with SecurityConfigurationComponent
54     with SegmentServiceComponent
55     with SequenceConfigurationComponent
56     with SessionHistoryCoordinatorServiceComponent
57     with UserHistoryCoordinatorServiceComponent
58     with Logging =>
59 
60   override lazy val sequenceService: DefaultSequenceService = new DefaultSequenceService
61 
62   class DefaultSequenceService extends SequenceService {
63 
64     override def startNewSequence[T: SequenceBehaviourProvider](
65       behaviourParam: T,
66       maybeUserId: Option[UserId],
67       includedProposalsIds: Seq[ProposalId],
68       requestContext: RequestContext,
69       cardId: Option[DemographicsCardId],
70       tokenOpt: Option[String],
71       configurationOverride: Option[SequenceConfiguration] = None,
72       preferredLanguage: Option[Language],
73       question: Question
74     ): Future[SequenceResult] = {
75       // Only use the preferredLanguage if the question allows it
76       val demographicsLanguage =
77         preferredLanguage.filter(question.languages.toList.contains).getOrElse(question.defaultLanguage)
78       (
79         logStartSequenceUserHistory(question.questionId, maybeUserId, includedProposalsIds, requestContext),
80         sessionHistoryCoordinatorService.retrieveVotedProposals(requestContext.sessionId),
81         config(question.questionId, configurationOverride),
82         operationOfQuestionService.findByQuestionId(question.questionId)
83       ).tupled.flatMap({
84         case (_, blacklist, config, ooq) =>
85           val sessionBindingMode = ooq.exists(_.sessionBindingMode)
86           val demographicsCardsF: Future[Seq[DemographicsCardResponse]] =
87             if (sessionBindingMode)
88               demographicsCardService
89                 .list(questionId = Some(question.questionId))
90                 .map(_.map { card =>
91                   val fallbackToken = demographicsCardService.generateToken(card.id, question.questionId)
92                   DemographicsCardResponse(card, tokenOpt.getOrElse(fallbackToken))
93                 })
94             else
95               demographicsCardService
96                 .getOrPickRandom(cardId, tokenOpt, question.questionId)
97                 .map(_.fold(Seq.empty[DemographicsCardResponse])(Seq(_)))
98           for {
99             behaviour <- createBehaviour(behaviourParam, question.questionId, requestContext, config)
100             sequenceProposals <- simpleSequence(
101               includedProposalsIds,
102               behaviour,
103               blacklist,
104               Some(requestContext.sessionId)
105             )
106             sequenceVotes     <- votesForProposals(maybeUserId, requestContext, sequenceProposals.map(_.id))
107             demographicsCards <- demographicsCardsF
108           } yield {
109             val proposals = sequenceProposals.map(indexed => {
110               val proposalKey = proposalService.generateProposalKeyHash(
111                 indexed.id,
112                 requestContext.sessionId,
113                 requestContext.location,
114                 securityConfiguration.secureVoteSalt
115               )
116               ProposalResponse(
117                 indexed,
118                 maybeUserId.contains(indexed.author.userId),
119                 sequenceVotes.get(indexed.id),
120                 proposalKey,
121                 config.newProposalsVoteThreshold,
122                 preferredLanguage,
123                 Some(question.defaultLanguage)
124               )
125             })
126             val demographics = demographicsCards.map(DemographicsCardForSequence(_, demographicsLanguage))
127             SequenceResult(proposals, demographics, sessionBindingMode)
128           }
129       })
130     }
131 
132     override def simpleSequence(
133       includedProposalsIds: Seq[ProposalId],
134       behaviour: SequenceBehaviour,
135       proposalsToExclude: Seq[ProposalId],
136       sessionId: Option[SessionId]
137     ): Future[Seq[IndexedProposal]] = {
138       def logFallback(count: Int, questionId: QuestionId): Unit = sessionId match {
139         case Some(id) =>
140           logger.warn(
141             s"Sequence fallback missing $count proposals for sessionId ${id.value} and question ${questionId.value}"
142           )
143         case None => logger.warn(s"Sequence fallback missing $count proposals for question ${questionId.value}")
144       }
145       chooseSequenceProposals(includedProposalsIds, behaviour, proposalsToExclude, logFallback)
146     }
147 
148     private def config(
149       questionId: QuestionId,
150       overrideConfiguration: Option[SequenceConfiguration]
151     ): Future[SequenceConfiguration] = {
152       overrideConfiguration match {
153         case Some(config) => Future.successful(config)
154         case None         => sequenceConfigurationService.getSequenceConfigurationByQuestionId(questionId)
155       }
156     }
157 
158     private def createBehaviour[T: SequenceBehaviourProvider](
159       behaviourParam: T,
160       questionId: QuestionId,
161       requestContext: RequestContext,
162       config: SequenceConfiguration
163     ): Future[SequenceBehaviour] = {
164       segmentService.resolveSegment(requestContext).map { maybeSegment =>
165         SequenceBehaviourProvider[T].behaviour(behaviourParam, config, questionId, maybeSegment)
166       }
167     }
168 
169     private def logStartSequenceUserHistory(
170       questionId: QuestionId,
171       maybeUserId: Option[UserId],
172       includedProposalsIds: Seq[ProposalId],
173       requestContext: RequestContext
174     ): Future[Unit] = {
175       (maybeUserId, requestContext.sessionId) match {
176         case (Some(userId), _) =>
177           userHistoryCoordinatorService.logTransactionalHistory(
178             LogUserStartSequenceEvent(
179               userId,
180               requestContext,
181               UserAction(
182                 date = DateHelper.now(),
183                 actionType = LogUserStartSequenceEvent.action,
184                 arguments = StartSequenceParameters(None, Some(questionId), includedProposalsIds)
185               )
186             )
187           )
188         case (None, sessionId) =>
189           sessionHistoryCoordinatorService.logTransactionalHistory(
190             LogSessionStartSequenceEvent(
191               sessionId,
192               requestContext,
193               SessionAction(
194                 date = DateHelper.now(),
195                 actionType = LogSessionStartSequenceEvent.action,
196                 arguments = StartSequenceParameters(None, Some(questionId), includedProposalsIds)
197               )
198             )
199           )
200       }
201     }
202 
203     private def futureIncludedProposals(includedProposalsIds: Seq[ProposalId]): Future[Seq[IndexedProposal]] =
204       if (includedProposalsIds.nonEmpty) {
205         elasticsearchProposalAPI
206           .searchProposals(
207             proposal.SearchQuery(
208               filters = Some(proposal.SearchFilters(proposal = Some(ProposalSearchFilter(includedProposalsIds)))),
209               limit = Some(Pagination.Limit(includedProposalsIds.size))
210             )
211           )
212           .map(_.results)
213       } else {
214         Future.successful(Seq.empty)
215       }
216 
217     private def chooseSequenceProposals(
218       includedProposalsIds: Seq[ProposalId],
219       behaviour: SequenceBehaviour,
220       proposalsToExclude: Seq[ProposalId],
221       logFallback: (Int, QuestionId) => Unit
222     ): Future[Seq[IndexedProposal]] = {
223 
224       def futureFallbackProposals(
225         excluded: Seq[ProposalId],
226         selectedProposals: Seq[IndexedProposal]
227       ): Future[Seq[IndexedProposal]] = {
228         behaviour.fallbackProposals(
229           currentSequenceSize = selectedProposals.size,
230           search = searchProposals(
231             excluded ++ selectedProposals.map(_.id),
232             behaviour.specificConfiguration.sequenceSize - selectedProposals.size
233           ),
234           logFallback
235         )
236       }
237 
238       val excluded = proposalsToExclude ++ includedProposalsIds
239       for {
240         includedProposals <- futureIncludedProposals(includedProposalsIds)
241         newProposals <- behaviour.newProposals(
242           searchProposals(excluded, behaviour.specificConfiguration.sequenceSize * 3)
243         )
244         testedProposals <- behaviour.testedProposals(
245           searchProposals(excluded, behaviour.specificConfiguration.maxTestedProposalCount)
246         )
247         selectedProposals = behaviour.selectProposals(includedProposals, newProposals, testedProposals)
248         fallbackProposals <- futureFallbackProposals(excluded, selectedProposals)
249       } yield selectedProposals ++ fallbackProposals
250     }
251 
252     private def votesForProposals(
253       maybeUserId: Option[UserId],
254       requestContext: RequestContext,
255       proposals: Seq[ProposalId]
256     ): Future[Map[ProposalId, VoteAndQualifications]] =
257       maybeUserId.map { userId =>
258         userHistoryCoordinatorService.retrieveVoteAndQualifications(userId, proposals)
259       }.getOrElse {
260         sessionHistoryCoordinatorService.retrieveVoteAndQualifications(requestContext.sessionId, proposals)
261       }
262 
263     private def searchProposals(excluded: Seq[ProposalId], limit: Int)(
264       questionId: QuestionId,
265       maybeSegment: Option[String],
266       maybePool: Option[SequencePool],
267       baseQuery: proposal.SearchQuery,
268       sortAlgorithm: SortAlgorithm
269     ): Future[Seq[IndexedProposal]] = {
270       val poolFilter = maybePool.map(SequencePoolSearchFilter.apply)
271       val query = baseQuery.copy(
272         filters = SearchFilters.merge(
273           baseQuery.filters,
274           Some(
275             SearchFilters(
276               sequencePool = maybeSegment.fold(poolFilter)(_ => None),
277               sequenceSegmentPool = maybeSegment *> poolFilter,
278               question = Some(QuestionSearchFilter(Seq(questionId))),
279               segment = maybeSegment.map(SegmentSearchFilter.apply)
280             )
281           )
282         ),
283         excludes = Some(proposal.SearchFilters(proposal = Some(ProposalSearchFilter(excluded)))),
284         limit = Some(Pagination.Limit(limit)),
285         sortAlgorithm = Some(sortAlgorithm)
286       )
287 
288       elasticsearchProposalAPI.searchProposals(query).map(_.results)
289     }
290   }
291 }