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.user
21 
22 import java.time.{LocalDate, ZoneOffset, ZonedDateTime}
23 import cats.data.NonEmptyList
24 import cats.implicits._
25 import com.github.t3hnar.bcrypt._
26 import grizzled.slf4j.Logging
27 import org.make.api.extensions.MakeDBExecutionContextComponent
28 import org.make.api.technical.DatabaseTransactions._
29 import org.make.api.technical.PersistentServiceUtils.sortOrderQuery
30 import org.make.api.technical.{PersistentCompanion, ScalikeSupport, ShortenedNames}
31 import org.make.api.technical.ScalikeSupport._
32 import org.make.api.user.DefaultPersistentUserServiceComponent.{FollowedUsers, PersistentUser}
33 import org.make.api.user.PersistentUserService.UpdateFailed
34 import org.make.core.{DateHelper, EventId, Order}
35 import org.make.core.technical.Pagination
36 import org.make.core.auth.UserRights
37 import org.make.core.operation.OperationId
38 import org.make.core.profile.{Gender, Profile, SocioProfessionalCategory}
39 import org.make.core.question.QuestionId
40 import org.make.core.reference.{Country, Language}
41 import org.make.core.technical.Pagination._
42 import org.make.core.user._
43 import scalikejdbc._
44 import scalikejdbc.interpolation.SQLSyntax._
45 
46 import scala.concurrent.Future
47 
48 trait DefaultPersistentUserServiceComponent extends PersistentUserServiceComponent with ShortenedNames with Logging {
49   this: MakeDBExecutionContextComponent =>
50 
51   override lazy val persistentUserService: PersistentUserService = new DefaultPersistentUserService
52 
53   class DefaultPersistentUserService extends PersistentUserService {
54 
55     private val userAlias = PersistentUser.alias
56     private val followedUsersAlias = FollowedUsers.followedUsersAlias
57     private val column = PersistentUser.column
58     private val followedUsersColumn = FollowedUsers.column
59 
60     private def defaultEnd(offset: Pagination.Offset): Option[Pagination.End] =
61       Some(End(offset.extractInt + 10))
62 
63     override def getFollowedUsers(userId: UserId): Future[Seq[String]] = {
64       implicit val cxt: EC = readExecutionContext
65       val futureUserFollowed = Future(NamedDB("READ").retryableTx { implicit session =>
66         withSQL {
67           select
68             .from(FollowedUsers.as(followedUsersAlias))
69             .leftJoin(PersistentUser.as(userAlias))
70             .on(userAlias.uuid, followedUsersAlias.followedUserId)
71             .where(sqls.eq(followedUsersAlias.userId, userId.value).and(sqls.eq(userAlias.publicProfile, true)))
72         }.map(FollowedUsers.apply()).list()
73       })
74 
75       futureUserFollowed.map(_.map(_.followedUserId))
76     }
77 
78     override def get(uuid: UserId): Future[Option[User]] = {
79       implicit val cxt: EC = readExecutionContext
80       val futurePersistentUser = Future(NamedDB("READ").retryableTx { implicit session =>
81         withSQL {
82           select
83             .from(PersistentUser.as(userAlias))
84             .where(sqls.eq(userAlias.uuid, uuid.value))
85         }.map(PersistentUser.apply()).single()
86       })
87 
88       futurePersistentUser.map(_.map(_.toUser))
89     }
90 
91     def findAllByUserIds(ids: Seq[UserId]): Future[Seq[User]] = {
92       implicit val cxt: EC = readExecutionContext
93       val futurePersistentUsers = Future(NamedDB("READ").retryableTx { implicit session =>
94         withSQL {
95           select
96             .from(PersistentUser.as(userAlias))
97             .where(sqls.in(userAlias.uuid, ids.map(_.value)))
98         }.map(PersistentUser.apply()).list()
99       })
100 
101       futurePersistentUsers.map(_.map(_.toUser))
102     }
103 
104     override def findByEmailAndPassword(email: String, password: String): Future[Option[User]] = {
105       implicit val cxt: EC = readExecutionContext
106       val futurePersistentUser = Future(NamedDB("READ").retryableTx { implicit session =>
107         withSQL {
108           select
109             .from(PersistentUser.as(userAlias))
110             .where(sqls.eq(userAlias.email, email.toLowerCase))
111         }.map(PersistentUser.apply()).single()
112       }).map(_.filter { persistentUser =>
113         persistentUser.hashedPassword != null && password.isBcryptedBounded(persistentUser.hashedPassword)
114       })
115 
116       futurePersistentUser.map(_.map(_.toUser))
117     }
118 
119     override def findByUserIdAndPassword(userId: UserId, password: Option[String]): Future[Option[User]] = {
120       implicit val cxt: EC = readExecutionContext
121       val futurePersistentUser = Future(NamedDB("READ").retryableTx { implicit session =>
122         withSQL {
123           select
124             .from(PersistentUser.as(userAlias))
125             .where(sqls.eq(userAlias.uuid, userId.value))
126         }.map(PersistentUser.apply()).single()
127       }).map(_.filter { persistentUser =>
128         persistentUser.hashedPassword == null || password.exists(_.isBcryptedBounded(persistentUser.hashedPassword))
129       })
130 
131       futurePersistentUser.map(_.map(_.toUser))
132     }
133 
134     override def findByUserIdAndUserType(userId: UserId, userType: UserType): Future[Option[User]] = {
135       implicit val cxt: EC = readExecutionContext
136       val futurePersistentUser = Future(NamedDB("READ").retryableTx { implicit session =>
137         withSQL {
138           select
139             .from(PersistentUser.as(userAlias))
140             .where(sqls.eq(userAlias.uuid, userId.value).and(sqls.eq(userAlias.userType, userType)))
141         }.map(PersistentUser.apply()).single()
142       })
143 
144       futurePersistentUser.map(_.map(_.toUser))
145     }
146 
147     override def findByEmail(email: String): Future[Option[User]] = {
148       implicit val cxt: EC = readExecutionContext
149       val futurePersistentUser = Future(NamedDB("READ").retryableTx { implicit session =>
150         withSQL {
151           select
152             .from(PersistentUser.as(userAlias))
153             .where(sqls.eq(userAlias.email, email))
154         }.map(PersistentUser.apply()).single()
155       })
156 
157       futurePersistentUser.map(_.map(_.toUser))
158     }
159 
160     override def findByReconnectTokenAndPassword(
161       reconnectToken: String,
162       password: String,
163       validityReconnectToken: Int
164     ): Future[Option[User]] = {
165       implicit val cxt: EC = readExecutionContext
166       val futurePersistentUser = Future(NamedDB("READ").retryableTx { implicit session =>
167         withSQL {
168           select
169             .from(PersistentUser.as(userAlias))
170             .where(sqls.eq(userAlias.reconnectToken, reconnectToken))
171         }.map(PersistentUser.apply()).single()
172       }).map(_.filter { persistentUser =>
173         persistentUser.hashedPassword != null && password.isBcryptedBounded(persistentUser.hashedPassword) &&
174         persistentUser.reconnectTokenCreatedAt.exists(_.plusMinutes(validityReconnectToken).isAfter(DateHelper.now()))
175       })
176 
177       futurePersistentUser.map(_.map(_.toUser))
178     }
179 
180     override def adminFindUsers(
181       offset: Pagination.Offset,
182       end: Option[Pagination.End],
183       sort: Option[String],
184       order: Option[Order],
185       ids: Option[Seq[UserId]],
186       email: Option[String],
187       firstName: Option[String],
188       lastName: Option[String],
189       maybeRole: Option[Role],
190       maybeUserType: Option[UserType]
191     ): Future[Seq[User]] = {
192       implicit val cxt: EC = readExecutionContext
193       val futurePersistentUser = Future(NamedDB("READ").retryableTx { implicit session =>
194         withSQL {
195           val query: scalikejdbc.PagingSQLBuilder[PersistentUser] = select
196             .from(PersistentUser.as(userAlias))
197             .where(
198               sqls.toAndConditionOpt(
199                 ids.map(userIds => sqls.in(userAlias.uuid, userIds.map(_.value))),
200                 email
201                   .map(email => sqls.like(sqls.lower(userAlias.email), s"%${email.replace("%", "\\%").toLowerCase}%")),
202                 firstName.map(
203                   firstName =>
204                     sqls.like(sqls.lower(userAlias.firstName), s"%${firstName.replace("%", "\\%").toLowerCase}%")
205                 ),
206                 lastName.map(
207                   lastName =>
208                     sqls.like(sqls.lower(userAlias.lastName), s"%${lastName.replace("%", "\\%").toLowerCase}%")
209                 ),
210                 maybeRole.map(role         => sqls.isNotNull(sqls"array_position(${userAlias.roles}, ${role.value})")),
211                 maybeUserType.map(userType => sqls.eq(userAlias.userType, userType))
212               )
213             )
214           sortOrderQuery(offset, end.orElse(defaultEnd(offset)), sort, order, query)
215         }.map(PersistentUser.apply()).list()
216       })
217 
218       futurePersistentUser.map(_.map(_.toUser))
219     }
220 
221     override def findAllOrganisations(): Future[Seq[User]] = {
222       implicit val cxt: EC = readExecutionContext
223       val futurePersistentUsers: Future[List[PersistentUser]] = Future(NamedDB("READ").retryableTx { implicit session =>
224         withSQL {
225           select
226             .from(PersistentUser.as(userAlias))
227             .where(sqls.eq(userAlias.userType, UserType.UserTypeOrganisation))
228         }.map(PersistentUser.apply()).list()
229       })
230 
231       futurePersistentUsers.map(_.map(_.toUser))
232 
233     }
234 
235     override def findOrganisations(
236       offset: Pagination.Offset,
237       end: Option[Pagination.End],
238       sort: Option[String],
239       order: Option[Order],
240       ids: Option[Seq[UserId]],
241       organisationName: Option[String]
242     ): Future[Seq[User]] = {
243       implicit val cxt: EC = readExecutionContext
244       val futurePersistentUsers: Future[List[PersistentUser]] = Future(NamedDB("READ").retryableTx { implicit session =>
245         withSQL {
246           val query: scalikejdbc.PagingSQLBuilder[PersistentUser] =
247             select
248               .from(PersistentUser.as(userAlias))
249               .where(
250                 sqls
251                   .eq(userAlias.userType, UserType.UserTypeOrganisation)
252                   .and(
253                     sqls.toAndConditionOpt(
254                       ids.map(userIds => sqls.in(userAlias.uuid, userIds.map(_.value))),
255                       organisationName.map(
256                         organisationName =>
257                           sqls.like(
258                             sqls.lower(userAlias.organisationName),
259                             s"%${organisationName.replace("%", "\\%").toLowerCase}%"
260                           )
261                       )
262                     )
263                   )
264               )
265           sortOrderQuery(offset, end.orElse(defaultEnd(offset)), sort.orElse(Some("organisationName")), order, query)
266         }.map(PersistentUser.apply()).list()
267       })
268 
269       futurePersistentUsers.map(_.map(_.toUser))
270     }
271 
272     override def findUserByUserIdAndResetToken(userId: UserId, resetToken: String): Future[Option[User]] = {
273       implicit val cxt: EC = readExecutionContext
274       val futurePersistentUser = Future(NamedDB("READ").retryableTx { implicit session =>
275         withSQL {
276           select
277             .from(PersistentUser.as(userAlias))
278             .where(sqls.eq(userAlias.uuid, userId.value).and(sqls.eq(userAlias.resetToken, resetToken)))
279         }.map(PersistentUser.apply()).single()
280       })
281 
282       futurePersistentUser.map(_.map(_.toUser))
283     }
284 
285     override def findUserByUserIdAndVerificationToken(
286       userId: UserId,
287       verificationToken: String
288     ): Future[Option[User]] = {
289       implicit val cxt: EC = readExecutionContext
290       val futurePersistentUser = Future(NamedDB("READ").retryableTx { implicit session =>
291         withSQL {
292           select
293             .from(PersistentUser.as(userAlias))
294             .where(sqls.eq(userAlias.uuid, userId.value).and(sqls.eq(userAlias.verificationToken, verificationToken)))
295         }.map(PersistentUser.apply()).single()
296       })
297 
298       futurePersistentUser.map(_.map(_.toUser))
299     }
300 
301     override def findUserIdByEmail(email: String): Future[Option[UserId]] = {
302       implicit val cxt: EC = readExecutionContext
303       val futurePersistentUserId = Future(NamedDB("READ").retryableTx { implicit session =>
304         withSQL {
305           select(userAlias.result.uuid)
306             .from(PersistentUser.as(userAlias))
307             .where(sqls.eq(userAlias.email, email))
308         }.map(_.string(userAlias.resultName.uuid)).single()
309       })
310 
311       futurePersistentUserId.map(_.map(UserId(_)))
312     }
313 
314     override def findUsersWithoutRegisterQuestion: Future[Seq[User]] = {
315       implicit val cxt: EC = readExecutionContext
316       val futurePersistentUsers = Future(NamedDB("READ").retryableTx { implicit session =>
317         withSQL {
318           select
319             .from(PersistentUser.as(userAlias))
320             .where(sqls.isNull(userAlias.registerQuestionId))
321         }.map(PersistentUser.apply()).list()
322       })
323 
324       futurePersistentUsers.map(_.map(_.toUser))
325     }
326 
327     override def emailExists(email: String): Future[Boolean] = {
328       implicit val ctx: EC = readExecutionContext
329       Future(NamedDB("READ").retryableTx { implicit session =>
330         withSQL {
331           select(count(userAlias.email))
332             .from(PersistentUser.as(userAlias))
333             .where(sqls.eq(userAlias.email, email))
334         }.map(_.int(1) > 0).single()
335       }).map(_.getOrElse(false))
336     }
337 
338     override def verificationTokenExists(verificationToken: String): Future[Boolean] = {
339       implicit val ctx: EC = readExecutionContext
340       Future(NamedDB("READ").retryableTx { implicit session =>
341         withSQL {
342           select(count(userAlias.verificationToken))
343             .from(PersistentUser.as(userAlias))
344             .where(sqls.eq(userAlias.verificationToken, verificationToken))
345         }.map(_.int(1) > 0).single()
346       }).map(_.getOrElse(false))
347     }
348 
349     override def resetTokenExists(resetToken: String): Future[Boolean] = {
350       implicit val ctx: EC = readExecutionContext
351       Future(NamedDB("READ").retryableTx { implicit session =>
352         withSQL {
353           select(count(userAlias.resetToken))
354             .from(PersistentUser.as(userAlias))
355             .where(sqls.eq(userAlias.resetToken, resetToken))
356         }.map(_.int(1) > 0).single()
357       }).map(_.getOrElse(false))
358     }
359 
360     override def persist(user: User): Future[User] = {
361       implicit val ctx: EC = writeExecutionContext
362       Future(NamedDB("WRITE").retryableTx { implicit session =>
363         withSQL {
364           insert
365             .into(PersistentUser)
366             .namedValues(
367               column.uuid -> user.userId.value,
368               column.createdAt -> DateHelper.now(),
369               column.updatedAt -> DateHelper.now(),
370               column.email -> user.email,
371               column.firstName -> user.firstName,
372               column.lastName -> user.lastName,
373               column.lastIp -> user.lastIp,
374               column.hashedPassword -> user.hashedPassword,
375               column.enabled -> user.enabled,
376               column.emailVerified -> user.emailVerified,
377               column.userType -> user.userType,
378               column.lastConnection -> user.lastConnection,
379               column.verificationToken -> user.verificationToken,
380               column.verificationTokenExpiresAt -> user.verificationTokenExpiresAt,
381               column.resetToken -> user.resetToken,
382               column.resetTokenExpiresAt -> user.resetTokenExpiresAt,
383               column.roles -> session.connection
384                 .createArrayOf("VARCHAR", user.roles.map(_.value).toArray),
385               column.avatarUrl -> user.profile.flatMap(_.avatarUrl),
386               column.profession -> user.profile.flatMap(_.profession),
387               column.phoneNumber -> user.profile.flatMap(_.phoneNumber),
388               column.description -> user.profile.flatMap(_.description),
389               column.twitterId -> user.profile.flatMap(_.twitterId),
390               column.facebookId -> user.profile.flatMap(_.facebookId),
391               column.googleId -> user.profile.flatMap(_.googleId),
392               column.oidcInfos -> user.profile.flatMap(_.oidcInfos),
393               column.gender -> user.profile.flatMap(_.gender),
394               column.genderName -> user.profile.flatMap(_.genderName),
395               column.postalCode -> user.profile.flatMap(_.postalCode),
396               column.country -> user.country.value,
397               column.language -> user.language.value,
398               column.crmCountry -> user.profile.fold("FR")(_.crmCountry.value),
399               column.crmLanguage -> user.profile.fold("fr")(_.crmLanguage.value),
400               column.karmaLevel -> user.profile.flatMap(_.karmaLevel),
401               column.locale -> user.profile.flatMap(_.locale),
402               column.dateOfBirth -> user.profile.flatMap(_.dateOfBirth.map(_.atStartOfDay(ZoneOffset.UTC))),
403               column.optInNewsletter -> user.profile.forall(_.optInNewsletter),
404               column.isHardBounce -> user.isHardBounce,
405               column.lastMailingErrorDate -> user.lastMailingError.map(_.date),
406               column.lastMailingErrorMessage -> user.lastMailingError.map(_.error),
407               column.organisationName -> user.organisationName,
408               column.publicProfile -> user.publicProfile,
409               column.socioProfessionalCategory -> user.profile.flatMap(_.socioProfessionalCategory),
410               column.registerQuestionId -> user.profile.flatMap(_.registerQuestionId.map(_.value)),
411               column.optInPartner -> user.profile.flatMap(_.optInPartner),
412               column.availableQuestions -> session.connection
413                 .createArrayOf("VARCHAR", user.availableQuestions.map(_.value).toArray),
414               column.availableEvents -> session.connection
415                 .createArrayOf("VARCHAR", user.availableEvents.map(_.value).toArray),
416               column.politicalParty -> user.profile.flatMap(_.politicalParty),
417               column.website -> user.profile.flatMap(_.website),
418               column.legalMinorConsent -> user.profile.flatMap(_.legalMinorConsent),
419               column.legalAdvisorApproval -> user.profile.flatMap(_.legalAdvisorApproval),
420               column.privacyPolicyApprovalDate -> user.privacyPolicyApprovalDate,
421               column.connectionAttemptsSinceLastSuccessful -> user.connectionAttemptsSinceLastSuccessful
422             )
423         }.execute()
424       }).map(_ => user)
425     }
426 
427     override def modifyOrganisation(organisation: User): Future[Either[UpdateFailed, User]] = {
428       implicit val ctx: EC = writeExecutionContext
429       val nowDate: ZonedDateTime = DateHelper.now()
430       Future(NamedDB("WRITE").retryableTx { implicit session =>
431         withSQL {
432           update(PersistentUser)
433             .set(
434               column.organisationName -> organisation.organisationName,
435               column.email -> organisation.email,
436               column.avatarUrl -> organisation.profile.flatMap(_.avatarUrl),
437               column.description -> organisation.profile.flatMap(_.description),
438               column.crmCountry -> organisation.profile.fold("FR")(_.crmCountry.value),
439               column.crmLanguage -> organisation.profile.fold("fr")(_.crmLanguage.value),
440               column.website -> organisation.profile.flatMap(_.website),
441               column.optInNewsletter -> organisation.profile.forall(_.optInNewsletter),
442               column.updatedAt -> nowDate
443             )
444             .where(
445               sqls
446                 .eq(column.uuid, organisation.userId.value)
447             )
448         }.executeUpdate()
449       }).flatMap {
450         case 1 => Future.successful(Right(organisation.copy(updatedAt = Some(nowDate))))
451         case 0 =>
452           logger.error(s"Organisation '${organisation.userId.value}' not found")
453           Future.successful(Left(UpdateFailed()))
454         case _ =>
455           logger.error(s"Update of organisation '${organisation.userId.value}' failed - not found")
456           Future.successful(Left(UpdateFailed()))
457       }
458     }
459 
460     override def updateConnectionInfos(
461       userId: UserId,
462       lastConnection: Option[ZonedDateTime],
463       connectionAttemptsSinceLastSuccessful: Int,
464       privacyPolicyApprovalDate: Option[ZonedDateTime]
465     ): Future[Unit] = {
466       implicit val ctx: EC = writeExecutionContext
467       Future(NamedDB("WRITE").retryableTx { implicit session =>
468         withSQL {
469           update(PersistentUser)
470             .set(
471               column.lastConnection -> lastConnection,
472               column.connectionAttemptsSinceLastSuccessful -> connectionAttemptsSinceLastSuccessful,
473               column.privacyPolicyApprovalDate -> privacyPolicyApprovalDate
474             )
475             .where(sqls.eq(column.uuid, userId.value))
476         }.executeUpdate()
477       }).map(_ => ())
478     }
479 
480     override def updateUser(user: User): Future[User] = {
481       implicit val ctx: EC = writeExecutionContext
482       Future(NamedDB("WRITE").retryableTx { implicit session =>
483         withSQL {
484           update(PersistentUser)
485             .set(
486               column.createdAt -> user.createdAt,
487               column.updatedAt -> DateHelper.now(),
488               column.email -> user.email,
489               column.firstName -> user.firstName,
490               column.lastName -> user.lastName,
491               column.lastIp -> user.lastIp,
492               column.enabled -> user.enabled,
493               column.emailVerified -> user.emailVerified,
494               column.userType -> user.userType,
495               column.lastConnection -> user.lastConnection,
496               column.verificationToken -> user.verificationToken,
497               column.verificationTokenExpiresAt -> user.verificationTokenExpiresAt,
498               column.resetToken -> user.resetToken,
499               column.resetTokenExpiresAt -> user.resetTokenExpiresAt,
500               column.roles -> session.connection
501                 .createArrayOf("VARCHAR", user.roles.map(_.value).toArray),
502               column.avatarUrl -> user.profile.flatMap(_.avatarUrl),
503               column.profession -> user.profile.flatMap(_.profession),
504               column.phoneNumber -> user.profile.flatMap(_.phoneNumber),
505               column.description -> user.profile.flatMap(_.description),
506               column.twitterId -> user.profile.flatMap(_.twitterId),
507               column.facebookId -> user.profile.flatMap(_.facebookId),
508               column.googleId -> user.profile.flatMap(_.googleId),
509               column.oidcInfos -> user.profile.flatMap(_.oidcInfos),
510               column.gender -> user.profile.flatMap(_.gender),
511               column.genderName -> user.profile.flatMap(_.genderName),
512               column.postalCode -> user.profile.flatMap(_.postalCode),
513               column.country -> user.country.value,
514               column.language -> user.language.value,
515               column.crmCountry -> user.profile.fold("FR")(_.crmCountry.value),
516               column.crmLanguage -> user.profile.fold("fr")(_.crmLanguage.value),
517               column.karmaLevel -> user.profile.flatMap(_.karmaLevel),
518               column.locale -> user.profile.flatMap(_.locale),
519               column.dateOfBirth -> user.profile.flatMap(_.dateOfBirth.map(_.atStartOfDay(ZoneOffset.UTC))),
520               column.optInNewsletter -> user.profile.forall(_.optInNewsletter),
521               column.isHardBounce -> user.isHardBounce,
522               column.lastMailingErrorDate -> user.lastMailingError.map(_.date),
523               column.lastMailingErrorMessage -> user.lastMailingError.map(_.error),
524               column.organisationName -> user.organisationName,
525               column.publicProfile -> user.publicProfile,
526               column.socioProfessionalCategory -> user.profile.flatMap(_.socioProfessionalCategory),
527               column.registerQuestionId -> user.profile.flatMap(_.registerQuestionId.map(_.value)),
528               column.optInPartner -> user.profile.flatMap(_.optInPartner),
529               column.availableQuestions -> session.connection
530                 .createArrayOf("VARCHAR", user.availableQuestions.map(_.value).toArray),
531               column.availableEvents -> session.connection
532                 .createArrayOf("VARCHAR", user.availableEvents.map(_.value).toArray),
533               column.politicalParty -> user.profile.flatMap(_.politicalParty),
534               column.website -> user.profile.flatMap(_.website),
535               column.legalMinorConsent -> user.profile.flatMap(_.legalMinorConsent),
536               column.legalAdvisorApproval -> user.profile.flatMap(_.legalAdvisorApproval),
537               column.privacyPolicyApprovalDate -> user.privacyPolicyApprovalDate,
538               column.connectionAttemptsSinceLastSuccessful -> user.connectionAttemptsSinceLastSuccessful,
539               column.lastFailedConnectionAttempt -> user.lastFailedConnectionAttempt
540             )
541             .where(
542               sqls
543                 .eq(column.uuid, user.userId.value)
544             )
545         }.executeUpdate() match {
546           case 1 => user.copy(updatedAt = Some(DateHelper.now()))
547           case _ =>
548             logger.error(s"Update of user '${user.userId.value}' failed - not found")
549             user
550         }
551       })
552     }
553 
554     override def requestResetPassword(
555       userId: UserId,
556       resetToken: String,
557       resetTokenExpiresAt: Option[ZonedDateTime]
558     ): Future[Boolean] = {
559       implicit val ctx: EC = writeExecutionContext
560       Future(NamedDB("WRITE").retryableTx { implicit session =>
561         withSQL {
562           update(PersistentUser)
563             .set(
564               column.resetToken -> resetToken,
565               column.resetTokenExpiresAt -> resetTokenExpiresAt,
566               column.updatedAt -> DateHelper.now()
567             )
568             .where(
569               sqls
570                 .eq(column.uuid, userId.value)
571             )
572         }.executeUpdate() match {
573           case 1 => true
574           case _ => false
575         }
576       })
577     }
578 
579     override def updatePassword(userId: UserId, resetToken: Option[String], hashedPassword: String): Future[Boolean] = {
580       implicit val ctx: EC = writeExecutionContext
581       Future(NamedDB("WRITE").retryableTx { implicit session =>
582         withSQL {
583           val query = update(PersistentUser)
584             .set(
585               column.hashedPassword -> hashedPassword,
586               column.resetToken -> None,
587               column.resetTokenExpiresAt -> None,
588               column.updatedAt -> DateHelper.now()
589             )
590           resetToken match {
591             case Some(token) =>
592               query.where(
593                 sqls
594                   .eq(column.uuid, userId.value)
595                   .and(sqls.eq(column.resetToken, token))
596               )
597             case _ =>
598               query.where(
599                 sqls
600                   .eq(column.uuid, userId.value)
601               )
602           }
603         }.executeUpdate() match {
604           case 1 => true
605           case _ => false
606         }
607       })
608     }
609 
610     override def validateEmail(verificationToken: String): Future[Boolean] = {
611       implicit val ctx: EC = writeExecutionContext
612       Future(NamedDB("WRITE").retryableTx { implicit session =>
613         withSQL {
614           update(PersistentUser)
615             .set(
616               column.emailVerified -> true,
617               column.verificationToken -> None,
618               column.verificationTokenExpiresAt -> None,
619               column.updatedAt -> DateHelper.now()
620             )
621             .where(sqls.eq(column.verificationToken, verificationToken))
622         }.executeUpdate() match {
623           case 1 => true
624           case _ => false
625         }
626       })
627     }
628 
629     override def updateOptInNewsletter(userId: UserId, optInNewsletter: Boolean): Future[Boolean] = {
630       implicit val ctx: EC = writeExecutionContext
631       Future(NamedDB("WRITE").retryableTx { implicit session =>
632         withSQL {
633           update(PersistentUser)
634             .set(column.optInNewsletter -> optInNewsletter, column.updatedAt -> DateHelper.now())
635             .where(sqls.eq(column.uuid, userId.value))
636         }.executeUpdate() match {
637           case 1 => true
638           case _ => false
639         }
640       })
641     }
642 
643     override def updateIsHardBounce(userId: UserId, isHardBounce: Boolean): Future[Boolean] = {
644       implicit val ctx: EC = writeExecutionContext
645       Future(NamedDB("WRITE").retryableTx { implicit session =>
646         withSQL {
647           update(PersistentUser)
648             .set(column.isHardBounce -> isHardBounce, column.updatedAt -> DateHelper.now())
649             .where(sqls.eq(column.uuid, userId.value))
650         }.executeUpdate() match {
651           case 1 => true
652           case _ => false
653         }
654       })
655     }
656 
657     override def updateLastMailingError(userId: UserId, lastMailingError: Option[MailingErrorLog]): Future[Boolean] = {
658       implicit val ctx: EC = writeExecutionContext
659       Future(NamedDB("WRITE").retryableTx { implicit session =>
660         withSQL {
661           update(PersistentUser)
662             .set(
663               column.lastMailingErrorDate -> lastMailingError.map(_.date),
664               column.lastMailingErrorMessage -> lastMailingError.map(_.error),
665               column.updatedAt -> DateHelper.now()
666             )
667             .where(sqls.eq(column.uuid, userId.value))
668         }.executeUpdate() match {
669           case 1 => true
670           case _ => false
671         }
672       })
673     }
674 
675     override def updateOptInNewsletter(email: String, optInNewsletter: Boolean): Future[Boolean] = {
676       implicit val ctx: EC = writeExecutionContext
677       Future(NamedDB("WRITE").retryableTx { implicit session =>
678         withSQL {
679           update(PersistentUser)
680             .set(column.optInNewsletter -> optInNewsletter, column.updatedAt -> DateHelper.now())
681             .where(sqls.eq(column.email, email))
682         }.executeUpdate() match {
683           case 1 => true
684           case _ => false
685         }
686       })
687     }
688 
689     override def updateIsHardBounce(email: String, isHardBounce: Boolean): Future[Boolean] = {
690       implicit val ctx: EC = writeExecutionContext
691       Future(NamedDB("WRITE").retryableTx { implicit session =>
692         withSQL {
693           update(PersistentUser)
694             .set(column.isHardBounce -> isHardBounce, column.updatedAt -> DateHelper.now())
695             .where(sqls.eq(column.email, email))
696         }.executeUpdate() match {
697           case 1 => true
698           case _ => false
699         }
700       })
701     }
702 
703     override def updateLastMailingError(email: String, lastMailingError: Option[MailingErrorLog]): Future[Boolean] = {
704       implicit val ctx: EC = writeExecutionContext
705       Future(NamedDB("WRITE").retryableTx { implicit session =>
706         withSQL {
707           update(PersistentUser)
708             .set(
709               column.lastMailingErrorDate -> lastMailingError.map(_.date),
710               column.lastMailingErrorMessage -> lastMailingError.map(_.error),
711               column.updatedAt -> DateHelper.now()
712             )
713             .where(sqls.eq(column.email, email))
714         }.executeUpdate() match {
715           case 1 => true
716           case _ => false
717         }
718       })
719     }
720 
721     override def updateSocialUser(user: User): Future[Boolean] = {
722       implicit val ctx: EC = writeExecutionContext
723       Future(NamedDB("WRITE").retryableTx { implicit session =>
724         withSQL {
725           update(PersistentUser)
726             .set(
727               column.updatedAt -> DateHelper.now(),
728               column.firstName -> user.firstName,
729               column.lastName -> user.lastName,
730               column.dateOfBirth -> user.profile.flatMap(_.dateOfBirth),
731               column.lastIp -> user.lastIp,
732               column.lastConnection -> Option(DateHelper.now()),
733               column.avatarUrl -> user.profile.flatMap(_.avatarUrl),
734               column.facebookId -> user.profile.flatMap(_.facebookId),
735               column.googleId -> user.profile.flatMap(_.googleId),
736               column.oidcInfos -> user.profile.flatMap(_.oidcInfos),
737               column.gender -> user.profile.flatMap(_.gender),
738               column.genderName -> user.profile.flatMap(_.genderName),
739               column.country -> user.country.value,
740               column.language -> user.language.value,
741               column.socioProfessionalCategory -> user.profile.flatMap(_.socioProfessionalCategory),
742               column.emailVerified -> user.emailVerified,
743               column.hashedPassword -> user.hashedPassword,
744               column.privacyPolicyApprovalDate -> user.privacyPolicyApprovalDate
745             )
746             .where(sqls.eq(column.uuid, user.userId.value))
747         }.executeUpdate() match {
748           case 1 => true
749           case _ => false
750         }
751       })
752     }
753 
754     override def removeAnonymizedUserFromFollowedUserTable(userId: UserId): Future[Unit] = {
755       implicit val cxt: EC = readExecutionContext
756       Future(NamedDB("WRITE").retryableTx { implicit session =>
757         withSQL {
758           delete
759             .from(FollowedUsers.as(followedUsersAlias))
760             .where(
761               sqls
762                 .eq(followedUsersAlias.userId, userId.value)
763                 .or(sqls.eq(followedUsersAlias.followedUserId, userId.value))
764             )
765         }.executeUpdate()
766       }).void
767     }
768 
769     override def followUser(followedUserId: UserId, userId: UserId): Future[Unit] = {
770       implicit val ctx: EC = writeExecutionContext
771       Future(NamedDB("WRITE").retryableTx { implicit session =>
772         withSQL {
773           insert
774             .into(FollowedUsers)
775             .namedValues(
776               followedUsersColumn.userId -> userId.value,
777               followedUsersColumn.followedUserId -> followedUserId.value,
778               followedUsersColumn.date -> DateHelper.now()
779             )
780         }.execute()
781       }).void
782     }
783 
784     override def unfollowUser(followedUserId: UserId, userId: UserId): Future[Unit] = {
785       implicit val ctx: EC = writeExecutionContext
786       Future(NamedDB("WRITE").retryableTx { implicit session =>
787         withSQL {
788           delete
789             .from(FollowedUsers)
790             .where(
791               sqls
792                 .eq(followedUsersAlias.userId, userId.value)
793                 .and(sqls.eq(followedUsersAlias.followedUserId, followedUserId.value))
794             )
795         }.executeUpdate()
796       }).void
797     }
798 
799     override def countOrganisations(ids: Option[Seq[UserId]], organisationName: Option[String]): Future[Int] = {
800       implicit val ctx: EC = readExecutionContext
801       Future(NamedDB("READ").retryableTx { implicit session =>
802         withSQL {
803           select(sqls.count)
804             .from(PersistentUser.as(userAlias))
805             .where(
806               sqls
807                 .eq(userAlias.userType, UserType.UserTypeOrganisation)
808                 .and(
809                   sqls.toAndConditionOpt(
810                     ids.map(userId => sqls.in(userAlias.uuid, userId.map(_.value))),
811                     organisationName.map(
812                       organisationName =>
813                         sqls.like(
814                           sqls.lower(userAlias.organisationName),
815                           s"%${organisationName.replace("%", "\\%").toLowerCase}%"
816                         )
817                     )
818                   )
819                 )
820             )
821         }.map(_.int(1)).single().getOrElse(0)
822       })
823     }
824 
825     override def adminCountUsers(
826       ids: Option[Seq[UserId]],
827       email: Option[String],
828       firstName: Option[String],
829       lastName: Option[String],
830       maybeRole: Option[Role],
831       maybeUserType: Option[UserType]
832     ): Future[Int] = {
833       implicit val ctx: EC = readExecutionContext
834       Future(NamedDB("READ").retryableTx { implicit session =>
835         withSQL {
836           select(sqls.count)
837             .from(PersistentUser.as(userAlias))
838             .where(
839               sqls.toAndConditionOpt(
840                 ids.map(userIds => sqls.in(userAlias.uuid, userIds.map(_.value))),
841                 email
842                   .map(email => sqls.like(sqls.lower(userAlias.email), s"%${email.replace("%", "\\%").toLowerCase}%")),
843                 firstName.map(
844                   firstName =>
845                     sqls.like(sqls.lower(userAlias.firstName), s"%${firstName.replace("%", "\\%").toLowerCase}%")
846                 ),
847                 lastName.map(
848                   lastName =>
849                     sqls.like(sqls.lower(userAlias.lastName), s"%${lastName.replace("%", "\\%").toLowerCase}%")
850                 ),
851                 maybeRole.map(role         => sqls.isNotNull(sqls"array_position(${userAlias.roles}, ${role.value})")),
852                 maybeUserType.map(userType => sqls.eq(userAlias.userType, userType))
853               )
854             )
855         }.map(_.int(1)).single().getOrElse(0)
856       })
857     }
858 
859     override def findAllByEmail(emails: Seq[String]): Future[Seq[User]] = {
860       implicit val cxt: EC = readExecutionContext
861       val futurePersistentUsers = Future(NamedDB("READ").retryableTx { implicit session =>
862         withSQL {
863           select
864             .from(PersistentUser.as(userAlias))
865             .where(sqls.in(userAlias.email, emails))
866         }.map(PersistentUser.apply()).list()
867       })
868 
869       futurePersistentUsers.map(_.map(_.toUser))
870     }
871 
872     override def updateReconnectToken(
873       userId: UserId,
874       reconnectToken: String,
875       reconnectTokenCreatedAt: ZonedDateTime
876     ): Future[Boolean] = {
877       implicit val ctx: EC = writeExecutionContext
878       Future(NamedDB("WRITE").retryableTx { implicit session =>
879         withSQL {
880           update(PersistentUser)
881             .set(
882               column.reconnectToken -> reconnectToken,
883               column.reconnectTokenCreatedAt -> reconnectTokenCreatedAt,
884               column.updatedAt -> DateHelper.now()
885             )
886             .where(sqls.eq(column.uuid, userId.value))
887         }.executeUpdate() match {
888           case 1 => true
889           case _ => false
890         }
891       })
892     }
893   }
894 }
895 
896 object DefaultPersistentUserServiceComponent {
897 
898   @SuppressWarnings(Array("org.wartremover.warts.ArrayEquals"))
899   final case class PersistentUser(
900     uuid: String,
901     createdAt: ZonedDateTime,
902     updatedAt: ZonedDateTime,
903     email: String,
904     firstName: Option[String],
905     lastName: Option[String],
906     lastIp: Option[String],
907     hashedPassword: String,
908     enabled: Boolean,
909     emailVerified: Boolean,
910     userType: String,
911     lastConnection: Option[ZonedDateTime],
912     verificationToken: Option[String],
913     verificationTokenExpiresAt: Option[ZonedDateTime],
914     resetToken: Option[String],
915     resetTokenExpiresAt: Option[ZonedDateTime],
916     roles: Array[String],
917     dateOfBirth: Option[LocalDate],
918     avatarUrl: Option[String],
919     profession: Option[String],
920     phoneNumber: Option[String],
921     description: Option[String],
922     twitterId: Option[String],
923     facebookId: Option[String],
924     googleId: Option[String],
925     oidcInfos: Option[Map[OperationId, OidcInfo]],
926     gender: String,
927     genderName: Option[String],
928     postalCode: Option[String],
929     country: String,
930     language: String,
931     crmCountry: String,
932     crmLanguage: String,
933     karmaLevel: Option[Int],
934     locale: Option[String],
935     optInNewsletter: Boolean,
936     isHardBounce: Boolean,
937     lastMailingErrorDate: Option[ZonedDateTime],
938     lastMailingErrorMessage: Option[String],
939     organisationName: Option[String],
940     publicProfile: Boolean,
941     socioProfessionalCategory: String,
942     registerQuestionId: Option[String],
943     optInPartner: Option[Boolean],
944     availableQuestions: Array[String],
945     availableEvents: Array[String],
946     reconnectToken: Option[String],
947     reconnectTokenCreatedAt: Option[ZonedDateTime],
948     politicalParty: Option[String],
949     website: Option[String],
950     legalMinorConsent: Option[Boolean],
951     legalAdvisorApproval: Option[Boolean],
952     privacyPolicyApprovalDate: Option[ZonedDateTime],
953     connectionAttemptsSinceLastSuccessful: Int,
954     lastFailedConnectionAttempt: Option[ZonedDateTime]
955   ) {
956     def toUser: User = {
957       User(
958         userId = UserId(uuid),
959         email = email,
960         createdAt = Some(createdAt),
961         updatedAt = Some(updatedAt),
962         firstName = firstName,
963         lastName = lastName,
964         lastIp = lastIp,
965         hashedPassword = Option(hashedPassword),
966         enabled = enabled,
967         emailVerified = emailVerified,
968         userType = UserType(userType),
969         lastConnection = lastConnection,
970         verificationToken = verificationToken,
971         verificationTokenExpiresAt = verificationTokenExpiresAt,
972         resetToken = resetToken,
973         resetTokenExpiresAt = resetTokenExpiresAt,
974         roles = roles.toSeq.map(Role.apply),
975         country = Country(country),
976         language = Language(language),
977         profile = toProfile,
978         isHardBounce = isHardBounce,
979         lastMailingError = lastMailingErrorMessage.flatMap { message =>
980           lastMailingErrorDate.map { date =>
981             MailingErrorLog(error = message, date = date)
982           }
983         },
984         organisationName = organisationName,
985         publicProfile = publicProfile,
986         availableQuestions = availableQuestions.toSeq.map(QuestionId.apply),
987         availableEvents = availableEvents.toSeq.map(EventId.apply),
988         privacyPolicyApprovalDate = privacyPolicyApprovalDate,
989         connectionAttemptsSinceLastSuccessful = connectionAttemptsSinceLastSuccessful,
990         lastFailedConnectionAttempt = lastFailedConnectionAttempt
991       )
992     }
993 
994     def toUserRights: UserRights = {
995       UserRights(
996         userId = UserId(uuid),
997         roles = roles.toSeq.map(Role.apply),
998         availableQuestions = availableQuestions.toSeq.map(QuestionId.apply),
999         emailVerified = emailVerified,
1000         oidcInfos = oidcInfos
1001       )
1002     }
1003 
1004     private def toGender: String                    => Option[Gender] = Gender.withValueOpt
1005     private def toSocioProfessionalCategory: String => Option[SocioProfessionalCategory] =
1006       SocioProfessionalCategory.withValueOpt
1007 
1008     private def toProfile: Option[Profile] = {
1009       Profile.parseProfile(
1010         dateOfBirth = dateOfBirth,
1011         avatarUrl = avatarUrl,
1012         profession = profession,
1013         phoneNumber = phoneNumber,
1014         description = description,
1015         twitterId = twitterId,
1016         facebookId = facebookId,
1017         googleId = googleId,
1018         oidcInfos = oidcInfos,
1019         gender = toGender(gender),
1020         genderName = genderName,
1021         postalCode = postalCode,
1022         karmaLevel = karmaLevel,
1023         locale = locale,
1024         crmCountry = Country(crmCountry),
1025         crmLanguage = Language(crmLanguage),
1026         optInNewsletter = optInNewsletter,
1027         socioProfessionalCategory = toSocioProfessionalCategory(socioProfessionalCategory),
1028         registerQuestionId = registerQuestionId.map(QuestionId.apply),
1029         optInPartner = optInPartner,
1030         politicalParty = politicalParty,
1031         website = website,
1032         legalMinorConsent = legalMinorConsent,
1033         legalAdvisorApproval = legalAdvisorApproval
1034       )
1035     }
1036   }
1037 
1038   implicit object PersistentUser extends PersistentCompanion[PersistentUser, User] with ShortenedNames with Logging {
1039 
1040     private val profileColumnNames: Seq[String] = Seq(
1041       "date_of_birth",
1042       "avatar_url",
1043       "profession",
1044       "phone_number",
1045       "description",
1046       "twitter_id",
1047       "facebook_id",
1048       "google_id",
1049       "oidc_infos",
1050       "gender",
1051       "gender_name",
1052       "postal_code",
1053       "karma_level",
1054       "locale",
1055       "opt_in_newsletter",
1056       "socio_professional_category",
1057       "register_question_id",
1058       "opt_in_partner",
1059       "political_party",
1060       "website",
1061       "legal_minor_consent",
1062       "legal_advisor_approval",
1063       "crm_country",
1064       "crm_language"
1065     )
1066 
1067     private val userColumnNames: Seq[String] = Seq(
1068       "uuid",
1069       "created_at",
1070       "updated_at",
1071       "email",
1072       "first_name",
1073       "last_name",
1074       "last_ip",
1075       "hashed_password",
1076       "enabled",
1077       "email_verified",
1078       "user_type",
1079       "last_connection",
1080       "verification_token",
1081       "verification_token_expires_at",
1082       "reset_token",
1083       "reset_token_expires_at",
1084       "roles",
1085       "country",
1086       "language",
1087       "is_hard_bounce",
1088       "last_mailing_error_date",
1089       "last_mailing_error_message",
1090       "organisation_name",
1091       "public_profile",
1092       "available_questions",
1093       "available_events",
1094       "reconnect_token",
1095       "reconnect_token_created_at",
1096       "privacy_policy_approval_date",
1097       "connection_attempts_since_last_successful",
1098       "last_failed_connection_attempt"
1099     )
1100 
1101     override val columnNames: Seq[String] = userColumnNames ++ profileColumnNames
1102     final val swaggerAllowableValues =
1103       "uuid,created_at,updated_at,email,first_name,last_name,last_ip,hashed_password,enabled,email_verified,user_type,last_connection,verification_token,verification_token_expires_at,reset_token,reset_token_expires_at,roles,country,is_hard_bounce,last_mailing_error_date,last_mailing_error_message,organisation_name,public_profile,available_questions,reconnect_token,reconnect_token_created_at,privacy_policy_approval_date,date_of_birth,avatar_url,profession,phone_number,description,twitter_id,facebook_id,google_id,gender,gender_name,postal_code,karma_level,locale,opt_in_newsletter,socio_professional_category,register_question_id,opt_in_partner,political_party,website,legal_minor_consent,legal_advisor_approval"
1104 
1105     override val tableName: String = "make_user"
1106 
1107     override lazy val alias: SyntaxProvider[PersistentUser] = syntax("u")
1108 
1109     override lazy val defaultSortColumns: NonEmptyList[SQLSyntax] = NonEmptyList.of(alias.email)
1110 
1111     implicit val oidcInfosBinders: Binders[Option[Map[OperationId, OidcInfo]]] =
1112       ScalikeSupport.optCustomMapConverter[OperationId, OidcInfo]
1113 
1114     @SuppressWarnings(Array("org.wartremover.warts.AsInstanceOf"))
1115     def apply(
1116       userResultName: ResultName[PersistentUser] = alias.resultName
1117     )(resultSet: WrappedResultSet): PersistentUser = {
1118       PersistentUser(
1119         uuid = resultSet.string(userResultName.uuid),
1120         email = resultSet.string(userResultName.email),
1121         firstName = resultSet.stringOpt(userResultName.firstName),
1122         lastName = resultSet.stringOpt(userResultName.lastName),
1123         createdAt = resultSet.zonedDateTime(userResultName.createdAt),
1124         updatedAt = resultSet.zonedDateTime(userResultName.updatedAt),
1125         lastIp = resultSet.stringOpt(userResultName.lastIp),
1126         hashedPassword = resultSet.string(userResultName.hashedPassword),
1127         enabled = resultSet.boolean(userResultName.enabled),
1128         emailVerified = resultSet.boolean(userResultName.emailVerified),
1129         userType = resultSet.string(userResultName.userType),
1130         lastConnection = resultSet.zonedDateTimeOpt(userResultName.lastConnection),
1131         verificationToken = resultSet.stringOpt(userResultName.verificationToken),
1132         verificationTokenExpiresAt = resultSet.zonedDateTimeOpt(userResultName.verificationTokenExpiresAt),
1133         resetToken = resultSet.stringOpt(userResultName.resetToken),
1134         resetTokenExpiresAt = resultSet.zonedDateTimeOpt(userResultName.resetTokenExpiresAt),
1135         roles = resultSet
1136           .arrayOpt(userResultName.roles)
1137           .map(_.getArray.asInstanceOf[Array[String]])
1138           .getOrElse(Array()),
1139         dateOfBirth = resultSet.localDateOpt(userResultName.dateOfBirth),
1140         avatarUrl = resultSet.stringOpt(userResultName.avatarUrl),
1141         profession = resultSet.stringOpt(userResultName.profession),
1142         phoneNumber = resultSet.stringOpt(userResultName.phoneNumber),
1143         description = resultSet.stringOpt(userResultName.description),
1144         twitterId = resultSet.stringOpt(userResultName.twitterId),
1145         facebookId = resultSet.stringOpt(userResultName.facebookId),
1146         googleId = resultSet.stringOpt(userResultName.googleId),
1147         oidcInfos = resultSet.get[Option[Map[OperationId, OidcInfo]]](userResultName.oidcInfos),
1148         gender = resultSet.string(userResultName.gender),
1149         genderName = resultSet.stringOpt(userResultName.genderName),
1150         postalCode = resultSet.stringOpt(userResultName.postalCode),
1151         country = resultSet.string(userResultName.country),
1152         language = resultSet.string(userResultName.language),
1153         crmCountry = resultSet.string(userResultName.crmCountry),
1154         crmLanguage = resultSet.string(userResultName.crmLanguage),
1155         karmaLevel = resultSet.intOpt(userResultName.karmaLevel),
1156         locale = resultSet.stringOpt(userResultName.locale),
1157         optInNewsletter = resultSet.boolean(userResultName.optInNewsletter),
1158         isHardBounce = resultSet.boolean(userResultName.isHardBounce),
1159         lastMailingErrorDate = resultSet.zonedDateTimeOpt(userResultName.lastMailingErrorDate),
1160         lastMailingErrorMessage = resultSet.stringOpt(userResultName.lastMailingErrorMessage),
1161         organisationName = resultSet.stringOpt(userResultName.organisationName),
1162         publicProfile = resultSet.boolean(userResultName.publicProfile),
1163         socioProfessionalCategory = resultSet.string(userResultName.socioProfessionalCategory),
1164         registerQuestionId = resultSet.stringOpt(userResultName.registerQuestionId),
1165         optInPartner = resultSet.booleanOpt(userResultName.optInPartner),
1166         availableQuestions = resultSet
1167           .arrayOpt(userResultName.availableQuestions)
1168           .map(_.getArray.asInstanceOf[Array[String]])
1169           .getOrElse(Array()),
1170         availableEvents = resultSet
1171           .arrayOpt(userResultName.availableEvents)
1172           .map(_.getArray.asInstanceOf[Array[String]])
1173           .getOrElse(Array()),
1174         reconnectToken = resultSet.stringOpt(userResultName.reconnectToken),
1175         reconnectTokenCreatedAt = resultSet.zonedDateTimeOpt(userResultName.reconnectTokenCreatedAt),
1176         politicalParty = resultSet.stringOpt(userResultName.politicalParty),
1177         website = resultSet.stringOpt(userResultName.website),
1178         legalMinorConsent = resultSet.booleanOpt(userResultName.legalMinorConsent),
1179         legalAdvisorApproval = resultSet.booleanOpt(userResultName.legalAdvisorApproval),
1180         privacyPolicyApprovalDate = resultSet.zonedDateTimeOpt(userResultName.privacyPolicyApprovalDate),
1181         connectionAttemptsSinceLastSuccessful = resultSet.short(userResultName.connectionAttemptsSinceLastSuccessful),
1182         lastFailedConnectionAttempt = resultSet.dateTimeOpt(userResultName.lastFailedConnectionAttempt)
1183       )
1184     }
1185   }
1186 
1187   final case class FollowedUsers(userId: String, followedUserId: String, date: ZonedDateTime)
1188 
1189   object FollowedUsers extends SQLSyntaxSupport[FollowedUsers] with ShortenedNames with Logging {
1190 
1191     override val columnNames: Seq[String] = Seq("user_id", "followed_user_id", "date")
1192 
1193     override val tableName: String = "followed_user"
1194 
1195     lazy val followedUsersAlias: QuerySQLSyntaxProvider[SQLSyntaxSupport[FollowedUsers], FollowedUsers] = syntax(
1196       "followed_user"
1197     )
1198 
1199     def apply(
1200       followedUsersResultName: ResultName[FollowedUsers] = followedUsersAlias.resultName
1201     )(resultSet: WrappedResultSet): FollowedUsers = {
1202       FollowedUsers(
1203         userId = resultSet.string(followedUsersResultName.userId),
1204         followedUserId = resultSet.string(followedUsersResultName.followedUserId),
1205         date = resultSet.zonedDateTime(followedUsersResultName.date)
1206       )
1207     }
1208   }
1209 
1210 }