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.organisation
21 
22 import cats.implicits._
23 import akka.http.scaladsl.server._
24 import akka.http.scaladsl.unmarshalling.Unmarshaller._
25 import grizzled.slf4j.Logging
26 import io.swagger.annotations._
27 import org.make.api.operation.OperationServiceComponent
28 
29 import javax.ws.rs.Path
30 import org.make.api.proposal.{
31   ProposalServiceComponent,
32   ProposalsResultSeededResponse,
33   ProposalsResultWithUserVoteSeededResponse
34 }
35 import org.make.api.question.QuestionServiceComponent
36 import org.make.api.technical.MakeAuthenticationDirectives
37 import org.make.api.technical.CsvReceptacle._
38 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
39 import org.make.api.technical.directives.FutureDirectivesExtensions._
40 import org.make.api.user.UserResponse
41 import org.make.core.auth.UserRights
42 import org.make.core.technical.Pagination
43 import org.make.core.common.indexed.Sort
44 import org.make.core.operation.OperationKind
45 import org.make.core.profile.Profile
46 import org.make.core.proposal.indexed.ProposalElasticsearchFieldName
47 import org.make.core.proposal._
48 import org.make.core.reference.{Country, Language}
49 import org.make.core.user.UserId
50 import org.make.core.{HttpCodes, Order, ParameterExtractors}
51 import scalaoauth2.provider.AuthInfo
52 
53 @Api(value = "Organisations")
54 @Path(value = "/organisations")
55 trait OrganisationApi extends Directives {
56 
57   @ApiOperation(value = "get-organisation", httpMethod = "GET", code = HttpCodes.OK)
58   @ApiImplicitParams(
59     value = Array(new ApiImplicitParam(name = "organisationId", paramType = "path", dataType = "string"))
60   )
61   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[UserResponse])))
62   @Path(value = "/{organisationId}")
63   def getOrganisation: Route
64 
65   @ApiOperation(value = "get-organisation-profile", httpMethod = "GET", code = HttpCodes.OK)
66   @ApiImplicitParams(
67     value = Array(new ApiImplicitParam(name = "organisationId", paramType = "path", dataType = "string"))
68   )
69   @ApiResponses(
70     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[OrganisationProfileResponse]))
71   )
72   @Path(value = "/{organisationId}/profile")
73   def getOrganisationProfile: Route
74 
75   @ApiOperation(value = "get-organisations", httpMethod = "GET", code = HttpCodes.OK)
76   @ApiImplicitParams(
77     value = Array(
78       new ApiImplicitParam(name = "organisationIds", paramType = "query", dataType = "string"),
79       new ApiImplicitParam(name = "organisationName", paramType = "query", dataType = "string"),
80       new ApiImplicitParam(name = "slug", paramType = "query", dataType = "string"),
81       new ApiImplicitParam(name = "country", paramType = "query", dataType = "string"),
82       new ApiImplicitParam(name = "language", paramType = "query", dataType = "string")
83     )
84   )
85   @ApiResponses(
86     value =
87       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[OrganisationsSearchResultResponse]))
88   )
89   def getOrganisations: Route
90 
91   @ApiOperation(value = "get-organisation-proposals", httpMethod = "GET", code = HttpCodes.OK)
92   @ApiImplicitParams(
93     value = Array(
94       new ApiImplicitParam(name = "organisationId", paramType = "path", dataType = "string"),
95       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string", example = "fr"),
96       new ApiImplicitParam(
97         name = "sort",
98         paramType = "query",
99         dataType = "string",
100         example = "createdAt",
101         allowableValues = ProposalElasticsearchFieldName.swaggerAllowableValues
102       ),
103       new ApiImplicitParam(
104         name = "order",
105         paramType = "query",
106         dataType = "string",
107         allowableValues = Order.swaggerAllowableValues
108       ),
109       new ApiImplicitParam(
110         name = "limit",
111         paramType = "query",
112         dataType = "int",
113         allowableValues = "range[0, infinity]"
114       ),
115       new ApiImplicitParam(name = "skip", paramType = "query", dataType = "int", allowableValues = "range[0, infinity]")
116     )
117   )
118   @ApiResponses(
119     value =
120       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ProposalsResultSeededResponse]))
121   )
122   @Path(value = "/{organisationId}/proposals")
123   def getOrganisationProposals: Route
124 
125   @ApiOperation(value = "get-organisation-votes", httpMethod = "GET", code = HttpCodes.OK)
126   @ApiImplicitParams(
127     value = Array(
128       new ApiImplicitParam(name = "organisationId", paramType = "path", dataType = "string"),
129       new ApiImplicitParam(
130         name = "votes",
131         paramType = "query",
132         dataType = "string",
133         allowableValues = VoteKey.swaggerAllowableValues,
134         allowMultiple = true
135       ),
136       new ApiImplicitParam(
137         name = "qualifications",
138         paramType = "query",
139         dataType = "string",
140         allowableValues = QualificationKey.swaggerAllowableValues,
141         allowMultiple = true
142       ),
143       new ApiImplicitParam(
144         name = "sort",
145         paramType = "query",
146         dataType = "string",
147         example = "createdAt",
148         allowableValues = ProposalElasticsearchFieldName.swaggerAllowableValues
149       ),
150       new ApiImplicitParam(
151         name = "order",
152         paramType = "query",
153         dataType = "string",
154         allowableValues = Order.swaggerAllowableValues
155       ),
156       new ApiImplicitParam(
157         name = "limit",
158         paramType = "query",
159         dataType = "int",
160         allowableValues = "range[0, infinity]"
161       ),
162       new ApiImplicitParam(name = "skip", paramType = "query", dataType = "int", allowableValues = "range[0, infinity]")
163     )
164   )
165   @ApiResponses(
166     value = Array(
167       new ApiResponse(
168         code = HttpCodes.OK,
169         message = "Ok",
170         response = classOf[ProposalsResultWithUserVoteSeededResponse]
171       )
172     )
173   )
174   @Path(value = "/{organisationId}/votes")
175   def getOrganisationVotes: Route
176 
177   @ApiOperation(
178     value = "update-organisation-profile",
179     httpMethod = "PUT",
180     authorizations = Array(
181       new Authorization(
182         value = "MakeApi",
183         scopes = Array(new AuthorizationScope(scope = "user", description = "application user"))
184       )
185     )
186   )
187   @ApiResponses(
188     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[OrganisationProfileResponse]))
189   )
190   @ApiImplicitParams(
191     value = Array(
192       new ApiImplicitParam(name = "organisationId", paramType = "path", dataType = "string"),
193       new ApiImplicitParam(
194         value = "body",
195         paramType = "body",
196         dataType = "org.make.api.organisation.OrganisationProfileRequest"
197       )
198     )
199   )
200   @Path(value = "/{organisationId}/profile")
201   def updateProfile: Route
202 
203   def routes: Route =
204     getOrganisation ~ getOrganisations ~ getOrganisationProposals ~ getOrganisationVotes ~ getOrganisationProfile ~ updateProfile
205 
206 }
207 
208 trait OrganisationApiComponent {
209   def organisationApi: OrganisationApi
210 }
211 
212 trait DefaultOrganisationApiComponent
213     extends OrganisationApiComponent
214     with MakeAuthenticationDirectives
215     with Logging
216     with ParameterExtractors {
217 
218   this: MakeDirectivesDependencies
219     with OrganisationServiceComponent
220     with ProposalServiceComponent
221     with QuestionServiceComponent
222     with OperationServiceComponent =>
223 
224   override lazy val organisationApi: OrganisationApi = new DefaultOrganisationApi
225 
226   class DefaultOrganisationApi extends OrganisationApi {
227     val organisationId: PathMatcher1[UserId] = Segment.map(id => UserId(id))
228 
229     override def getOrganisation: Route =
230       get {
231         path("organisations" / organisationId) { organisationId =>
232           makeOperation("GetOrganisation") { _ =>
233             organisationService.getOrganisation(organisationId).asDirectiveOrNotFound { user =>
234               complete(UserResponse(user))
235             }
236           }
237         }
238       }
239 
240     override def getOrganisationProfile: Route = {
241       get {
242         path("organisations" / organisationId / "profile") { organisationId =>
243           makeOperation("GetOrganisationProfile") { _ =>
244             organisationService.getOrganisation(organisationId).asDirectiveOrNotFound { organisation =>
245               complete(
246                 OrganisationProfileResponse(
247                   organisationName = organisation.organisationName,
248                   avatarUrl = organisation.profile.flatMap(_.avatarUrl),
249                   description = organisation.profile.flatMap(_.description),
250                   website = organisation.profile.flatMap(_.website),
251                   optInNewsletter = organisation.profile.forall(_.optInNewsletter),
252                   crmCountry = organisation.profile.map(_.crmCountry),
253                   crmLanguage = organisation.profile.map(_.crmLanguage)
254                 )
255               )
256             }
257           }
258         }
259       }
260     }
261 
262     override def getOrganisations: Route =
263       get {
264         path("organisations") {
265           makeOperation("GetOrganisations") { _ =>
266             parameters(
267               "organisationIds".as[Seq[UserId]].?,
268               "organisationName".as[String].?,
269               "slug".as[String].?,
270               "country".as[Country].?,
271               "language".as[Language].?
272             ) {
273               (
274                 organisationIds: Option[Seq[UserId]],
275                 organisationName: Option[String],
276                 slug: Option[String],
277                 country: Option[Country],
278                 language: Option[Language]
279               ) =>
280                 organisationService
281                   .search(organisationName, slug, organisationIds, country, language)
282                   .asDirective(
283                     results => complete(OrganisationsSearchResultResponse.fromOrganisationSearchResult(results))
284                   )
285             }
286           }
287         }
288       }
289 
290     override def getOrganisationProposals: Route =
291       get {
292         path("organisations" / organisationId / "proposals") { organisationId =>
293           makeOperation("GetOrganisationProposals") { requestContext =>
294             optionalMakeOAuth2 { optionalUserAuth: Option[AuthInfo[UserRights]] =>
295               parameters(
296                 "preferredLanguage".as[Language].?,
297                 "sort".?,
298                 "order".as[Order].?,
299                 "limit".as[Pagination.Limit].?,
300                 "skip".as[Pagination.Offset].?
301               ) {
302                 (
303                   preferredLanguage: Option[Language],
304                   sort: Option[String],
305                   order: Option[Order],
306                   limit: Option[Pagination.Limit],
307                   offset: Option[Pagination.Offset]
308                 ) =>
309                   val defaultSort = Some("createdAt")
310                   val defaultOrder = Some(Order.desc)
311                   (
312                     organisationService.getOrganisation(organisationId).asDirectiveOrNotFound.void,
313                     proposalService
314                       .searchForUser(
315                         optionalUserAuth.map(_.user.userId),
316                         SearchQuery(
317                           filters = Some(
318                             SearchFilters(
319                               users = Some(UserSearchFilter(Seq(organisationId))),
320                               operationKinds = Some(OperationKindsSearchFilter(OperationKind.publicKinds))
321                             )
322                           ),
323                           excludes = optionalUserAuth.map(_.user.userId) match {
324                             case Some(userId) if userId == organisationId => None
325                             case _                                        => Some(SearchFilters(isAnonymous = Some(IsAnonymousSearchFiler(true))))
326                           },
327                           sort = Some(
328                             Sort(field = sort.orElse(defaultSort), mode = order.orElse(defaultOrder).map(_.sortOrder))
329                           ),
330                           limit = limit,
331                           offset = offset
332                         ),
333                         requestContext,
334                         preferredLanguage,
335                         None
336                       )
337                       .asDirective
338                   ).mapN((_, proposalsResponse) => proposalsResponse).apply(complete(_))
339               }
340             }
341           }
342         }
343       }
344 
345     override def getOrganisationVotes: Route =
346       get {
347         path("organisations" / organisationId / "votes") { organisationId =>
348           makeOperation("GetOrganisationVotes") { requestContext =>
349             optionalMakeOAuth2 { userAuth: Option[AuthInfo[UserRights]] =>
350               organisationService.getOrganisation(organisationId).asDirectiveOrNotFound { _ =>
351                 parameters(
352                   "votes".csv[VoteKey],
353                   "qualifications".csv[QualificationKey],
354                   "sort".?,
355                   "order".as[Order].?,
356                   "limit".as[Pagination.Limit].?,
357                   "skip".as[Pagination.Offset].?
358                 ) {
359                   (
360                     votes: Option[Seq[VoteKey]],
361                     qualifications: Option[Seq[QualificationKey]],
362                     sort: Option[String],
363                     order: Option[Order],
364                     limit: Option[Pagination.Limit],
365                     offset: Option[Pagination.Offset]
366                   ) =>
367                     val defaultSort = Some("createdAt")
368                     val defaultOrder = Some(Order.desc)
369                     onSuccess(
370                       organisationService.getVotedProposals(
371                         organisationId = organisationId,
372                         maybeUserId = userAuth.map(_.user.userId),
373                         filterVotes = votes,
374                         filterQualifications = qualifications,
375                         sort = Some(
376                           Sort(field = sort.orElse(defaultSort), mode = order.orElse(defaultOrder).map(_.sortOrder))
377                         ),
378                         limit = limit,
379                         offset = offset,
380                         requestContext = requestContext
381                       )
382                     ) { proposals =>
383                       complete(proposals)
384                     }
385                 }
386               }
387             }
388           }
389         }
390       }
391 
392     override def updateProfile: Route = {
393       put {
394         path("organisations" / organisationId / "profile") { organisationId =>
395           makeOperation("UpdateOrganisationProfile") { requestContext =>
396             makeOAuth2 { user =>
397               authorize(user.user.userId == organisationId) {
398                 decodeRequest {
399                   entity(as[OrganisationProfileRequest]) { request =>
400                     organisationService.getOrganisation(organisationId).asDirectiveOrNotFound { organisation =>
401                       val modifiedProfile = organisation.profile
402                         .orElse(Profile.parseProfile())
403                         .map(
404                           _.copy(
405                             avatarUrl = request.avatarUrl.map(_.value),
406                             description = request.description,
407                             website = request.website.map(_.value),
408                             optInNewsletter = request.optInNewsletter,
409                             crmCountry = request.crmCountry.getOrElse(Country("FR")),
410                             crmLanguage = request.crmLanguage.getOrElse(Language("fr"))
411                           )
412                         )
413 
414                       val modifiedOrganisation =
415                         organisation.copy(profile = modifiedProfile, organisationName = Some(request.organisationName))
416 
417                       organisationService
418                         .update(
419                           organisation = modifiedOrganisation,
420                           moderatorId = None,
421                           oldEmail = modifiedOrganisation.email,
422                           requestContext = requestContext
423                         )
424                         .asDirective { _ =>
425                           complete(
426                             OrganisationProfileResponse(
427                               organisationName = modifiedOrganisation.organisationName,
428                               avatarUrl = modifiedOrganisation.profile.flatMap(_.avatarUrl),
429                               description = modifiedOrganisation.profile.flatMap(_.description),
430                               website = modifiedOrganisation.profile.flatMap(_.website),
431                               optInNewsletter = modifiedOrganisation.profile.forall(_.optInNewsletter),
432                               crmCountry = modifiedOrganisation.profile.map(_.crmCountry),
433                               crmLanguage = modifiedOrganisation.profile.map(_.crmLanguage)
434                             )
435                           )
436                         }
437                     }
438                   }
439                 }
440               }
441             }
442           }
443         }
444       }
445     }
446   }
447 }