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
21 
22 import akka.http.scaladsl.model.StatusCodes
23 import akka.http.scaladsl.server.{Directives, Route}
24 import grizzled.slf4j.Logging
25 import io.swagger.annotations._
26 import org.make.api.operation.OperationServiceComponent
27 import org.make.api.question.QuestionServiceComponent
28 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
29 import org.make.api.user.UserServiceComponent
30 import org.make.api.userhistory.UserHistoryCoordinatorServiceComponent
31 import org.make.core._
32 import org.make.core.technical.Pagination
33 
34 import javax.ws.rs.Path
35 import scala.concurrent.ExecutionContext.Implicits.global
36 import scala.concurrent.Future
37 import scala.util.{Failure, Success}
38 
39 @Api(value = "Migrations")
40 @Path(value = "/migrations")
41 trait MigrationApi extends Directives {
42 
43   def emptyRoute: Route
44 
45   @ApiOperation(
46     value = "modify-avatars-swift-path",
47     httpMethod = "POST",
48     code = HttpCodes.NoContent,
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(new ApiImplicitParam(name = "dry", paramType = "query", dataType = "boolean", required = true))
58   )
59   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.NoContent, message = "No Content")))
60   @Path(value = "/modify-avatars-swift-path")
61   def modifyAvatarsSwiftPath: Route
62 
63   def routes: Route = modifyAvatarsSwiftPath
64 }
65 
66 trait MigrationApiComponent {
67   def migrationApi: MigrationApi
68 }
69 
70 trait DefaultMigrationApiComponent extends MigrationApiComponent with MakeAuthenticationDirectives with Logging {
71   this: MakeDirectivesDependencies
72     with ActorSystemComponent
73     with ReadJournalComponent
74     with UserServiceComponent
75     with UserHistoryCoordinatorServiceComponent
76     with QuestionServiceComponent
77     with OperationServiceComponent =>
78 
79   override lazy val migrationApi: MigrationApi = new DefaultMigrationApi
80 
81   class DefaultMigrationApi extends MigrationApi {
82     override def emptyRoute: Route =
83       get {
84         path("migrations") {
85           complete(StatusCodes.OK)
86         }
87       }
88 
89     override def modifyAvatarsSwiftPath: Route = post {
90       path("migrations" / "modify-avatars-swift-path") {
91         makeOperation("ModifyAvatarsSwiftPath") { _ =>
92           makeOAuth2 { userAuth =>
93             requireAdminRole(userAuth.user) {
94               parameter("dry".as[Boolean]) { dry =>
95                 val batchSize: Int = 1000
96                 val startTime = System.currentTimeMillis()
97                 val eventDate = DateHelper.now()
98                 StreamUtils
99                   .asyncPageToPageSource(
100                     offset =>
101                       userService.adminFindUsers(
102                         Pagination.Offset(offset),
103                         Some(Pagination.End(offset + batchSize)),
104                         None,
105                         None,
106                         None,
107                         None,
108                         None,
109                         None,
110                         None,
111                         None
112                       )
113                   )
114                   .map { users =>
115                     users.map(user => user.userId -> user.profile.flatMap(_.avatarUrl))
116                   }
117                   .mapConcat(identity)
118                   .collect { case (id, Some(avatarUrl)) => id -> avatarUrl }
119                   .mapAsync(5) {
120                     case (id, avatarUrl) =>
121                       if (dry) {
122                         Future.successful(1)
123                       } else {
124                         userService
125                           .changeAvatarForUser(id, avatarUrl, RequestContext.empty, eventDate)
126                           .map(_ => 1)
127                       }
128                   }
129                   .runFold(0)(_ + _)
130                   .onComplete {
131                     case Success(count) =>
132                       val time = System.currentTimeMillis() - startTime
133                       logger.info(s"$count users have had their avatars updated in $time ms")
134                     case Failure(exception) =>
135                       logger.error("Error while updating avatars path:", exception)
136                   }
137 
138                 complete(StatusCodes.NoContent)
139               }
140             }
141           }
142         }
143       }
144     }
145 
146   }
147 }