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 cats.data.NonEmptyList
25 import grizzled.slf4j.Logging
26 import org.make.api.extensions.MakeDBExecutionContextComponent
27 import org.make.api.technical.DatabaseTransactions._
28 import org.make.api.technical.PersistentServiceUtils.sortOrderQuery
29 import org.make.api.technical.auth.DefaultPersistentClientServiceComponent.{
30   GRANT_TYPE_SEPARATOR,
31   PersistentClient,
32   ROLE_SEPARATOR
33 }
34 import org.make.api.technical.{PersistentCompanion, ShortenedNames}
35 import org.make.core.DateHelper
36 import org.make.core.technical.Pagination
37 import org.make.core.auth.{Client, ClientId}
38 import org.make.core.user.{Role, UserId}
39 import scalikejdbc._
40 
41 import scala.concurrent.Future
42 
43 object DefaultPersistentClientServiceComponent {
44 
45   val GRANT_TYPE_SEPARATOR: String = ","
46   val ROLE_SEPARATOR: String = ","
47 
48   final case class PersistentClient(
49     uuid: String,
50     name: String,
51     allowedGrantTypes: String,
52     secret: Option[String],
53     scope: Option[String],
54     redirectUri: Option[String],
55     createdAt: ZonedDateTime,
56     updatedAt: ZonedDateTime,
57     defaultUserId: Option[String],
58     roles: String,
59     tokenExpirationSeconds: Int,
60     refreshExpirationSeconds: Int,
61     reconnectExpirationSeconds: Int
62   ) {
63     def toClient: Client =
64       Client(
65         clientId = ClientId(uuid),
66         name = name,
67         allowedGrantTypes = allowedGrantTypes.split(GRANT_TYPE_SEPARATOR).toIndexedSeq,
68         secret = secret,
69         scope = scope,
70         redirectUri = redirectUri,
71         createdAt = Some(createdAt),
72         updatedAt = Some(updatedAt),
73         defaultUserId = defaultUserId.map(UserId(_)),
74         roles = roles.split(ROLE_SEPARATOR).toIndexedSeq.map(Role.apply),
75         tokenExpirationSeconds = tokenExpirationSeconds,
76         refreshExpirationSeconds = refreshExpirationSeconds,
77         reconnectExpirationSeconds = reconnectExpirationSeconds
78       )
79   }
80 
81   implicit object PersistentClient
82       extends PersistentCompanion[PersistentClient, Client]
83       with ShortenedNames
84       with Logging {
85 
86     override val columnNames: Seq[String] =
87       Seq(
88         "uuid",
89         "name",
90         "secret",
91         "allowed_grant_types",
92         "scope",
93         "redirect_uri",
94         "created_at",
95         "updated_at",
96         "default_user_id",
97         "roles",
98         "token_expiration_seconds",
99         "refresh_expiration_seconds",
100         "reconnect_expiration_seconds"
101       )
102 
103     override val tableName: String = "oauth_client"
104 
105     override lazy val alias: SyntaxProvider[PersistentClient] = syntax("c")
106 
107     override lazy val defaultSortColumns: NonEmptyList[SQLSyntax] = NonEmptyList.of(alias.uuid)
108 
109     def apply(
110       clientResultName: ResultName[PersistentClient] = alias.resultName
111     )(resultSet: WrappedResultSet): PersistentClient = {
112       PersistentClient(
113         uuid = resultSet.string(clientResultName.uuid),
114         name = resultSet.string(clientResultName.name),
115         allowedGrantTypes = resultSet.string(clientResultName.allowedGrantTypes),
116         secret = resultSet.stringOpt(clientResultName.secret),
117         scope = resultSet.stringOpt(clientResultName.scope),
118         redirectUri = resultSet.stringOpt(clientResultName.redirectUri),
119         createdAt = resultSet.zonedDateTime(clientResultName.createdAt),
120         updatedAt = resultSet.zonedDateTime(clientResultName.updatedAt),
121         defaultUserId = resultSet.stringOpt(clientResultName.defaultUserId),
122         roles = resultSet.string(clientResultName.roles),
123         tokenExpirationSeconds = resultSet.int(clientResultName.tokenExpirationSeconds),
124         refreshExpirationSeconds = resultSet.int(clientResultName.refreshExpirationSeconds),
125         reconnectExpirationSeconds = resultSet.int(clientResultName.reconnectExpirationSeconds)
126       )
127     }
128   }
129 
130 }
131 
132 trait DefaultPersistentClientServiceComponent extends PersistentClientServiceComponent {
133   self: MakeDBExecutionContextComponent =>
134 
135   override lazy val persistentClientService: DefaultPersistentClientService = new DefaultPersistentClientService
136 
137   class DefaultPersistentClientService extends PersistentClientService with ShortenedNames with Logging {
138 
139     private val clientAlias = PersistentClient.alias
140     private val column = PersistentClient.column
141 
142     override def get(clientId: ClientId): Future[Option[Client]] = {
143       implicit val cxt: EC = readExecutionContext
144       val futureClient = Future(NamedDB("READ").retryableTx { implicit session =>
145         withSQL {
146           select
147             .from(PersistentClient.as(clientAlias))
148             .where(sqls.eq(clientAlias.uuid, clientId.value))
149         }.map(PersistentClient.apply()).single()
150       })
151 
152       futureClient.map(_.map(_.toClient))
153     }
154 
155     override def findByClientIdAndSecret(clientId: String, secret: Option[String]): Future[Option[Client]] = {
156       implicit val cxt: EC = readExecutionContext
157       val futurePersistentClient = Future(NamedDB("READ").retryableTx { implicit session =>
158         withSQL {
159           select
160             .from(PersistentClient.as(clientAlias))
161             .where(
162               sqls
163                 .eq(clientAlias.uuid, clientId)
164                 //TODO: Test this function with both secret value: Some(secret) || None
165                 .and(sqls.eq(clientAlias.secret, secret))
166             )
167         }.map(PersistentClient.apply()).single()
168       })
169 
170       futurePersistentClient.map(_.map(_.toClient))
171     }
172 
173     override def persist(client: Client): Future[Client] = {
174       implicit val ctx: EC = writeExecutionContext
175       val nowDate: ZonedDateTime = DateHelper.now()
176       Future(NamedDB("WRITE").retryableTx { implicit session =>
177         withSQL {
178           insert
179             .into(PersistentClient)
180             .namedValues(
181               column.uuid -> client.clientId.value,
182               column.name -> client.name,
183               column.allowedGrantTypes -> client.allowedGrantTypes.mkString(GRANT_TYPE_SEPARATOR),
184               column.secret -> client.secret,
185               column.redirectUri -> client.redirectUri,
186               column.scope -> client.scope,
187               column.createdAt -> nowDate,
188               column.updatedAt -> nowDate,
189               column.defaultUserId -> client.defaultUserId.map(_.value),
190               column.roles -> client.roles.map(_.value).mkString(ROLE_SEPARATOR),
191               column.tokenExpirationSeconds -> client.tokenExpirationSeconds,
192               column.refreshExpirationSeconds -> client.refreshExpirationSeconds,
193               column.reconnectExpirationSeconds -> client.reconnectExpirationSeconds
194             )
195         }.execute()
196       }).map(_ => client)
197     }
198 
199     override def update(client: Client): Future[Option[Client]] = {
200       implicit val ctx: EC = writeExecutionContext
201       val nowDate: ZonedDateTime = DateHelper.now()
202       Future(NamedDB("WRITE").retryableTx { implicit session =>
203         withSQL {
204           scalikejdbc
205             .update(PersistentClient)
206             .set(
207               column.name -> client.name,
208               column.allowedGrantTypes -> client.allowedGrantTypes.mkString(GRANT_TYPE_SEPARATOR),
209               column.secret -> client.secret,
210               column.redirectUri -> client.redirectUri,
211               column.scope -> client.scope,
212               column.createdAt -> nowDate,
213               column.updatedAt -> nowDate,
214               column.defaultUserId -> client.defaultUserId.map(_.value),
215               column.roles -> client.roles.map(_.value).mkString(ROLE_SEPARATOR),
216               column.tokenExpirationSeconds -> client.tokenExpirationSeconds,
217               column.refreshExpirationSeconds -> client.refreshExpirationSeconds,
218               column.reconnectExpirationSeconds -> client.reconnectExpirationSeconds
219             )
220             .where(sqls.eq(column.uuid, client.clientId.value))
221         }.executeUpdate()
222       }).map {
223         case 1 => Some(client)
224         case 0 =>
225           logger.error(s"Client '${client.clientId.value}' not found")
226           None
227       }
228     }
229 
230     override def search(
231       offset: Pagination.Offset,
232       end: Option[Pagination.End],
233       name: Option[String]
234     ): Future[Seq[Client]] = {
235       implicit val context: EC = readExecutionContext
236 
237       val futurePersistentClients: Future[List[PersistentClient]] = Future(NamedDB("READ").retryableTx {
238         implicit session =>
239           withSQL {
240 
241             val query: scalikejdbc.PagingSQLBuilder[PersistentClient] =
242               select
243                 .from(PersistentClient.as(clientAlias))
244                 .where(
245                   sqls.toAndConditionOpt(
246                     name
247                       .map(n => sqls.like(sqls"lower(${clientAlias.name})", s"%${n.toLowerCase.replace("%", "\\%")}%"))
248                   )
249                 )
250 
251             sortOrderQuery(offset, end, None, None, query)
252           }.map(PersistentClient.apply()).list()
253       })
254 
255       futurePersistentClients.map(_.map(_.toClient))
256     }
257 
258     override def count(name: Option[String]): Future[Int] = {
259       implicit val context: EC = readExecutionContext
260 
261       Future(NamedDB("READ").retryableTx { implicit session =>
262         withSQL {
263 
264           select(sqls.count)
265             .from(PersistentClient.as(clientAlias))
266             .where(
267               sqls.toAndConditionOpt(
268                 name
269                   .map(n => sqls.like(sqls"lower(${clientAlias.name})", s"%${n.toLowerCase.replace("%", "\\%")}%"))
270               )
271             )
272         }.map(_.int(1)).single().getOrElse(0)
273       })
274     }
275   }
276 }