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.demographics
21 
22 import org.make.api.operation.OperationServiceComponent
23 import org.make.api.question.QuestionServiceComponent
24 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
25 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
26 import org.make.api.technical.CsvReceptacle._
27 import org.make.api.technical.directives.FutureDirectivesExtensions._
28 import org.make.core._
29 import org.make.core.Validation._
30 import org.make.core.auth.UserRights
31 import org.make.core.demographics.{DemographicsCard, DemographicsCardId, LabelsValue}
32 import org.make.core.question.QuestionId
33 import org.make.core.reference.Language
34 import org.make.core.technical.{Multilingual, Pagination}
35 
36 import cats.data.NonEmptyList
37 import cats.implicits._
38 import akka.http.scaladsl.model.StatusCodes
39 import akka.http.scaladsl.server._
40 import eu.timepit.refined.api.Refined
41 import eu.timepit.refined.auto.autoUnwrap
42 import eu.timepit.refined.collection.MaxSize
43 import io.circe.generic.semiauto.deriveCodec
44 import io.circe.refined._
45 import io.circe.Codec
46 import io.swagger.annotations._
47 import scalaoauth2.provider.AuthInfo
48 
49 import javax.ws.rs.Path
50 import scala.annotation.meta.field
51 
52 @Api(value = "Admin DemographicsCards")
53 @Path(value = "/admin/demographics-cards")
54 trait AdminDemographicsCardApi extends Directives {
55 
56   @ApiOperation(
57     value = "list-demographics-cards",
58     httpMethod = "GET",
59     code = HttpCodes.OK,
60     authorizations = Array(
61       new Authorization(
62         value = "MakeApi",
63         scopes = Array(
64           new AuthorizationScope(scope = "admin", description = "BO Admin"),
65           new AuthorizationScope(scope = "operator", description = "BO Operator")
66         )
67       )
68     )
69   )
70   @ApiImplicitParams(
71     value = Array(
72       new ApiImplicitParam(
73         name = "_start",
74         paramType = "query",
75         dataType = "int",
76         allowableValues = "range[0, infinity]"
77       ),
78       new ApiImplicitParam(
79         name = "_end",
80         paramType = "query",
81         dataType = "int",
82         allowableValues = "range[0, infinity]"
83       ),
84       new ApiImplicitParam(
85         name = "_sort",
86         paramType = "query",
87         dataType = "string",
88         allowableValues = "name, layout, dataType, language, title, createdAt, updatedAt"
89       ),
90       new ApiImplicitParam(
91         name = "_order",
92         paramType = "query",
93         dataType = "string",
94         allowableValues = Order.swaggerAllowableValues
95       ),
96       new ApiImplicitParam(name = "languages", paramType = "query", dataType = "string", allowMultiple = true),
97       new ApiImplicitParam(name = "dataType", paramType = "query", dataType = "string"),
98       new ApiImplicitParam(
99         name = "questionId",
100         paramType = "query",
101         dataType = "string",
102         example = "11111111-2222-3333-4444-555555555555"
103       )
104     )
105   )
106   @ApiResponses(
107     value = Array(
108       new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[AdminDemographicsCardResponse]])
109     )
110   )
111   @Path(value = "/")
112   def list: Route
113 
114   @ApiOperation(
115     value = "create-demographics-card",
116     httpMethod = "POST",
117     code = HttpCodes.Created,
118     authorizations = Array(
119       new Authorization(
120         value = "MakeApi",
121         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
122       )
123     )
124   )
125   @ApiImplicitParams(
126     value = Array(
127       new ApiImplicitParam(
128         value = "body",
129         paramType = "body",
130         dataType = "org.make.api.demographics.AdminDemographicsCardRequest"
131       )
132     )
133   )
134   @ApiResponses(
135     value = Array(
136       new ApiResponse(code = HttpCodes.Created, message = "Ok", response = classOf[AdminDemographicsCardResponse])
137     )
138   )
139   @Path(value = "/")
140   def create: Route
141 
142   @ApiOperation(
143     value = "delete-demographics-card",
144     httpMethod = "DELETE",
145     code = HttpCodes.OK,
146     authorizations = Array(
147       new Authorization(
148         value = "MakeApi",
149         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
150       )
151     )
152   )
153   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "id", paramType = "path", dataType = "string")))
154   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "")))
155   @Path(value = "/{id}")
156   def remove: Route
157 
158   def routes: Route = list ~ create ~ remove
159 
160 }
161 
162 trait AdminDemographicsCardApiComponent {
163   def adminDemographicsCardApi: AdminDemographicsCardApi
164 }
165 
166 trait DefaultAdminDemographicsCardApiComponent
167     extends AdminDemographicsCardApiComponent
168     with MakeAuthenticationDirectives
169     with ParameterExtractors {
170   self: MakeDirectivesDependencies
171     with DemographicsCardServiceComponent
172     with QuestionServiceComponent
173     with OperationServiceComponent =>
174 
175   override val adminDemographicsCardApi: AdminDemographicsCardApi = new AdminDemographicsCardApi {
176 
177     private val id: PathMatcher1[DemographicsCardId] = Segment.map(DemographicsCardId.apply)
178 
179     override def list: Route = get {
180       path("admin" / "demographics-cards") {
181         parameters(
182           "_start".as[Pagination.Offset].?,
183           "_end".as[Pagination.End].?,
184           "_sort".?,
185           "_order".as[Order].?,
186           "languages".csv[Language],
187           "dataType".?,
188           "questionId".as[QuestionId].?
189         ) {
190           (
191             offset: Option[Pagination.Offset],
192             end: Option[Pagination.End],
193             sort: Option[String],
194             order: Option[Order],
195             languages: Option[Seq[Language]],
196             dataType: Option[String],
197             questionId: Option[QuestionId]
198           ) =>
199             makeOperation("AdminDemographicsCardsList") { _ =>
200               makeOAuth2 { userAuth: AuthInfo[UserRights] =>
201                 requireAdminRole(userAuth.user) {
202                   val languagesList = languages.map(_.toList)
203                   (
204                     demographicsCardService.count(languagesList, dataType, questionId).asDirective,
205                     demographicsCardService
206                       .list(offset, end, sort, order, languagesList, dataType, questionId)
207                       .asDirective
208                   ).tupled.apply({
209                     case (count: Int, demographicsCards: Seq[DemographicsCard]) =>
210                       complete(
211                         (
212                           StatusCodes.OK,
213                           List(`X-Total-Count`(count.toString)),
214                           demographicsCards.map(AdminDemographicsCardResponse.apply)
215                         )
216                       )
217                   })
218                 }
219               }
220             }
221         }
222       }
223     }
224 
225     override def create: Route = post {
226       path("admin" / "demographics-cards") {
227         makeOperation("AdminDemographicsCardsCreate") { _ =>
228           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
229             requireOperatorRole(userAuth.user) {
230               decodeRequest {
231                 entity(as[AdminDemographicsCardRequest]) { request: AdminDemographicsCardRequest =>
232                   Validation.validate(request.validateParameters: _*)
233                   demographicsCardService
234                     .create(
235                       name = request.name,
236                       layout = request.layout,
237                       dataType = request.dataType,
238                       languages = request.languages,
239                       titles = request.titles.mapTranslations(autoUnwrap(_)),
240                       parameters = request.parameters,
241                       questionId = request.questionId
242                     )
243                     .asDirective
244                     .apply(
245                       demographicsCard => complete(StatusCodes.Created, AdminDemographicsCardResponse(demographicsCard))
246                     )
247                 }
248               }
249             }
250           }
251         }
252       }
253     }
254 
255     override def remove: Route = delete {
256       path("admin" / "demographics-cards" / id) { id =>
257         makeOperation("AdminDeleteDemographicsCard") { _ =>
258           makeOAuth2 { auth: AuthInfo[UserRights] =>
259             requireAdminRole(auth.user) {
260               demographicsCardService.get(id).asDirectiveOrNotFound { _ =>
261                 demographicsCardService.delete(id).asDirective { _ =>
262                   complete(StatusCodes.NoContent)
263                 }
264               }
265             }
266           }
267         }
268       }
269     }
270 
271   }
272 
273 }
274 
275 final case class AdminDemographicsCardRequest(
276   name: String Refined MaxSize[256],
277   @(ApiModelProperty @field)(
278     dataType = "string",
279     allowableValues = DemographicsCard.Layout.swaggerAllowableValues,
280     required = true
281   )
282   layout: DemographicsCard.Layout,
283   @(ApiModelProperty @field)(dataType = "string", allowableValues = "age, gender, region", required = true)
284   dataType: String Refined Slug,
285   @(ApiModelProperty @field)(dataType = "string", example = "fr", required = true)
286   languages: NonEmptyList[Language],
287   titles: Multilingual[String Refined MaxSize[64]],
288   @(ApiModelProperty @field)(dataType = "object", required = true)
289   parameters: NonEmptyList[LabelsValue],
290   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
291   questionId: QuestionId
292 ) {
293   @(ApiModelProperty @field)(hidden = true)
294   val validateParameters: Seq[Requirement] = {
295     def validLabelsLengths(layout: DemographicsCard.Layout, labelLength: Int = 64) = {
296       Validation.validateField(
297         field = "parameters",
298         key = "invalid_value",
299         condition = parameters.forall(_.label.translations.forall(_.length < labelLength)),
300         message = s"At least one parameter label exceeds limit label length of $labelLength for layout $layout"
301       )
302     }
303     def validateSize(layout: DemographicsCard.Layout, size: Int) =
304       Validation.validateField(
305         field = "parameters",
306         key = "invalid_value",
307         condition = parameters.size <= size,
308         message = s"$layout card can contain max $size parameters"
309       )
310     layout match {
311       case l @ DemographicsCard.Layout.OneColumnRadio    => Seq(validLabelsLengths(l), validateSize(l, 3))
312       case l @ DemographicsCard.Layout.ThreeColumnsRadio => Seq(validLabelsLengths(l), validateSize(l, 9))
313       case l                                             => Seq(validLabelsLengths(l))
314     }
315   }
316 }
317 
318 object AdminDemographicsCardRequest {
319   implicit val codec: Codec[AdminDemographicsCardRequest] = deriveCodec
320 }
321 
322 final case class AdminDemographicsCardResponse(
323   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
324   id: DemographicsCardId,
325   name: String,
326   @(ApiModelProperty @field)(dataType = "string", allowableValues = DemographicsCard.Layout.swaggerAllowableValues)
327   layout: DemographicsCard.Layout,
328   @(ApiModelProperty @field)(dataType = "string", allowableValues = "age,gender,region")
329   dataType: String,
330   @(ApiModelProperty @field)(dataType = "string", example = "fr")
331   languages: NonEmptyList[Language],
332   titles: Multilingual[String],
333   @(ApiModelProperty @field)(dataType = "object")
334   parameters: NonEmptyList[LabelsValue],
335   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
336   questionId: QuestionId
337 )
338 
339 object AdminDemographicsCardResponse {
340 
341   def apply(card: DemographicsCard): AdminDemographicsCardResponse =
342     AdminDemographicsCardResponse(
343       id = card.id,
344       name = card.name,
345       layout = card.layout,
346       dataType = card.dataType,
347       languages = card.languages,
348       titles = card.titles,
349       parameters = card.parameters,
350       questionId = card.questionId
351     )
352 
353   implicit val codec: Codec[AdminDemographicsCardResponse] = deriveCodec
354 
355 }