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.model._
24 import akka.http.scaladsl.server._
25 import io.circe.generic.semiauto.{deriveDecoder, deriveEncoder}
26 import io.circe.{Decoder, Encoder}
27 import io.swagger.annotations._
28 import org.make.api.operation.OperationServiceComponent
29 import org.make.api.personality.DefaultPersistentPersonalityRoleFieldServiceComponent.PersistentPersonalityRoleField
30 import org.make.api.personality.DefaultPersistentPersonalityRoleServiceComponent.PersistentPersonalityRole
31 import org.make.api.question.QuestionServiceComponent
32 
33 import javax.ws.rs.Path
34 import org.make.api.technical.MakeDirectives.MakeDirectivesDependencies
35 import org.make.api.technical.{`X-Total-Count`, MakeAuthenticationDirectives}
36 import org.make.api.technical.directives.FutureDirectivesExtensions._
37 import org.make.core._
38 import org.make.core.technical.Pagination
39 import org.make.core.auth.UserRights
40 import org.make.core.personality.{
41   FieldType,
42   PersonalityRole,
43   PersonalityRoleField,
44   PersonalityRoleFieldId,
45   PersonalityRoleId
46 }
47 import scalaoauth2.provider.AuthInfo
48 
49 import scala.annotation.meta.field
50 
51 @Api(
52   value = "Admin Personality Roles",
53   authorizations = Array(
54     new Authorization(
55       value = "MakeApi",
56       scopes = Array(new AuthorizationScope(scope = "admin", description = "BO Admin"))
57     )
58   )
59 )
60 @Path(value = "/admin/personality-roles")
61 trait AdminPersonalityRoleApi extends Directives {
62 
63   @ApiOperation(value = "get-personality-role", httpMethod = "GET", code = HttpCodes.OK)
64   @ApiResponses(
65     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[PersonalityRoleResponse]))
66   )
67   @ApiImplicitParams(
68     value = Array(
69       new ApiImplicitParam(
70         name = "personalityRoleId",
71         paramType = "path",
72         dataType = "string",
73         example = "11111111-2222-3333-4444-555555555555"
74       )
75     )
76   )
77   @Path(value = "/{personalityRoleId}")
78   def getPersonalityRole: Route
79 
80   @ApiOperation(value = "list-personality-roles", httpMethod = "GET", code = HttpCodes.OK)
81   @ApiImplicitParams(
82     value = Array(
83       new ApiImplicitParam(
84         name = "_start",
85         paramType = "query",
86         dataType = "int",
87         allowableValues = "range[0, infinity]"
88       ),
89       new ApiImplicitParam(
90         name = "_end",
91         paramType = "query",
92         dataType = "int",
93         allowableValues = "range[0, infinity]"
94       ),
95       new ApiImplicitParam(
96         name = "_sort",
97         paramType = "query",
98         dataType = "string",
99         allowableValues = PersistentPersonalityRole.swaggerAllowableValues
100       ),
101       new ApiImplicitParam(
102         name = "_order",
103         paramType = "query",
104         dataType = "string",
105         allowableValues = Order.swaggerAllowableValues
106       ),
107       new ApiImplicitParam(name = "name", paramType = "query", dataType = "string")
108     )
109   )
110   @ApiResponses(
111     value =
112       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[PersonalityRoleResponse]]))
113   )
114   @Path(value = "/")
115   def listPersonalityRoles: Route
116 
117   @ApiOperation(value = "create-personality-role", httpMethod = "POST", code = HttpCodes.Created)
118   @ApiImplicitParams(
119     value = Array(
120       new ApiImplicitParam(
121         value = "body",
122         paramType = "body",
123         dataType = "org.make.api.personality.CreatePersonalityRoleRequest"
124       )
125     )
126   )
127   @ApiResponses(
128     value =
129       Array(new ApiResponse(code = HttpCodes.Created, message = "Ok", response = classOf[PersonalityRoleResponse]))
130   )
131   @Path(value = "/")
132   def createPersonalityRole: Route
133 
134   @ApiOperation(value = "update-personality-role", httpMethod = "PUT", code = HttpCodes.OK)
135   @ApiImplicitParams(
136     value = Array(
137       new ApiImplicitParam(
138         name = "personalityRoleId",
139         paramType = "path",
140         dataType = "string",
141         example = "11111111-2222-3333-4444-555555555555"
142       ),
143       new ApiImplicitParam(
144         value = "body",
145         paramType = "body",
146         dataType = "org.make.api.personality.UpdatePersonalityRoleRequest"
147       )
148     )
149   )
150   @ApiResponses(
151     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[PersonalityRoleResponse]))
152   )
153   @Path(value = "/{personalityRoleId}")
154   def updatePersonalityRole: Route
155 
156   @ApiOperation(value = "delete-personality-role", httpMethod = "DELETE", code = HttpCodes.OK)
157   @ApiImplicitParams(
158     value = Array(
159       new ApiImplicitParam(
160         name = "personalityRoleId",
161         paramType = "path",
162         dataType = "string",
163         example = "11111111-2222-3333-4444-555555555555"
164       )
165     )
166   )
167   @ApiResponses(
168     value = Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[PersonalityRoleIdResponse]))
169   )
170   @Path(value = "/{personalityRoleId}")
171   def deletePersonalityRole: Route
172 
173   @ApiOperation(value = "get-personality-role-field", httpMethod = "GET", code = HttpCodes.OK)
174   @ApiResponses(
175     value =
176       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[PersonalityRoleFieldResponse]))
177   )
178   @ApiImplicitParams(
179     value = Array(
180       new ApiImplicitParam(
181         name = "personalityRoleId",
182         paramType = "path",
183         dataType = "string",
184         example = "11111111-2222-3333-4444-555555555555"
185       ),
186       new ApiImplicitParam(
187         name = "personalityRoleFieldId",
188         paramType = "path",
189         dataType = "string",
190         example = "11111111-2222-3333-4444-555555555555"
191       )
192     )
193   )
194   @Path(value = "/{personalityRoleId}/fields/{personalityRoleFieldId}")
195   def getPersonalityRoleField: Route
196 
197   @ApiOperation(value = "list-personality-role-fields", httpMethod = "GET", code = HttpCodes.OK)
198   @ApiImplicitParams(
199     value = Array(
200       new ApiImplicitParam(
201         name = "personalityRoleId",
202         paramType = "path",
203         dataType = "string",
204         example = "11111111-2222-3333-4444-555555555555"
205       ),
206       new ApiImplicitParam(
207         name = "_start",
208         paramType = "query",
209         dataType = "int",
210         allowableValues = "range[0, infinity]"
211       ),
212       new ApiImplicitParam(
213         name = "_end",
214         paramType = "query",
215         dataType = "int",
216         allowableValues = "range[0, infinity]"
217       ),
218       new ApiImplicitParam(
219         name = "_sort",
220         paramType = "query",
221         dataType = "string",
222         allowableValues = PersistentPersonalityRoleField.swaggerAllowableValues
223       ),
224       new ApiImplicitParam(
225         name = "_order",
226         paramType = "query",
227         dataType = "string",
228         allowableValues = Order.swaggerAllowableValues
229       ),
230       new ApiImplicitParam(name = "name", paramType = "query", dataType = "string"),
231       new ApiImplicitParam(
232         name = "fieldType",
233         paramType = "query",
234         dataType = "string",
235         allowableValues = FieldType.swaggerAllowableValues
236       ),
237       new ApiImplicitParam(name = "required", paramType = "query", dataType = "boolean")
238     )
239   )
240   @ApiResponses(
241     value = Array(
242       new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[Array[PersonalityRoleFieldResponse]])
243     )
244   )
245   @Path(value = "/{personalityRoleId}/fields")
246   def listPersonalityRoleFields: Route
247 
248   @ApiOperation(value = "create-personality-role-field", httpMethod = "POST", code = HttpCodes.Created)
249   @ApiImplicitParams(
250     value = Array(
251       new ApiImplicitParam(
252         name = "personalityRoleId",
253         paramType = "path",
254         dataType = "string",
255         example = "11111111-2222-3333-4444-555555555555"
256       ),
257       new ApiImplicitParam(
258         value = "body",
259         paramType = "body",
260         dataType = "org.make.api.personality.CreatePersonalityRoleFieldRequest"
261       )
262     )
263   )
264   @ApiResponses(
265     value =
266       Array(new ApiResponse(code = HttpCodes.Created, message = "Ok", response = classOf[PersonalityRoleFieldResponse]))
267   )
268   @Path(value = "/{personalityRoleId}/fields")
269   def createPersonalityRoleField: Route
270 
271   @ApiOperation(value = "update-personality-role-field", httpMethod = "PUT", code = HttpCodes.OK)
272   @ApiImplicitParams(
273     value = Array(
274       new ApiImplicitParam(
275         name = "personalityRoleId",
276         paramType = "path",
277         dataType = "string",
278         example = "11111111-2222-3333-4444-555555555555"
279       ),
280       new ApiImplicitParam(
281         name = "personalityRoleFieldId",
282         paramType = "path",
283         dataType = "string",
284         example = "11111111-2222-3333-4444-555555555555"
285       ),
286       new ApiImplicitParam(
287         value = "body",
288         paramType = "body",
289         dataType = "org.make.api.personality.UpdatePersonalityRoleFieldRequest"
290       )
291     )
292   )
293   @ApiResponses(
294     value =
295       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[PersonalityRoleFieldResponse]))
296   )
297   @Path(value = "/{personalityRoleId}/fields/{personalityRoleFieldId}")
298   def updatePersonalityRoleField: Route
299 
300   @ApiOperation(value = "delete-personality-role-field", httpMethod = "DELETE", code = HttpCodes.OK)
301   @ApiImplicitParams(
302     value = Array(
303       new ApiImplicitParam(
304         name = "personalityRoleId",
305         paramType = "path",
306         dataType = "string",
307         example = "11111111-2222-3333-4444-555555555555"
308       ),
309       new ApiImplicitParam(
310         name = "personalityRoleFieldId",
311         paramType = "path",
312         dataType = "string",
313         example = "11111111-2222-3333-4444-555555555555"
314       )
315     )
316   )
317   @ApiResponses(
318     value =
319       Array(new ApiResponse(code = HttpCodes.OK, message = "Ok", response = classOf[PersonalityRoleFieldIdResponse]))
320   )
321   @Path(value = "/{personalityRoleId}/fields/{personalityRoleFieldId}")
322   def deletePersonalityRoleField: Route
323 
324   def routes: Route =
325     getPersonalityRole ~
326       listPersonalityRoles ~
327       createPersonalityRole ~
328       updatePersonalityRole ~
329       deletePersonalityRole ~
330       getPersonalityRoleField ~
331       listPersonalityRoleFields ~
332       createPersonalityRoleField ~
333       updatePersonalityRoleField ~
334       deletePersonalityRoleField
335 
336 }
337 
338 trait AdminPersonalityRoleApiComponent {
339   def adminPersonalityRoleApi: AdminPersonalityRoleApi
340 }
341 
342 trait DefaultAdminPersonalityRoleApiComponent
343     extends AdminPersonalityRoleApiComponent
344     with MakeAuthenticationDirectives
345     with ParameterExtractors {
346   this: MakeDirectivesDependencies
347     with PersonalityRoleServiceComponent
348     with PersonalityRoleFieldServiceComponent
349     with QuestionServiceComponent
350     with OperationServiceComponent =>
351 
352   override lazy val adminPersonalityRoleApi: AdminPersonalityRoleApi = new DefaultAdminPersonalityRoleApi
353 
354   class DefaultAdminPersonalityRoleApi extends AdminPersonalityRoleApi {
355 
356     val personalityRoleId: PathMatcher1[PersonalityRoleId] = Segment.map(PersonalityRoleId.apply)
357     val personalityRoleFieldId: PathMatcher1[PersonalityRoleFieldId] = Segment.map(PersonalityRoleFieldId.apply)
358 
359     override def getPersonalityRole: Route = get {
360       path("admin" / "personality-roles" / personalityRoleId) { personalityRoleId =>
361         makeOperation("GetPersonalityRole") { _ =>
362           makeOAuth2 { auth: AuthInfo[UserRights] =>
363             requireAdminRole(auth.user) {
364               personalityRoleService.getPersonalityRole(personalityRoleId).asDirectiveOrNotFound { personalityRole =>
365                 complete(PersonalityRoleResponse(personalityRole))
366               }
367             }
368           }
369         }
370       }
371     }
372 
373     override def listPersonalityRoles: Route = get {
374       path("admin" / "personality-roles") {
375         makeOperation("GetPersonalityRoles") { _ =>
376           parameters(
377             "_start".as[Pagination.Offset].?,
378             "_end".as[Pagination.End].?,
379             "_sort".?,
380             "_order".as[Order].?,
381             "name".?
382           ) {
383             (
384               offset: Option[Pagination.Offset],
385               end: Option[Pagination.End],
386               sort: Option[String],
387               order: Option[Order],
388               name: Option[String]
389             ) =>
390               makeOAuth2 { auth: AuthInfo[UserRights] =>
391                 requireAdminRole(auth.user) {
392                   (
393                     personalityRoleService.count(roleIds = None, name = name).asDirective,
394                     personalityRoleService
395                       .find(offset = offset.orZero, end = end, sort = sort, order = order, roleIds = None, name = name)
396                       .asDirective
397                   ).tupled.apply({
398                     case (count, personalityRoles) =>
399                       complete(
400                         (
401                           StatusCodes.OK,
402                           List(`X-Total-Count`(count.toString)),
403                           personalityRoles.map(PersonalityRoleResponse.apply)
404                         )
405                       )
406                   })
407                 }
408               }
409           }
410         }
411       }
412     }
413 
414     override def createPersonalityRole: Route = post {
415       path("admin" / "personality-roles") {
416         makeOperation("CreatePersonalityRole") { _ =>
417           makeOAuth2 { auth: AuthInfo[UserRights] =>
418             requireAdminRole(auth.user) {
419               decodeRequest {
420                 entity(as[CreatePersonalityRoleRequest]) { request: CreatePersonalityRoleRequest =>
421                   personalityRoleService
422                     .createPersonalityRole(request)
423                     .asDirective { result =>
424                       complete(StatusCodes.Created -> PersonalityRoleResponse(result))
425                     }
426                 }
427               }
428             }
429           }
430         }
431       }
432     }
433 
434     override def updatePersonalityRole: Route =
435       put {
436         path("admin" / "personality-roles" / personalityRoleId) { personalityRoleId =>
437           makeOperation("UpdatePersonalityRole") { _ =>
438             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
439               requireAdminRole(userAuth.user) {
440                 decodeRequest {
441                   entity(as[UpdatePersonalityRoleRequest]) { request: UpdatePersonalityRoleRequest =>
442                     personalityRoleService.updatePersonalityRole(personalityRoleId, request).asDirectiveOrNotFound {
443                       personalityRole =>
444                         complete(StatusCodes.OK -> PersonalityRoleResponse(personalityRole))
445                     }
446                   }
447                 }
448               }
449             }
450           }
451         }
452       }
453 
454     override def deletePersonalityRole: Route =
455       delete {
456         path("admin" / "personality-roles" / personalityRoleId) { personalityRoleId =>
457           makeOperation("UpdatePersonalityRole") { _ =>
458             makeOAuth2 { userAuth: AuthInfo[UserRights] =>
459               requireAdminRole(userAuth.user) {
460                 personalityRoleService.deletePersonalityRole(personalityRoleId).asDirective { _ =>
461                   complete(StatusCodes.OK -> PersonalityRoleIdResponse(personalityRoleId))
462                 }
463               }
464             }
465           }
466         }
467       }
468 
469     override def getPersonalityRoleField: Route = get {
470       path("admin" / "personality-roles" / personalityRoleId / "fields" / personalityRoleFieldId) {
471         (personalityRoleId, personalityRoleFieldId) =>
472           makeOperation("GetPersonalityRoleField") { _ =>
473             makeOAuth2 { auth: AuthInfo[UserRights] =>
474               requireAdminRole(auth.user) {
475                 personalityRoleFieldService
476                   .getPersonalityRoleField(personalityRoleFieldId, personalityRoleId)
477                   .asDirectiveOrNotFound { personalityRoleField =>
478                     complete(PersonalityRoleFieldResponse(personalityRoleField))
479                   }
480               }
481             }
482           }
483       }
484     }
485 
486     override def listPersonalityRoleFields: Route = get {
487       path("admin" / "personality-roles" / personalityRoleId / "fields") { personalityRoleId =>
488         makeOperation("GetPersonalityRoleFields") { _ =>
489           parameters(
490             "_start".as[Pagination.Offset].?,
491             "_end".as[Pagination.End].?,
492             "_sort".?,
493             "_order".as[Order].?,
494             "name".?,
495             "fieldType".as[FieldType].?,
496             "required".as[Boolean].?
497           ) {
498             (
499               offset: Option[Pagination.Offset],
500               end: Option[Pagination.End],
501               sort: Option[String],
502               order: Option[Order],
503               name: Option[String],
504               fieldType: Option[FieldType],
505               required: Option[Boolean]
506             ) =>
507               makeOAuth2 { auth: AuthInfo[UserRights] =>
508                 requireAdminRole(auth.user) {
509                   (
510                     personalityRoleFieldService
511                       .count(
512                         personalityRoleId = Some(personalityRoleId),
513                         name = name,
514                         fieldType = fieldType,
515                         required = required
516                       )
517                       .asDirective,
518                     personalityRoleFieldService
519                       .find(
520                         offset = offset.orZero,
521                         end = end,
522                         sort = sort,
523                         order = order,
524                         personalityRoleId = Some(personalityRoleId),
525                         name = name,
526                         fieldType = fieldType,
527                         required = required
528                       )
529                       .asDirective
530                   ).tupled.apply({
531                     case (count, personalityRoleFields) =>
532                       complete(
533                         (
534                           StatusCodes.OK,
535                           List(`X-Total-Count`(count.toString)),
536                           personalityRoleFields.map(PersonalityRoleFieldResponse.apply)
537                         )
538                       )
539                   })
540                 }
541               }
542           }
543         }
544       }
545     }
546 
547     override def createPersonalityRoleField: Route = post {
548       path("admin" / "personality-roles" / personalityRoleId / "fields") { personalityRoleId =>
549         makeOperation("CreatePersonalityRoleField") { _ =>
550           makeOAuth2 { auth: AuthInfo[UserRights] =>
551             requireAdminRole(auth.user) {
552               decodeRequest {
553                 entity(as[CreatePersonalityRoleFieldRequest]) { request: CreatePersonalityRoleFieldRequest =>
554                   personalityRoleFieldService
555                     .createPersonalityRoleField(personalityRoleId, request)
556                     .asDirective { result =>
557                       complete(StatusCodes.Created -> PersonalityRoleFieldResponse(result))
558                     }
559                 }
560               }
561             }
562           }
563         }
564       }
565     }
566 
567     override def updatePersonalityRoleField: Route =
568       put {
569         path("admin" / "personality-roles" / personalityRoleId / "fields" / personalityRoleFieldId) {
570           (personalityRoleId, personalityRoleFieldId) =>
571             makeOperation("UpdatePersonalityRoleField") { _ =>
572               makeOAuth2 { userAuth: AuthInfo[UserRights] =>
573                 requireAdminRole(userAuth.user) {
574                   decodeRequest {
575                     entity(as[UpdatePersonalityRoleFieldRequest]) { request: UpdatePersonalityRoleFieldRequest =>
576                       personalityRoleFieldService
577                         .updatePersonalityRoleField(personalityRoleFieldId, personalityRoleId, request)
578                         .asDirectiveOrNotFound { personalityRoleField =>
579                           complete(StatusCodes.OK -> PersonalityRoleFieldResponse(personalityRoleField))
580                         }
581                     }
582                   }
583                 }
584               }
585             }
586         }
587       }
588 
589     override def deletePersonalityRoleField: Route =
590       delete {
591         path("admin" / "personality-roles" / personalityRoleId / "fields" / personalityRoleFieldId) {
592           (_, personalityRoleFieldId) =>
593             makeOperation("UpdatePersonalityRoleField") { _ =>
594               makeOAuth2 { userAuth: AuthInfo[UserRights] =>
595                 requireAdminRole(userAuth.user) {
596                   personalityRoleFieldService
597                     .deletePersonalityRoleField(personalityRoleFieldId)
598                     .asDirective { _ =>
599                       complete(StatusCodes.OK -> PersonalityRoleFieldIdResponse(personalityRoleFieldId))
600                     }
601                 }
602               }
603             }
604         }
605       }
606 
607   }
608 
609 }
610 
611 final case class PersonalityRoleResponse(
612   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true) id: PersonalityRoleId,
613   name: String
614 )
615 
616 object PersonalityRoleResponse {
617   implicit val encoder: Encoder[PersonalityRoleResponse] = deriveEncoder[PersonalityRoleResponse]
618   implicit val decoder: Decoder[PersonalityRoleResponse] = deriveDecoder[PersonalityRoleResponse]
619 
620   def apply(personalityRole: PersonalityRole): PersonalityRoleResponse =
621     PersonalityRoleResponse(id = personalityRole.personalityRoleId, name = personalityRole.name)
622 }
623 
624 final case class PersonalityRoleIdResponse(
625   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
626   id: PersonalityRoleId
627 )
628 
629 object PersonalityRoleIdResponse {
630   implicit val encoder: Encoder[PersonalityRoleIdResponse] = deriveEncoder[PersonalityRoleIdResponse]
631   implicit val decoder: Decoder[PersonalityRoleIdResponse] = deriveDecoder[PersonalityRoleIdResponse]
632 }
633 
634 final case class PersonalityRoleFieldResponse(
635   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true) id: PersonalityRoleFieldId,
636   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true) personalityRoleId: PersonalityRoleId,
637   name: String,
638   @(ApiModelProperty @field)(dataType = "string", allowableValues = FieldType.swaggerAllowableValues, required = true) fieldType: FieldType,
639   required: Boolean
640 )
641 
642 object PersonalityRoleFieldResponse {
643   implicit val encoder: Encoder[PersonalityRoleFieldResponse] = deriveEncoder[PersonalityRoleFieldResponse]
644   implicit val decoder: Decoder[PersonalityRoleFieldResponse] = deriveDecoder[PersonalityRoleFieldResponse]
645 
646   def apply(personalityRoleField: PersonalityRoleField): PersonalityRoleFieldResponse =
647     PersonalityRoleFieldResponse(
648       id = personalityRoleField.personalityRoleFieldId,
649       personalityRoleId = personalityRoleField.personalityRoleId,
650       name = personalityRoleField.name,
651       fieldType = personalityRoleField.fieldType,
652       required = personalityRoleField.required
653     )
654 }
655 
656 final case class PersonalityRoleFieldIdResponse(
657   @(ApiModelProperty @field)(dataType = "string", example = "11111111-2222-3333-4444-555555555555", required = true)
658   id: PersonalityRoleFieldId
659 )
660 
661 object PersonalityRoleFieldIdResponse {
662   implicit val encoder: Encoder[PersonalityRoleFieldIdResponse] = deriveEncoder[PersonalityRoleFieldIdResponse]
663   implicit val decoder: Decoder[PersonalityRoleFieldIdResponse] = deriveDecoder[PersonalityRoleFieldIdResponse]
664 }