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.technical.generator.fixtures
21 
22 import akka.http.scaladsl.model.StatusCodes
23 import akka.http.scaladsl.server.{Directives, Route}
24 import cats.data.{NonEmptyList => Nel}
25 import grizzled.slf4j.Logging
26 import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
27 import io.circe.{Decoder, Encoder}
28 import io.swagger.annotations._
29 import org.make.api.operation.OperationServiceComponent
30 import org.make.api.question.QuestionServiceComponent
31 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
32 import org.make.api.technical._
33 import org.make.api.technical.directives.FutureDirectivesExtensions._
34 import org.make.core.{HttpCodes, Validation}
35 import org.make.core.operation.OperationId
36 import org.make.core.question.QuestionId
37 import org.make.core.reference.{Country, Language}
38 
39 import javax.ws.rs.Path
40 import scala.annotation.meta.field
41 import scala.concurrent.Future
42 
43 @Api(value = "Fixtures")
44 @Path(value = "/fixtures")
45 trait FixturesApi extends Directives {
46   @ApiOperation(value = "generate-fixtures", httpMethod = "POST", code = HttpCodes.Created)
47   @ApiImplicitParams(
48     value = Array(
49       new ApiImplicitParam(
50         name = "body",
51         paramType = "body",
52         dataType = "org.make.api.technical.generator.fixtures.GenerateFixturesRequest"
53       )
54     )
55   )
56   @ApiResponses(
57     value = Array(new ApiResponse(code = HttpCodes.Created, message = "Ok", response = classOf[FixtureResponse]))
58   )
59   @Path(value = "/generate")
60   def generateFixtures: Route
61 
62   def routes: Route = generateFixtures
63 }
64 
65 trait FixturesApiComponent {
66   def fixturesApi: FixturesApi
67 }
68 
69 trait DefaultFixturesApiComponent extends FixturesApiComponent with MakeAuthenticationDirectives with Logging {
70   this: MakeDirectivesDependencies
71     with FixturesServiceComponent
72     with OperationServiceComponent
73     with QuestionServiceComponent =>
74 
75   override lazy val fixturesApi: FixturesApi = new DefaultFixturesApi
76 
77   class DefaultFixturesApi extends FixturesApi {
78     override def generateFixtures: Route = post {
79       path("fixtures" / "generate") {
80         makeOperation("GenerateFixtures") { _ =>
81           withoutRequestTimeout {
82             decodeRequest {
83               entity(as[GenerateFixturesRequest]) { request =>
84                 val futureOperation = request.operationId match {
85                   case Some(operationId) => operationService.findOne(operationId)
86                   case None              => Future.successful(None)
87                 }
88                 val futureQuestion = request.questionId match {
89                   case Some(questionId) => questionService.getQuestion(questionId)
90                   case None             => Future.successful(None)
91                 }
92                 futureOperation.asDirective { operation =>
93                   futureQuestion.asDirective { question =>
94                     Validation.validateOptional(
95                       request.questionId.map { qId =>
96                         Validation.validateField(
97                           "questionId",
98                           "not_found",
99                           question.isDefined,
100                           s"Question ${qId.value} doesn't exist"
101                         )
102                       },
103                       request.operationId.map { opId =>
104                         Validation.validateField(
105                           "operationId",
106                           "not_found",
107                           operation.isDefined,
108                           s"Operation ${opId.value} doesn't exist"
109                         )
110                       }
111                     )
112                     fixturesService
113                       .generate(
114                         maybeOperationId = request.operationId,
115                         maybeQuestionId = request.questionId,
116                         forceCountries = request.forceCountries,
117                         forceLanguage = request.forceLanguage
118                       )
119                       .asDirective { result =>
120                         complete(StatusCodes.Created -> result)
121                       }
122                   }
123                 }
124               }
125             }
126           }
127         }
128       }
129     }
130   }
131 
132 }
133 
134 final case class GenerateFixturesRequest(
135   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
136   operationId: Option[OperationId],
137   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555")
138   questionId: Option[QuestionId],
139   @(ApiModelProperty @field)(dataType = "list[string]")
140   forceCountries: Option[Nel[Country]],
141   @(ApiModelProperty @field)(dataType = "string", example = "fr")
142   forceLanguage: Option[Language]
143 )
144 
145 object GenerateFixturesRequest {
146   implicit val decoder: Decoder[GenerateFixturesRequest] = deriveDecoder[GenerateFixturesRequest]
147 }
148 
149 final case class FixtureResponse(
150   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
151   operationId: OperationId,
152   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
153   questionId: QuestionId,
154   userCount: Int,
155   organisationCount: Int,
156   partnerCount: Int,
157   tagCount: Int,
158   proposalCount: Int,
159   organisationsVoteCount: Int
160 )
161 
162 object FixtureResponse {
163   implicit val encoder: Encoder[FixtureResponse] = deriveEncoder[FixtureResponse]
164 }