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.{deriveDecoder, deriveEncoder}
26 import io.circe.{Decoder, Encoder}
27 import io.swagger.annotations._
28 import org.make.api.feature.DefaultPersistentFeatureServiceComponent.PersistentFeature
29 import org.make.api.question.{ModerationQuestionResponse, QuestionServiceComponent, SearchQuestionRequest}
30 
31 import javax.ws.rs.Path
32 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
33 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
34 import org.make.api.technical.directives.FutureDirectivesExtensions._
35 import org.make.core.technical.ValidatedUtils.ValidatedNecWithUtils
36 import org.make.core.technical.Pagination
37 import org.make.core.auth.UserRights
38 import org.make.core.feature.{Feature, FeatureId, FeatureSlug}
39 import org.make.core.question.Question
40 import org.make.core.{HttpCodes, Order, ParameterExtractors, Validation}
41 import Validation.StringWithParsers
42 import org.make.api.operation.OperationServiceComponent
43 import scalaoauth2.provider.AuthInfo
44 
45 import scala.annotation.meta.field
46 
47 @Api(value = "Admin Features")
48 @Path(value = "/admin/features")
49 trait AdminFeatureApi extends Directives {
50 
51   @Path(value = "/{featureId}")
52   @ApiOperation(
53     value = "get-feature",
54     httpMethod = "GET",
55     code = HttpCodes.OK,
56     authorizations = Array(
57       new Authorization(
58         value = "MakeApi",
59         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
60       )
61     )
62   )
63   @ApiResponses(
64     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[FeatureResponse]))
65   )
66   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "featureId", paramType = "path", dataType = "string")))
67   def adminGetFeature: Route
68 
69   @ApiOperation(
70     value = "create-feature",
71     httpMethod = "POST",
72     code = HttpCodes.OK,
73     authorizations = Array(
74       new Authorization(
75         value = "MakeApi",
76         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
77       )
78     )
79   )
80   @ApiImplicitParams(
81     value = Array(
82       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.feature.CreateFeatureRequest")
83     )
84   )
85   @ApiResponses(
86     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[FeatureResponse]))
87   )
88   @Path(value = "/")
89   def adminCreateFeature: Route
90 
91   @ApiOperation(
92     value = "list-features",
93     httpMethod = "GET",
94     code = HttpCodes.OK,
95     authorizations = Array(
96       new Authorization(
97         value = "MakeApi",
98         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
99       )
100     )
101   )
102   @ApiImplicitParams(
103     value = Array(
104       new ApiImplicitParam(
105         name = "_start",
106         paramType = "query",
107         dataType = "int",
108         allowableValues = "range[0, infinity]"
109       ),
110       new ApiImplicitParam(
111         name = "_end",
112         paramType = "query",
113         dataType = "int",
114         allowableValues = "range[0, infinity]"
115       ),
116       new ApiImplicitParam(
117         name = "_sort",
118         paramType = "query",
119         dataType = "string",
120         allowableValues = PersistentFeature.swaggerAllowableValues
121       ),
122       new ApiImplicitParam(
123         name = "_order",
124         paramType = "query",
125         dataType = "string",
126         allowableValues = Order.swaggerAllowableValues
127       ),
128       new ApiImplicitParam(name = "slug", paramType = "query", dataType = "string")
129     )
130   )
131   @ApiResponses(
132     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[FeatureResponse]]))
133   )
134   @Path(value = "/")
135   def adminListFeatures: Route
136 
137   @ApiOperation(
138     value = "update-feature",
139     httpMethod = "PUT",
140     code = HttpCodes.OK,
141     authorizations = Array(
142       new Authorization(
143         value = "MakeApi",
144         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
145       )
146     )
147   )
148   @ApiImplicitParams(
149     value = Array(
150       new ApiImplicitParam(name = "featureId", paramType = "path", dataType = "string"),
151       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.feature.UpdateFeatureRequest")
152     )
153   )
154   @ApiResponses(
155     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[FeatureResponse]))
156   )
157   @Path(value = "/{featureId}")
158   def adminUpdateFeature: Route
159 
160   @ApiOperation(
161     value = "delete-feature",
162     httpMethod = "DELETE",
163     code = HttpCodes.OK,
164     authorizations = Array(
165       new Authorization(
166         value = "MakeApi",
167         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
168       )
169     )
170   )
171   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "featureId", paramType = "path", dataType = "string")))
172   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok")))
173   @Path(value = "/{featureId}")
174   def adminDeleteFeature: Route
175 
176   def routes: Route = adminGetFeature ~ adminCreateFeature ~ adminListFeatures ~ adminUpdateFeature ~ adminDeleteFeature
177 }
178 
179 trait AdminFeatureApiComponent {
180   def adminFeatureApi: AdminFeatureApi
181 }
182 
183 trait DefaultAdminFeatureApiComponent
184     extends AdminFeatureApiComponent
185     with MakeAuthenticationDirectives
186     with ParameterExtractors {
187   this: MakeDirectivesDependencies
188     with FeatureServiceComponent
189     with ActiveFeatureServiceComponent
190     with QuestionServiceComponent
191     with OperationServiceComponent =>
192 
193   override lazy val adminFeatureApi: AdminFeatureApi = new DefaultAdminFeatureApi
194 
195   class DefaultAdminFeatureApi extends AdminFeatureApi {
196 
197     val adminFeatureId: PathMatcher1[FeatureId] = Segment.map(id => FeatureId(id))
198 
199     override def adminGetFeature: Route = {
200       get {
201         path("admin" / "features" / adminFeatureId) { featureId =>
202           makeOperation("AdminGetFeature") { _ =>
203             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
204               requireAdminRole(userAuth.user) {
205                 (
206                   featureService.getFeature(featureId).asDirectiveOrNotFound,
207                   activeFeatureService.find(featureIds = Some(Seq(featureId))).asDirective
208                 ).tupled.apply({
209                   case (feature, activeFeatures) =>
210                     val questionIds = activeFeatures.flatMap(_.maybeQuestionId).distinct
211                     questionService.searchQuestion(SearchQuestionRequest(Some(questionIds))).asDirective { questions =>
212                       complete(FeatureResponse(feature, questions))
213                     }
214                 })
215               }
216             }
217           }
218         }
219       }
220     }
221 
222     import Validation.{IterableWithParsers, StringWithParsers}
223 
224     @SuppressWarnings(Array("org.wartremover.warts.Throw"))
225     override def adminCreateFeature: Route = post {
226       path("admin" / "features") {
227         makeOperation("AdminRegisterFeature") { _ =>
228           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
229             requireAdminRole(userAuth.user) {
230               decodeRequest {
231                 entity(as[CreateFeatureRequest]) { request: CreateFeatureRequest =>
232                   featureService.findBySlug(request.slug).asDirective { featureList =>
233                     (
234                       featureList.toEmpty(
235                         "feature_slug",
236                         Some("Feature slug already exists in this context. Duplicates are forbidden")
237                       ),
238                       request.name.toSanitizedInput("name")
239                     ).tupled.toValidationEither.fold(failWith(_), {
240                       case (_, sanitizedName) =>
241                         onSuccess(featureService.createFeature(name = sanitizedName.value, slug = request.slug)) {
242                           feature =>
243                             complete(StatusCodes.Created -> FeatureResponse(feature, Seq.empty))
244                         }
245                     })
246                   }
247                 }
248               }
249             }
250           }
251         }
252       }
253     }
254 
255     override def adminListFeatures: Route = {
256       get {
257         path("admin" / "features") {
258           makeOperation("AdminSearchFeature") { _ =>
259             parameters(
260               "_start".as[Pagination.Offset].?,
261               "_end".as[Pagination.End].?,
262               "_sort".?,
263               "_order".as[Order].?,
264               "slug".?
265             ) {
266               (
267                 offset: Option[Pagination.Offset],
268                 end: Option[Pagination.End],
269                 sort: Option[String],
270                 order: Option[Order],
271                 maybeSlug: Option[String]
272               ) =>
273                 makeOAuth2 { userAuth: AuthInfo[UserRights] =>
274                   requireAdminRole(userAuth.user) {
275                     val futureFeatures = featureService
276                       .find(offset = offset.orZero, end = end, sort = sort, order = order, slug = maybeSlug)
277 
278                     featureService.count(slug = maybeSlug).asDirective { count =>
279                       onSuccess(futureFeatures) { filteredFeatures =>
280                         activeFeatureService.find(featureIds = Some(filteredFeatures.map(_.featureId))).asDirective {
281                           activeFeatures =>
282                             val questionIds = activeFeatures.flatMap(_.maybeQuestionId).distinct
283                             questionService.searchQuestion(SearchQuestionRequest(Some(questionIds))).asDirective {
284                               questions =>
285                                 val questionsByFeature =
286                                   activeFeatures.groupMapReduce(_.featureId)(af => Set.from(af.maybeQuestionId))(_ ++ _)
287                                 val response = filteredFeatures.map { feature =>
288                                   FeatureResponse(
289                                     feature = feature,
290                                     questions = questions.filter(
291                                       q =>
292                                         questionsByFeature
293                                           .getOrElse(feature.featureId, Set.empty)
294                                           .contains(q.questionId)
295                                     )
296                                   )
297                                 }
298                                 complete((StatusCodes.OK, List(`X-Total-Count`(count.toString)), response))
299                             }
300                         }
301                       }
302                     }
303                   }
304                 }
305             }
306           }
307         }
308       }
309     }
310 
311     override def adminUpdateFeature: Route = put {
312       path("admin" / "features" / adminFeatureId) { featureId =>
313         makeOperation("AdminUpdateFeature") { _ =>
314           makeOAuth2 { auth: AuthInfo[UserRights] =>
315             requireAdminRole(auth.user) {
316               decodeRequest {
317                 entity(as[UpdateFeatureRequest]) { request: UpdateFeatureRequest =>
318                   featureService.findBySlug(request.slug).asDirective { featureList =>
319                     Validation.validate(
320                       Validation.requireEmpty(
321                         fieldName = "slug",
322                         fieldValue = featureList.filterNot(feature => feature.featureId == featureId),
323                         message = Some("Feature slug already exists in this context. Duplicates are not allowed")
324                       )
325                     )
326                     (
327                       featureService
328                         .updateFeature(featureId = featureId, slug = request.slug, name = request.name)
329                         .asDirectiveOrNotFound,
330                       activeFeatureService.find(featureIds = Some(Seq(featureId))).asDirective
331                     ).tupled.apply({
332                       case (feature, activeFeatures) =>
333                         val questionIds = activeFeatures.flatMap(_.maybeQuestionId).distinct
334                         questionService.searchQuestion(SearchQuestionRequest(Some(questionIds))).asDirective {
335                           questions =>
336                             complete(FeatureResponse(feature, questions))
337                         }
338                     })
339                   }
340                 }
341               }
342 
343             }
344           }
345         }
346       }
347     }
348 
349     override def adminDeleteFeature: Route = delete {
350       path("admin" / "features" / adminFeatureId) { featureId =>
351         makeOperation("AdminDeleteFeature") { _ =>
352           makeOAuth2 { auth: AuthInfo[UserRights] =>
353             requireAdminRole(auth.user) {
354               featureService.getFeature(featureId).asDirectiveOrNotFound { _ =>
355                 featureService.deleteFeature(featureId).asDirective { _ =>
356                   complete(StatusCodes.OK -> FeatureIdResponse(featureId))
357                 }
358               }
359             }
360           }
361         }
362       }
363     }
364   }
365 }
366 
367 final case class CreateFeatureRequest(
368   name: String,
369   @(ApiModelProperty @field)(dataType = "string", example = "sequence-custom-data-segment", required = true)
370   slug: FeatureSlug
371 ) {
372 
373   slug.value.toNonEmpty("slug", Some("Slug must not be empty")).throwIfInvalid()
374 }
375 
376 object CreateFeatureRequest {
377   implicit val decoder: Decoder[CreateFeatureRequest] = deriveDecoder[CreateFeatureRequest]
378 }
379 
380 final case class UpdateFeatureRequest(
381   name: String,
382   @(ApiModelProperty @field)(dataType = "string", example = "sequence-custom-data-segment", required = true)
383   slug: FeatureSlug
384 ) {
385 
386   slug.value.toNonEmpty("slug", Some("Slug must not be empty")).throwIfInvalid()
387 }
388 
389 object UpdateFeatureRequest {
390   implicit val decoder: Decoder[UpdateFeatureRequest] = deriveDecoder[UpdateFeatureRequest]
391 }
392 
393 final case class FeatureResponse(
394   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555") id: FeatureId,
395   name: String,
396   @(ApiModelProperty @field)(dataType = "string", example = "sequence-custom-data-segment")
397   slug: FeatureSlug,
398   questions: Seq[ModerationQuestionResponse]
399 )
400 
401 object FeatureResponse {
402   implicit val encoder: Encoder[FeatureResponse] = deriveEncoder[FeatureResponse]
403   implicit val decoder: Decoder[FeatureResponse] = deriveDecoder[FeatureResponse]
404 
405   def apply(feature: Feature, questions: Seq[Question]): FeatureResponse =
406     FeatureResponse(
407       id = feature.featureId,
408       name = feature.name,
409       slug = feature.slug,
410       questions = questions.map(ModerationQuestionResponse.apply)
411     )
412 }
413 
414 final case class FeatureIdResponse(
415   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
416   id: FeatureId,
417   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
418   featureId: FeatureId
419 )
420 
421 object FeatureIdResponse {
422   implicit val encoder: Encoder[FeatureIdResponse] = deriveEncoder[FeatureIdResponse]
423 
424   def apply(id: FeatureId): FeatureIdResponse = FeatureIdResponse(id, id)
425 }