1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2018 Make.org
4  *
5  * This program is free software: you can redistribute it and/or modify
6  *  it under the terms of the GNU Affero General Public License as
7  *  published by the Free Software Foundation, either version 3 of the
8  *  License, or (at your option) any later version.
9  *
10  *  This program is distributed in the hope that it will be useful,
11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  *  GNU Affero General Public License for more details.
14  *
15  *  You should have received a copy of the GNU Affero General Public License
16  *  along with this program.  If not, see <https://www.gnu.org/licenses/>.
17  *
18  */
19 
20 package org.make.api.operation
21 
22 import cats.data.OptionT
23 import cats.implicits._
24 import grizzled.slf4j.Logging
25 import org.make.api.operation.ModerationMode.Enrichment
26 import org.make.api.proposal.ProposalSearchEngineComponent
27 import org.make.api.question.{PersistentQuestionServiceComponent, QuestionServiceComponent, SearchQuestionRequest}
28 import org.make.api.sequence.PersistentSequenceConfigurationComponent
29 import org.make.api.tag.{TagFilter, TagServiceComponent}
30 import org.make.api.technical.IdGeneratorComponent
31 import org.make.core.technical.{Multilingual, Pagination}
32 import org.make.core.elasticsearch.IndexationStatus
33 import org.make.core.operation._
34 import org.make.core.operation.indexed.{IndexedOperationOfQuestion, OperationOfQuestionSearchResult}
35 import org.make.core.proposal.ProposalStatus
36 import org.make.core.question.{Question, QuestionId}
37 import org.make.core.sequence.{ExplorationSequenceConfiguration, SequenceConfiguration, SpecificSequenceConfiguration}
38 import org.make.core.{DateHelper, Order}
39 
40 import scala.concurrent.ExecutionContext.Implicits.global
41 import scala.concurrent.Future
42 import cats.data.NonEmptyList
43 
44 trait DefaultOperationOfQuestionServiceComponent extends OperationOfQuestionServiceComponent with Logging {
45   this: PersistentQuestionServiceComponent
46     with PersistentSequenceConfigurationComponent
47     with PersistentOperationOfQuestionServiceComponent
48     with OperationOfQuestionSearchEngineComponent
49     with ProposalSearchEngineComponent
50     with IdGeneratorComponent
51     with QuestionServiceComponent
52     with OperationServiceComponent
53     with TagServiceComponent =>
54 
55   override lazy val operationOfQuestionService: OperationOfQuestionService = new DefaultOperationOfQuestionService
56 
57   class DefaultOperationOfQuestionService extends OperationOfQuestionService {
58 
59     override def count(query: OperationOfQuestionSearchQuery): Future[Long] =
60       elasticsearchOperationOfQuestionAPI.count(query)
61 
62     override def find(
63       offset: Pagination.Offset = Pagination.Offset.zero,
64       end: Option[Pagination.End] = None,
65       sort: Option[String] = None,
66       order: Option[Order] = None,
67       request: SearchOperationsOfQuestions = SearchOperationsOfQuestions()
68     ): Future[scala.Seq[OperationOfQuestion]] = {
69       persistentOperationOfQuestionService.search(
70         offset,
71         end,
72         sort,
73         order,
74         request.questionIds,
75         request.operationIds,
76         request.operationKind,
77         request.openAt,
78         request.endAfter,
79         request.slug
80       )
81     }
82 
83     override def findByQuestionId(questionId: QuestionId): Future[Option[OperationOfQuestion]] = {
84       persistentOperationOfQuestionService.getById(questionId)
85     }
86 
87     override def findByOperationId(operationId: OperationId): Future[Seq[OperationOfQuestion]] = {
88       persistentOperationOfQuestionService.find(Some(operationId))
89     }
90 
91     override def findByQuestionSlug(slug: String): Future[Option[OperationOfQuestion]] = {
92       persistentQuestionService.find(SearchQuestionRequest(maybeSlug = Some(slug))).flatMap { results =>
93         results.headOption.map { question =>
94           findByQuestionId(question.questionId)
95         }.getOrElse(Future.successful(None))
96       }
97     }
98 
99     override def search(searchQuery: OperationOfQuestionSearchQuery): Future[OperationOfQuestionSearchResult] = {
100       elasticsearchOperationOfQuestionAPI.searchOperationOfQuestions(searchQuery)
101     }
102 
103     override def updateWithQuestion(
104       operationOfQuestion: OperationOfQuestion,
105       question: Question
106     ): Future[OperationOfQuestion] = {
107       for {
108         _       <- persistentQuestionService.modify(question)
109         updated <- persistentOperationOfQuestionService.modify(operationOfQuestion)
110         _       <- indexById(question.questionId)
111       } yield updated
112     }
113 
114     override def update(operationOfQuestion: OperationOfQuestion): Future[OperationOfQuestion] = {
115       for {
116         result <- persistentOperationOfQuestionService.modify(operationOfQuestion)
117         _      <- indexById(operationOfQuestion.questionId)
118       } yield result
119     }
120 
121     override def incrementProposalsCount(id: QuestionId): Future[OperationOfQuestion] =
122       persistentOperationOfQuestionService
123         .getById(id)
124         .flatMap({
125           case Some(opOfQuestion) =>
126             persistentOperationOfQuestionService
127               .modify(opOfQuestion.copy(proposalsCount = opOfQuestion.proposalsCount + 1))
128           case None => Future.failed(new Error("Question ID not found"))
129         })
130 
131     /**
132       * Deletes an OperationOfQuestion and all its associated objects:
133       * - The associated Question
134       * - The associated sequence configuration
135       *
136       * @param questionId the operationOfQuestion to delete
137       * @return a future to follow the completion
138       */
139     override def delete(questionId: QuestionId): Future[Unit] = {
140 
141       for {
142         _ <- persistentOperationOfQuestionService.delete(questionId)
143         _ <- persistentSequenceConfigurationService.delete(questionId)
144         _ <- persistentQuestionService.delete(questionId)
145       } yield {}
146 
147     }
148 
149     /**
150       * This function will:
151       * - Create a new question
152       * - Create a new sequence for this question
153       * - Create a new OperationOfQuestion
154       *
155       * @param parameters all needed parameters to create everything
156       * @return the created OperationOfQuestion
157       */
158     override def create(parameters: CreateOperationOfQuestion): Future[OperationOfQuestion] = {
159       val questionId = idGenerator.nextQuestionId()
160       val languages = NonEmptyList.of(parameters.defaultLanguage)
161 
162       val question = Question(
163         questionId = questionId,
164         slug = parameters.slug,
165         countries = parameters.countries,
166         defaultLanguage = parameters.defaultLanguage,
167         languages = languages,
168         questions = Multilingual(parameters.defaultLanguage -> parameters.question),
169         shortTitles = None,
170         operationId = Some(parameters.operationId)
171       )
172 
173       val operationOfQuestion = OperationOfQuestion(
174         questionId = questionId,
175         operationId = parameters.operationId,
176         startDate = parameters.startDate,
177         endDate = parameters.endDate,
178         operationTitles = Multilingual(parameters.defaultLanguage -> parameters.operationTitle),
179         proposalPrefixes = Multilingual(parameters.defaultLanguage -> parameters.proposalPrefix),
180         canPropose = true,
181         sequenceCardsConfiguration = SequenceCardsConfiguration.default,
182         aboutUrls = None,
183         metas = Metas(None, None, None),
184         theme = QuestionTheme.default,
185         descriptions = None,
186         consultationImages = None,
187         consultationImageAlts = None,
188         descriptionImages = None,
189         descriptionImageAlts = None,
190         partnersLogos = None,
191         partnersLogosAlt = None,
192         initiatorsLogos = None,
193         initiatorsLogosAlt = None,
194         consultationHeader = None,
195         consultationHeaderAlts = None,
196         cobrandingLogo = None,
197         cobrandingLogoAlt = None,
198         resultsLink = None,
199         proposalsCount = 0,
200         participantsCount = 0,
201         actions = None,
202         featured = parameters.featured,
203         votesCount = 0,
204         votesTarget = 100_000,
205         timeline = OperationOfQuestionTimeline(None, None, None),
206         createdAt = DateHelper.now(),
207         sessionBindingMode = false,
208         reportUrl = None,
209         actionsUrl = None
210       )
211 
212       val sequenceConfiguration: SequenceConfiguration = createSequenceConfiguration(questionId)
213 
214       for {
215         _         <- persistentQuestionService.persist(question)
216         _         <- persistentSequenceConfigurationService.persist(sequenceConfiguration)
217         persisted <- persistentOperationOfQuestionService.persist(operationOfQuestion)
218         _         <- indexById(questionId)
219       } yield persisted
220     }
221 
222     private def createSequenceConfiguration(questionId: QuestionId) = {
223       def specificSequenceConfigurationId() = idGenerator.nextSpecificSequenceConfigurationId()
224 
225       val mainSequence = ExplorationSequenceConfiguration.default(idGenerator.nextExplorationSequenceConfigurationId())
226       val controversialSequence = SpecificSequenceConfiguration.otherSequenceDefault(specificSequenceConfigurationId())
227       val popularSequence = SpecificSequenceConfiguration.otherSequenceDefault(specificSequenceConfigurationId())
228       val keywordSequence = SpecificSequenceConfiguration.otherSequenceDefault(specificSequenceConfigurationId())
229 
230       val sequenceConfiguration =
231         SequenceConfiguration.default.copy(
232           questionId = questionId,
233           mainSequence = mainSequence,
234           controversial = controversialSequence,
235           popular = popularSequence,
236           keyword = keywordSequence
237         )
238       sequenceConfiguration
239     }
240 
241     override def count(request: SearchOperationsOfQuestions): Future[Int] = {
242       persistentOperationOfQuestionService.count(
243         request.questionIds,
244         request.operationIds,
245         request.openAt,
246         request.endAfter,
247         request.slug
248       )
249     }
250 
251     override def indexById(questionId: QuestionId): Future[Option[IndexationStatus]] = {
252       val immutableFields = elasticsearchOperationOfQuestionAPI
253         .findOperationOfQuestionById(questionId)
254         .map(_.map(_.immutableFields).getOrElse(IndexedOperationOfQuestion.ImmutableFields.empty))
255       val futureIndexedOperationOfQuestion: Future[Option[IndexedOperationOfQuestion]] = (for {
256         question            <- OptionT(questionService.getQuestion(questionId))
257         operationOfQuestion <- OptionT(findByQuestionId(question.questionId))
258         operation           <- OptionT(operationService.findOneSimple(operationOfQuestion.operationId))
259       } yield IndexedOperationOfQuestion.createFromOperationOfQuestion(operationOfQuestion, operation, question)).value
260 
261       futureIndexedOperationOfQuestion.flatMap { ooq =>
262         immutableFields.map(fields => ooq.map(_.applyImmutableFields(fields)))
263       }.flatMap {
264         case None => Future.successful(None)
265         case Some(operationOfQuestion) =>
266           elasticsearchOperationOfQuestionAPI.indexOperationOfQuestion(operationOfQuestion, None).map(Some(_))
267       }
268 
269     }
270 
271     override def getQuestionsInfos(
272       questionIds: Option[Seq[QuestionId]],
273       moderationMode: ModerationMode,
274       minVotesCount: Option[Int],
275       minScore: Option[Double]
276     ): Future[Seq[ModerationOperationOfQuestionInfosResponse]] = {
277       elasticsearchOperationOfQuestionAPI
278         .searchOperationOfQuestions(
279           OperationOfQuestionSearchQuery(
280             filters = Some(
281               OperationOfQuestionSearchFilters(
282                 questionIds = questionIds.map(QuestionIdsSearchFilter),
283                 startDate = Some(StartDateSearchFilter(lte = Some(DateHelper.now()), gte = None)),
284                 endDate = Some(EndDateSearchFilter(lte = None, gte = Some(DateHelper.now().minusWeeks(2)))),
285                 operationKinds = Some(OperationKindsSearchFilter(OperationKind.values))
286               )
287             ),
288             limit = questionIds.map(_.length + 1).orElse(Some(10000)).map(Pagination.Limit(_))
289           )
290         )
291         .flatMap { questions =>
292           val futureProposalToModerateByQuestion = elasticsearchProposalAPI.countProposalsByQuestion(
293             maybeQuestionIds = Some(questions.results.map(_.questionId)),
294             status =
295               if (moderationMode == Enrichment) Some(Seq(ProposalStatus.Accepted))
296               else Some(Seq(ProposalStatus.Pending)),
297             maybeUserId = None,
298             toEnrich = if (moderationMode == Enrichment) Some(true) else None,
299             minVotesCount = if (moderationMode == Enrichment) minVotesCount else None,
300             minScore = if (moderationMode == Enrichment) minScore else None
301           )
302           val futureProposalCountByQuestion = elasticsearchProposalAPI.countProposalsByQuestion(
303             maybeQuestionIds = Some(questions.results.map(_.questionId)),
304             status = Some(ProposalStatus.values),
305             maybeUserId = None,
306             toEnrich = None,
307             minVotesCount = None,
308             minScore = None
309           )
310           val futureHasTags = Future
311             .traverse(questions.results) { q =>
312               tagService.count(tagFilter = TagFilter(questionIds = Some(Seq(q.questionId)))).map(_ > 0).map { hasTags =>
313                 q.questionId -> hasTags
314               }
315             }
316             .map(_.toMap)
317           for {
318             moderateCount <- futureProposalToModerateByQuestion
319             totalCount    <- futureProposalCountByQuestion
320             hasTags       <- futureHasTags
321           } yield {
322             questions.results.map { q =>
323               ModerationOperationOfQuestionInfosResponse(
324                 q,
325                 moderateCount.getOrElse(q.questionId, 0L).toInt,
326                 totalCount.getOrElse(q.questionId, 0L).toInt,
327                 hasTags.getOrElse(q.questionId, false)
328               )
329             }.sortBy(_.proposalToModerateCount * -1)
330           }
331         }
332     }
333 
334   }
335 }