1 /*
2  *  Make.org Core API
3  *  Copyright (C) 2021 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.widget
21 
22 import cats.implicits._
23 import akka.http.scaladsl.model.StatusCodes
24 import akka.http.scaladsl.server._
25 import io.circe.Codec
26 import io.circe.generic.semiauto.deriveCodec
27 import io.swagger.annotations.{
28   Api,
29   ApiImplicitParam,
30   ApiImplicitParams,
31   ApiModelProperty,
32   ApiOperation,
33   ApiResponse,
34   ApiResponses,
35   Authorization,
36   AuthorizationScope
37 }
38 import org.make.api.operation.OperationServiceComponent
39 import org.make.api.question.QuestionServiceComponent
40 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
41 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
42 import org.make.api.technical.directives.FutureDirectivesExtensions._
43 import org.make.core.{HttpCodes, Order, ParameterExtractors, ValidationError}
44 import org.make.core.auth.UserRights
45 import org.make.core.technical.Pagination
46 import org.make.core.widget.{Source, SourceId}
47 import scalaoauth2.provider.AuthInfo
48 
49 import javax.ws.rs.Path
50 import scala.annotation.meta.field
51 
52 @Api(value = "Admin Sources")
53 @Path(value = "/admin/sources")
54 trait AdminSourceApi extends Directives {
55 
56   @ApiOperation(
57     value = "list-sources",
58     httpMethod = "GET",
59     code = HttpCodes.OK,
60     authorizations = Array(
61       new Authorization(
62         value = "MakeApi",
63         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
64       )
65     )
66   )
67   @ApiImplicitParams(
68     value = Array(
69       new ApiImplicitParam(
70         name = "_start",
71         paramType = "query",
72         dataType = "int",
73         allowableValues = "range[0, infinity]"
74       ),
75       new ApiImplicitParam(
76         name = "_end",
77         paramType = "query",
78         dataType = "int",
79         allowableValues = "range[0, infinity]"
80       ),
81       new ApiImplicitParam(name = "_sort", paramType = "query", dataType = "string", allowableValues = "source,name"),
82       new ApiImplicitParam(
83         name = "_order",
84         paramType = "query",
85         dataType = "string",
86         allowableValues = Order.swaggerAllowableValues
87       ),
88       new ApiImplicitParam(name = "name", paramType = "query", dataType = "string"),
89       new ApiImplicitParam(name = "source", paramType = "query", dataType = "string")
90     )
91   )
92   @ApiResponses(
93     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[AdminSourceResponse]]))
94   )
95   @Path(value = "/")
96   def list: Route
97 
98   @ApiOperation(
99     value = "get-source-by-id",
100     httpMethod = "GET",
101     code = HttpCodes.OK,
102     authorizations = Array(
103       new Authorization(
104         value = "MakeApi",
105         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
106       )
107     )
108   )
109   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "id", paramType = "path", dataType = "string")))
110   @ApiResponses(
111     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[AdminSourceResponse]))
112   )
113   @Path(value = "/{id}")
114   def getById: Route
115 
116   @ApiOperation(
117     value = "create-source",
118     httpMethod = "POST",
119     code = HttpCodes.Created,
120     authorizations = Array(
121       new Authorization(
122         value = "MakeApi",
123         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
124       )
125     )
126   )
127   @ApiImplicitParams(
128     value = Array(
129       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.widget.AdminSourceRequest")
130     )
131   )
132   @ApiResponses(
133     value = Array(new ApiResponse(code = HttpCodes.Created, message = "Ok", response = classOf[AdminSourceResponse]))
134   )
135   @Path(value = "/")
136   def create: Route
137 
138   @ApiOperation(
139     value = "update-source",
140     httpMethod = "PUT",
141     code = HttpCodes.OK,
142     authorizations = Array(
143       new Authorization(
144         value = "MakeApi",
145         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
146       )
147     )
148   )
149   @ApiImplicitParams(
150     value = Array(
151       new ApiImplicitParam(name = "id", paramType = "path", dataType = "string"),
152       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.widget.AdminSourceRequest")
153     )
154   )
155   @ApiResponses(
156     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[AdminSourceResponse]))
157   )
158   @Path(value = "/{id}")
159   def update: Route
160 
161   def routes: Route = list ~ getById ~ create ~ update
162 
163 }
164 
165 trait AdminSourceApiComponent {
166   def adminSourceApi: AdminSourceApi
167 }
168 
169 trait DefaultAdminSourceApiComponent
170     extends AdminSourceApiComponent
171     with MakeAuthenticationDirectives
172     with ParameterExtractors {
173 
174   self: MakeDirectivesDependencies
175     with SourceServiceComponent
176     with QuestionServiceComponent
177     with OperationServiceComponent =>
178 
179   override val adminSourceApi: AdminSourceApi = new AdminSourceApi {
180 
181     private val id: PathMatcher1[SourceId] = Segment.map(SourceId.apply)
182 
183     override def list: Route = get {
184       path("admin" / "sources") {
185         parameters(
186           "_start".as[Pagination.Offset].?,
187           "_end".as[Pagination.End].?,
188           "_sort".?,
189           "_order".as[Order].?,
190           "name".?,
191           "source".?
192         ) {
193           (
194             offset: Option[Pagination.Offset],
195             end: Option[Pagination.End],
196             sort: Option[String],
197             order: Option[Order],
198             name: Option[String],
199             source: Option[String]
200           ) =>
201             makeOperation("AdminSourcesList") { _ =>
202               makeOAuth2 { userAuth: AuthInfo[UserRights] =>
203                 requireAdminRole(userAuth.user) {
204                   (
205                     sourceService.list(offset, end, sort, order, name, source).asDirective,
206                     sourceService.count(name, source).asDirective
207                   ).tupled.apply {
208                     case (sources, count) =>
209                       complete(
210                         (StatusCodes.OK, List(`X-Total-Count`(count.toString)), sources.map(AdminSourceResponse.apply))
211                       )
212                   }
213                 }
214               }
215             }
216         }
217       }
218     }
219 
220     override def getById: Route = get {
221       path("admin" / "sources" / id) { id =>
222         makeOperation("AdminSourcesGetById") { _ =>
223           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
224             requireAdminRole(userAuth.user) {
225               sourceService.get(id).asDirectiveOrNotFound { source =>
226                 complete(AdminSourceResponse(source))
227               }
228             }
229           }
230         }
231       }
232     }
233 
234     override def create: Route = post {
235       path("admin" / "sources") {
236         makeOperation("AdminSourcesCreate") { _ =>
237           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
238             requireAdminRole(userAuth.user) {
239               decodeRequest {
240                 entity(as[AdminSourceRequest]) { request: AdminSourceRequest =>
241                   sourceService.findBySource(request.source).asDirective {
242                     case Some(_) =>
243                       complete(
244                         StatusCodes.BadRequest -> ValidationError(
245                           "source",
246                           "already_defined",
247                           Some(s"Source ${request.source} already exists")
248                         )
249                       )
250                     case _ =>
251                       sourceService
252                         .create(name = request.name, source = request.source, userId = userAuth.user.userId)
253                         .asDirective
254                         .apply(source => complete(StatusCodes.Created, AdminSourceResponse(source)))
255                   }
256                 }
257               }
258             }
259           }
260         }
261       }
262     }
263 
264     override def update: Route = put {
265       path("admin" / "sources" / id) { id =>
266         makeOperation("AdminSourcesUpdate") { _ =>
267           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
268             requireAdminRole(userAuth.user) {
269               decodeRequest {
270                 entity(as[AdminSourceRequest]) { request: AdminSourceRequest =>
271                   sourceService.findBySource(request.source).asDirective {
272                     case Some(source) if source.id != id =>
273                       complete(
274                         StatusCodes.BadRequest -> ValidationError(
275                           "source",
276                           "already_defined",
277                           Some(s"Source ${request.source} already exists")
278                         )
279                       )
280                     case _ =>
281                       sourceService
282                         .update(id = id, name = request.name, source = request.source, userId = userAuth.user.userId)
283                         .asDirectiveOrNotFound
284                         .apply(source => complete(AdminSourceResponse(source)))
285                   }
286                 }
287               }
288             }
289           }
290         }
291       }
292     }
293 
294   }
295 
296 }
297 
298 final case class AdminSourceRequest(name: String, source: String)
299 
300 object AdminSourceRequest {
301   implicit val codec: Codec[AdminSourceRequest] = deriveCodec
302 }
303 
304 final case class AdminSourceResponse(
305   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
306   id: SourceId,
307   name: String,
308   source: String
309 )
310 
311 object AdminSourceResponse {
312 
313   def apply(source: Source): AdminSourceResponse =
314     AdminSourceResponse(id = source.id, name = source.name, source = source.source)
315 
316   implicit val codec: Codec[AdminSourceResponse] = deriveCodec
317 
318 }