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.user
21 
22 import cats.implicits._
23 import akka.http.scaladsl.server._
24 import grizzled.slf4j.Logging
25 import io.swagger.annotations._
26 import scalaoauth2.provider.AuthInfo
27 import io.circe.Codec
28 import io.circe.generic.semiauto.deriveCodec
29 import org.make.api.operation.OperationServiceComponent
30 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
31 import org.make.api.technical.MakeAuthenticationDirectives
32 import org.make.api.technical.directives.FutureDirectivesExtensions._
33 import org.make.api.question.QuestionServiceComponent
34 import org.make.api.proposal.MaxPropositionsThresholdsComponent
35 import org.make.core._
36 import org.make.core.auth.UserRights
37 import org.make.core.question.QuestionId
38 import org.make.core.user._
39 
40 import javax.ws.rs.Path
41 
42 @Api(value = "Moderator Users")
43 @Path(value = "/moderation/users")
44 trait ModerationUserApi extends Directives {
45 
46   @ApiOperation(
47     value = "proposals-count",
48     httpMethod = "GET",
49     code = HttpCodes.OK,
50     authorizations = Array(
51       new Authorization(
52         value = "MakeApi",
53         scopes = Array(new AuthorizationScope(scope = "moderation", description = "BO Moderation"))
54       )
55     )
56   )
57   @ApiImplicitParams(
58     value = Array(
59       new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string"),
60       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string")
61     )
62   )
63   @ApiResponses(
64     value = Array(new ApiResponse(code = HttpCodes.OK, message = "OK", response = classOf[NumberOfProposalsResponse]))
65   )
66   @Path(value = "/{userId}/{questionId}/proposals-count")
67   def getNumberOfProposals: Route
68 
69   def routes: Route = getNumberOfProposals
70 }
71 
72 trait ModerationUserApiComponent {
73 
74   def moderationUserApi: ModerationUserApi
75 }
76 
77 trait DefaultModerationUserApiComponent
78     extends ModerationUserApiComponent
79     with MakeAuthenticationDirectives
80     with Logging
81     with ParameterExtractors {
82 
83   this: MakeDirectivesDependencies
84     with UserServiceComponent
85     with QuestionServiceComponent
86     with OperationServiceComponent
87     with UserProposalsServiceComponent
88     with MaxPropositionsThresholdsComponent =>
89 
90   override lazy val moderationUserApi: ModerationUserApi = new DefaultModerationUserApi
91 
92   class DefaultModerationUserApi extends ModerationUserApi {
93 
94     private val userId = Segment.map(UserId.apply)
95     private val questionId = Segment.map(QuestionId.apply)
96 
97     private val thresholds =
98       MaxPropositionsThresholdsResponse(
99         maxPropositionsThresholds.warnThreshold,
100         maxPropositionsThresholds.blockThreshold
101       )
102 
103     override def getNumberOfProposals: Route =
104       get {
105         path("moderation" / "users" / userId / questionId / "proposals-count") {
106           case (userId, questionId) =>
107             makeOperation("GetProposalsCounter") { _ =>
108               makeOAuth2 { auth: AuthInfo[UserRights] =>
109                 requireModerationRole(auth.user) {
110                   userService.getUser(userId).asDirectiveOrNotFound { _ =>
111                     questionService.getQuestion(questionId).asDirectiveOrNotFound { _ =>
112                       userProposalsService.getCounter(userId, questionId).asDirective { count =>
113                         complete(NumberOfProposalsResponse(count, thresholds))
114                       }
115                     }
116                   }
117                 }
118               }
119             }
120         }
121       }
122   }
123 }
124 
125 final case class NumberOfProposalsResponse(count: Int, thresholds: MaxPropositionsThresholdsResponse)
126 
127 object NumberOfProposalsResponse {
128 
129   implicit val codec: Codec[NumberOfProposalsResponse] = deriveCodec
130 }
131 
132 final case class MaxPropositionsThresholdsResponse(warn: Int, block: Int)
133 
134 object MaxPropositionsThresholdsResponse {
135 
136   implicit val codec: Codec[MaxPropositionsThresholdsResponse] = deriveCodec
137 }