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.technical.auth
21 
22 import java.time.ZonedDateTime
23 
24 import grizzled.slf4j.Logging
25 import org.make.api.extensions.MakeDBExecutionContextComponent
26 import org.make.api.technical.DatabaseTransactions._
27 import org.make.api.technical.ShortenedNames
28 import org.make.api.technical.auth.DefaultPersistentClientServiceComponent.PersistentClient
29 import org.make.api.technical.auth.DefaultPersistentTokenServiceComponent.PersistentToken
30 import org.make.api.user.PersistentUserServiceComponent
31 import org.make.api.user.DefaultPersistentUserServiceComponent.PersistentUser
32 import org.make.core.DateHelper
33 import org.make.core.auth.Token
34 import org.make.core.user.UserId
35 import scalikejdbc._
36 
37 import scala.concurrent.Future
38 
39 object DefaultPersistentTokenServiceComponent {
40 
41   final case class PersistentToken(
42     accessToken: String,
43     refreshToken: Option[String],
44     scope: Option[String],
45     createdAt: Option[ZonedDateTime],
46     updatedAt: Option[ZonedDateTime],
47     expiresIn: Int,
48     refreshExpiresIn: Int,
49     makeUserUuid: PersistentUser,
50     clientUuid: PersistentClient
51   ) {
52     def toToken: Token = {
53       Token(
54         accessToken = accessToken,
55         refreshToken = refreshToken,
56         scope = scope,
57         createdAt = createdAt,
58         updatedAt = updatedAt,
59         expiresIn = expiresIn,
60         user = makeUserUuid.toUserRights,
61         client = clientUuid.toClient,
62         refreshExpiresIn = refreshExpiresIn
63       )
64     }
65   }
66 
67   object PersistentToken extends SQLSyntaxSupport[PersistentToken] with ShortenedNames with Logging {
68 
69     override val columnNames: Seq[String] =
70       Seq(
71         "access_token",
72         "refresh_token",
73         "scope",
74         "created_at",
75         "updated_at",
76         "expires_in",
77         "make_user_uuid",
78         "client_uuid",
79         "refresh_expires_in"
80       )
81 
82     override val tableName: String = "access_token"
83 
84     lazy val tokenAlias: QuerySQLSyntaxProvider[SQLSyntaxSupport[PersistentToken], PersistentToken] = syntax("t")
85 
86     def apply(
87       tokenResultName: ResultName[PersistentToken] = tokenAlias.resultName,
88       userResultName: ResultName[PersistentUser] = PersistentUser.alias.resultName,
89       clientResultName: ResultName[PersistentClient] = PersistentClient.alias.resultName
90     )(resultSet: WrappedResultSet): PersistentToken = {
91       val persistentUser = PersistentUser(userResultName)(resultSet)
92       val persistentClient = PersistentClient(clientResultName)(resultSet)
93       PersistentToken(
94         accessToken = resultSet.string(tokenResultName.accessToken),
95         refreshToken = resultSet.stringOpt(tokenResultName.refreshToken),
96         scope = resultSet.stringOpt(tokenResultName.scope),
97         createdAt = resultSet.zonedDateTimeOpt(tokenResultName.createdAt),
98         updatedAt = resultSet.zonedDateTimeOpt(tokenResultName.updatedAt),
99         expiresIn = resultSet.int(tokenResultName.expiresIn),
100         refreshExpiresIn = resultSet.int(tokenResultName.refreshExpiresIn),
101         makeUserUuid = persistentUser,
102         clientUuid = persistentClient
103       )
104     }
105   }
106 
107 }
108 
109 trait DefaultPersistentTokenServiceComponent extends PersistentTokenServiceComponent {
110   self: MakeDBExecutionContextComponent with PersistentUserServiceComponent with PersistentClientServiceComponent =>
111 
112   override lazy val persistentTokenService: PersistentTokenService = new DefaultPersistentTokenService
113 
114   class DefaultPersistentTokenService extends PersistentTokenService with ShortenedNames with Logging {
115 
116     private val tokenAlias = PersistentToken.tokenAlias
117     private val column = PersistentToken.column
118 
119     override def accessTokenExists(token: String): Future[Boolean] = {
120       get(token).map(_.isDefined)(ECGlobal)
121     }
122 
123     override def refreshTokenExists(token: String): Future[Boolean] = {
124       findByRefreshToken(token).map(_.isDefined)(ECGlobal)
125     }
126 
127     override def findByRefreshToken(token: String): Future[Option[Token]] = {
128       implicit val cxt: EC = readExecutionContext
129       val futurePersistentToken: Future[Option[PersistentToken]] = Future(NamedDB("READ").retryableTx {
130         implicit session =>
131           val userAlias = PersistentUser.alias
132           val clientAlias = PersistentClient.alias
133           withSQL {
134             val req: scalikejdbc.SQLBuilder[PersistentUser] = select
135               .from(PersistentToken.as(tokenAlias))
136               .innerJoin(PersistentUser.as(userAlias))
137               .on(userAlias.uuid, tokenAlias.makeUserUuid)
138               .innerJoin(PersistentClient.as(clientAlias))
139               .on(clientAlias.uuid, tokenAlias.clientUuid)
140               .where(sqls.eq(tokenAlias.refreshToken, token))
141             req
142           }.map(
143               PersistentToken(
144                 tokenResultName = tokenAlias.resultName,
145                 userResultName = userAlias.resultName,
146                 clientResultName = clientAlias.resultName
147               )
148             )
149             .single()
150       })
151 
152       futurePersistentToken.map(_.map(_.toToken))
153     }
154 
155     override def get(accessToken: String): Future[Option[Token]] = {
156       implicit val cxt: EC = readExecutionContext
157       val futurePersistentToken: Future[Option[PersistentToken]] = Future(NamedDB("READ").retryableTx {
158         implicit session =>
159           val userAlias = PersistentUser.alias
160           val clientAlias = PersistentClient.alias
161           withSQL {
162             select
163               .from(PersistentToken.as(tokenAlias))
164               .innerJoin(PersistentUser.as(userAlias))
165               .on(userAlias.uuid, tokenAlias.makeUserUuid)
166               .innerJoin(PersistentClient.as(clientAlias))
167               .on(clientAlias.uuid, tokenAlias.clientUuid)
168               .where(sqls.eq(tokenAlias.accessToken, accessToken))
169           }.map(PersistentToken.apply(tokenAlias.resultName, userAlias.resultName, clientAlias.resultName))
170             .single()
171       })
172 
173       futurePersistentToken.map(_.map(_.toToken))
174     }
175 
176     override def findByUserId(userId: UserId): Future[Option[Token]] = {
177       implicit val cxt: EC = readExecutionContext
178       val futurePersistentToken = Future(NamedDB("READ").retryableTx { implicit session =>
179         withSQL {
180           select
181             .from(PersistentToken.as(tokenAlias))
182             .innerJoin(PersistentUser.as(PersistentUser.alias))
183             .on(PersistentUser.alias.uuid, tokenAlias.makeUserUuid)
184             .innerJoin(PersistentClient.as(PersistentClient.alias))
185             .on(PersistentClient.alias.uuid, tokenAlias.clientUuid)
186             .where(sqls.eq(tokenAlias.makeUserUuid, userId.value))
187             .orderBy(tokenAlias.updatedAt)
188             .desc
189             .limit(1)
190         }.map(PersistentToken.apply()).single()
191       })
192 
193       futurePersistentToken.map(_.map(_.toToken))
194     }
195 
196     override def persist(token: Token): Future[Token] = {
197       implicit val ctx: EC = writeExecutionContext
198       Future(NamedDB("WRITE").retryableTx { implicit session =>
199         withSQL {
200           insert
201             .into(PersistentToken)
202             .namedValues(
203               column.accessToken -> token.accessToken,
204               column.refreshToken -> token.refreshToken,
205               column.scope -> token.scope,
206               column.createdAt -> DateHelper.now(),
207               column.updatedAt -> DateHelper.now(),
208               column.expiresIn -> token.expiresIn,
209               column.refreshExpiresIn -> token.refreshExpiresIn,
210               column.makeUserUuid -> token.user.userId.value,
211               column.clientUuid -> token.client.clientId.value
212             )
213         }.execute()
214       }).map(_ => token)
215     }
216 
217     override def deleteByAccessToken(accessToken: String): Future[Int] = {
218       implicit val ctx: EC = writeExecutionContext
219       Future(NamedDB("WRITE").retryableTx { implicit session =>
220         withSQL {
221           delete
222             .from(PersistentToken.as(tokenAlias))
223             .where
224             .eq(tokenAlias.accessToken, accessToken)
225         }.update()
226       })
227     }
228 
229     override def deleteByUserId(userId: UserId): Future[Int] = {
230       implicit val ctx: EC = writeExecutionContext
231       Future(NamedDB("WRITE").retryableTx { implicit session =>
232         withSQL {
233           delete
234             .from(PersistentToken.as(tokenAlias))
235             .where
236             .eq(tokenAlias.makeUserUuid, userId.value)
237         }.update()
238       })
239     }
240 
241   }
242 }