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 akka.http.scaladsl.model.StatusCodes
23 import akka.http.scaladsl.server._
24 import cats.implicits._
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.api.user.UserServiceComponent
44 import org.make.core.{CirceFormatters, HttpCodes, Order, ParameterExtractors, ValidationError}
45 import org.make.core.auth.UserRights
46 import org.make.core.question.QuestionId
47 import org.make.core.reference.{Country, Language}
48 import org.make.core.sequence.SequenceKind
49 import org.make.core.technical.Pagination
50 import org.make.core.technical.ValidatedUtils.ValidatedNecWithUtils
51 import org.make.core.user.User
52 import org.make.core.Validation._
53 import org.make.core.widget.{SourceId, Widget, WidgetId}
54 import scalaoauth2.provider.AuthInfo
55 
56 import java.time.ZonedDateTime
57 import javax.ws.rs.Path
58 import scala.annotation.meta.field
59 
60 @Api(value = "Admin Widgets")
61 @Path(value = "/admin/widgets")
62 trait AdminWidgetApi extends Directives {
63 
64   @ApiOperation(
65     value = "list-widgets",
66     httpMethod = "GET",
67     code = HttpCodes.OK,
68     authorizations = Array(
69       new Authorization(
70         value = "MakeApi",
71         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
72       )
73     )
74   )
75   @ApiImplicitParams(
76     value = Array(
77       new ApiImplicitParam(name = "sourceId", required = true, paramType = "query", dataType = "string"),
78       new ApiImplicitParam(
79         name = "_start",
80         paramType = "query",
81         dataType = "int",
82         allowableValues = "range[0, infinity]"
83       ),
84       new ApiImplicitParam(
85         name = "_end",
86         paramType = "query",
87         dataType = "int",
88         allowableValues = "range[0, infinity]"
89       ),
90       new ApiImplicitParam(
91         name = "_sort",
92         paramType = "query",
93         dataType = "string",
94         allowableValues = "version,country,createdAt"
95       ),
96       new ApiImplicitParam(
97         name = "_order",
98         paramType = "query",
99         dataType = "string",
100         allowableValues = Order.swaggerAllowableValues
101       )
102     )
103   )
104   @ApiResponses(
105     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[AdminWidgetResponse]]))
106   )
107   @Path(value = "/")
108   def list: Route
109 
110   @ApiOperation(
111     value = "get-widget-by-id",
112     httpMethod = "GET",
113     code = HttpCodes.OK,
114     authorizations = Array(
115       new Authorization(
116         value = "MakeApi",
117         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
118       )
119     )
120   )
121   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "id", paramType = "path", dataType = "string")))
122   @ApiResponses(
123     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[AdminWidgetResponse]))
124   )
125   @Path(value = "/{id}")
126   def getById: Route
127 
128   @ApiOperation(
129     value = "create-widget",
130     httpMethod = "POST",
131     code = HttpCodes.Created,
132     authorizations = Array(
133       new Authorization(
134         value = "MakeApi",
135         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
136       )
137     )
138   )
139   @ApiImplicitParams(
140     value = Array(
141       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.widget.AdminWidgetRequest")
142     )
143   )
144   @ApiResponses(
145     value = Array(new ApiResponse(code = HttpCodes.Created, message = "Ok", response = classOf[AdminWidgetResponse]))
146   )
147   @Path(value = "/")
148   def create: Route
149 
150   def routes: Route = list ~ getById ~ create
151 
152 }
153 
154 trait AdminWidgetApiComponent {
155   def adminWidgetApi: AdminWidgetApi
156 }
157 
158 trait DefaultAdminWidgetApiComponent
159     extends AdminWidgetApiComponent
160     with MakeAuthenticationDirectives
161     with ParameterExtractors {
162 
163   self: MakeDirectivesDependencies
164     with QuestionServiceComponent
165     with OperationServiceComponent
166     with SourceServiceComponent
167     with UserServiceComponent
168     with WidgetServiceComponent =>
169 
170   override val adminWidgetApi: AdminWidgetApi = new AdminWidgetApi {
171 
172     private val id: PathMatcher1[WidgetId] = Segment.map(WidgetId.apply)
173 
174     override def list: Route = get {
175       path("admin" / "widgets") {
176         parameters(
177           "sourceId".as[SourceId],
178           "_start".as[Pagination.Offset].?,
179           "_end".as[Pagination.End].?,
180           "_sort".?,
181           "_order".as[Order].?
182         ) {
183           (
184             sourceId: SourceId,
185             offset: Option[Pagination.Offset],
186             end: Option[Pagination.End],
187             sort: Option[String],
188             order: Option[Order]
189           ) =>
190             makeOperation("AdminWidgetsList") { _ =>
191               makeOAuth2 { userAuth: AuthInfo[UserRights] =>
192                 requireAdminRole(userAuth.user) {
193                   (
194                     widgetService.count(sourceId).asDirective,
195                     widgetService.list(sourceId, offset, end, sort, order).asDirective
196                   ).tupled.apply {
197                     case (total, widgets) =>
198                       userService.getUsersByUserIds(widgets.map(_.author).distinct).asDirective { authors =>
199                         val authorsById = authors.toList.groupByNel(_.userId)
200                         complete(
201                           StatusCodes.OK,
202                           List(`X-Total-Count`(total.toString)),
203                           widgets.map(widget => AdminWidgetResponse(widget, authorsById.get(widget.author).map(_.head)))
204                         )
205                       }
206                   }
207                 }
208               }
209             }
210         }
211       }
212     }
213 
214     override def getById: Route = get {
215       path("admin" / "widgets" / id) { id =>
216         makeOperation("AdminWidgetsGetById") { _ =>
217           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
218             requireAdminRole(userAuth.user) {
219               widgetService.get(id).asDirectiveOrNotFound { widget =>
220                 userService.getUser(widget.author).asDirectiveOrNotFound { author =>
221                   complete(AdminWidgetResponse(widget, Some(author)))
222                 }
223               }
224             }
225           }
226         }
227       }
228     }
229 
230     override def create: Route = post {
231       path("admin" / "widgets") {
232         makeOperation("AdminWidgetsCreate") { _ =>
233           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
234             requireAdminRole(userAuth.user) {
235               decodeRequest {
236                 entity(as[AdminWidgetRequest]) { request: AdminWidgetRequest =>
237                   (
238                     sourceService
239                       .get(request.sourceId)
240                       .asDirectiveOrBadRequest(
241                         ValidationError(
242                           "sourceId",
243                           "not_found",
244                           Some(s"Source ${request.sourceId.value} doesn't exist")
245                         )
246                       ),
247                     questionService
248                       .getQuestion(request.questionId)
249                       .asDirectiveOrBadRequest(
250                         ValidationError(
251                           "questionId",
252                           "not_found",
253                           Some(s"Question ${request.questionId.value} doesn't exist")
254                         )
255                       )
256                   ).mapN((source, question) => {
257                       request.country
258                         .predicateValidated(
259                           country => question.countries.toList.contains(country),
260                           "country",
261                           "invalid_value",
262                           Some(s"Country ${request.country.value} is not one of question's countries")
263                         )
264                         .throwIfInvalid()
265                       (
266                         userService.getUser(userAuth.user.userId).asDirectiveOrNotFound,
267                         widgetService
268                           .create(
269                             source,
270                             question,
271                             request.country,
272                             request.language,
273                             request.sequenceKind,
274                             userAuth.user.userId
275                           )
276                           .asDirective
277                       ).mapN((author, widget) => AdminWidgetResponse(widget, Some(author)))
278                     })
279                     .flatten
280                     .apply(response => complete(StatusCodes.Created -> response))
281                 }
282               }
283             }
284           }
285         }
286       }
287     }
288   }
289 
290 }
291 
292 final case class AdminWidgetRequest(
293   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
294   sourceId: SourceId,
295   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
296   questionId: QuestionId,
297   @(ApiModelProperty @field)(dataType = "string", example = "FR", required = true)
298   country: Country,
299   @(ApiModelProperty @field)(dataType = "string", example = "fr", required = true)
300   language: Language,
301   @(ApiModelProperty @field)(
302     dataType = "string",
303     required = true,
304     allowableValues = SequenceKind.swaggerAllowableValues
305   )
306   sequenceKind: SequenceKind
307 )
308 
309 object AdminWidgetRequest {
310   implicit val codec: Codec[AdminWidgetRequest] = deriveCodec
311 }
312 
313 final case class AdminWidgetResponse(
314   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
315   id: WidgetId,
316   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
317   questionId: QuestionId,
318   @(ApiModelProperty @field)(dataType = "string", example = "FR", required = true)
319   country: Country,
320   @(ApiModelProperty @field)(dataType = "string", example = "fr", required = true)
321   language: Language,
322   script: String,
323   @(ApiModelProperty @field)(
324     dataType = "string",
325     required = true,
326     allowableValues = Widget.Version.swaggerAllowableValues
327   )
328   version: Widget.Version,
329   authorDisplayName: Option[String],
330   @(ApiModelProperty @field)(
331     dataType = "string",
332     required = true,
333     allowableValues = SequenceKind.swaggerAllowableValues
334   )
335   sequenceKind: SequenceKind,
336   createdAt: ZonedDateTime
337 )
338 
339 object AdminWidgetResponse extends CirceFormatters {
340 
341   def apply(widget: Widget, author: Option[User]): AdminWidgetResponse =
342     AdminWidgetResponse(
343       id = widget.id,
344       questionId = widget.questionId,
345       country = widget.country,
346       language = widget.language,
347       script = widget.script,
348       version = widget.version,
349       authorDisplayName = author.flatMap(_.displayName),
350       sequenceKind = widget.sequenceKind,
351       createdAt = widget.createdAt
352     )
353 
354   implicit val codec: Codec[AdminWidgetResponse] = deriveCodec
355 
356 }