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 
24 import cats.data.NonEmptyList
25 import enumeratum.{Circe, Enum, EnumEntry}
26 import io.circe.Decoder
27 import org.make.api.proposal.{ContextFilterRequest, ProposalContextResponse, ProposalResponse, VoteResponse}
28 import org.make.api.technical.MakeRandom
29 import org.make.api.technical.graphql.GraphQLRuntimeComponent.RuntimeType
30 import org.make.core.common.indexed.Sort
31 import org.make.core.idea.IdeaId
32 import org.make.core.operation.{OperationId, OperationKind}
33 import org.make.core.proposal._
34 import org.make.core.proposal.indexed.ProposalElasticsearchFieldName
35 import org.make.core.question.QuestionId
36 import org.make.core.reference.{Country, Language}
37 import org.make.core.tag.TagId
38 import org.make.core.user.UserType
39 import org.make.core.{Order, RequestContext}
40 import zio.RIO
41 import zio.query.{DataSource, ZQuery}
42 import org.make.core.technical.Pagination
43 
44 final case class GraphQLProposal(
45   id: ProposalId,
46   content: String,
47   slug: String,
48   status: ProposalStatus,
49   createdAt: ZonedDateTime,
50   updatedAt: Option[ZonedDateTime],
51   myProposal: Boolean,
52   votes: Seq[VoteResponse],
53   context: Option[ProposalContextResponse],
54   proposalKey: String,
55   author: Option[ZQuery[Any, Throwable, GraphQLAuthor]],
56   question: Option[ZQuery[Any, Throwable, GraphQLQuestion]],
57   organisations: ZQuery[Any, Throwable, Seq[GraphQLOrganisation]],
58   tags: ZQuery[Any, Throwable, Seq[GraphQLTag]],
59   selectedStakeTag: Option[GraphQLTag],
60   idea: Option[ZQuery[Any, Throwable, GraphQLIdea]]
61 )
62 
63 object GraphQLProposal {
64 
65   def fromProposalResponse(proposal: ProposalResponse)(
66     userDataSource: DataSource[Any, GetAuthor],
67     questionDataSource: DataSource[Any, GetQuestion],
68     organisationDataSource: DataSource[Any, GetOrganisations],
69     tagDataSource: DataSource[Any, GetTags],
70     ideaDataSource: DataSource[Any, GetIdea]
71   ): GraphQLProposal = {
72     GraphQLProposal(
73       id = proposal.id,
74       content = proposal.content,
75       slug = proposal.slug,
76       status = proposal.status,
77       createdAt = proposal.createdAt,
78       updatedAt = proposal.updatedAt,
79       myProposal = proposal.myProposal,
80       votes = proposal.votes,
81       context = proposal.context,
82       proposalKey = proposal.proposalKey,
83       author = proposal.author.map(u => ZQuery.fromRequest(GetAuthor(u.userId))(userDataSource)),
84       question = proposal.question.map { question =>
85         ZQuery.fromRequest(GetQuestion(question.questionId))(questionDataSource)
86       },
87       organisations = ZQuery
88         .fromRequest(GetOrganisations(proposal.organisations.map(_.organisationId).toList))(organisationDataSource),
89       tags = ZQuery.fromRequest(GetTags(proposal.tags.map(_.tagId).toList))(tagDataSource),
90       selectedStakeTag = proposal.selectedStakeTag.map(GraphQLTag.fromTag),
91       idea = proposal.idea.map { ideaId =>
92         ZQuery.fromRequest(GetIdea(ideaId))(ideaDataSource)
93       }
94     )
95   }
96 }
97 
98 object GraphQLProposalQuery {
99 
100   sealed abstract class ProposalSortableFieldNames(val value: String) extends EnumEntry
101 
102   object ProposalSortableFieldNames extends Enum[ProposalSortableFieldNames] {
103 
104     case object Slug extends ProposalSortableFieldNames(ProposalElasticsearchFieldName.slug.value)
105     case object CreatedAt extends ProposalSortableFieldNames(ProposalElasticsearchFieldName.createdAt.value)
106     case object UpdatedAt extends ProposalSortableFieldNames(ProposalElasticsearchFieldName.updatedAt.value)
107     case object Country extends ProposalSortableFieldNames(ProposalElasticsearchFieldName.country.value)
108     case object Language extends ProposalSortableFieldNames(ProposalElasticsearchFieldName.language.value)
109     case object TopScoreAjustedWithVotes
110         extends ProposalSortableFieldNames(ProposalElasticsearchFieldName.scoreLowerBound.value)
111 
112     override val values: IndexedSeq[ProposalSortableFieldNames] = findValues
113     implicit val decoder: Decoder[ProposalSortableFieldNames] = Circe.decodeCaseInsensitive(this)
114 
115   }
116 
117   final case class ProposalSearchParams(
118     proposalIds: Option[Seq[ProposalId]],
119     questionIds: Option[Seq[QuestionId]],
120     tagsIds: Option[Seq[TagId]],
121     operationId: Option[OperationId],
122     content: Option[String],
123     slug: Option[String],
124     seed: Option[Int],
125     source: Option[String],
126     location: Option[String],
127     question: Option[String],
128     languages: Option[NonEmptyList[Language]],
129     country: Option[Country],
130     sort: Option[ProposalSortableFieldNames],
131     order: Option[Order],
132     limit: Option[Pagination.Limit],
133     offset: Option[Pagination.Offset],
134     sortAlgorithm: Option[AlgorithmSelector],
135     operationKinds: Option[Seq[OperationKind]],
136     userTypes: Option[Seq[UserType]],
137     ideaIds: Option[Seq[IdeaId]]
138   ) {
139     def toSearchQuery(requestContext: RequestContext): SearchQuery = {
140       val context: Option[ContextFilterRequest] = ContextFilterRequest.parse(operationId, source, location, question)
141 
142       val filters: Option[SearchFilters] =
143         SearchFilters.parse(
144           proposals = proposalIds.map(ProposalSearchFilter.apply),
145           tags = tagsIds.map(TagsSearchFilter.apply),
146           operation = operationId.map(opId => OperationSearchFilter(Seq(opId))),
147           question = questionIds.map(QuestionSearchFilter.apply),
148           content = content.map(ContentSearchFilter.apply),
149           slug = slug.map(value => SlugSearchFilter(value)),
150           context = context.map(_.toContext),
151           languages = languages.map(_.map(LanguageSearchFilter.apply)),
152           country = country.map(CountrySearchFilter.apply),
153           operationKinds = operationKinds.map(OperationKindsSearchFilter.apply),
154           userTypes = userTypes.map(UserTypesSearchFilter.apply),
155           idea = ideaIds.map(IdeaSearchFilter.apply)
156         )
157 
158       SearchQuery(
159         filters = filters,
160         sort = Sort.parse(sort.map(_.value), order),
161         limit = limit,
162         offset = offset,
163         language = requestContext.languageContext.language,
164         sortAlgorithm = sortAlgorithm.map(_.build(seed.getOrElse(MakeRandom.nextInt())))
165       )
166     }
167   }
168 
169   final case class GraphQLProposalQueries(search: ProposalSearchParams => RIO[RuntimeType, Seq[GraphQLProposal]])
170 
171 }