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.operation
21 
22 import akka.http.scaladsl.model.StatusCodes
23 import akka.http.scaladsl.server.{Directives, PathMatcher1, Route}
24 import eu.timepit.refined.types.numeric.NonNegInt
25 import grizzled.slf4j.Logging
26 import io.circe.generic.semiauto._
27 import io.circe.refined._
28 import eu.timepit.refined.auto._
29 import io.circe.Codec
30 import io.swagger.annotations._
31 
32 import javax.ws.rs.Path
33 import org.make.api.keyword.KeywordServiceComponent
34 import org.make.api.question.QuestionServiceComponent
35 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
36 import org.make.api.technical.MakeAuthenticationDirectives
37 import org.make.api.technical.directives.FutureDirectivesExtensions._
38 import org.make.core._
39 import org.make.core.auth.UserRights
40 import org.make.core.keyword.Keyword
41 import org.make.core.question.QuestionId
42 import scalaoauth2.provider.AuthInfo
43 
44 import scala.annotation.meta.field
45 
46 @Api(value = "Admin Question")
47 @Path(value = "/admin/questions")
48 trait AdminOperationOfQuestionApi extends Directives {
49 
50   @ApiOperation(
51     value = "update-question-highlights",
52     httpMethod = "PUT",
53     code = HttpCodes.NoContent,
54     authorizations = Array(
55       new Authorization(
56         value = "MakeApi",
57         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
58       )
59     )
60   )
61   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
62   @ApiImplicitParams(
63     value = Array(
64       new ApiImplicitParam(name = "questionId", paramType = "path", required = true, dataType = "string"),
65       new ApiImplicitParam(
66         value = "body",
67         paramType = "body",
68         required = true,
69         dataType = "org.make.api.operation.UpdateHighlights"
70       )
71     )
72   )
73   @Path(value = "/{questionId}/highlights")
74   def updateHighlights: Route
75 
76   @ApiOperation(
77     value = "update-question-keywords",
78     httpMethod = "PUT",
79     code = HttpCodes.NoContent,
80     authorizations = Array(
81       new Authorization(
82         value = "MakeApi",
83         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
84       )
85     )
86   )
87   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
88   @ApiImplicitParams(
89     value = Array(
90       new ApiImplicitParam(name = "questionId", paramType = "path", required = true, dataType = "string"),
91       new ApiImplicitParam(
92         value = "body",
93         paramType = "body",
94         required = true,
95         dataType = "org.make.api.operation.UpdateKeywords"
96       )
97     )
98   )
99   @Path(value = "/{questionId}/keywords")
100   def updateKeywords: Route
101 
102   def routes: Route = updateHighlights ~ updateKeywords
103 }
104 
105 trait AdminOperationOfQuestionApiComponent {
106   def adminOperationOfQuestionApi: AdminOperationOfQuestionApi
107 }
108 
109 trait DefaultAdminOperationOfQuestionApiComponent
110     extends AdminOperationOfQuestionApiComponent
111     with MakeAuthenticationDirectives
112     with Logging
113     with ParameterExtractors {
114 
115   this: MakeDirectivesDependencies
116     with OperationOfQuestionServiceComponent
117     with KeywordServiceComponent
118     with QuestionServiceComponent
119     with OperationServiceComponent =>
120 
121   val questionId: PathMatcher1[QuestionId] = Segment.map(id => QuestionId(id))
122 
123   override lazy val adminOperationOfQuestionApi: DefaultAdminOperationOfQuestionApi =
124     new DefaultAdminOperationOfQuestionApi
125 
126   class DefaultAdminOperationOfQuestionApi extends AdminOperationOfQuestionApi {
127     override def updateHighlights: Route = put {
128       path("admin" / "questions" / questionId / "highlights") { questionId =>
129         makeOperation("UpdateQuestionHighlights") { _ =>
130           makeOAuth2 { auth: AuthInfo[UserRights] =>
131             requireAdminRole(auth.user) {
132               decodeRequest {
133                 entity(as[UpdateHighlights]) { request =>
134                   operationOfQuestionService.findByQuestionId(questionId).asDirectiveOrNotFound { operationOfQuestion =>
135                     onSuccess(
136                       operationOfQuestionService.update(
137                         operationOfQuestion
138                           .copy(
139                             proposalsCount = request.proposalsCount,
140                             participantsCount = request.participantsCount,
141                             votesCount = request.votesCount
142                           )
143                       )
144                     ) { _ =>
145                       complete(StatusCodes.NoContent)
146                     }
147                   }
148                 }
149               }
150             }
151           }
152         }
153       }
154     }
155 
156     override def updateKeywords: Route = put {
157       path("admin" / "questions" / questionId / "keywords") { questionId =>
158         makeOperation("UpdateQuestionKeywords") { _ =>
159           makeOAuth2 { auth: AuthInfo[UserRights] =>
160             requireAdminRole(auth.user) {
161               decodeRequest {
162                 entity(as[UpdateKeywords]) { request =>
163                   operationOfQuestionService.findByQuestionId(questionId).asDirectiveOrNotFound { _ =>
164                     val duplicateKeys: Set[String] = request.keywords
165                       .groupBy(_.key)
166                       .collect {
167                         case (key, seq) if seq.sizeIs > 1 => key
168                       }
169                       .toSet
170                     Validation.validate(
171                       Validation.validateField(
172                         "keywords",
173                         "invalid_value",
174                         duplicateKeys.isEmpty,
175                         s"keywords contain duplicate keys: ${duplicateKeys.mkString(", ")}"
176                       )
177                     )
178                     keywordService
179                       .addAndReplaceTop(questionId, request.keywords.map(_.toKeyword(questionId)))
180                       .asDirective { _ =>
181                         complete(StatusCodes.NoContent)
182                       }
183                   }
184                 }
185               }
186             }
187           }
188         }
189       }
190     }
191   }
192 }
193 
194 @ApiModel
195 final case class UpdateHighlights(
196   @(ApiModelProperty @field)(dataType = "int", allowableValues = "range[0, infinity]")
197   proposalsCount: NonNegInt,
198   @(ApiModelProperty @field)(dataType = "int", allowableValues = "range[0, infinity]")
199   participantsCount: NonNegInt,
200   @(ApiModelProperty @field)(dataType = "int", allowableValues = "range[0, infinity]")
201   votesCount: NonNegInt
202 )
203 
204 object UpdateHighlights extends CirceFormatters {
205   implicit val codec: Codec[UpdateHighlights] = deriveCodec
206 }
207 
208 final case class UpdateKeywords(keywords: Seq[KeywordRequest])
209 
210 object UpdateKeywords {
211   implicit val codec: Codec[UpdateKeywords] = deriveCodec
212 }
213 
214 final case class KeywordRequest(
215   key: String,
216   label: String,
217   score: Float,
218   @(ApiModelProperty @field)(dataType = "int", allowableValues = "range[0, infinity]")
219   count: NonNegInt
220 ) {
221   def toKeyword(questionId: QuestionId): Keyword =
222     Keyword(questionId = questionId, key = key, label = label, score = score, count = count, topKeyword = true)
223 }
224 
225 object KeywordRequest {
226   implicit val codec: Codec[KeywordRequest] = deriveCodec
227 }