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 com.github.t3hnar.bcrypt._
23 import org.make.api.extensions.MakeSettingsComponent
24 import org.make.api.proposal.PublishedProposalEvent.ReindexProposal
25 import org.make.api.proposal._
26 import org.make.api.technical.auth.UserTokenGeneratorComponent
27 import org.make.api.technical.{EventBusServiceComponent, IdGeneratorComponent, ShortenedNames}
28 import org.make.api.user.UserExceptions.EmailAlreadyRegisteredException
29 import org.make.api.user.{PersistentUserServiceComponent, UserServiceComponent}
30 import org.make.api.userhistory.{
31   OrganisationEmailChangedEvent,
32   OrganisationRegisteredEvent,
33   OrganisationUpdatedEvent,
34   RequestUserVotedProposals,
35   UserHistoryCoordinatorServiceComponent
36 }
37 import org.make.core.technical.Pagination
38 import org.make.core.common.indexed.Sort
39 import org.make.core.history.HistoryActions
40 import org.make.core.operation.OperationKind
41 import org.make.core.profile.Profile
42 import org.make.core.proposal.{CountrySearchFilter => _, LanguageSearchFilter => _, _}
43 import org.make.core.reference.{Country, Language}
44 import org.make.core.user._
45 import org.make.core.user.indexed.OrganisationSearchResult
46 import org.make.core.{user, DateHelper, Order, RequestContext}
47 
48 import scala.concurrent.ExecutionContext.Implicits.global
49 import scala.concurrent.Future
50 
51 trait DefaultOrganisationServiceComponent extends OrganisationServiceComponent with ShortenedNames {
52   this: IdGeneratorComponent
53     with UserServiceComponent
54     with PersistentUserServiceComponent
55     with EventBusServiceComponent
56     with UserHistoryCoordinatorServiceComponent
57     with ProposalServiceComponent
58     with ProposalSearchEngineComponent
59     with OrganisationSearchEngineComponent
60     with UserTokenGeneratorComponent
61     with MakeSettingsComponent =>
62 
63   override lazy val organisationService: OrganisationService = new DefaultOrganisationService
64 
65   class DefaultOrganisationService extends OrganisationService {
66 
67     val resetTokenB2BExpiresIn: Long = makeSettings.resetTokenB2BExpiresIn.toSeconds
68 
69     override def getOrganisation(userId: UserId): Future[Option[User]] = {
70       persistentUserService.findByUserIdAndUserType(userId, UserType.UserTypeOrganisation)
71     }
72 
73     override def getOrganisations: Future[Seq[User]] = {
74       persistentUserService.findAllOrganisations()
75     }
76 
77     /**
78       * This method fetch the organisations from cockroach
79       * start and end are here to paginate the result
80       * sort and order are here to sort the result
81       */
82     override def find(
83       offset: Pagination.Offset,
84       end: Option[Pagination.End],
85       sort: Option[String],
86       order: Option[Order],
87       ids: Option[Seq[UserId]],
88       organisationName: Option[String]
89     ): Future[Seq[User]] = {
90       persistentUserService.findOrganisations(offset, end, sort, order, ids, organisationName)
91     }
92 
93     override def count(ids: Option[Seq[UserId]], organisationName: Option[String]): Future[Int] = {
94       persistentUserService.countOrganisations(ids, organisationName)
95     }
96 
97     /**
98       * This method fetch the organisations from elasticsearch
99       * organisations can be search by name or slug
100       */
101     override def search(
102       organisationName: Option[String],
103       slug: Option[String],
104       organisationIds: Option[Seq[UserId]],
105       country: Option[Country],
106       language: Option[Language]
107     ): Future[OrganisationSearchResult] = {
108       elasticsearchOrganisationAPI.searchOrganisations(
109         OrganisationSearchQuery(filters = OrganisationSearchFilters
110           .parse(
111             organisationName = organisationName.map(orgaName => OrganisationNameSearchFilter(orgaName)),
112             slug = slug.map(user.SlugSearchFilter.apply),
113             organisationIds = organisationIds.map(OrganisationIdsSearchFilter.apply),
114             country = country.map(CountrySearchFilter.apply),
115             language = language.map(LanguageSearchFilter.apply)
116           )
117         )
118       )
119     }
120 
121     override def searchWithQuery(query: OrganisationSearchQuery): Future[OrganisationSearchResult] = {
122       elasticsearchOrganisationAPI.searchOrganisations(query)
123     }
124 
125     private def registerOrganisation(
126       organisationRegisterData: OrganisationRegisterData,
127       lowerCasedEmail: String,
128       country: Country,
129       language: Language,
130       resetToken: String
131     ): Future[User] = {
132       val user = User(
133         userId = idGenerator.nextUserId(),
134         email = lowerCasedEmail,
135         firstName = None,
136         lastName = None,
137         organisationName = Some(organisationRegisterData.name),
138         lastIp = None,
139         hashedPassword = organisationRegisterData.password.map(_.boundedBcrypt),
140         enabled = true,
141         emailVerified = true,
142         userType = UserType.UserTypeOrganisation,
143         lastConnection = None,
144         verificationToken = None,
145         verificationTokenExpiresAt = None,
146         resetToken = Some(resetToken),
147         resetTokenExpiresAt = Some(DateHelper.now().plusSeconds(resetTokenB2BExpiresIn)),
148         roles = Seq(Role.RoleActor),
149         country = country,
150         language = language,
151         profile = Profile.parseProfile(
152           avatarUrl = organisationRegisterData.avatar,
153           description = organisationRegisterData.description,
154           optInNewsletter = false,
155           website = organisationRegisterData.website,
156           crmCountry = country,
157           crmLanguage = language
158         ),
159         publicProfile = true,
160         availableQuestions = Seq.empty,
161         availableEvents = Seq.empty,
162         privacyPolicyApprovalDate = Some(DateHelper.now())
163       )
164       persistentUserService.persist(user)
165     }
166 
167     override def register(
168       organisationRegisterData: OrganisationRegisterData,
169       requestContext: RequestContext
170     ): Future[User] = {
171 
172       val trimmedRegisterData = organisationRegisterData.trim
173       val country = trimmedRegisterData.country
174       val language = trimmedRegisterData.language
175       val lowerCasedEmail: String = trimmedRegisterData.email.toLowerCase()
176 
177       val result = for {
178         emailExists <- persistentUserService.emailExists(lowerCasedEmail)
179         _           <- verifyEmail(lowerCasedEmail, emailExists)
180         resetToken  <- userTokenGenerator.generateResetToken().map { case (_, token) => token }
181         user        <- registerOrganisation(trimmedRegisterData, lowerCasedEmail, country, language, resetToken)
182       } yield user
183 
184       result.map { user =>
185         eventBusService.publish(
186           OrganisationRegisteredEvent(
187             connectedUserId = Some(user.userId),
188             userId = user.userId,
189             requestContext = requestContext,
190             email = user.email,
191             country = user.country,
192             eventDate = DateHelper.now(),
193             eventId = Some(idGenerator.nextEventId())
194           )
195         )
196         user
197       }
198     }
199 
200     private def updateProposalsFromOrganisation(
201       organisationId: UserId,
202       requestContext: RequestContext
203     ): Future[Unit] = {
204       for {
205         _ <- getVotedProposals(
206           organisationId,
207           maybeUserId = None,
208           filterVotes = None,
209           filterQualifications = None,
210           sort = None,
211           limit = None,
212           offset = None,
213           requestContext
214         ).map(
215           result =>
216             result.results.foreach(
217               proposalWithVote =>
218                 eventBusService
219                   .publish(
220                     ReindexProposal(
221                       proposalWithVote.proposal.id,
222                       DateHelper.now(),
223                       requestContext,
224                       Some(idGenerator.nextEventId())
225                     )
226                   )
227             )
228         )
229         _ <- elasticsearchProposalAPI
230           .searchProposals(searchQuery = SearchQuery(filters = Some(
231             SearchFilters(
232               users = Some(UserSearchFilter(userIds = Seq(organisationId))),
233               status = Some(StatusSearchFilter(ProposalStatus.values.filter(_ != ProposalStatus.Archived)))
234             )
235           )
236           )
237           )
238           .map(
239             result =>
240               result.results.foreach(
241                 proposal =>
242                   eventBusService
243                     .publish(
244                       ReindexProposal(proposal.id, DateHelper.now(), requestContext, Some(idGenerator.nextEventId()))
245                     )
246               )
247           )
248       } yield {}
249     }
250 
251     private def updateOrganisationEmail(
252       organisation: User,
253       moderatorId: Option[UserId],
254       newEmail: Option[String],
255       oldEmail: String,
256       requestContext: RequestContext
257     ): Future[Unit] = {
258       newEmail match {
259         case Some(email) =>
260           Future {
261             eventBusService.publish(
262               OrganisationEmailChangedEvent(
263                 connectedUserId = moderatorId,
264                 userId = organisation.userId,
265                 requestContext = requestContext,
266                 country = organisation.country,
267                 eventDate = DateHelper.now(),
268                 oldEmail = oldEmail,
269                 newEmail = email,
270                 eventId = Some(idGenerator.nextEventId())
271               )
272             )
273           }
274         case None => Future.unit
275       }
276     }
277 
278     override def update(
279       organisation: User,
280       moderatorId: Option[UserId],
281       oldEmail: String,
282       requestContext: RequestContext
283     ): Future[UserId] = {
284 
285       val newEmail: Option[String] = organisation.email.trim match {
286         case email if email.toLowerCase == oldEmail.toLowerCase => None
287         case email                                              => Some(email)
288       }
289 
290       for {
291         emailExists <- updateMailExists(newEmail.map(_.toLowerCase))
292         _           <- verifyEmail(organisation.email.toLowerCase, emailExists)
293         update <- persistentUserService.modifyOrganisation(organisation).flatMap {
294           case Right(orga) =>
295             updateOrganisationEmail(organisation, moderatorId, newEmail, oldEmail, requestContext).flatMap { _ =>
296               updateProposalsFromOrganisation(orga.userId, requestContext).flatMap { _ =>
297                 eventBusService.publish(
298                   OrganisationUpdatedEvent(
299                     connectedUserId = Some(orga.userId),
300                     userId = orga.userId,
301                     requestContext = requestContext,
302                     country = orga.country,
303                     eventDate = DateHelper.now(),
304                     eventId = Some(idGenerator.nextEventId())
305                   )
306                 )
307                 Future.successful(orga.userId)
308               }
309             }
310           case Left(e) => Future.failed(e)
311         }
312       } yield update
313     }
314 
315     private def verifyEmail(lowerCasedEmail: String, emailExists: Boolean): Future[Boolean] = {
316       if (emailExists) {
317         Future.failed(EmailAlreadyRegisteredException(lowerCasedEmail))
318       } else {
319         Future.successful(true)
320       }
321     }
322 
323     private def updateMailExists(lowerCasedEmail: Option[String]): Future[Boolean] = {
324       lowerCasedEmail.map { mail =>
325         persistentUserService.emailExists(mail)
326       }.getOrElse(Future.successful(false))
327     }
328 
329     override def getVotedProposals(
330       organisationId: UserId,
331       maybeUserId: Option[UserId],
332       filterVotes: Option[Seq[VoteKey]],
333       filterQualifications: Option[Seq[QualificationKey]],
334       sort: Option[Sort],
335       limit: Option[Pagination.Limit],
336       offset: Option[Pagination.Offset],
337       requestContext: RequestContext
338     ): Future[ProposalsResultWithUserVoteSeededResponse] = {
339       val futureProposalWithVotes: Future[Map[ProposalId, HistoryActions.VoteAndQualifications]] = for {
340         proposalIds <- userHistoryCoordinatorService.retrieveVotedProposals(
341           RequestUserVotedProposals(
342             organisationId,
343             filterVotes = filterVotes,
344             filterQualifications = filterQualifications
345           )
346         )
347         withVotes <- userHistoryCoordinatorService.retrieveVoteAndQualifications(organisationId, proposalIds)
348       } yield withVotes
349 
350       futureProposalWithVotes.flatMap {
351         case proposalIdsWithVotes if proposalIdsWithVotes.isEmpty =>
352           Future.successful(ProposalsResultWithUserVoteSeededResponse(total = 0, Seq.empty, None))
353         case proposalIdsWithVotes =>
354           val proposalIds: Seq[ProposalId] = proposalIdsWithVotes.toSeq.sortWith {
355             case ((_, firstVotesAndQualifications), (_, nextVotesAndQualifications)) =>
356               firstVotesAndQualifications.date.isAfter(nextVotesAndQualifications.date)
357           }.map {
358             case (proposalId, _) => proposalId
359           }
360           proposalService
361             .searchForUser(
362               userId = Some(organisationId),
363               query = SearchQuery(
364                 filters = Some(
365                   SearchFilters(
366                     proposal = Some(ProposalSearchFilter(proposalIds = proposalIds)),
367                     operationKinds = Some(OperationKindsSearchFilter(OperationKind.publicKinds))
368                   )
369                 ),
370                 sort = sort,
371                 limit = limit,
372                 offset = offset
373               ),
374               requestContext = requestContext,
375               preferredLanguage = None,
376               questionDefaultLanguage = None
377             )
378             .map { proposalResultSeededResponse =>
379               proposalResultSeededResponse.copy(results = proposalResultSeededResponse.results.sortWith {
380                 case (first, next) => proposalIds.indexOf(first.id) < proposalIds.indexOf(next.id)
381               })
382             }
383             .map { proposalResults =>
384               ProposalsResultWithUserVoteSeededResponse(
385                 total = proposalResults.total,
386                 results = proposalResults.results.map { proposal =>
387                   val proposalVoteAndQualification = proposalIdsWithVotes(proposal.id)
388                   ProposalResultWithUserVote(
389                     proposal,
390                     proposalVoteAndQualification.voteKey,
391                     proposalVoteAndQualification.date,
392                     proposal.votes.find(_.voteKey == proposalVoteAndQualification.voteKey)
393                   )
394                 },
395                 seed = None
396               )
397             }
398       }
399     }
400 
401   }
402 }