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.partner
21 
22 import cats.implicits._
23 import akka.http.scaladsl.model.StatusCodes
24 import akka.http.scaladsl.server._
25 import io.circe.{Decoder, Encoder}
26 import io.swagger.annotations._
27 
28 import javax.ws.rs.Path
29 import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
30 import org.make.api.operation.OperationServiceComponent
31 import org.make.api.partner.DefaultPersistentPartnerServiceComponent.PersistentPartner
32 import org.make.api.question.QuestionServiceComponent
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.{HttpCodes, Order, ParameterExtractors}
37 import org.make.core.technical.Pagination
38 import org.make.core.auth.UserRights
39 import org.make.core.partner.{Partner, PartnerId, PartnerKind}
40 import org.make.core.question.QuestionId
41 import org.make.core.user.UserId
42 import scalaoauth2.provider.AuthInfo
43 
44 import scala.annotation.meta.field
45 
46 @Api(
47   value = "Admin Partner",
48   authorizations = Array(
49     new Authorization(
50       value = "MakeApi",
51       scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
52     )
53   )
54 )
55 @Path(value = "/admin/partners")
56 trait AdminPartnerApi extends Directives {
57 
58   @ApiOperation(value = "post-partner", httpMethod = "POST", code = HttpCodes.Created)
59   @ApiResponses(
60     value = Array(new ApiResponse(code = HttpCodes.Created, message = "Created", response = classOf[PartnerIdResponse]))
61   )
62   @ApiImplicitParams(
63     value = Array(
64       new ApiImplicitParam(name = "body", paramType = "body", dataType = "org.make.api.partner.CreatePartnerRequest")
65     )
66   )
67   @Path(value = "/")
68   def adminPostPartner: Route
69 
70   @ApiOperation(value = "put-partner", httpMethod = "PUT", code = HttpCodes.OK)
71   @ApiResponses(
72     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[PartnerIdResponse]))
73   )
74   @ApiImplicitParams(
75     value = Array(
76       new ApiImplicitParam(name = "body", paramType = "body", dataType = "org.make.api.partner.UpdatePartnerRequest"),
77       new ApiImplicitParam(name = "partnerId", paramType = "path", dataType = "string")
78     )
79   )
80   @Path(value = "/{partnerId}")
81   def adminPutPartner: Route
82 
83   @ApiOperation(value = "get-partners", httpMethod = "GET", code = HttpCodes.OK)
84   @ApiResponses(
85     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[PartnerResponse]]))
86   )
87   @ApiImplicitParams(
88     value = Array(
89       new ApiImplicitParam(
90         name = "_start",
91         paramType = "query",
92         dataType = "int",
93         allowableValues = "range[0, infinity]"
94       ),
95       new ApiImplicitParam(
96         name = "_end",
97         paramType = "query",
98         dataType = "int",
99         allowableValues = "range[0, infinity]"
100       ),
101       new ApiImplicitParam(
102         name = "_sort",
103         paramType = "query",
104         dataType = "string",
105         allowableValues = PersistentPartner.swaggerAllowableValues
106       ),
107       new ApiImplicitParam(
108         name = "_order",
109         paramType = "query",
110         dataType = "string",
111         allowableValues = Order.swaggerAllowableValues
112       ),
113       new ApiImplicitParam(name = "questionId", paramType = "query", dataType = "string"),
114       new ApiImplicitParam(name = "organisationId", paramType = "query", dataType = "string"),
115       new ApiImplicitParam(
116         name = "partnerKind",
117         paramType = "query",
118         dataType = "string",
119         allowableValues = PartnerKind.swaggerAllowableValues
120       )
121     )
122   )
123   @Path(value = "/")
124   def adminGetPartners: Route
125 
126   @ApiOperation(value = "get-partner", httpMethod = "GET", code = HttpCodes.OK)
127   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "partnerId", paramType = "path", dataType = "string")))
128   @ApiResponses(
129     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[PartnerResponse]))
130   )
131   @Path(value = "/{partnerId}")
132   def adminGetPartner: Route
133 
134   @ApiOperation(value = "delete-partner", httpMethod = "DELETE", code = HttpCodes.NoContent)
135   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
136   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "partnerId", paramType = "path", dataType = "string")))
137   @Path(value = "/{partnerId}")
138   def adminDeletePartner: Route
139 
140   def routes: Route =
141     adminGetPartner ~ adminGetPartners ~ adminPostPartner ~ adminPutPartner ~ adminDeletePartner
142 }
143 
144 trait AdminPartnerApiComponent {
145   def adminPartnerApi: AdminPartnerApi
146 }
147 
148 trait DefaultAdminPartnerApiComponent
149     extends AdminPartnerApiComponent
150     with MakeAuthenticationDirectives
151     with ParameterExtractors {
152   this: MakeDirectivesDependencies
153     with PartnerServiceComponent
154     with QuestionServiceComponent
155     with OperationServiceComponent =>
156 
157   override lazy val adminPartnerApi: AdminPartnerApi = new DefaultAdminPartnerApi
158 
159   class DefaultAdminPartnerApi extends AdminPartnerApi {
160 
161     private val partnerId: PathMatcher1[PartnerId] = Segment.map(id => PartnerId(id))
162 
163     override def adminPostPartner: Route = {
164       post {
165         path("admin" / "partners") {
166           makeOperation("ModerationPostPartner") { _ =>
167             makeOAuth2 { auth: AuthInfo[UserRights] =>
168               requireAdminRole(auth.user) {
169                 decodeRequest {
170                   entity(as[CreatePartnerRequest]) { request =>
171                     onSuccess(partnerService.createPartner(request)) { result =>
172                       complete(StatusCodes.Created -> PartnerIdResponse(result.partnerId))
173                     }
174                   }
175                 }
176               }
177             }
178           }
179         }
180       }
181     }
182 
183     override def adminPutPartner: Route = {
184       put {
185         path("admin" / "partners" / partnerId) { partnerId =>
186           makeOperation("ModerationPutPartner") { _ =>
187             makeOAuth2 { auth: AuthInfo[UserRights] =>
188               requireAdminRole(auth.user) {
189                 decodeRequest {
190                   entity(as[UpdatePartnerRequest]) { request =>
191                     partnerService.updatePartner(partnerId, request).asDirectiveOrNotFound { result =>
192                       complete(StatusCodes.OK -> PartnerIdResponse(result.partnerId))
193                     }
194                   }
195                 }
196               }
197             }
198           }
199         }
200       }
201     }
202 
203     override def adminGetPartners: Route = {
204       get {
205         path("admin" / "partners") {
206           makeOperation("ModerationGetPartners") { _ =>
207             parameters(
208               "_start".as[Pagination.Offset].?,
209               "_end".as[Pagination.End].?,
210               "_sort".?,
211               "_order".as[Order].?,
212               "questionId".as[QuestionId].?,
213               "organisationId".as[UserId].?,
214               "partnerKind".as[PartnerKind].?
215             ) {
216               (
217                 offset: Option[Pagination.Offset],
218                 end: Option[Pagination.End],
219                 sort: Option[String],
220                 order: Option[Order],
221                 questionId: Option[QuestionId],
222                 organisationId: Option[UserId],
223                 partnerKind: Option[PartnerKind]
224               ) =>
225                 makeOAuth2 { auth: AuthInfo[UserRights] =>
226                   requireAdminRole(auth.user) {
227                     (
228                       partnerService
229                         .find(offset.orZero, end, sort, order, questionId, organisationId, partnerKind)
230                         .asDirective,
231                       partnerService.count(questionId, organisationId, partnerKind).asDirective
232                     ).tupled.apply {
233                       case (result, count) =>
234                         complete(
235                           (StatusCodes.OK, List(`X-Total-Count`(count.toString)), result.map(PartnerResponse.apply))
236                         )
237                     }
238                   }
239                 }
240             }
241           }
242         }
243       }
244     }
245 
246     override def adminGetPartner: Route = {
247       get {
248         path("admin" / "partners" / partnerId) { partnerId =>
249           makeOperation("ModerationGetPartner") { _ =>
250             makeOAuth2 { auth: AuthInfo[UserRights] =>
251               requireAdminRole(auth.user) {
252                 partnerService.getPartner(partnerId).asDirectiveOrNotFound { partner =>
253                   complete(PartnerResponse(partner))
254                 }
255               }
256             }
257           }
258         }
259       }
260     }
261 
262     override def adminDeletePartner: Route = {
263       delete {
264         path("admin" / "partners" / partnerId) { partnerId =>
265           makeOperation("ModerationDeletePartner") { _ =>
266             makeOAuth2 { auth: AuthInfo[UserRights] =>
267               requireAdminRole(auth.user) {
268                 partnerService.deletePartner(partnerId).asDirective { _ =>
269                   complete(StatusCodes.NoContent)
270                 }
271               }
272             }
273           }
274         }
275       }
276     }
277   }
278 }
279 
280 final case class PartnerResponse(
281   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
282   id: PartnerId,
283   name: String,
284   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/logo.png")
285   logo: Option[String],
286   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/link")
287   link: Option[String],
288   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
289   organisationId: Option[UserId],
290   @(ApiModelProperty @field)(dataType = "string", allowableValues = PartnerKind.swaggerAllowableValues)
291   partnerKind: PartnerKind,
292   weight: Float
293 )
294 
295 object PartnerResponse {
296   def apply(partner: Partner): PartnerResponse = PartnerResponse(
297     id = partner.partnerId,
298     name = partner.name,
299     logo = partner.logo,
300     link = partner.link,
301     organisationId = partner.organisationId,
302     partnerKind = partner.partnerKind,
303     weight = partner.weight
304   )
305 
306   implicit val decoder: Decoder[PartnerResponse] = deriveDecoder[PartnerResponse]
307   implicit val encoder: Encoder[PartnerResponse] = deriveEncoder[PartnerResponse]
308 }
309 
310 final case class PartnerIdResponse(
311   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
312   id: PartnerId,
313   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
314   partnerId: PartnerId
315 )
316 
317 object PartnerIdResponse {
318   implicit val encoder: Encoder[PartnerIdResponse] = deriveEncoder[PartnerIdResponse]
319 
320   def apply(id: PartnerId): PartnerIdResponse = PartnerIdResponse(id, id)
321 }