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 import cats.implicits._
24 import grizzled.slf4j.Logging
25 import org.make.api.extensions.MakeDBExecutionContextComponent
26 import org.make.api.technical.ShortenedNames
27 import org.make.core.auth.{AuthCode, ClientId}
28 import org.make.core.user.UserId
29 import org.make.api.technical.DatabaseTransactions._
30 import scalikejdbc._
31 
32 import scala.concurrent.Future
33 
34 trait DefaultPersistentAuthCodeServiceComponent extends PersistentAuthCodeServiceComponent with ShortenedNames {
35   self: MakeDBExecutionContextComponent =>
36 
37   override lazy val persistentAuthCodeService: PersistentAuthCodeService = new DefaultPersistentAuthCodeService
38 
39   private class DefaultPersistentAuthCodeService extends PersistentAuthCodeService {
40 
41     val alias
42       : scalikejdbc.QuerySQLSyntaxProvider[scalikejdbc.SQLSyntaxSupport[PersistentAuthCode], PersistentAuthCode] =
43       PersistentAuthCode.authCodeAlias
44 
45     val columns: scalikejdbc.ColumnName[PersistentAuthCode] = PersistentAuthCode.column
46 
47     override def persist(authCode: AuthCode): Future[AuthCode] = {
48       implicit val cxt: EC = readExecutionContext
49       Future(NamedDB("READ").retryableTx { implicit session =>
50         withSQL {
51           insert
52             .into(PersistentAuthCode)
53             .namedValues(
54               columns.authorizationCode -> authCode.authorizationCode,
55               columns.scope -> authCode.scope,
56               columns.redirectUri -> authCode.redirectUri,
57               columns.createdAt -> authCode.createdAt,
58               columns.expiresIn -> authCode.expiresIn,
59               columns.makeUserUuid -> authCode.user.value,
60               columns.clientUuid -> authCode.client.value
61             )
62         }.execute()
63       }).map(_ => authCode)
64     }
65 
66     override def findByCode(code: String): Future[Option[AuthCode]] = {
67       implicit val cxt: EC = readExecutionContext
68       Future(NamedDB("READ").retryableTx { implicit session =>
69         withSQL {
70           select
71             .from(PersistentAuthCode.as(alias))
72             .where(sqls.eq(alias.authorizationCode, code))
73         }.map(PersistentAuthCode.apply()).single()
74       }).map(_.map(_.toAuthCode))
75     }
76 
77     override def deleteByCode(code: String): Future[Unit] = {
78       implicit val cxt: EC = readExecutionContext
79       Future(NamedDB("READ").retryableTx { implicit session =>
80         withSQL {
81           delete
82             .from(PersistentAuthCode.as(alias))
83             .where(sqls.eq(alias.authorizationCode, code))
84         }.map(PersistentAuthCode.apply()).update()
85       }).void
86     }
87   }
88 }
89 
90 final case class PersistentAuthCode(
91   authorizationCode: String,
92   scope: Option[String],
93   redirectUri: Option[String],
94   createdAt: ZonedDateTime,
95   expiresIn: Int,
96   makeUserUuid: String,
97   clientUuid: String
98 ) {
99   def toAuthCode: AuthCode =
100     AuthCode(authorizationCode, scope, redirectUri, createdAt, expiresIn, UserId(makeUserUuid), ClientId(clientUuid))
101 }
102 
103 object PersistentAuthCode extends SQLSyntaxSupport[PersistentAuthCode] with ShortenedNames with Logging {
104   override val columnNames: Seq[String] =
105     Seq("authorization_code", "scope", "redirect_uri", "created_at", "expires_in", "make_user_uuid", "client_uuid")
106 
107   override val tableName: String = "auth_code"
108 
109   lazy val authCodeAlias: SyntaxProvider[PersistentAuthCode] = syntax("auth_code")
110 
111   def apply(
112     authCodeResultName: ResultName[PersistentAuthCode] = authCodeAlias.resultName
113   )(resultSet: WrappedResultSet): PersistentAuthCode = {
114     PersistentAuthCode(
115       authorizationCode = resultSet.string(authCodeResultName.authorizationCode),
116       scope = resultSet.stringOpt(authCodeResultName.scope),
117       redirectUri = resultSet.stringOpt(authCodeResultName.redirectUri),
118       createdAt = resultSet.zonedDateTime(authCodeResultName.createdAt),
119       expiresIn = resultSet.int(authCodeResultName.expiresIn),
120       makeUserUuid = resultSet.string(authCodeResultName.makeUserUuid),
121       clientUuid = resultSet.string(authCodeResultName.clientUuid)
122     )
123   }
124 }