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.idea
21 
22 import akka.http.scaladsl.model.StatusCodes
23 import akka.http.scaladsl.server._
24 import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
25 import io.circe.{Decoder, Encoder}
26 import io.swagger.annotations._
27 import org.make.api.operation.OperationServiceComponent
28 
29 import javax.ws.rs.Path
30 import org.make.api.question.QuestionServiceComponent
31 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
32 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
33 import org.make.api.technical.directives.FutureDirectivesExtensions._
34 import org.make.core.{HttpCodes, Order, ParameterExtractors}
35 import org.make.core.Validation._
36 import org.make.core.auth.UserRights
37 import org.make.core.idea._
38 import org.make.core.idea.indexed.IndexedIdea
39 import org.make.core.operation.OperationId
40 import org.make.core.question.{Question, QuestionId}
41 import org.make.core.technical.Pagination
42 import org.make.core.technical.ValidatedUtils.ValidatedNecWithUtils
43 import scalaoauth2.provider.AuthInfo
44 
45 import scala.annotation.meta.field
46 import scala.concurrent.Future
47 
48 @Api(value = "Moderation Idea")
49 @Path(value = "/moderation/ideas")
50 trait ModerationIdeaApi extends Directives {
51 
52   @ApiOperation(
53     value = "list-ideas",
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[Array[IdeaResponse]]))
65   )
66   @ApiImplicitParams(
67     value = Array(
68       new ApiImplicitParam(name = "name", paramType = "query", dataType = "string"),
69       new ApiImplicitParam(name = "questionId", paramType = "query", dataType = "string"),
70       new ApiImplicitParam(
71         name = "_start",
72         paramType = "query",
73         dataType = "int",
74         allowableValues = "range[0, infinity]"
75       ),
76       new ApiImplicitParam(
77         name = "_end",
78         paramType = "query",
79         dataType = "int",
80         allowableValues = "range[0, infinity]"
81       ),
82       new ApiImplicitParam(
83         name = "_sort",
84         paramType = "query",
85         dataType = "string",
86         allowableValues =
87           "ideaId, name, status, createdAt, updatedAt, operationId, questionId, question, language, country"
88       ),
89       new ApiImplicitParam(
90         name = "_order",
91         paramType = "query",
92         dataType = "string",
93         allowableValues = Order.swaggerAllowableValues
94       )
95     )
96   )
97   @Path(value = "/")
98   def listIdeas: Route
99 
100   @ApiOperation(
101     value = "get-idea",
102     httpMethod = "GET",
103     code = HttpCodes.OK,
104     authorizations = Array(
105       new Authorization(
106         value = "MakeApi",
107         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
108       )
109     )
110   )
111   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "ideaId", paramType = "path", dataType = "string")))
112   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[IdeaResponse])))
113   @Path(value = "/{ideaId}")
114   def getIdea: Route
115 
116   @ApiOperation(
117     value = "create-idea",
118     httpMethod = "POST",
119     code = HttpCodes.Created,
120     authorizations = Array(
121       new Authorization(
122         value = "MakeApi",
123         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
124       )
125     )
126   )
127   @ApiImplicitParams(
128     value =
129       Array(new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.idea.CreateIdeaRequest"))
130   )
131   @ApiResponses(
132     value = Array(new ApiResponse(code = HttpCodes.Created, message = "Created", response = classOf[IdeaResponse]))
133   )
134   @Path(value = "/")
135   def createIdea: Route
136 
137   @ApiOperation(
138     value = "update-idea",
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 = "ideaId", paramType = "path", dataType = "string"),
151       new ApiImplicitParam(value = "body", paramType = "body", dataType = "org.make.api.idea.UpdateIdeaRequest")
152     )
153   )
154   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[IdeaIdResponse])))
155   @Path(value = "/{ideaId}")
156   def updateIdea: Route
157 
158   def routes: Route = createIdea ~ updateIdea ~ listIdeas ~ getIdea
159 }
160 
161 trait ModerationIdeaApiComponent {
162   def moderationIdeaApi: ModerationIdeaApi
163 }
164 
165 trait DefaultModerationIdeaApiComponent
166     extends ModerationIdeaApiComponent
167     with MakeAuthenticationDirectives
168     with ParameterExtractors {
169   this: MakeDirectivesDependencies
170     with IdeaServiceComponent
171     with QuestionServiceComponent
172     with OperationServiceComponent =>
173 
174   override lazy val moderationIdeaApi: ModerationIdeaApi = new DefaultModerationIdeaApi
175 
176   class DefaultModerationIdeaApi extends ModerationIdeaApi {
177 
178     val ideaId: PathMatcher1[IdeaId] = Segment.map(id => IdeaId(id))
179 
180     private val SortingChoices =
181       Seq(
182         "ideaId",
183         "name",
184         "status",
185         "createdAt",
186         "updatedAt",
187         "operationId",
188         "questionId",
189         "question",
190         "language",
191         "country"
192       )
193 
194     override def listIdeas: Route = {
195       get {
196         path("moderation" / "ideas") {
197           parameters(
198             "name".?,
199             "questionId".as[QuestionId].?,
200             "_end".as[Pagination.End].?,
201             "_start".as[Pagination.Offset].?,
202             "_sort".?,
203             "_order".as[Order].?
204           ) { (name, questionId, end, offset, sort, order) =>
205             makeOperation("GetAllIdeas") { requestContext =>
206               makeOAuth2 { userAuth: AuthInfo[UserRights] =>
207                 requireModerationRole(userAuth.user) {
208                   sort.foreach(
209                     sortValue =>
210                       sortValue
211                         .toOneOf(
212                           SortingChoices,
213                           "_sort",
214                           Some(
215                             s"Invalid sort. Got $sortValue but expected one of: ${SortingChoices.mkString("\"", "\", \"", "\"")}"
216                           )
217                         )
218                         .throwIfInvalid()
219                   )
220                   val filters: IdeaFiltersRequest =
221                     IdeaFiltersRequest(
222                       name = name,
223                       questionId = questionId,
224                       limit = end.map(_.toLimit(offset.orZero)),
225                       offset = offset,
226                       sort = sort,
227                       order = order
228                     )
229                   ideaService.fetchAll(filters.toSearchQuery(requestContext)).asDirective { ideas =>
230                     complete(
231                       (
232                         StatusCodes.OK,
233                         List(`X-Total-Count`(ideas.total.toString)),
234                         ideas.results.map(IdeaResponse.apply)
235                       )
236                     )
237                   }
238                 }
239               }
240             }
241           }
242         }
243       }
244     }
245 
246     override def getIdea: Route = {
247       get {
248         path("moderation" / "ideas" / ideaId) { ideaId =>
249           makeOperation("GetIdea") { _ =>
250             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
251               requireModerationRole(userAuth.user) {
252                 ideaService.fetchOne(ideaId).asDirectiveOrNotFound { idea =>
253                   complete(IdeaResponse(idea))
254                 }
255               }
256             }
257           }
258         }
259       }
260     }
261 
262     override def createIdea: Route = post {
263       path("moderation" / "ideas") {
264         makeOperation("CreateIdea") { _ =>
265           makeOAuth2 { userAuth: AuthInfo[UserRights] =>
266             requireAdminRole(userAuth.user) {
267               decodeRequest {
268                 entity(as[CreateIdeaRequest]) { request: CreateIdeaRequest =>
269                   request.questionId
270                     .getValidated("question", None, Some("question should not be empty"))
271                     .throwIfInvalid()
272 
273                   request.questionId
274                     .map(questionId => questionService.getQuestion(questionId))
275                     .getOrElse(Future.successful(None))
276                     .asDirectiveOrNotFound
277                     .apply { question: Question =>
278                       ideaService.fetchOneByName(question.questionId, request.name).asDirective { idea =>
279                         idea
280                           .getNone("name", Some("idea already exist. Duplicates are not allowed"))
281                           .throwIfInvalid()
282 
283                         onSuccess(ideaService.insert(name = request.name, question = question)) { idea =>
284                           complete(StatusCodes.Created -> IdeaResponse(idea))
285                         }
286                       }
287                     }
288                 }
289               }
290             }
291           }
292         }
293       }
294     }
295 
296     override def updateIdea: Route = put {
297       path("moderation" / "ideas" / ideaId) { ideaId =>
298         makeOperation("UpdateIdea") { _ =>
299           makeOAuth2 { auth: AuthInfo[UserRights] =>
300             requireAdminRole(auth.user) {
301               decodeRequest {
302                 entity(as[UpdateIdeaRequest]) { request: UpdateIdeaRequest =>
303                   ideaService.fetchOne(ideaId).asDirectiveOrNotFound { idea =>
304                     idea.questionId
305                       .map(questionId => questionService.getQuestion(questionId))
306                       .getOrElse(Future.successful(None))
307                       .asDirectiveOrNotFound
308                       .apply { question =>
309                         ideaService.fetchOneByName(question.questionId, request.name).asDirective { duplicateIdea =>
310                           if (!duplicateIdea.map(_.ideaId).contains(ideaId)) {
311                             duplicateIdea
312                               .getNone("name", Some("idea already exist. Duplicates are not allowed"))
313                               .throwIfInvalid()
314                           }
315                           onSuccess(ideaService.update(ideaId = ideaId, name = request.name, status = request.status)) {
316                             _ =>
317                               complete(IdeaIdResponse(ideaId))
318                           }
319                         }
320                       }
321                   }
322                 }
323               }
324             }
325           }
326         }
327       }
328     }
329   }
330 }
331 
332 final case class CreateIdeaRequest(
333   name: String,
334   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
335   questionId: Option[QuestionId]
336 ) {
337 
338   name.toSanitizedInput("name").throwIfInvalid()
339 }
340 
341 object CreateIdeaRequest {
342   implicit val decoder: Decoder[CreateIdeaRequest] = deriveDecoder[CreateIdeaRequest]
343 }
344 
345 final case class UpdateIdeaRequest(
346   name: String,
347   @(ApiModelProperty @field)(dataType = "string", allowableValues = IdeaStatus.swaggerAllowableValues, required = true)
348   status: IdeaStatus
349 ) {
350 
351   name.toSanitizedInput("name").throwIfInvalid()
352 }
353 
354 object UpdateIdeaRequest {
355   implicit val decoder: Decoder[UpdateIdeaRequest] = deriveDecoder[UpdateIdeaRequest]
356 }
357 
358 final case class IdeaIdResponse(
359   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true) id: IdeaId,
360   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true) ideaId: IdeaId
361 )
362 
363 object IdeaIdResponse {
364   implicit val encoder: Encoder[IdeaIdResponse] = deriveEncoder[IdeaIdResponse]
365   implicit val decoder: Decoder[IdeaIdResponse] = deriveDecoder[IdeaIdResponse]
366 
367   def apply(id: IdeaId): IdeaIdResponse = IdeaIdResponse(id, id)
368 }
369 
370 final case class IdeaResponse(
371   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true) id: IdeaId,
372   name: String,
373   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
374   operationId: Option[OperationId],
375   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
376   questionId: Option[QuestionId],
377   @(ApiModelProperty @field)(dataType = "string", allowableValues = IdeaStatus.swaggerAllowableValues, required = true)
378   status: IdeaStatus
379 )
380 
381 object IdeaResponse {
382   implicit val encoder: Encoder[IdeaResponse] = deriveEncoder[IdeaResponse]
383   implicit val decoder: Decoder[IdeaResponse] = deriveDecoder[IdeaResponse]
384 
385   def apply(idea: Idea): IdeaResponse = {
386     IdeaResponse(
387       id = idea.ideaId,
388       name = idea.name,
389       operationId = idea.operationId,
390       questionId = idea.questionId,
391       status = idea.status
392     )
393   }
394 
395   def apply(idea: IndexedIdea): IdeaResponse = {
396     IdeaResponse(
397       id = idea.ideaId,
398       name = idea.name,
399       operationId = idea.operationId,
400       questionId = idea.questionId,
401       status = idea.status
402     )
403   }
404 }