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.elasticsearch
21 
22 import akka.http.scaladsl.model.StatusCodes
23 import akka.http.scaladsl.server.{Directives, Route}
24 import io.circe.Decoder
25 import io.circe.generic.semiauto.deriveDecoder
26 import io.swagger.annotations._
27 import org.make.api.operation.OperationServiceComponent
28 import org.make.api.question.QuestionServiceComponent
29 
30 import javax.ws.rs.Path
31 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
32 import org.make.api.technical.{EndpointType, MakeAuthenticationDirectives}
33 import org.make.api.technical.directives.FutureDirectivesExtensions._
34 import org.make.core.HttpCodes
35 import org.make.core.auth.UserRights
36 import org.make.core.job.Job.JobId.{Reindex, ReindexPosts}
37 import scalaoauth2.provider.AuthInfo
38 
39 import scala.annotation.meta.field
40 
41 @Api(value = "Elasticsearch")
42 @Path(value = "/technical/elasticsearch")
43 trait ElasticSearchApi extends Directives {
44 
45   @ApiOperation(
46     value = "reindex",
47     httpMethod = "POST",
48     code = HttpCodes.Accepted,
49     authorizations = Array(
50       new Authorization(
51         value = "MakeApi",
52         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
53       )
54     )
55   )
56   @ApiImplicitParams(
57     value = Array(
58       new ApiImplicitParam(
59         value = "body",
60         paramType = "body",
61         dataType = "org.make.api.technical.elasticsearch.ReindexRequest"
62       )
63     )
64   )
65   @ApiResponses(
66     value = Array(
67       new ApiResponse(code = HttpCodes.Accepted, message = "Ok"),
68       new ApiResponse(code = HttpCodes.Conflict, message = "Conflict")
69     )
70   )
71   @Path(value = "/reindex")
72   def reindex: Route
73 
74   @ApiOperation(
75     value = "reindex-posts",
76     httpMethod = "POST",
77     code = HttpCodes.Accepted,
78     authorizations = Array(
79       new Authorization(
80         value = "MakeApi",
81         scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
82       )
83     )
84   )
85   @ApiResponses(
86     value = Array(
87       new ApiResponse(code = HttpCodes.Accepted, message = "Accepted"),
88       new ApiResponse(code = HttpCodes.Conflict, message = "Conflict")
89     )
90   )
91   @Path(value = "/reindex-posts")
92   def reindexPosts: Route
93 
94   final def routes: Route = reindex ~ reindexPosts
95 }
96 
97 trait ElasticSearchApiComponent {
98   def elasticSearchApi: ElasticSearchApi
99 }
100 
101 trait DefaultElasticSearchApiComponent extends ElasticSearchApiComponent with MakeAuthenticationDirectives {
102   this: MakeDirectivesDependencies
103     with IndexationComponent
104     with QuestionServiceComponent
105     with OperationServiceComponent =>
106 
107   override lazy val elasticSearchApi: ElasticSearchApi = new DefaultElasticSearchApi
108 
109   class DefaultElasticSearchApi extends ElasticSearchApi {
110     def reindex: Route = post {
111       path("technical" / "elasticsearch" / "reindex") {
112         makeOperation(Reindex.value) { _ =>
113           makeOAuth2 { auth: AuthInfo[UserRights] =>
114             requireAdminRole(auth.user) {
115               decodeRequest {
116                 entity(as[ReindexRequest]) { request: ReindexRequest =>
117                   // Do not wait until the reindexation job is over to give an answer
118                   indexationService
119                     .reindexData(
120                       Seq(request.forceAll, request.forceIdeas).flatten.contains(true),
121                       Seq(request.forceAll, request.forceOrganisations).flatten.contains(true),
122                       Seq(request.forceAll, request.forceProposals).flatten.contains(true),
123                       Seq(request.forceAll, request.forceOperationOfQuestions).flatten.contains(true)
124                     )
125                     .asDirective { acceptance =>
126                       if (acceptance.isAccepted) {
127                         complete(StatusCodes.Accepted -> Reindex)
128                       } else {
129                         complete(StatusCodes.Conflict -> Reindex)
130                       }
131                     }
132                 }
133               }
134             }
135           }
136         }
137       }
138     }
139 
140     def reindexPosts: Route = post {
141       path("technical" / "elasticsearch" / "reindex-posts") {
142         makeOperation(ReindexPosts.value, EndpointType.CoreOnly) { _ =>
143           makeOAuth2 { auth: AuthInfo[UserRights] =>
144             requireAdminRole(auth.user) {
145               // Do not wait until the reindexation job is over to give an answer
146               indexationService.reindexPostsData().asDirective { acceptance =>
147                 if (acceptance.isAccepted) {
148                   complete(StatusCodes.Accepted -> ReindexPosts)
149                 } else {
150                   complete(StatusCodes.Conflict -> ReindexPosts)
151                 }
152               }
153             }
154           }
155         }
156       }
157     }
158   }
159 }
160 
161 @ApiModel
162 final case class ReindexRequest(
163   @(ApiModelProperty @field)(dataType = "boolean") forceIdeas: Option[Boolean],
164   @(ApiModelProperty @field)(dataType = "boolean") forceOrganisations: Option[Boolean],
165   @(ApiModelProperty @field)(dataType = "boolean") forceProposals: Option[Boolean],
166   @(ApiModelProperty @field)(dataType = "boolean") forceOperationOfQuestions: Option[Boolean],
167   @(ApiModelProperty @field)(dataType = "boolean") forceAll: Option[Boolean]
168 )
169 
170 object ReindexRequest {
171   implicit val decoder: Decoder[ReindexRequest] = deriveDecoder[ReindexRequest]
172 }