1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2019 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 org.make.api.operation._
23 import org.make.api.post.PostServiceComponent
24 import org.make.api.question.QuestionOfOperationResponse
25 import org.make.api.user.UserServiceComponent
26 import org.make.api.views.HomePageViewResponse.PostResponse
27 import org.make.core.Order
28 import org.make.core.technical.Pagination
29 import org.make.core.operation._
30 import org.make.core.operation.indexed.OperationOfQuestionElasticsearchFieldName
31 import org.make.core.post.indexed.{
32   DisplayHomeSearchFilter,
33   PostCountriesFilter,
34   PostElasticsearchFieldNames,
35   PostSearchFilters,
36   PostSearchQuery
37 }
38 import org.make.core.reference.{Country, Language}
39 import org.make.core.user.UserType
40 
41 import scala.concurrent.ExecutionContext.Implicits.global
42 import scala.concurrent.Future
43 
44 trait DefaultHomeViewServiceComponent extends HomeViewServiceComponent {
45   this: OperationOfQuestionSearchEngineComponent with UserServiceComponent with PostServiceComponent =>
46 
47   override lazy val homeViewService: HomeViewService = new DefaultHomeViewService
48 
49   class DefaultHomeViewService extends HomeViewService {
50 
51     override def getHomePageViewResponse(
52       country: Country,
53       preferredLanguage: Option[Language],
54       postAdditionalCountry: Option[Country]
55     ): Future[HomePageViewResponse] = {
56 
57       def searchQuestionOfOperations(query: OperationOfQuestionSearchQuery): Future[Seq[QuestionOfOperationResponse]] =
58         elasticsearchOperationOfQuestionAPI
59           .searchOperationOfQuestions(
60             query.copy(filters = query.filters.map(_.copy(country = Some(CountrySearchFilter(country)))))
61           )
62           .map(_.results.map(QuestionOfOperationResponse.apply(_, preferredLanguage)))
63 
64       val futurePartnersCount = userService.adminCountUsers(
65         ids = None,
66         email = None,
67         firstName = None,
68         lastName = None,
69         role = None,
70         userType = Some(UserType.UserTypeOrganisation)
71       )
72 
73       val futureOtherCounts = elasticsearchOperationOfQuestionAPI.highlights()
74 
75       val futureCurrentQuestions = searchQuestionOfOperations(
76         OperationOfQuestionSearchQuery(
77           filters =
78             Some(OperationOfQuestionSearchFilters(status = Some(StatusSearchFilter(OperationOfQuestion.Status.Open)))),
79           limit = Some(Pagination.Limit(4)),
80           sortAlgorithm = Some(SortAlgorithm.Featured)
81         )
82       )
83 
84       val futurePastQuestions = searchQuestionOfOperations(
85         OperationOfQuestionSearchQuery(
86           filters = Some(
87             OperationOfQuestionSearchFilters(
88               status = Some(StatusSearchFilter(OperationOfQuestion.Status.Finished)),
89               hasResults = Some(HasResultsSearchFilter)
90             )
91           ),
92           limit = Some(Pagination.Limit(4)),
93           sort = Some(OperationOfQuestionElasticsearchFieldName.endDate),
94           order = Some(Order.desc)
95         )
96       )
97 
98       val futureFeaturedQuestions = searchQuestionOfOperations(
99         OperationOfQuestionSearchQuery(
100           filters = Some(OperationOfQuestionSearchFilters(featured = Some(FeaturedSearchFilter(true)))),
101           sortAlgorithm = Some(SortAlgorithm.Chronological),
102           // MP-1846 force to 15 until the design team comes up with a page working for any number of featured questions
103           limit = Some(Pagination.Limit(15))
104         )
105       )
106 
107       val futurePosts: Future[Seq[PostResponse]] = postService
108         .search(
109           PostSearchQuery(
110             filters = Some(
111               PostSearchFilters(
112                 displayHome = Some(DisplayHomeSearchFilter(true)),
113                 countries = Some(PostCountriesFilter((country :: postAdditionalCountry.toList).toSet.toSeq))
114               )
115             ),
116             sort = Some(PostElasticsearchFieldNames.postDate),
117             order = Some(Order.desc),
118             limit = Some(Pagination.Limit(3))
119           )
120         )
121         .map(_.results.map(HomePageViewResponse.PostResponse.fromIndexedPost))
122 
123       for {
124         partnersCount     <- futurePartnersCount
125         otherCounts       <- futureOtherCounts
126         currentQuestions  <- futureCurrentQuestions
127         pastQuestions     <- futurePastQuestions
128         featuredQuestions <- futureFeaturedQuestions
129         posts             <- futurePosts
130       } yield {
131         HomePageViewResponse(
132           highlights = otherCounts.copy(partnersCount = partnersCount),
133           currentQuestions = currentQuestions,
134           pastQuestions = pastQuestions,
135           featuredQuestions = featuredQuestions,
136           posts = posts
137         )
138       }
139     }
140   }
141 }