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.views
21 
22 import cats.data.NonEmptyList
23 import cats.implicits._
24 import akka.http.scaladsl.server.{Directives, PathMatcher1, Route}
25 import com.sksamuel.elastic4s.requests.searches.suggestion.Fuzziness
26 import grizzled.slf4j.Logging
27 import io.swagger.annotations._
28 
29 import javax.ws.rs.Path
30 import org.make.api.operation._
31 import org.make.api.organisation.{OrganisationServiceComponent, OrganisationsSearchResultResponse}
32 import org.make.api.proposal.ProposalServiceComponent
33 import org.make.api.question.{QuestionServiceComponent, SearchQuestionResponse, SearchQuestionsResponse}
34 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
35 import org.make.api.technical.MakeAuthenticationDirectives
36 import org.make.api.technical.directives.FutureDirectivesExtensions._
37 import org.make.core.auth.UserRights
38 import org.make.core.technical.Pagination
39 import org.make.core.operation._
40 import org.make.core.proposal.{CountrySearchFilter, LanguageSearchFilter, SearchQuery}
41 import org.make.core.reference.{Country, Language}
42 import org.make.core.user.{OrganisationNameSearchFilter, OrganisationSearchFilters, OrganisationSearchQuery}
43 import org.make.core._
44 import scalaoauth2.provider.AuthInfo
45 
46 import scala.concurrent.ExecutionContext.Implicits.global
47 
48 @Api(value = "Home view")
49 @Path(value = "/views")
50 trait ViewApi extends Directives {
51 
52   @ApiOperation(value = "get-home-page-view", httpMethod = "GET", code = HttpCodes.OK)
53   @ApiImplicitParams(
54     value = Array(
55       new ApiImplicitParam(name = "country", paramType = "path", dataType = "string"),
56       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string")
57     )
58   )
59   @ApiResponses(
60     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[HomePageViewResponse]))
61   )
62   @Path(value = "/home-page/{country}")
63   def homePageView: Route
64 
65   @ApiOperation(value = "deprecated-get-home-page-view", httpMethod = "GET", code = HttpCodes.OK)
66   @ApiImplicitParams(
67     value = Array(
68       new ApiImplicitParam(name = "country", paramType = "path", dataType = "string"),
69       new ApiImplicitParam(name = "language", paramType = "path", dataType = "string")
70     )
71   )
72   @ApiResponses(
73     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[HomePageViewResponse]))
74   )
75   @Path(value = "/home-page/{country}/{language}")
76   def homePageViewWithLanguage: Route
77 
78   @ApiOperation(value = "get-search-view", httpMethod = "GET", code = HttpCodes.OK)
79   @ApiImplicitParams(
80     value = Array(
81       new ApiImplicitParam(name = "content", paramType = "query", dataType = "string", required = true),
82       new ApiImplicitParam(
83         name = "proposalLimit",
84         paramType = "query",
85         dataType = "int",
86         allowableValues = "range[0, 30000]"
87       ),
88       new ApiImplicitParam(
89         name = "questionLimit",
90         paramType = "query",
91         dataType = "int",
92         allowableValues = "range[0, 30000]"
93       ),
94       new ApiImplicitParam(
95         name = "organisationLimit",
96         paramType = "query",
97         dataType = "int",
98         allowableValues = "range[0, 30000]"
99       ),
100       new ApiImplicitParam(name = "country", paramType = "query", dataType = "string"),
101       new ApiImplicitParam(name = "language", paramType = "query", dataType = "string"),
102       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string")
103     )
104   )
105   @ApiResponses(
106     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[SearchViewResponse]))
107   )
108   @Path(value = "/search")
109   def searchView: Route
110 
111   @ApiOperation(value = "list-available-countries", httpMethod = "GET", code = HttpCodes.OK)
112   @ApiResponses(
113     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[AvailableCountry]]))
114   )
115   @Path(value = "/countries")
116   def listAvailableCountries: Route
117 
118   def routes: Route = homePageView ~ homePageViewWithLanguage ~ searchView ~ listAvailableCountries
119 }
120 
121 trait ViewApiComponent {
122   def viewApi: ViewApi
123 }
124 
125 trait DefaultViewApiComponent
126     extends ViewApiComponent
127     with MakeAuthenticationDirectives
128     with ParameterExtractors
129     with Logging {
130 
131   this: MakeDirectivesDependencies
132     with HomeViewServiceComponent
133     with OperationOfQuestionServiceComponent
134     with ProposalServiceComponent
135     with OrganisationServiceComponent
136     with QuestionServiceComponent
137     with OperationServiceComponent =>
138 
139   override lazy val viewApi: ViewApi = new DefaultViewApi
140 
141   class DefaultViewApi extends ViewApi {
142 
143     private val country: PathMatcher1[Country] = Segment.map(Country.apply)
144     private val language: PathMatcher1[Language] = Segment.map(Language.apply)
145 
146     override def homePageViewWithLanguage: Route = {
147       get {
148         path("views" / "home-page" / country / language) { (country, language) =>
149           makeOperation("GetHomePageView") { _ =>
150             homeViewService
151               .getHomePageViewResponse(country, Some(language))
152               .asDirective
153               .apply(complete(_))
154           }
155         }
156       }
157     }
158 
159     override def homePageView: Route = {
160       get {
161         path("views" / "home-page" / country) { country =>
162           parameters("preferredLanguage".as[Language].?) { maybePreferedLanguage =>
163             makeOperation("GetHomePageView") { _ =>
164               val excludedCountries = Set(Country("FR"), Country("DE"), Country("BE"))
165               val postAdditionalCountry = Option.when(!excludedCountries(country))(Country("BE"))
166               homeViewService
167                 .getHomePageViewResponse(country, maybePreferedLanguage, postAdditionalCountry)
168                 .asDirective
169                 .apply(complete(_))
170             }
171           }
172         }
173       }
174     }
175 
176     override def searchView: Route = {
177       get {
178         path("views" / "search") {
179           makeOperation("GetSearchView") { requestContext =>
180             optionalMakeOAuth2 { auth: Option[AuthInfo[UserRights]] =>
181               parameters(
182                 "content",
183                 "proposalLimit".as[Pagination.Limit].?,
184                 "questionLimit".as[Pagination.Limit].?,
185                 "organisationLimit".as[Pagination.Limit].?,
186                 "preferredLanguage".as[Language].?,
187                 "country".as[Country].?,
188                 "language".as[Language].?
189               ) { (content, proposalLimit, questionLimit, organisationLimit, preferredLanguage, country, language) =>
190                 val proposalQuery = SearchQuery(
191                   filters = Some(
192                     proposal.SearchFilters(
193                       content = Some(proposal.ContentSearchFilter(content.toLowerCase)),
194                       operationKinds = Some(proposal.OperationKindsSearchFilter(OperationKind.publicKinds)),
195                       country = country.map(CountrySearchFilter.apply),
196                       languages = language.map(l => NonEmptyList.of(LanguageSearchFilter(l)))
197                     )
198                   ),
199                   limit = proposalLimit,
200                   language = requestContext.languageContext.language
201                 )
202                 val questionQuery = OperationOfQuestionSearchQuery(
203                   filters = Some(
204                     OperationOfQuestionSearchFilters(
205                       question = Some(QuestionContentSearchFilter(content.toLowerCase, fuzzy = Some(Fuzziness.Auto))),
206                       operationKinds = Some(operation.OperationKindsSearchFilter(OperationKind.publicKinds)),
207                       country = country.map(operation.CountrySearchFilter.apply),
208                       language = language.map(operation.LanguageSearchFilter.apply)
209                     )
210                   ),
211                   limit = questionLimit
212                 )
213                 val organisationQuery = OrganisationSearchQuery(
214                   filters = Some(
215                     OrganisationSearchFilters(
216                       organisationName = Some(OrganisationNameSearchFilter(content.toLowerCase)),
217                       country = country.map(user.CountrySearchFilter.apply),
218                       language = language.map(user.LanguageSearchFilter.apply)
219                     )
220                   ),
221                   limit = organisationLimit
222                 )
223                 (
224                   proposalService
225                     .searchForUser(auth.map(_.user.userId), proposalQuery, requestContext, preferredLanguage, None)
226                     .asDirective,
227                   operationOfQuestionService.search(questionQuery).asDirective,
228                   organisationService
229                     .searchWithQuery(organisationQuery)
230                     .map(OrganisationsSearchResultResponse.fromOrganisationSearchResult)
231                     .asDirective
232                 ).mapN(
233                     (proposals, questions, organisations) =>
234                       SearchViewResponse(
235                         proposals = proposals,
236                         questions = SearchQuestionsResponse(
237                           total = questions.total,
238                           results = questions.results.map(SearchQuestionResponse.apply(_, preferredLanguage))
239                         ),
240                         organisations = organisations
241                       )
242                   )
243                   .apply(complete(_))
244               }
245             }
246           }
247         }
248       }
249     }
250 
251     override def listAvailableCountries: Route = {
252       get {
253         path("views" / "countries") {
254           makeOperation("ListAvailableCountries") { _ =>
255             val query = OperationOfQuestionSearchQuery(filters = Some(
256               OperationOfQuestionSearchFilters(
257                 operationKinds = Some(operation.OperationKindsSearchFilter(OperationKind.publicKinds)),
258                 status = Some(StatusSearchFilter(OperationOfQuestion.Status.Open, OperationOfQuestion.Status.Finished))
259               )
260             )
261             )
262             operationOfQuestionService
263               .count(query)
264               .flatMap(
265                 count =>
266                   operationOfQuestionService
267                     .search(query.copy(limit = Some(Pagination.Limit(count.toInt))))
268                     .map(
269                       _.results
270                         .flatMap(
271                           ooq =>
272                             ooq.countries
273                               .map(_.value)
274                               .toList
275                               .zip(LazyList.continually(ooq.status == OperationOfQuestion.Status.Open))
276                         )
277                         .foldLeft(Map.empty[String, AvailableCountry]) {
278                           case (map, (country, open)) =>
279                             map.updatedWith(country)(
280                               existing =>
281                                 Some(AvailableCountry(country, open || existing.exists(_.activeConsultations)))
282                             )
283                         }
284                         .values
285                     )
286               )
287               .asDirective
288               .apply(complete(_))
289           }
290         }
291       }
292     }
293   }
294 
295 }