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.question
21 
22 import akka.stream.scaladsl.{Sink, Source}
23 import cats.data.NonEmptyList
24 import cats.implicits._
25 import eu.timepit.refined.api.Refined
26 import eu.timepit.refined.collection._
27 import org.make.api.organisation.OrganisationSearchEngineComponent
28 import org.make.api.personality.QuestionPersonalityServiceComponent
29 import org.make.api.proposal.ProposalSearchEngineComponent
30 import org.make.api.technical.{ActorSystemComponent, IdGeneratorComponent}
31 import org.make.api.user.UserServiceComponent
32 import org.make.core.technical.{Multilingual, Pagination}
33 import org.make.core.operation.OperationId
34 import org.make.core.personality.PersonalityRoleId
35 import org.make.core.question.{Question, QuestionId}
36 import org.make.core.reference.{Country, Language}
37 import org.make.core.user._
38 import org.make.core.user.indexed.OrganisationSearchResult
39 import org.make.core.{ValidationError, ValidationFailedError}
40 import scalacache._
41 import scalacache.guava._
42 import scalacache.modes.scalaFuture._
43 
44 import scala.concurrent.ExecutionContext.Implicits.global
45 import scala.concurrent.Future
46 import scala.concurrent.duration.DurationInt
47 import org.make.core.technical.Pagination._
48 import scalacache.memoization.memoizeF
49 
50 trait DefaultQuestionServiceComponent extends QuestionServiceComponent {
51   this: PersistentQuestionServiceComponent
52     with ActorSystemComponent
53     with IdGeneratorComponent
54     with QuestionPersonalityServiceComponent
55     with UserServiceComponent
56     with OrganisationSearchEngineComponent
57     with ProposalSearchEngineComponent =>
58 
59   override lazy val questionService: QuestionService = new DefaultQuestionService
60 
61   class DefaultQuestionService extends QuestionService {
62 
63     implicit val guavaCache: Cache[Option[Question]] = GuavaCache[Option[Question]]
64 
65     override def getQuestions(questionIds: Seq[QuestionId]): Future[Seq[Question]] = {
66       persistentQuestionService.getByIds(questionIds)
67     }
68 
69     override def getQuestionByQuestionIdValueOrSlug(questionIdValueOrSlug: String): Future[Option[Question]] = {
70       persistentQuestionService.getByQuestionIdValueOrSlug(questionIdValueOrSlug)
71     }
72 
73     override def getQuestion(questionId: QuestionId): Future[Option[Question]] = {
74       persistentQuestionService.getById(questionId)
75     }
76 
77     override def getCachedQuestion(questionId: QuestionId): Future[Option[Question]] = {
78       memoizeF[Future, Option[Question]](Some(3.hours)) {
79         getQuestion(questionId)
80       }
81     }
82 
83     override def findQuestion(
84       maybeOperationId: Option[OperationId],
85       country: Country,
86       language: Language
87     ): Future[Option[Question]] = {
88 
89       maybeOperationId match {
90         case None =>
91           Future.failed(
92             ValidationFailedError(
93               Seq(ValidationError("unknown", "mandatory", Some("operationId must be provided to question search")))
94             )
95           )
96         case _ =>
97           persistentQuestionService
98             .find(
99               SearchQuestionRequest(
100                 country = Some(country),
101                 language = Some(language),
102                 maybeOperationIds = maybeOperationId.map(operationId => Seq(operationId))
103               )
104             )
105             .map(_.headOption)
106       }
107 
108     }
109 
110     override def searchQuestion(request: SearchQuestionRequest): Future[Seq[Question]] = {
111       persistentQuestionService.find(request)
112     }
113 
114     override def countQuestion(request: SearchQuestionRequest): Future[Int] = {
115       persistentQuestionService.count(request)
116     }
117 
118     override def createQuestion(
119       countries: NonEmptyList[Country],
120       defaultLanguage: Language,
121       languages: NonEmptyList[Language],
122       questions: Multilingual[String Refined NonEmpty],
123       shortTitles: Option[Multilingual[String Refined NonEmpty]],
124       slug: String
125     ): Future[Question] = {
126       persistentQuestionService.persist(
127         Question(
128           questionId = idGenerator.nextQuestionId(),
129           slug = slug,
130           countries = countries,
131           defaultLanguage = defaultLanguage,
132           languages = languages,
133           questions = questions,
134           shortTitles = shortTitles,
135           operationId = None
136         )
137       )
138     }
139 
140     override def getQuestionPersonalities(
141       offset: Offset,
142       end: Option[End],
143       questionId: QuestionId,
144       personalityRoleId: Option[PersonalityRoleId]
145     ): Future[Seq[QuestionPersonalityResponse]] = {
146       Source
147         .future(
148           questionPersonalityService.find(
149             offset = offset,
150             end = end,
151             sort = None,
152             order = None,
153             userId = None,
154             questionId = Some(questionId),
155             personalityRoleId = personalityRoleId
156           )
157         )
158         .mapConcat(identity)
159         .mapAsync(1) { personality =>
160           userService.getPersonality(personality.userId)
161         }
162         .collect {
163           case Some(user) =>
164             QuestionPersonalityResponse(
165               userId = user.userId,
166               firstName = user.firstName,
167               lastName = user.lastName,
168               politicalParty = user.profile.flatMap(_.politicalParty),
169               avatarUrl = user.profile.flatMap(_.avatarUrl),
170               gender = user.profile.flatMap(_.gender.map(_.value))
171             )
172         }
173         .runWith(Sink.seq[QuestionPersonalityResponse])
174     }
175 
176     override def getPartners(
177       questionId: QuestionId,
178       organisationIds: Seq[UserId],
179       sortAlgorithm: Option[OrganisationSortAlgorithm],
180       limit: Option[Pagination.Limit],
181       offset: Option[Pagination.Offset]
182     ): Future[OrganisationSearchResult] = {
183       val query = OrganisationSearchQuery(
184         filters = Some(OrganisationSearchFilters(organisationIds = Some(OrganisationIdsSearchFilter(organisationIds)))),
185         sortAlgorithm = sortAlgorithm,
186         limit = sortAlgorithm.as(Pagination.Limit(1000)).orElse(limit),
187         offset = sortAlgorithm.as(Pagination.Offset(0)).orElse(offset)
188       )
189 
190       val offsetOrZero = offset.fold(0)(_.extractInt)
191       elasticsearchOrganisationAPI.searchOrganisations(query).map { organisationSearchResult =>
192         sortAlgorithm.collect {
193           case ParticipationAlgorithm(_) =>
194             organisationSearchResult.copy(results = organisationSearchResult.results.sortBy { orga =>
195               orga.countsByQuestion.collect {
196                 case counts if counts.questionId == questionId =>
197                   counts.proposalsCount + counts.votesCount
198               }.sum * -1
199             }.slice(offsetOrZero, offsetOrZero + limit.fold(organisationSearchResult.total.toInt)(_.extractInt)))
200         }.getOrElse(organisationSearchResult)
201       }
202 
203     }
204   }
205 }