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.tag
21 
22 import akka.http.scaladsl.model.StatusCodes
23 import akka.http.scaladsl.server._
24 import io.swagger.annotations._
25 import org.make.api.operation.OperationServiceComponent
26 
27 import javax.ws.rs.Path
28 import org.make.api.technical.directives.FutureDirectivesExtensions._
29 import org.make.api.question.QuestionServiceComponent
30 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
31 import org.make.api.technical.MakeAuthenticationDirectives
32 import org.make.core.operation.{OperationId, OperationKind}
33 import org.make.core.question.QuestionId
34 import org.make.core.tag.TagId
35 import org.make.core.{tag, HttpCodes, ParameterExtractors}
36 import org.make.core.technical.Pagination
37 
38 @Api(value = "Tags")
39 @Path(value = "/tags")
40 trait TagApi extends Directives {
41 
42   @Path(value = "/{tagId}")
43   @ApiOperation(value = "get-tag", httpMethod = "GET", code = HttpCodes.OK)
44   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[tag.Tag])))
45   @ApiImplicitParams(value = Array(new ApiImplicitParam(name = "tagId", paramType = "path", dataType = "string")))
46   def getTag: Route
47 
48   @ApiOperation(value = "list-tags", httpMethod = "GET", code = HttpCodes.OK)
49   @ApiImplicitParams(
50     value = Array(
51       new ApiImplicitParam(
52         name = "start",
53         paramType = "query",
54         dataType = "int",
55         allowableValues = "range[0, infinity]"
56       ),
57       new ApiImplicitParam(name = "end", paramType = "query", dataType = "int", allowableValues = "range[0, infinity]"),
58       new ApiImplicitParam(name = "questionId", paramType = "query", dataType = "string")
59     )
60   )
61   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[tag.Tag]])))
62   @Path(value = "/")
63   def listTags: Route
64 
65   final def routes: Route = getTag ~ listTags
66 
67   val tagId: PathMatcher1[TagId] =
68     Segment.map(id => TagId(id))
69 }
70 
71 trait TagApiComponent {
72   def tagApi: TagApi
73 }
74 
75 trait DefaultTagApiComponent extends TagApiComponent with MakeAuthenticationDirectives with ParameterExtractors {
76   this: MakeDirectivesDependencies
77     with TagServiceComponent
78     with QuestionServiceComponent
79     with OperationServiceComponent =>
80 
81   override lazy val tagApi: TagApi = new DefaultTagApi
82 
83   class DefaultTagApi extends TagApi {
84 
85     override def getTag: Route = get {
86       path("tags" / tagId) { tagId =>
87         makeOperation("GetTag") { _ =>
88           tagService.getTag(tagId).asDirectiveOrNotFound { tag =>
89             operationService.findOne(tag.operationId.getOrElse(OperationId(""))).asDirectiveOrNotFound { operation =>
90               operation.operationKind match {
91                 case kind if OperationKind.unsecuredKinds.contains(kind) => complete(tag)
92                 case _                                                   => complete(StatusCodes.NotFound)
93               }
94             }
95           }
96         }
97       }
98     }
99 
100     override def listTags: Route = get {
101       path("tags") {
102         makeOperation("Search") { _ =>
103           parameters("start".as[Pagination.Offset].?, "end".as[Pagination.End].?, "questionId".as[QuestionId].?) {
104             (offset, end, maybeQuestionId) =>
105               tagService
106                 .find(
107                   offset = offset.orZero,
108                   end = end,
109                   onlyDisplayed = true,
110                   tagFilter = TagFilter(questionIds = maybeQuestionId.map(Seq(_)))
111                 )
112                 .asDirective { tags =>
113                   val operationIds = tags.flatMap(_.operationId).distinct
114                   operationService.find(Some(operationIds)).asDirective { operations =>
115                     val securedOperationIds =
116                       operations.filter(_.operationKind == OperationKind.SecuredConsultation).map(_.operationId)
117                     val filteredTags = tags.filterNot(_.operationId match {
118                       case Some(operationId) if securedOperationIds.contains(operationId) => true
119                       case _                                                              => false
120                     })
121                     complete(filteredTags)
122                   }
123                 }
124           }
125         }
126       }
127     }
128   }
129 
130 }