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.operation
21 
22 import cats.implicits._
23 import akka.http.scaladsl.model.StatusCodes
24 import akka.http.scaladsl.server._
25 import grizzled.slf4j.Logging
26 import io.swagger.annotations._
27 import eu.timepit.refined.auto._
28 import org.make.api.operation.DefaultPersistentOperationServiceComponent.PersistentOperation
29 import org.make.api.question.QuestionServiceComponent
30 
31 import javax.ws.rs.Path
32 import org.make.api.sequence.SequenceServiceComponent
33 import org.make.api.tag.TagServiceComponent
34 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
35 import org.make.api.technical.CsvReceptacle._
36 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
37 import org.make.api.technical.directives.FutureDirectivesExtensions._
38 import org.make.api.user.UserServiceComponent
39 import org.make.core.auth.UserRights
40 import org.make.core.technical.Pagination
41 import org.make.core.operation._
42 import org.make.core.{HttpCodes, Order, ParameterExtractors, Validation}
43 import scalaoauth2.provider.AuthInfo
44 
45 @Api(
46   value = "admin Operation",
47   authorizations = Array(
48     new Authorization(
49       value = "MakeApi",
50       scopes = Array(
51         new AuthorizationScope(scope = "admin", description = "BO Admin"),
52         new AuthorizationScope(scope = "moderator", description = "BO Moderator")
53       )
54     )
55   )
56 )
57 @Path(value = "/admin/operations")
58 trait AdminOperationApi extends Directives {
59 
60   @ApiOperation(value = "post-operation", httpMethod = "POST", code = HttpCodes.OK)
61   @ApiResponses(
62     value = Array(new ApiResponse(code = HttpCodes.Created, message = "Ok", response = classOf[OperationIdResponse]))
63   )
64   @ApiImplicitParams(
65     value = Array(
66       new ApiImplicitParam(
67         name = "body",
68         paramType = "body",
69         dataType = "org.make.api.operation.AdminCreateOperationRequest"
70       )
71     )
72   )
73   @Path(value = "/")
74   def adminPostOperation: Route
75 
76   @ApiOperation(value = "put-operation", httpMethod = "PUT", code = HttpCodes.OK)
77   @ApiResponses(
78     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[OperationIdResponse]))
79   )
80   @ApiImplicitParams(
81     value = Array(
82       new ApiImplicitParam(name = "operationId", paramType = "path", dataType = "string"),
83       new ApiImplicitParam(
84         name = "body",
85         paramType = "body",
86         dataType = "org.make.api.operation.AdminUpdateOperationRequest"
87       )
88     )
89   )
90   @Path(value = "/{operationId}")
91   def adminPutOperation: Route
92 
93   @ApiOperation(value = "get-operation", httpMethod = "GET", code = HttpCodes.OK)
94   @ApiResponses(
95     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[AdminOperationResponse]))
96   )
97   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "operationId", paramType = "path", dataType = "string")))
98   @Path(value = "/{operationId}")
99   def adminGetOperation: Route
100 
101   @ApiOperation(value = "get-operations", httpMethod = "GET", code = HttpCodes.OK)
102   @ApiResponses(
103     value =
104       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[AdminOperationResponse]]))
105   )
106   @ApiImplicitParams(
107     value = Array(
108       new ApiImplicitParam(
109         name = "_start",
110         paramType = "query",
111         dataType = "int",
112         allowableValues = "range[0, infinity]"
113       ),
114       new ApiImplicitParam(
115         name = "_end",
116         paramType = "query",
117         dataType = "int",
118         allowableValues = "range[0, infinity]"
119       ),
120       new ApiImplicitParam(
121         name = "_sort",
122         paramType = "query",
123         dataType = "string",
124         allowableValues = PersistentOperation.swaggerAllowableValues
125       ),
126       new ApiImplicitParam(
127         name = "_order",
128         paramType = "query",
129         dataType = "string",
130         allowableValues = Order.swaggerAllowableValues
131       ),
132       new ApiImplicitParam(name = "slug", paramType = "query", required = false, dataType = "string"),
133       new ApiImplicitParam(
134         name = "operationKind",
135         paramType = "query",
136         dataType = "string",
137         allowableValues = OperationKind.swaggerAllowableValues,
138         allowMultiple = true
139       )
140     )
141   )
142   @Path(value = "/")
143   def adminGetOperations: Route
144 
145   def routes: Route =
146     adminPostOperation ~ adminGetOperation ~ adminGetOperations ~ adminPutOperation
147 
148   protected val operationId: PathMatcher1[OperationId] = Segment.map(id => OperationId(id))
149 }
150 
151 trait AdminOperationApiComponent {
152   def adminOperationApi: AdminOperationApi
153 }
154 
155 trait DefaultAdminOperationApiComponent
156     extends AdminOperationApiComponent
157     with MakeAuthenticationDirectives
158     with Logging
159     with ParameterExtractors {
160 
161   this: MakeDirectivesDependencies
162     with QuestionServiceComponent
163     with OperationServiceComponent
164     with SequenceServiceComponent
165     with TagServiceComponent
166     with UserServiceComponent =>
167 
168   override lazy val adminOperationApi: AdminOperationApi = new DefaultAdminOperationApi
169 
170   class DefaultAdminOperationApi extends AdminOperationApi {
171 
172     private def allowedSameSlugValidation(slug: String, operationId: String, operationIdOfSlug: String) =
173       Validation.validateField(
174         "slug",
175         "invalid_value",
176         operationId === operationIdOfSlug,
177         s"Slug '$slug' already exist"
178       )
179 
180     def adminPostOperation: Route = {
181       post {
182         path("admin" / "operations") {
183           makeOperation("adminPostOperation") { _ =>
184             makeOAuth2 { auth: AuthInfo[UserRights] =>
185               requireAdminRole(auth.user) {
186                 decodeRequest {
187                   entity(as[AdminCreateOperationRequest]) { request: AdminCreateOperationRequest =>
188                     operationService.findOneBySlug(request.slug).asDirective { maybeOperation =>
189                       Validation.validate(
190                         Validation
191                           .requireNotPresent("slug", maybeOperation, Some(s"Slug '${request.slug}' already exists"))
192                       )
193                       onSuccess(
194                         operationService
195                           .create(
196                             userId = auth.user.userId,
197                             slug = request.slug,
198                             operationKind = request.operationKind,
199                             operationAuthentication = request.operationAuthentication
200                           )
201                       ) { operationId =>
202                         complete(StatusCodes.Created -> OperationIdResponse(operationId))
203                       }
204                     }
205                   }
206                 }
207               }
208             }
209           }
210         }
211       }
212     }
213 
214     def adminPutOperation: Route = {
215       put {
216         path("admin" / "operations" / operationId) { operationId =>
217           makeOperation("adminPutOperation") { _ =>
218             makeOAuth2 { auth: AuthInfo[UserRights] =>
219               requireAdminRole(auth.user) {
220                 operationService.findOneSimple(operationId).asDirectiveOrNotFound { _ =>
221                   decodeRequest {
222                     entity(as[AdminUpdateOperationRequest]) { request: AdminUpdateOperationRequest =>
223                       operationService.findOneBySlug(request.slug).asDirective { maybeOperation =>
224                         maybeOperation.foreach { operation =>
225                           Validation.validate(
226                             allowedSameSlugValidation(request.slug, operation.operationId.value, operationId.value)
227                           )
228                         }
229                         operationService
230                           .update(
231                             operationId = operationId,
232                             userId = auth.user.userId,
233                             slug = Some(request.slug),
234                             operationKind = Some(request.operationKind),
235                             operationAuthentication = request.operationAuthentication
236                           )
237                           .asDirectiveOrNotFound { id =>
238                             complete(OperationIdResponse(id))
239                           }
240                       }
241                     }
242                   }
243                 }
244               }
245             }
246           }
247         }
248       }
249     }
250 
251     def adminGetOperation: Route = {
252       get {
253         path("admin" / "operations" / operationId) { operationId =>
254           makeOperation("adminGetOperation") { _ =>
255             makeOAuth2 { auth: AuthInfo[UserRights] =>
256               requireAdminRole(auth.user) {
257                 operationService.findOneSimple(operationId).asDirectiveOrNotFound { operation =>
258                   complete(AdminOperationResponse.apply(operation = operation))
259                 }
260               }
261             }
262           }
263         }
264       }
265     }
266 
267     def adminGetOperations: Route = {
268       get {
269         path("admin" / "operations") {
270           makeOperation("adminGetOperations") { _ =>
271             parameters(
272               "_start".as[Pagination.Offset].?,
273               "_end".as[Pagination.End].?,
274               "_sort".?,
275               "_order".as[Order].?,
276               "slug".?,
277               "operationKind".csv[OperationKind]
278             ) {
279               (
280                 offset: Option[Pagination.Offset],
281                 end: Option[Pagination.End],
282                 sort: Option[String],
283                 order: Option[Order],
284                 slug: Option[String],
285                 operationKinds: Option[Seq[OperationKind]]
286               ) =>
287                 makeOAuth2 { auth: AuthInfo[UserRights] =>
288                   requireAdminRole(auth.user) {
289                     (
290                       operationService.count(slug = slug, operationKinds = operationKinds).asDirective,
291                       operationService
292                         .findSimple(
293                           offset = offset.orZero,
294                           end = end,
295                           sort = sort,
296                           order = order,
297                           slug = slug,
298                           operationKinds = operationKinds
299                         )
300                         .asDirective
301                     ).tupled.apply({
302                       case (count, operations) =>
303                         val operationResponses: Seq[AdminOperationResponse] =
304                           operations.map(AdminOperationResponse(_))
305                         complete((StatusCodes.OK, List(`X-Total-Count`(count.toString)), operationResponses))
306                     })
307                   }
308                 }
309             }
310           }
311         }
312       }
313     }
314   }
315 }