1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2020 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.technical.graphql
21 
22 import java.time.ZonedDateTime
23 import cats.Id
24 import cats.data.NonEmptyList
25 import org.make.api.operation.{OperationOfQuestionServiceComponent, SearchOperationsOfQuestions}
26 import org.make.api.question.{QuestionServiceComponent, SimpleQuestionWordingResponse}
27 import org.make.core.question.QuestionId
28 import org.make.core.technical.MultilingualType
29 import org.make.core.reference.{Country, Language}
30 import zio.query.DataSource
31 
32 import scala.concurrent.{ExecutionContext, Future}
33 
34 trait GraphQLQuestionServiceComponent {
35   def questionDataSource: DataSource[Any, GetQuestion]
36 }
37 
38 trait DefaultGraphQLQuestionServiceComponent extends GraphQLQuestionServiceComponent {
39   this: QuestionServiceComponent with OperationOfQuestionServiceComponent =>
40 
41   override val questionDataSource: DataSource[Any, GetQuestion] = {
42     def findFromIds(
43       questionIds: Seq[QuestionId]
44     )(executionContext: ExecutionContext): Future[Map[QuestionId, GraphQLQuestion]] = {
45       implicit val ec: ExecutionContext = executionContext
46       for {
47         questions <- questionService.getQuestions(questionIds)
48         ooqs      <- operationOfQuestionService.find(request = SearchOperationsOfQuestions(questionIds = Some(questionIds)))
49       } yield {
50         val questionMap = questions.map(q => q.questionId -> q).toMap
51         val ooqMap = ooqs.map(ooq         => ooq.questionId -> ooq).toMap
52         questionMap.keys.toSeq.flatMap { questionId =>
53           for {
54             question <- questionMap.get(questionId)
55             ooq      <- ooqMap.get(questionId)
56           } yield questionId -> GraphQLQuestion(
57             questionId = questionId,
58             slug = question.slug,
59             wording = SimpleQuestionWordingResponse(
60               title = ooq.operationTitles.getTranslationUnsafe(question.defaultLanguage),
61               question = question.questions.getTranslationUnsafe(question.defaultLanguage)
62             ),
63             countries = question.countries,
64             defaultLanguage = question.defaultLanguage,
65             languages = question.languages,
66             startDate = ooq.startDate,
67             endDate = ooq.endDate
68           )
69         }.toMap
70       }
71     }
72 
73     DataSourceHelper.one("questions-datasource", findFromIds)
74   }
75 }
76 final case class GetQuestion(ids: QuestionId) extends IdsRequest[Id, QuestionId, GraphQLQuestion]
77 
78 final case class GraphQLQuestion(
79   questionId: QuestionId,
80   slug: String,
81   wording: SimpleQuestionWordingResponse,
82   countries: NonEmptyList[Country],
83   defaultLanguage: Language,
84   languages: NonEmptyList[Language],
85   startDate: ZonedDateTime,
86   endDate: ZonedDateTime
87 ) extends MultilingualType