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 org.make.api.extensions.MakeSettingsComponent
23 import org.make.api.technical.IdGeneratorComponent
24 import org.make.core.auth.{Client, ClientId}
25 import org.make.core.technical.Pagination
26 import org.make.core.user.{CustomRole, UserId}
27 import scalaoauth2.provider.{InvalidClient, InvalidRequest, OAuthError}
28 
29 import scala.concurrent.ExecutionContext.Implicits.global
30 import scala.concurrent.Future
31 
32 trait DefaultClientServiceComponent extends ClientServiceComponent {
33   this: PersistentClientServiceComponent with IdGeneratorComponent with MakeSettingsComponent =>
34 
35   override lazy val clientService: ClientService = new DefaultClientService
36 
37   class DefaultClientService extends ClientService {
38 
39     override def getClient(clientId: ClientId): Future[Option[Client]] = {
40       persistentClientService.get(clientId)
41     }
42 
43     override def createClient(
44       name: String,
45       allowedGrantTypes: Seq[String],
46       secret: Option[String],
47       scope: Option[String],
48       redirectUri: Option[String],
49       defaultUserId: Option[UserId],
50       roles: Seq[CustomRole],
51       tokenExpirationSeconds: Int,
52       refreshExpirationSeconds: Int,
53       reconnectExpirationSeconds: Int
54     ): Future[Client] = {
55       persistentClientService.persist(
56         Client(
57           clientId = idGenerator.nextClientId(),
58           name = name,
59           allowedGrantTypes = allowedGrantTypes,
60           secret = secret,
61           scope = scope,
62           redirectUri = redirectUri,
63           defaultUserId = defaultUserId,
64           roles = roles,
65           tokenExpirationSeconds = tokenExpirationSeconds,
66           refreshExpirationSeconds = refreshExpirationSeconds,
67           reconnectExpirationSeconds = reconnectExpirationSeconds
68         )
69       )
70     }
71 
72     override def search(
73       offset: Pagination.Offset,
74       end: Option[Pagination.End],
75       name: Option[String]
76     ): Future[Seq[Client]] =
77       persistentClientService.search(offset = offset, end = end, name = name)
78 
79     override def updateClient(
80       clientId: ClientId,
81       name: String,
82       allowedGrantTypes: Seq[String],
83       secret: Option[String],
84       scope: Option[String],
85       redirectUri: Option[String],
86       defaultUserId: Option[UserId],
87       roles: Seq[CustomRole],
88       tokenExpirationSeconds: Int,
89       refreshExpirationSeconds: Int,
90       reconnectExpirationSeconds: Int
91     ): Future[Option[Client]] = {
92       getClient(clientId).flatMap {
93         case Some(client) =>
94           persistentClientService
95             .update(
96               client.copy(
97                 name = name,
98                 allowedGrantTypes = allowedGrantTypes,
99                 secret = secret,
100                 scope = scope,
101                 redirectUri = redirectUri,
102                 defaultUserId = defaultUserId,
103                 roles = roles,
104                 tokenExpirationSeconds = tokenExpirationSeconds,
105                 refreshExpirationSeconds = refreshExpirationSeconds,
106                 reconnectExpirationSeconds = reconnectExpirationSeconds
107               )
108             )
109         case None => Future.successful(None)
110       }
111     }
112 
113     override def count(name: Option[String]): Future[Int] = {
114       persistentClientService.count(name = name)
115     }
116 
117     override def getClient(clientId: ClientId, secret: Option[String]): Future[Either[OAuthError, Client]] = {
118       getClient(clientId).map {
119         case Some(client) =>
120           if (client.secret == secret) {
121             Right(client)
122           } else {
123             Left(new InvalidClient(s"Credentials mismatch for client ${clientId.value}."))
124           }
125 
126         case None => Left(new InvalidClient(s"Client ${clientId.value} was not found."))
127       }
128     }
129 
130     override def getDefaultClient(): Future[Either[OAuthError, Client]] = {
131       getClient(ClientId(makeSettings.Authentication.defaultClientId)).map {
132         case Some(client) => Right(client)
133         case None         => Left(new InvalidRequest("Default client was not found, check your configuration."))
134       }
135     }
136   }
137 }