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 akka.util.Timeout
23 import org.make.api.proposal.{ProposalResponse, ProposalServiceComponent}
24 import org.make.api.sequence.SequenceBehaviour.ConsensusParam
25 import org.make.api.sequence.SequenceCacheManager.{GetConsensusProposal, GetControversyProposal, GetProposal}
26 import org.make.api.technical.{ActorSystemComponent, TimeSettings}
27 import org.make.api.technical.BetterLoggingActors.BetterLoggingTypedActorRef
28 import org.make.api.technical.security.SecurityConfigurationComponent
29 import org.make.core.RequestContext
30 import org.make.core.reference.Language
31 import org.make.core.proposal.indexed.IndexedProposal
32 import org.make.core.question.QuestionId
33 
34 import scala.concurrent.Future
35 import scala.concurrent.ExecutionContext.Implicits.global
36 
37 trait DefaultSequenceCacheManagerServiceComponent extends SequenceCacheManagerServiceComponent {
38   this: SequenceCacheManagerComponent
39     with ActorSystemComponent
40     with ProposalServiceComponent
41     with SecurityConfigurationComponent
42     with SequenceConfigurationComponent =>
43 
44   override lazy val sequenceCacheManagerService: SequenceCacheManagerService = new DefaultSequenceCacheManagerService
45 
46   class DefaultSequenceCacheManagerService extends SequenceCacheManagerService {
47     implicit val timeout: Timeout = TimeSettings.defaultTimeout
48 
49     // These methods are meant to be used by the widget.
50     // Widget does not support cookies thus users will not be authenticated.
51     // There's no need to populate `myProposal` and `voteAndQualifications`
52     override def getProposal(
53       id: QuestionId,
54       requestContext: RequestContext,
55       preferredLanguage: Option[Language],
56       questionDefaultLanguage: Language
57     ): Future[ProposalResponse] =
58       (sequenceCacheManager ?? (GetProposal(id, _)))
59         .flatMap(shapeResponse(_, requestContext, preferredLanguage, questionDefaultLanguage))
60 
61     override def getControversyProposal(
62       id: QuestionId,
63       requestContext: RequestContext,
64       preferredLanguage: Option[Language],
65       questionDefaultLanguage: Language
66     ): Future[ProposalResponse] =
67       (sequenceCacheManager ?? (GetControversyProposal(id, _)))
68         .flatMap(shapeResponse(_, requestContext, preferredLanguage, questionDefaultLanguage))
69 
70     override def getConsensusProposal(
71       id: QuestionId,
72       threshold: () => Future[ConsensusParam],
73       requestContext: RequestContext,
74       preferredLanguage: Option[Language],
75       questionDefaultLanguage: Language
76     ): Future[ProposalResponse] =
77       (sequenceCacheManager ?? (GetConsensusProposal(id, threshold, _)))
78         .flatMap(shapeResponse(_, requestContext, preferredLanguage, questionDefaultLanguage))
79 
80     def shapeResponse(
81       proposal: IndexedProposal,
82       requestContext: RequestContext,
83       preferredLanguage: Option[Language],
84       questionDefaultLanguage: Language
85     ): Future[ProposalResponse] = {
86       val proposalKey =
87         proposalService.generateProposalKeyHash(
88           proposal.id,
89           requestContext.sessionId,
90           requestContext.location,
91           securityConfiguration.secureVoteSalt
92         )
93 
94       val futureThreshold = proposal.question.map(_.questionId) match {
95         case None => Future.successful(0)
96         case Some(questionId) =>
97           sequenceConfigurationService
98             .getSequenceConfigurationByQuestionId(questionId)
99             .map(_.newProposalsVoteThreshold)
100       }
101 
102       futureThreshold.map(
103         newProposalsVoteThreshold =>
104           ProposalResponse(
105             indexedProposal = proposal,
106             myProposal = false,
107             voteAndQualifications = None,
108             proposalKey = proposalKey,
109             newProposalsVoteThreshold = newProposalsVoteThreshold,
110             preferredLanguage = preferredLanguage,
111             questionDefaultLanguage = Some(questionDefaultLanguage)
112           )
113       )
114     }
115   }
116 }