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.sequence
21 
22 import org.make.api.technical.directives.FutureDirectivesExtensions._
23 import org.make.api.keyword.KeywordServiceComponent
24 import org.make.api.operation.OperationOfQuestionSearchEngineComponent
25 import org.make.api.question.QuestionServiceComponent
26 import org.make.api.sequence.SequenceBehaviour.ConsensusParam
27 import org.make.api.technical.CsvReceptacle._
28 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
29 import org.make.core.auth.UserRights
30 import org.make.core.{HttpCodes, ParameterExtractors}
31 import org.make.core.demographics.DemographicsCardId
32 import org.make.core.proposal.{ProposalId, ProposalKeywordKey}
33 import org.make.core.proposal.indexed.Zone
34 import org.make.core.question.QuestionId
35 import org.make.core.reference.Language
36 
37 import cats.implicits._
38 import akka.http.scaladsl.server._
39 import eu.timepit.refined.auto._
40 import grizzled.slf4j.Logging
41 import io.swagger.annotations._
42 import scalaoauth2.provider.AuthInfo
43 
44 import javax.ws.rs.Path
45 import scala.concurrent.ExecutionContext.Implicits.global
46 import scala.concurrent.Future
47 import org.make.core.keyword.Keyword
48 
49 trait SequenceApiComponent {
50   def sequenceApi: SequenceApi
51 }
52 
53 @Api(value = "Sequences")
54 @Path(value = "/sequences")
55 trait SequenceApi extends Directives {
56 
57   @ApiOperation(value = "start-standard-sequence", httpMethod = "GET", code = HttpCodes.OK)
58   @ApiImplicitParams(
59     value = Array(
60       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
61       new ApiImplicitParam(name = "include", paramType = "query", dataType = "string", allowMultiple = true),
62       new ApiImplicitParam(name = "demographicsCardId", paramType = "query", dataType = "string"),
63       new ApiImplicitParam(name = "token", paramType = "query", dataType = "string"),
64       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string", example = "fr")
65     )
66   )
67   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[SequenceResult])))
68   @Path(value = "/standard/{questionId}")
69   def startStandardSequence: Route
70 
71   @ApiOperation(value = "start-consensus-sequence", httpMethod = "GET", code = HttpCodes.OK)
72   @ApiImplicitParams(
73     value = Array(
74       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
75       new ApiImplicitParam(name = "include", paramType = "query", dataType = "string", allowMultiple = true),
76       new ApiImplicitParam(name = "demographicsCardId", paramType = "query", dataType = "string"),
77       new ApiImplicitParam(name = "token", paramType = "query", dataType = "string"),
78       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string", example = "fr")
79     )
80   )
81   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[SequenceResult])))
82   @Path(value = "/consensus/{questionId}")
83   def startConsensusSequence: Route
84 
85   @ApiOperation(value = "start-controversy-sequence", httpMethod = "GET", code = HttpCodes.OK)
86   @ApiImplicitParams(
87     value = Array(
88       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
89       new ApiImplicitParam(name = "include", paramType = "query", dataType = "string", allowMultiple = true),
90       new ApiImplicitParam(name = "demographicsCardId", paramType = "query", dataType = "string"),
91       new ApiImplicitParam(name = "token", paramType = "query", dataType = "string"),
92       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string", example = "fr")
93     )
94   )
95   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[SequenceResult])))
96   @Path(value = "/controversy/{questionId}")
97   def startControversySequence: Route
98 
99   @ApiOperation(value = "start-keyword-sequence", httpMethod = "GET", code = HttpCodes.OK)
100   @ApiImplicitParams(
101     value = Array(
102       new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string"),
103       new ApiImplicitParam(name = "keywordKey", paramType = "path", dataType = "string"),
104       new ApiImplicitParam(name = "include", paramType = "query", dataType = "string", allowMultiple = true),
105       new ApiImplicitParam(name = "demographicsCardId", paramType = "query", dataType = "string"),
106       new ApiImplicitParam(name = "token", paramType = "query", dataType = "string"),
107       new ApiImplicitParam(name = "preferredLanguage", paramType = "query", dataType = "string", example = "fr")
108     )
109   )
110   @ApiResponses(
111     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[KeywordSequenceResult]))
112   )
113   @Path(value = "/keyword/{questionId}/{keywordKey}")
114   def startKeywordSequence: Route
115 
116   @ApiOperation(value = "get-standard-first-proposal", httpMethod = "GET", code = HttpCodes.OK)
117   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string")))
118   @ApiResponses(
119     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[FirstProposalResponse]))
120   )
121   @Path(value = "/standard/{questionId}/first-proposal")
122   def getStandardFirstProposal: Route
123 
124   @ApiOperation(value = "get-controversy-first-proposal", httpMethod = "GET", code = HttpCodes.OK)
125   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string")))
126   @ApiResponses(
127     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[FirstProposalResponse]))
128   )
129   @Path(value = "/controversy/{questionId}/first-proposal")
130   def getControversyFirstProposal: Route
131 
132   @ApiOperation(value = "get-consensus-first-proposal", httpMethod = "GET", code = HttpCodes.OK)
133   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "questionId", paramType = "path", dataType = "string")))
134   @ApiResponses(
135     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[FirstProposalResponse]))
136   )
137   @Path(value = "/consensus/{questionId}/first-proposal")
138   def getConsensusFirstProposal: Route
139 
140   def routes: Route =
141     startStandardSequence ~
142       startConsensusSequence ~
143       startControversySequence ~
144       startKeywordSequence ~
145       getStandardFirstProposal ~
146       getControversyFirstProposal ~
147       getConsensusFirstProposal
148 }
149 
150 trait DefaultSequenceApiComponent extends SequenceApiComponent {
151 
152   this: MakeDirectivesDependencies
153     with SequenceServiceComponent
154     with SequenceCacheManagerServiceComponent
155     with SequenceConfigurationComponent
156     with OperationOfQuestionSearchEngineComponent
157     with QuestionServiceComponent
158     with KeywordServiceComponent =>
159 
160   override lazy val sequenceApi: SequenceApi = new DefaultSequenceApi
161 
162   class DefaultSequenceApi extends SequenceApi with Logging with ParameterExtractors {
163 
164     private val questionId: PathMatcher1[QuestionId] = Segment.map(QuestionId.apply)
165     private val keywordKey: PathMatcher1[ProposalKeywordKey] = Segment.map(ProposalKeywordKey.apply)
166 
167     override def startStandardSequence: Route = get {
168       path("sequences" / "standard" / questionId) { questionId =>
169         makeOperation("StartStandardSequence") { requestContext =>
170           optionalOidcAuth(questionId) { userAuth: Option[AuthInfo[UserRights]] =>
171             parameters(
172               "include".csv[ProposalId],
173               "demographicsCardId".as[DemographicsCardId].?,
174               "token".?,
175               "preferredLanguage".as[Language].?
176             ) {
177               (
178                 includes: Option[Seq[ProposalId]],
179                 cardId: Option[DemographicsCardId],
180                 token: Option[String],
181                 preferredLanguage: Option[Language]
182               ) =>
183                 questionService
184                   .getCachedQuestion(questionId)
185                   .asDirectiveOrNotFound { question =>
186                     sequenceService
187                       .startNewSequence(
188                         behaviourParam = (),
189                         maybeUserId = userAuth.map(_.user.userId),
190                         includedProposalsIds = includes.getOrElse(Seq.empty),
191                         requestContext = requestContext,
192                         cardId = cardId,
193                         token = token,
194                         preferredLanguage = preferredLanguage,
195                         question = question
196                       )
197                       .asDirective
198                       .apply(complete(_))
199                   }
200             }
201           }
202         }
203       }
204     }
205 
206     override def startConsensusSequence: Route = get {
207       path("sequences" / "consensus" / questionId) { questionId =>
208         makeOperation("StartConsensusSequence") { requestContext =>
209           optionalOidcAuth(questionId) { userAuth: Option[AuthInfo[UserRights]] =>
210             parameters(
211               "include".csv[ProposalId],
212               "demographicsCardId".as[DemographicsCardId].?,
213               "token".?,
214               "preferredLanguage".as[Language].?
215             ) {
216               (
217                 includes: Option[Seq[ProposalId]],
218                 cardId: Option[DemographicsCardId],
219                 token: Option[String],
220                 preferredLanguage: Option[Language]
221               ) =>
222                 val futureTop20ConsensusThreshold: Future[Option[Double]] =
223                   elasticsearchOperationOfQuestionAPI
224                     .findOperationOfQuestionById(questionId)
225                     .map(_.flatMap(_.top20ConsensusThreshold))
226                 questionService
227                   .getCachedQuestion(questionId)
228                   .asDirectiveOrNotFound { question =>
229                     futureTop20ConsensusThreshold.asDirective
230                       .flatMap(
231                         threshold =>
232                           sequenceService
233                             .startNewSequence(
234                               behaviourParam = ConsensusParam(threshold),
235                               maybeUserId = userAuth.map(_.user.userId),
236                               includedProposalsIds = includes.getOrElse(Seq.empty),
237                               requestContext = requestContext,
238                               cardId = cardId,
239                               token = token,
240                               preferredLanguage = preferredLanguage,
241                               question = question
242                             )
243                             .asDirective
244                       )
245                       .apply(complete(_))
246                   }
247             }
248           }
249         }
250       }
251     }
252 
253     override def startControversySequence: Route = get {
254       path("sequences" / "controversy" / questionId) { questionId =>
255         makeOperation("StartControversySequence") { requestContext =>
256           optionalOidcAuth(questionId) { userAuth: Option[AuthInfo[UserRights]] =>
257             parameters(
258               "include".csv[ProposalId],
259               "demographicsCardId".as[DemographicsCardId].?,
260               "token".?,
261               "preferredLanguage".as[Language].?
262             ) {
263               (
264                 includes: Option[Seq[ProposalId]],
265                 cardId: Option[DemographicsCardId],
266                 token: Option[String],
267                 preferredLanguage: Option[Language]
268               ) =>
269                 questionService
270                   .getCachedQuestion(questionId)
271                   .asDirectiveOrNotFound { question =>
272                     sequenceService
273                       .startNewSequence(
274                         behaviourParam = Zone.Controversy,
275                         maybeUserId = userAuth.map(_.user.userId),
276                         includedProposalsIds = includes.getOrElse(Seq.empty),
277                         requestContext = requestContext,
278                         cardId = cardId,
279                         token = token,
280                         preferredLanguage = preferredLanguage,
281                         question = question
282                       )
283                       .asDirective
284                       .apply(complete(_))
285                   }
286             }
287           }
288         }
289       }
290     }
291 
292     override def startKeywordSequence: Route = get {
293       path("sequences" / "keyword" / questionId / keywordKey) { (questionId, keywordKey) =>
294         makeOperation("StartKeywordSequence") { requestContext =>
295           optionalOidcAuth(questionId) { userAuth: Option[AuthInfo[UserRights]] =>
296             parameters(
297               "include".csv[ProposalId],
298               "demographicsCardId".as[DemographicsCardId].?,
299               "token".?,
300               "preferredLanguage".as[Language].?
301             ) {
302               (
303                 includes: Option[Seq[ProposalId]],
304                 cardId: Option[DemographicsCardId],
305                 token: Option[String],
306                 preferredLanguage: Option[Language]
307               ) =>
308                 (
309                   questionService.getCachedQuestion(questionId).asDirectiveOrNotFound,
310                   keywordService.get(keywordKey.value, questionId).asDirectiveOrNotFound
311                 ).tupled
312                   .flatMap({
313                     case (question, keyword: Keyword) =>
314                       sequenceService
315                         .startNewSequence(
316                           behaviourParam = keywordKey,
317                           maybeUserId = userAuth.map(_.user.userId),
318                           includedProposalsIds = includes.getOrElse(Seq.empty),
319                           requestContext = requestContext,
320                           cardId = cardId,
321                           token = token,
322                           preferredLanguage = preferredLanguage,
323                           question = question
324                         )
325                         .asDirective
326                         .map(
327                           sequenceResult =>
328                             KeywordSequenceResult(
329                               key = keyword.key,
330                               label = keyword.label,
331                               proposals = sequenceResult.proposals,
332                               demographics = sequenceResult.demographics
333                             )
334                         )
335                   })
336                   .apply(complete(_))
337             }
338           }
339         }
340       }
341     }
342 
343     override def getStandardFirstProposal: Route = get {
344       path("sequences" / "standard" / questionId / "first-proposal") { questionId =>
345         makeOperation("GetStandardFirstProposal") { requestContext =>
346           optionalOidcAuth(questionId) { _ =>
347             parameters("preferredLanguage".as[Language].?) {
348               (
349                 preferredLanguage: Option[Language]
350               ) =>
351                 (
352                   questionService.getCachedQuestion(questionId).asDirectiveOrNotFound,
353                   sequenceConfigurationService
354                     .getSequenceConfigurationByQuestionId(questionId)
355                     .asDirective
356                 ).tupled
357                   .flatMap({
358                     case (question, config) =>
359                       sequenceCacheManagerService
360                         .getProposal(questionId, requestContext, preferredLanguage, question.defaultLanguage)
361                         .asDirective
362                         .map(FirstProposalResponse(_, config.mainSequence.sequenceSize))
363                   })
364                   .apply(complete(_))
365             }
366           }
367         }
368       }
369     }
370 
371     override def getControversyFirstProposal: Route = get {
372       path("sequences" / "controversy" / questionId / "first-proposal") { questionId =>
373         makeOperation("GetControversyFirstProposal") { requestContext =>
374           optionalOidcAuth(questionId) { _ =>
375             parameters("preferredLanguage".as[Language].?) {
376               (
377                 preferredLanguage: Option[Language]
378               ) =>
379                 (
380                   questionService.getCachedQuestion(questionId).asDirectiveOrNotFound,
381                   sequenceConfigurationService.getSequenceConfigurationByQuestionId(questionId).asDirective
382                 ).tupled
383                   .flatMap({
384                     case (question, config) =>
385                       sequenceCacheManagerService
386                         .getControversyProposal(questionId, requestContext, preferredLanguage, question.defaultLanguage)
387                         .asDirective
388                         .map(FirstProposalResponse(_, config.controversial.sequenceSize))
389                   })
390                   .apply(complete(_))
391             }
392           }
393         }
394       }
395     }
396 
397     override def getConsensusFirstProposal: Route = get {
398       path("sequences" / "consensus" / questionId / "first-proposal") { questionId =>
399         makeOperation("GetConsensusFirstProposal") { requestContext =>
400           optionalOidcAuth(questionId) { _ =>
401             parameters("preferredLanguage".as[Language].?) {
402               (
403                 preferredLanguage: Option[Language]
404               ) =>
405                 (
406                   questionService.getCachedQuestion(questionId).asDirectiveOrNotFound,
407                   sequenceConfigurationService
408                     .getSequenceConfigurationByQuestionId(questionId)
409                     .asDirective
410                 ).tupled
411                   .flatMap({
412                     case (question, config) =>
413                       val futureTop20ConsensusThreshold: () => Future[ConsensusParam] = () =>
414                         elasticsearchOperationOfQuestionAPI
415                           .findOperationOfQuestionById(questionId)
416                           .map(_.flatMap(_.top20ConsensusThreshold))
417                           .map(ConsensusParam.apply)
418                       sequenceCacheManagerService
419                         .getConsensusProposal(
420                           questionId,
421                           futureTop20ConsensusThreshold,
422                           requestContext,
423                           preferredLanguage,
424                           question.defaultLanguage
425                         )
426                         .asDirective
427                         .map(FirstProposalResponse(_, config.popular.sequenceSize))
428                   })
429                   .apply(complete(_))
430             }
431           }
432         }
433       }
434     }
435   }
436 }