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.personality
21 
22 import cats.implicits._
23 import akka.http.scaladsl.server._
24 import eu.timepit.refined.api.Refined
25 import eu.timepit.refined.string.Url
26 import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
27 import io.circe.{Decoder, Encoder}
28 import io.circe.refined._
29 import io.swagger.annotations._
30 
31 import javax.ws.rs.Path
32 import org.make.api.operation.OperationServiceComponent
33 import org.make.api.question.QuestionServiceComponent
34 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
35 import org.make.api.technical.MakeAuthenticationDirectives
36 import org.make.api.technical.directives.FutureDirectivesExtensions._
37 import org.make.api.user.{UserResponse, UserServiceComponent}
38 import org.make.core.Validation._
39 import org.make.core._
40 import org.make.core.profile.Profile
41 import org.make.core.reference.{Country, Language}
42 import org.make.core.user.{User, UserId}
43 import org.make.core.technical.ValidatedUtils.ValidatedNecWithUtils
44 
45 import scala.annotation.meta.field
46 
47 @Api(value = "Personalities")
48 @Path(value = "/personalities")
49 trait PersonalityApi extends Directives {
50 
51   @ApiOperation(value = "get-personality", httpMethod = "GET", code = HttpCodes.OK)
52   @ApiResponses(value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[UserResponse])))
53   @ApiImplicitParams(
54     value = Array(
55       new ApiImplicitParam(
56         name = "userId",
57         paramType = "path",
58         dataType = "string",
59         example = "11111111-2222-3333-4444-555555555555"
60       )
61     )
62   )
63   @Path(value = "/{userId}")
64   def getPersonality: Route
65 
66   @ApiOperation(value = "get-personality", httpMethod = "GET", code = HttpCodes.OK)
67   @ApiResponses(
68     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[PersonalityProfileResponse]))
69   )
70   @ApiImplicitParams(
71     value = Array(
72       new ApiImplicitParam(
73         name = "userId",
74         paramType = "path",
75         dataType = "string",
76         example = "11111111-2222-3333-4444-555555555555"
77       )
78     )
79   )
80   @Path(value = "/{userId}/profile")
81   def getPersonalityProfile: Route
82 
83   @ApiOperation(
84     value = "update-personality-profile",
85     httpMethod = "PUT",
86     authorizations = Array(
87       new Authorization(
88         value = "MakeApi",
89         scopes = Array(new AuthorizationScope(scope = "user", description = "application user"))
90       )
91     )
92   )
93   @ApiResponses(
94     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[PersonalityProfileResponse]))
95   )
96   @ApiImplicitParams(
97     value = Array(
98       new ApiImplicitParam(name = "userId", paramType = "path", dataType = "string"),
99       new ApiImplicitParam(
100         value = "body",
101         paramType = "body",
102         dataType = "org.make.api.personality.PersonalityProfileRequest"
103       )
104     )
105   )
106   @Path(value = "/{userId}/profile")
107   def modifyPersonalityProfile: Route
108 
109   def routes: Route =
110     getPersonality ~ getPersonalityProfile ~ modifyPersonalityProfile
111 
112 }
113 
114 trait PersonalityApiComponent {
115   def personalityApi: PersonalityApi
116 }
117 
118 trait DefaultPersonalityApiComponent
119     extends PersonalityApiComponent
120     with MakeAuthenticationDirectives
121     with ParameterExtractors {
122   this: MakeDirectivesDependencies
123     with UserServiceComponent
124     with QuestionPersonalityServiceComponent
125     with QuestionServiceComponent
126     with OperationServiceComponent =>
127 
128   override lazy val personalityApi: PersonalityApi = new DefaultPersonalityApi
129 
130   class DefaultPersonalityApi extends PersonalityApi {
131 
132     val userId: PathMatcher1[UserId] = Segment.map(id => UserId(id))
133 
134     override def getPersonality: Route =
135       get {
136         path("personalities" / userId) { userId =>
137           makeOperation("GetPersonality") { _ =>
138             userService.getPersonality(userId).asDirectiveOrNotFound { user =>
139               complete(UserResponse(user))
140             }
141           }
142         }
143       }
144 
145     override def getPersonalityProfile: Route = {
146       get {
147         path("personalities" / userId / "profile") { userId =>
148           makeOperation("GetPersonalityProfile") { _ =>
149             userService.getPersonality(userId).asDirectiveOrNotFound { user =>
150               complete(PersonalityProfileResponse.fromUser(user))
151             }
152           }
153         }
154       }
155     }
156 
157     override def modifyPersonalityProfile: Route = {
158       put {
159         path("personalities" / userId / "profile") { personalityId =>
160           makeOperation("UpdatePersonalityProfile") { requestContext =>
161             decodeRequest {
162               entity(as[PersonalityProfileRequest]) { request =>
163                 makeOAuth2 { currentUser =>
164                   authorize(currentUser.user.userId == personalityId) {
165                     userService.getPersonality(personalityId).asDirectiveOrNotFound { personality =>
166                       val modifiedProfile = personality.profile
167                         .orElse(Profile.parseProfile())
168                         .map(
169                           _.copy(
170                             avatarUrl = request.avatarUrl.map(_.value),
171                             description = request.description,
172                             optInNewsletter = request.optInNewsletter,
173                             website = request.website.map(_.value),
174                             politicalParty = request.politicalParty,
175                             crmCountry = request.crmCountry.getOrElse(Country("FR")),
176                             crmLanguage = request.crmLanguage.getOrElse(Language("fr"))
177                           )
178                         )
179 
180                       val modifiedPersonality = personality.copy(
181                         firstName = Some(request.firstName),
182                         lastName = Some(request.lastName),
183                         profile = modifiedProfile
184                       )
185 
186                       userService.update(modifiedPersonality, requestContext).asDirective { result =>
187                         complete(PersonalityProfileResponse.fromUser(result))
188                       }
189                     }
190                   }
191                 }
192               }
193             }
194           }
195         }
196       }
197     }
198   }
199 }
200 
201 final case class PersonalityProfileResponse(
202   firstName: Option[String],
203   lastName: Option[String],
204   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/avatar.png")
205   avatarUrl: Option[String],
206   description: Option[String],
207   @(ApiModelProperty @field)(dataType = "boolean") optInNewsletter: Option[Boolean],
208   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/website")
209   website: Option[String],
210   politicalParty: Option[String],
211   @(ApiModelProperty @field)(dataType = "string", example = "FR") crmCountry: Option[Country],
212   @(ApiModelProperty @field)(dataType = "string", example = "fr") crmLanguage: Option[Language]
213 )
214 
215 object PersonalityProfileResponse {
216   implicit val encoder: Encoder[PersonalityProfileResponse] = deriveEncoder[PersonalityProfileResponse]
217   implicit val decoder: Decoder[PersonalityProfileResponse] = deriveDecoder[PersonalityProfileResponse]
218 
219   def fromUser(user: User): PersonalityProfileResponse = {
220     PersonalityProfileResponse(
221       firstName = user.firstName,
222       lastName = user.lastName,
223       avatarUrl = user.profile.flatMap(_.avatarUrl),
224       description = user.profile.flatMap(_.description),
225       website = user.profile.flatMap(_.website),
226       politicalParty = user.profile.flatMap(_.politicalParty),
227       optInNewsletter = user.profile.map(_.optInNewsletter),
228       crmCountry = user.profile.map(_.crmCountry),
229       crmLanguage = user.profile.map(_.crmLanguage)
230     )
231 
232   }
233 }
234 
235 final case class PersonalityProfileRequest(
236   firstName: String,
237   lastName: String,
238   @(ApiModelProperty @field)(dataType = "string", example = "https://example.com/logo.jpg")
239   avatarUrl: Option[String Refined Url],
240   description: Option[String],
241   optInNewsletter: Boolean,
242   @(ApiModelProperty @field)(dataType = "string", example = "https://make.org")
243   website: Option[String Refined Url],
244   politicalParty: Option[String],
245   @(ApiModelProperty @field)(dataType = "string", example = "FR") crmCountry: Option[Country],
246   @(ApiModelProperty @field)(dataType = "string", example = "fr") crmLanguage: Option[Language]
247 ) {
248   private val maxDescriptionLength = 450
249 
250   Seq(
251     description.map(_.withMaxLength(maxDescriptionLength, "description").void),
252     description.map(_.toSanitizedInput("description").void),
253     politicalParty.map(_.toSanitizedInput("politicalParty").void)
254   ).flatten.foreach(_.throwIfInvalid())
255 
256   (
257     firstName.toNonEmpty("firstName"),
258     firstName.toSanitizedInput("firstName"),
259     lastName.toNonEmpty("lastName"),
260     lastName.toSanitizedInput("lastName")
261   ).tupled.throwIfInvalid()
262 }
263 
264 object PersonalityProfileRequest {
265   implicit val encoder: Encoder[PersonalityProfileRequest] = deriveEncoder[PersonalityProfileRequest]
266   implicit val decoder: Decoder[PersonalityProfileRequest] = deriveDecoder[PersonalityProfileRequest]
267 }