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.feature
21 
22 import cats.implicits._
23 import akka.http.scaladsl.model.StatusCodes
24 import akka.http.scaladsl.server._
25 import io.circe.generic.semiauto.{deriveCodec, deriveDecoder}
26 import io.circe.{Codec, Decoder}
27 import io.swagger.annotations._
28 import org.make.api.feature.DefaultPersistentActiveFeatureServiceComponent.PersistentActiveFeature
29 import org.make.api.operation.OperationServiceComponent
30 import org.make.api.question.QuestionServiceComponent
31 
32 import javax.ws.rs.Path
33 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
34 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
35 import org.make.api.technical.directives.FutureDirectivesExtensions._
36 import org.make.core.technical.Pagination
37 import org.make.core.auth.UserRights
38 import org.make.core.feature.{ActiveFeature, ActiveFeatureId, FeatureId}
39 import org.make.core.question.QuestionId
40 import org.make.core.{HttpCodes, Order, ParameterExtractors, Validation, ValidationError}
41 import scalaoauth2.provider.AuthInfo
42 
43 import scala.annotation.meta.field
44 import scala.concurrent.ExecutionContext.Implicits.global
45 import scala.concurrent.Future
46 import org.make.core.question.Question
47 
48 @Api(value = "Admin Active Features")
49 @Path(value = "/admin/active-features")
50 trait AdminActiveFeatureApi extends Directives {
51 
52   @Path(value = "/{activeFeatureId}")
53   @ApiOperation(
54     value = "get-active-feature",
55     httpMethod = "GET",
56     code = HttpCodes.OK,
57     authorizations = Array(
58       new Authorization(
59         value = "MakeApi",
60         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
61       )
62     )
63   )
64   @ApiResponses(
65     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[ActiveFeatureResponse]))
66   )
67   @ApiImplicitParams(
68     value = Array(new ApiImplicitParam(name = "activeFeatureId", paramType = "path", dataType = "string"))
69   )
70   def adminGetActiveFeature: Route
71 
72   @ApiOperation(
73     value = "create-active-feature",
74     httpMethod = "POST",
75     code = HttpCodes.OK,
76     authorizations = Array(
77       new Authorization(
78         value = "MakeApi",
79         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
80       )
81     )
82   )
83   @ApiImplicitParams(
84     value = Array(
85       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.feature.ActiveFeatureRequest")
86     )
87   )
88   @ApiResponses(
89     value = Array(new ApiResponse(code = HttpCodes.Created, message = "Ok", response = classOf[ActiveFeatureResponse]))
90   )
91   @Path(value = "/")
92   def adminCreateActiveFeature: Route
93 
94   @ApiOperation(
95     value = "list-active-features",
96     httpMethod = "GET",
97     code = HttpCodes.OK,
98     authorizations = Array(
99       new Authorization(
100         value = "MakeApi",
101         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
102       )
103     )
104   )
105   @ApiImplicitParams(
106     value = Array(
107       new ApiImplicitParam(
108         name = "_start",
109         paramType = "query",
110         dataType = "int",
111         allowableValues = "range[0, infinity]"
112       ),
113       new ApiImplicitParam(
114         name = "_end",
115         paramType = "query",
116         dataType = "int",
117         allowableValues = "range[0, infinity]"
118       ),
119       new ApiImplicitParam(
120         name = "_sort",
121         paramType = "query",
122         dataType = "string",
123         allowableValues = PersistentActiveFeature.swaggerAllowableValues
124       ),
125       new ApiImplicitParam(
126         name = "_order",
127         paramType = "query",
128         dataType = "string",
129         allowableValues = Order.swaggerAllowableValues
130       ),
131       new ApiImplicitParam(name = "questionId", paramType = "query", dataType = "string")
132     )
133   )
134   @ApiResponses(
135     value =
136       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[ActiveFeatureResponse]]))
137   )
138   @Path(value = "/")
139   def adminListActiveFeatures: Route
140 
141   @ApiOperation(
142     value = "delete-active-feature",
143     httpMethod = "DELETE",
144     code = HttpCodes.OK,
145     authorizations = Array(
146       new Authorization(
147         value = "MakeApi",
148         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
149       )
150     )
151   )
152   @ApiImplicitParams(
153     value = Array(new ApiImplicitParam(name = "activeFeatureId", paramType = "path", dataType = "string"))
154   )
155   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "Ok")))
156   @Path(value = "/{activeFeatureId}")
157   def adminDeleteActiveFeature: Route
158 
159   @ApiOperation(
160     value = "delete-active-feature-from-feature-id",
161     httpMethod = "DELETE",
162     code = HttpCodes.OK,
163     authorizations = Array(
164       new Authorization(
165         value = "MakeApi",
166         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
167       )
168     )
169   )
170   @ApiImplicitParams(
171     value = Array(
172       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.feature.ActiveFeatureRequest")
173     )
174   )
175   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "Ok")))
176   @Path(value = "/")
177   def adminDeleteActiveFeatureFromFeatureId: Route
178 
179   def routes: Route =
180     adminGetActiveFeature ~ adminCreateActiveFeature ~ adminListActiveFeatures ~ adminDeleteActiveFeature ~ adminDeleteActiveFeatureFromFeatureId
181 }
182 
183 trait AdminActiveFeatureApiComponent {
184   def adminActiveFeatureApi: AdminActiveFeatureApi
185 }
186 
187 trait DefaultAdminActiveFeatureApiComponent
188     extends AdminActiveFeatureApiComponent
189     with MakeAuthenticationDirectives
190     with ParameterExtractors {
191   this: MakeDirectivesDependencies
192     with ActiveFeatureServiceComponent
193     with FeatureServiceComponent
194     with QuestionServiceComponent
195     with OperationServiceComponent =>
196 
197   override lazy val adminActiveFeatureApi: AdminActiveFeatureApi = new DefaultAdminActiveFeatureApi
198 
199   class DefaultAdminActiveFeatureApi extends AdminActiveFeatureApi {
200 
201     val adminActiveFeatureId: PathMatcher1[ActiveFeatureId] = Segment.map(id => ActiveFeatureId(id))
202 
203     override def adminGetActiveFeature: Route = {
204       get {
205         path("admin" / "active-features" / adminActiveFeatureId) { activeFeatureId =>
206           makeOperation("AdminGetActiveFeature") { _ =>
207             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
208               requireAdminRole(userAuth.user) {
209                 activeFeatureService.getActiveFeature(activeFeatureId).asDirectiveOrNotFound { activeFeature =>
210                   complete(ActiveFeatureResponse(activeFeature))
211                 }
212               }
213             }
214           }
215         }
216       }
217     }
218 
219     override def adminCreateActiveFeature: Route = post {
220       path("admin" / "active-features") {
221         makeOperation("AdminRegisterActiveFeature") { _ =>
222           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
223             requireAdminRole(userAuth.user) {
224               decodeRequest {
225                 entity(as[ActiveFeatureRequest]) { request: ActiveFeatureRequest =>
226                   (
227                     featureService
228                       .getFeature(request.featureId)
229                       .asDirectiveOrBadRequest(
230                         ValidationError(
231                           "featureId",
232                           "not_found",
233                           Some(s"Feature ${request.featureId.value} doesn't exist")
234                         )
235                       ),
236                     request.maybeQuestionId
237                       .fold(Future.successful(Option.empty[Question]))(questionService.getCachedQuestion)
238                       .asDirective
239                   ).tupled.flatMap {
240                     case (_, foundQuestion: Option[Question]) =>
241                       Validation.validateOptional(request.maybeQuestionId.map { qId =>
242                         Validation.validateField(
243                           "questionId",
244                           "not_found",
245                           foundQuestion.isDefined,
246                           s"Question ${qId.value} doesn't exist"
247                         )
248                       })
249                       activeFeatureService
250                         .find(
251                           maybeQuestionId = request.maybeQuestionId.map(Seq(_)),
252                           featureIds = Some(Seq(request.featureId))
253                         )
254                         .asDirective
255                   }.flatMap { actives =>
256                     Validation.validate(
257                       Validation.requireEmpty(
258                         "questionId",
259                         actives,
260                         Some(
261                           s"An active feature already exists for questionId ${request.maybeQuestionId} and featureId ${request.featureId}"
262                         )
263                       )
264                     )
265                     activeFeatureService
266                       .createActiveFeature(featureId = request.featureId, maybeQuestionId = request.maybeQuestionId)
267                       .asDirective
268                   }.apply { activeFeature =>
269                     complete(StatusCodes.Created -> ActiveFeatureResponse(activeFeature))
270                   }
271                 }
272               }
273             }
274           }
275         }
276       }
277     }
278 
279     override def adminListActiveFeatures: Route = {
280       get {
281         path("admin" / "active-features") {
282           makeOperation("AdminSearchActiveFeature") { _ =>
283             parameters(
284               "_start".as[Pagination.Offset].?,
285               "_end".as[Pagination.End].?,
286               "_sort".?,
287               "_order".as[Order].?,
288               "questionId".as[QuestionId].?
289             ) {
290               (
291                 offset: Option[Pagination.Offset],
292                 end: Option[Pagination.End],
293                 sort: Option[String],
294                 order: Option[Order],
295                 maybeQuestionId: Option[QuestionId]
296               ) =>
297                 makeOAuth2 { userAuth: AuthInfo[UserRights] =>
298                   requireAdminRole(userAuth.user) {
299                     activeFeatureService.count(maybeQuestionId = maybeQuestionId).asDirective { count =>
300                       onSuccess(
301                         activeFeatureService
302                           .find(
303                             offset = offset.orZero,
304                             end = end,
305                             sort = sort,
306                             order = order,
307                             maybeQuestionId = maybeQuestionId.map(Seq(_))
308                           )
309                       ) { filteredActiveFeatures =>
310                         complete(
311                           (
312                             StatusCodes.OK,
313                             List(`X-Total-Count`(count.toString)),
314                             filteredActiveFeatures.map(ActiveFeatureResponse.apply)
315                           )
316                         )
317                       }
318                     }
319                   }
320                 }
321             }
322           }
323         }
324       }
325     }
326 
327     override def adminDeleteActiveFeature: Route = delete {
328       path("admin" / "active-features" / adminActiveFeatureId) { activeFeatureId =>
329         makeOperation("AdminDeleteActiveFeature") { _ =>
330           makeOAuth2 { auth: AuthInfo[UserRights] =>
331             requireAdminRole(auth.user) {
332               activeFeatureService.getActiveFeature(activeFeatureId).asDirectiveOrNotFound { _ =>
333                 activeFeatureService.deleteActiveFeature(activeFeatureId).asDirective { _ =>
334                   complete(StatusCodes.NoContent)
335                 }
336               }
337             }
338           }
339         }
340       }
341     }
342 
343     override def adminDeleteActiveFeatureFromFeatureId: Route = delete {
344       path("admin" / "active-features") {
345         makeOperation("AdminDeleteActiveFeatureFromFeatureId") { _ =>
346           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
347             requireAdminRole(userAuth.user) {
348               decodeRequest {
349                 entity(as[ActiveFeatureRequest]) { request: ActiveFeatureRequest =>
350                   val foundActiveFeature = activeFeatureService
351                     .find(
352                       maybeQuestionId = request.maybeQuestionId.map(questionId => Seq(questionId)),
353                       featureIds = Some(Seq(request.featureId))
354                     )
355                     .map {
356                       case Seq(head) => Some(head)
357                       case _         => None
358                     }
359                   foundActiveFeature.asDirectiveOrNotFound { activeFeature =>
360                     activeFeatureService.deleteActiveFeature(activeFeature.activeFeatureId).asDirective { _ =>
361                       complete(StatusCodes.NoContent)
362                     }
363                   }
364                 }
365               }
366             }
367           }
368         }
369       }
370     }
371   }
372 }
373 
374 final case class ActiveFeatureRequest(
375   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
376   featureId: FeatureId,
377   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
378   maybeQuestionId: Option[QuestionId]
379 )
380 
381 object ActiveFeatureRequest {
382   implicit val decoder: Decoder[ActiveFeatureRequest] = deriveDecoder[ActiveFeatureRequest]
383 }
384 
385 final case class ActiveFeatureResponse(
386   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
387   id: ActiveFeatureId,
388   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
389   featureId: FeatureId,
390   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
391   maybeQuestionId: Option[QuestionId]
392 )
393 
394 object ActiveFeatureResponse {
395   implicit val codec: Codec[ActiveFeatureResponse] = deriveCodec
396 
397   def apply(activeFeature: ActiveFeature): ActiveFeatureResponse =
398     ActiveFeatureResponse(
399       id = activeFeature.activeFeatureId,
400       featureId = activeFeature.featureId,
401       maybeQuestionId = activeFeature.maybeQuestionId
402     )
403 }