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.personality
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.operation.OperationServiceComponent
29 import org.make.api.personality.DefaultPersistentQuestionPersonalityServiceComponent.PersistentPersonality
30 import org.make.api.question.QuestionServiceComponent
31 
32 import javax.ws.rs.Path
33 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
34 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
35 import org.make.api.technical.directives.FutureDirectivesExtensions._
36 import org.make.core.technical.Pagination
37 import org.make.core.auth.UserRights
38 import org.make.core.personality.{Personality, PersonalityId, PersonalityRole, PersonalityRoleId}
39 import org.make.core.question.QuestionId
40 import org.make.core.user.UserId
41 import org.make.core.{HttpCodes, Order, ParameterExtractors, ValidationError}
42 import scalaoauth2.provider.AuthInfo
43 
44 import scala.annotation.meta.field
45 import scala.concurrent.ExecutionContext.Implicits.global
46 import scala.concurrent.Future
47 
48 @Api(
49   value = "Admin Question Personalities",
50   authorizations = Array(
51     new Authorization(
52       value = "MakeApi",
53       scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
54     )
55   )
56 )
57 @Path(value = "/admin/question-personalities")
58 trait AdminQuestionPersonalityApi extends Directives {
59 
60   @ApiOperation(value = "admin-post-question-personality", httpMethod = "POST", code = HttpCodes.Created)
61   @ApiResponses(
62     value =
63       Array(new ApiResponse(code = HttpCodes.Created, message = "Created", response = classOf[PersonalityIdResponse]))
64   )
65   @ApiImplicitParams(
66     value = Array(
67       new ApiImplicitParam(
68         name = "body",
69         paramType = "body",
70         dataType = "org.make.api.personality.CreateQuestionPersonalityRequest"
71       )
72     )
73   )
74   @Path(value = "/")
75   def adminPostQuestionPersonality: Route
76 
77   @ApiOperation(value = "admin-put-question-personality", httpMethod = "PUT", code = HttpCodes.OK)
78   @ApiResponses(
79     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[PersonalityIdResponse]))
80   )
81   @ApiImplicitParams(
82     value = Array(
83       new ApiImplicitParam(name = "personalityId", paramType = "path", dataType = "string"),
84       new ApiImplicitParam(
85         name = "body",
86         paramType = "body",
87         dataType = "org.make.api.personality.UpdateQuestionPersonalityRequest"
88       )
89     )
90   )
91   @Path(value = "/{personalityId}")
92   def adminPutQuestionPersonality: Route
93 
94   @ApiOperation(value = "admin-get-question-personalities", httpMethod = "GET", code = HttpCodes.OK)
95   @ApiResponses(
96     value = Array(
97       new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[AdminQuestionPersonalityResponse]])
98     )
99   )
100   @ApiImplicitParams(
101     value = Array(
102       new ApiImplicitParam(
103         name = "_start",
104         paramType = "query",
105         dataType = "int",
106         allowableValues = "range[0, infinity]"
107       ),
108       new ApiImplicitParam(
109         name = "_end",
110         paramType = "query",
111         dataType = "int",
112         allowableValues = "range[0, infinity]"
113       ),
114       new ApiImplicitParam(
115         name = "_sort",
116         paramType = "query",
117         dataType = "string",
118         allowableValues = PersistentPersonality.swaggerAllowableValues
119       ),
120       new ApiImplicitParam(
121         name = "_order",
122         paramType = "query",
123         dataType = "string",
124         allowableValues = Order.swaggerAllowableValues
125       ),
126       new ApiImplicitParam(name = "userId", paramType = "query", dataType = "string"),
127       new ApiImplicitParam(name = "questionId", paramType = "query", dataType = "string"),
128       new ApiImplicitParam(
129         name = "personalityRole",
130         paramType = "query",
131         required = false,
132         dataType = "string",
133         allowableValues = "CANDIDATE"
134       )
135     )
136   )
137   @Path(value = "/")
138   def adminGetQuestionPersonalities: Route
139 
140   @ApiOperation(value = "admin-get-question-personality", httpMethod = "GET", code = HttpCodes.OK)
141   @ApiResponses(
142     value =
143       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[AdminQuestionPersonalityResponse]))
144   )
145   @ApiImplicitParams(
146     value = Array(new ApiImplicitParam(name = "personalityId", paramType = "path", dataType = "string"))
147   )
148   @Path(value = "/{personalityId}")
149   def adminGetQuestionPersonality: Route
150 
151   @ApiOperation(value = "admin-delete-question-personality", httpMethod = "DELETE", code = HttpCodes.NoContent)
152   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
153   @ApiImplicitParams(
154     value = Array(new ApiImplicitParam(name = "personalityId", paramType = "path", dataType = "string"))
155   )
156   @Path(value = "/{personalityId}")
157   def adminDeleteQuestionPersonality: Route
158 
159   def routes: Route =
160     adminGetQuestionPersonality ~ adminGetQuestionPersonalities ~ adminPostQuestionPersonality ~
161       adminPutQuestionPersonality ~ adminDeleteQuestionPersonality
162 }
163 
164 trait AdminQuestionPersonalityApiComponent {
165   def adminQuestionPersonalityApi: AdminQuestionPersonalityApi
166 }
167 
168 trait DefaultAdminQuestionPersonalityApiComponent
169     extends AdminQuestionPersonalityApiComponent
170     with MakeAuthenticationDirectives
171     with ParameterExtractors {
172   this: MakeDirectivesDependencies
173     with QuestionPersonalityServiceComponent
174     with PersonalityRoleServiceComponent
175     with QuestionServiceComponent
176     with OperationServiceComponent =>
177 
178   override lazy val adminQuestionPersonalityApi: AdminQuestionPersonalityApi = new DefaultAdminQuestionPersonalityApi
179 
180   class DefaultAdminQuestionPersonalityApi extends AdminQuestionPersonalityApi {
181 
182     private val personalityId: PathMatcher1[PersonalityId] = Segment.map(id => PersonalityId(id))
183 
184     override def adminPostQuestionPersonality: Route = {
185       post {
186         path("admin" / "question-personalities") {
187           makeOperation("ModerationPostQuestionPersonality") { _ =>
188             makeOAuth2 { auth: AuthInfo[UserRights] =>
189               requireAdminRole(auth.user) {
190                 decodeRequest {
191                   entity(as[CreateQuestionPersonalityRequest]) { request =>
192                     questionPersonalityService
193                       .find(
194                         offset = Pagination.Offset.zero,
195                         end = None,
196                         sort = None,
197                         order = None,
198                         userId = Some(request.userId),
199                         questionId = Some(request.questionId),
200                         personalityRoleId = None
201                       )
202                       .asDirective {
203                         case duplicates if duplicates.nonEmpty =>
204                           complete(
205                             StatusCodes.BadRequest -> ValidationError(
206                               "userId",
207                               "already_defined",
208                               Some(
209                                 s"User with id : ${request.userId.value} is already defined as a personality for this question"
210                               )
211                             )
212                           )
213                         case _ =>
214                           onSuccess(questionPersonalityService.createPersonality(request)) { result =>
215                             complete(StatusCodes.Created -> PersonalityIdResponse(result.personalityId))
216                           }
217                       }
218                   }
219                 }
220               }
221             }
222           }
223         }
224       }
225     }
226 
227     override def adminPutQuestionPersonality: Route = {
228       put {
229         path("admin" / "question-personalities" / personalityId) { personalityId =>
230           makeOperation("ModerationPutQuestionPersonality") { _ =>
231             makeOAuth2 { auth: AuthInfo[UserRights] =>
232               requireAdminRole(auth.user) {
233                 decodeRequest {
234                   entity(as[UpdateQuestionPersonalityRequest]) { request =>
235                     questionPersonalityService.updatePersonality(personalityId, request).asDirectiveOrNotFound {
236                       result =>
237                         complete(StatusCodes.OK -> PersonalityIdResponse(result.personalityId))
238                     }
239                   }
240                 }
241               }
242             }
243           }
244         }
245       }
246     }
247 
248     override def adminGetQuestionPersonalities: Route = {
249       get {
250         path("admin" / "question-personalities") {
251           makeOperation("ModerationGetQuestionPersonalities") { _ =>
252             parameters(
253               "_start".as[Pagination.Offset].?,
254               "_end".as[Pagination.End].?,
255               "_sort".?,
256               "_order".as[Order].?,
257               "userId".as[UserId].?,
258               "questionId".as[QuestionId].?,
259               "personalityRoleId".as[PersonalityRoleId].?
260             ) {
261               (
262                 offset: Option[Pagination.Offset],
263                 end: Option[Pagination.End],
264                 sort: Option[String],
265                 order: Option[Order],
266                 userId: Option[UserId],
267                 questionId: Option[QuestionId],
268                 personalityRoleId: Option[PersonalityRoleId]
269               ) =>
270                 makeOAuth2 { auth: AuthInfo[UserRights] =>
271                   requireAdminRole(auth.user) {
272                     (
273                       questionPersonalityService
274                         .find(offset.orZero, end, sort, order, userId, questionId, personalityRoleId)
275                         .asDirective,
276                       questionPersonalityService
277                         .count(userId, questionId, personalityRoleId)
278                         .asDirective
279                     ).tupled.apply({
280                       case (personalities, count) =>
281                         personalityRoleService
282                           .find(
283                             offset = Pagination.Offset.zero,
284                             end = None,
285                             sort = None,
286                             order = None,
287                             roleIds = Some(personalities.map(_.personalityRoleId)),
288                             name = None
289                           )
290                           .asDirective {
291                             personalityRoles =>
292                               @SuppressWarnings(Array("org.wartremover.warts.Throw"))
293                               val result = personalities.map { personality =>
294                                 personalityRoles
295                                   .find(role => role.personalityRoleId == personality.personalityRoleId) match {
296                                   case Some(personalityRole) =>
297                                     AdminQuestionPersonalityResponse(personality, personalityRole)
298                                   case None =>
299                                     throw new IllegalStateException(
300                                       s"Unable to find the personality role with id ${personality.personalityRoleId}"
301                                     )
302                                 }
303                               }
304                               complete((StatusCodes.OK, List(`X-Total-Count`(count.toString)), result))
305                           }
306                     })
307                   }
308                 }
309             }
310           }
311         }
312       }
313     }
314 
315     override def adminGetQuestionPersonality: Route = {
316       get {
317         path("admin" / "question-personalities" / personalityId) { personalityId =>
318           makeOperation("ModerationGetQuestionPersonality") { _ =>
319             makeOAuth2 { auth: AuthInfo[UserRights] =>
320               requireAdminRole(auth.user) {
321                 questionPersonalityService.getPersonality(personalityId).asDirectiveOrNotFound { personality =>
322                   personalityRoleService
323                     .getPersonalityRole(personality.personalityRoleId)
324                     .flatMap(
325                       _.fold(
326                         Future.failed[PersonalityRole](
327                           new IllegalStateException(s"Personality with the id $personalityId does not exist")
328                         )
329                       )(Future.successful)
330                     )
331                     .asDirective { personalityRole =>
332                       complete(AdminQuestionPersonalityResponse(personality, personalityRole))
333                     }
334                 }
335               }
336             }
337           }
338         }
339       }
340     }
341 
342     override def adminDeleteQuestionPersonality: Route = {
343       delete {
344         path("admin" / "question-personalities" / personalityId) { personalityId =>
345           makeOperation("ModerationDeleteQuestionPersonality") { _ =>
346             makeOAuth2 { auth: AuthInfo[UserRights] =>
347               requireAdminRole(auth.user) {
348                 questionPersonalityService.deletePersonality(personalityId).asDirective { _ =>
349                   complete(StatusCodes.NoContent)
350                 }
351               }
352             }
353           }
354         }
355       }
356     }
357   }
358 }
359 
360 final case class AdminQuestionPersonalityResponse(
361   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
362   id: PersonalityId,
363   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
364   userId: UserId,
365   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
366   personalityRoleId: PersonalityRoleId
367 )
368 
369 object AdminQuestionPersonalityResponse {
370   def apply(personality: Personality, personalityRole: PersonalityRole): AdminQuestionPersonalityResponse =
371     AdminQuestionPersonalityResponse(
372       id = personality.personalityId,
373       userId = personality.userId,
374       personalityRoleId = personalityRole.personalityRoleId
375     )
376 
377   implicit val decoder: Decoder[AdminQuestionPersonalityResponse] = deriveDecoder[AdminQuestionPersonalityResponse]
378   implicit val encoder: Encoder[AdminQuestionPersonalityResponse] = deriveEncoder[AdminQuestionPersonalityResponse]
379 }
380 
381 final case class PersonalityIdResponse(
382   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
383   id: PersonalityId,
384   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
385   personalityId: PersonalityId
386 )
387 
388 object PersonalityIdResponse {
389   implicit val encoder: Encoder[PersonalityIdResponse] = deriveEncoder[PersonalityIdResponse]
390 
391   def apply(id: PersonalityId): PersonalityIdResponse = PersonalityIdResponse(id, id)
392 }