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.user.social
21 
22 import grizzled.slf4j.Logging
23 import org.make.api.operation.OperationServiceComponent
24 import org.make.api.technical.auth.{MakeDataHandlerComponent, TokenResponse}
25 import org.make.api.user.SocialProvider.{Facebook, GooglePeople, OpenIDConnect}
26 import org.make.api.user.social.models.UserInfo
27 import org.make.api.user.{SocialLoginResponse, SocialProvider, UserServiceComponent}
28 import org.make.core.RequestContext
29 import org.make.core.auth.{ClientId, UserRights}
30 import org.make.core.operation.{OperationId, SimpleOperation}
31 import org.make.core.question.QuestionId
32 import org.make.core.reference.{Country, Language}
33 import org.make.core.user.{User, UserId}
34 import scalaoauth2.provider.AuthInfo
35 
36 import java.time.ZonedDateTime
37 import scala.concurrent.ExecutionContext.Implicits.global
38 import scala.concurrent.Future
39 
40 trait SocialServiceComponent extends GoogleApiComponent with FacebookApiComponent with OpenIDConnectApiComponent {
41   def socialService: SocialService
42 }
43 
44 trait SocialService {
45 
46   def login(
47     provider: SocialProvider,
48     token: String,
49     country: Country,
50     language: Language,
51     crmCountry: Country,
52     crmLanguage: Language,
53     questionId: Option[QuestionId],
54     requestContext: RequestContext,
55     validatedClientId: ClientId,
56     privacyPolicyApprovalDate: Option[ZonedDateTime],
57     optIn: Option[Boolean],
58     operationId: Option[OperationId],
59     redirectUri: Option[String]
60   ): Future[(UserId, SocialLoginResponse)]
61   def getUserByProviderAndToken(
62     provider: SocialProvider,
63     token: String,
64     operationId: Option[OperationId],
65     redirectUri: Option[String]
66   ): Future[Option[User]]
67 }
68 
69 trait DefaultSocialServiceComponent extends SocialServiceComponent {
70   self: UserServiceComponent with OperationServiceComponent with MakeDataHandlerComponent with Logging =>
71 
72   override lazy val socialService: SocialService = new DefaultSocialService
73 
74   class DefaultSocialService extends SocialService {
75 
76     private def getUserInfo(
77       provider: SocialProvider,
78       token: String,
79       operation: Option[SimpleOperation],
80       redirectUri: Option[String]
81     ): Future[UserInfo] = {
82       provider match {
83         case GooglePeople => googleApi.peopleInfo(token).map(_.toUserInfo())
84         case Facebook     => facebookApi.getUserInfo(token).map(_.toUserInfo())
85         case OpenIDConnect =>
86           (operation.map(_.operationId), operation.flatMap(_.operationAuthentication).flatMap(_.oidc), redirectUri) match {
87             case (Some(id), Some(oidc), Some(redirectUri)) =>
88               openIDConnectApi.getUserInfo(token, oidc, redirectUri).map(_.toUserInfo(id))
89             case _ => Future.failed(SocialProviderException("No OIDC configuration found"))
90           }
91       }
92     }
93 
94     override def login(
95       provider: SocialProvider,
96       token: String,
97       country: Country,
98       language: Language,
99       crmCountry: Country,
100       crmLanguage: Language,
101       questionId: Option[QuestionId],
102       requestContext: RequestContext,
103       validatedClientId: ClientId,
104       privacyPolicyApprovalDate: Option[ZonedDateTime],
105       optIn: Option[Boolean],
106       operationId: Option[OperationId],
107       redirectUri: Option[String]
108     ): Future[(UserId, SocialLoginResponse)] = {
109 
110       for {
111         operation <- operationId match {
112           case Some(id) => operationService.findOneSimple(id)
113           case None     => Future.successful(None)
114         }
115         userInfo <- getUserInfo(provider, token, operation, redirectUri)
116         (user, accountCreation) <- userService.createOrUpdateUserFromSocial(
117           userInfo,
118           questionId,
119           country,
120           language,
121           crmCountry,
122           crmLanguage,
123           requestContext,
124           privacyPolicyApprovalDate,
125           optIn
126         )
127         accessToken <- oauth2DataHandler.createAccessToken(authInfo = AuthInfo(
128           user = UserRights(user.userId, user.roles, user.availableQuestions, user.emailVerified),
129           clientId = Some(validatedClientId.value),
130           scope = None,
131           redirectUri = None
132         )
133         )
134       } yield {
135         (
136           user.userId,
137           SocialLoginResponse(token = TokenResponse.fromAccessToken(accessToken), accountCreation = accountCreation)
138         )
139       }
140     }
141 
142     override def getUserByProviderAndToken(
143       provider: SocialProvider,
144       token: String,
145       operationId: Option[OperationId],
146       redirectUri: Option[String]
147     ): Future[Option[User]] = {
148       val operation = operationId match {
149         case Some(id) => operationService.findOneSimple(id)
150         case None     => Future.successful(None)
151       }
152       val userEmail: Future[Option[String]] =
153         operation.flatMap(getUserInfo(provider, token, _, redirectUri).map(_.email))
154       userEmail.flatMap {
155         case None        => Future.successful(None)
156         case Some(email) => userService.getUserByEmail(email)
157       }
158     }
159 
160   }
161 }
162 
163 final case class SocialProviderException(message: String) extends Exception(message)