Supprime les étoiles dans les requêtes SQL

app/services/ApplicationService.scala

@@ -57,7 +57,7 @@ class ApplicationService @Inject() (
 
   import dataModels.Application.SeenByUser._
 
-  private val (applicationParser, applicationTableFields) = Macros.parserWithFields[Application](
+  private val (parser, tableFields) = Macros.parserWithFields[Application](
     "id",
     "creation_date",
     "creator_user_name",
@@ -84,9 +84,9 @@ class ApplicationService @Inject() (
     "personal_data_wiped"
   )
 
-  private val fieldsInSelect: String = applicationTableFields.mkString(", ")
+  private val fieldsInSelect: String = tableFields.mkString(", ")
 
-  private val simpleApplication: RowParser[Application] = applicationParser
+  private val simpleApplication: RowParser[Application] = parser
     .map(application =>
       application.copy(
         creationDate = application.creationDate.withZoneSameInstant(Time.timeZoneParis),
@@ -98,15 +98,15 @@ class ApplicationService @Inject() (
 
   private def setSeenByUsers(id: UUID, seenByUsers: List[SeenByUser])(implicit
       cnx: Connection
-  ) = {
+  ): Option[Application] = {
     val pgObject = new PGobject
     pgObject.setType("json")
     pgObject.setValue(toJson(seenByUsers).toString)
 
-    SQL("""UPDATE application
-          |SET seen_by_user_ids = {seen_by_users}::jsonb
-          |WHERE id = {id}::uuid
-          |RETURNING *;""".stripMargin)
+    SQL(s"""UPDATE application
+           |SET seen_by_user_ids = {seen_by_users}::jsonb
+           |WHERE id = {id}::uuid
+           |RETURNING $fieldsInSelect;""".stripMargin)
       .on(
         "id" -> id,
         "seen_by_users" -> anorm.Object(pgObject)
@@ -115,9 +115,9 @@ class ApplicationService @Inject() (
   }
 
   private def byId(id: UUID)(implicit cnx: Connection) =
-    SQL("""SELECT *
-          |FROM application
-          |WHERE id = {id}::uuid;""".stripMargin)
+    SQL(s"""SELECT $fieldsInSelect
+           |FROM application
+           |WHERE id = {id}::uuid;""".stripMargin)
       .on(
         "id" -> id
       )
@@ -155,7 +155,11 @@ class ApplicationService @Inject() (
   def openAndOlderThan(day: Int) =
     db.withConnection { implicit connection =>
       SQL(
-        s"SELECT * FROM application WHERE closed = false AND age(creation_date) > '$day days' AND expert_invited = false"
+        s"""SELECT $fieldsInSelect
+            FROM application
+            WHERE closed = false
+            AND age(creation_date) > '$day days'
+            AND expert_invited = false"""
       ).as(simpleApplication.*)
     }
 
@@ -165,7 +169,7 @@ class ApplicationService @Inject() (
       referenceDate: ZonedDateTime
   ): List[Application] =
     db.withConnection { implicit connection =>
-      val result = SQL("""SELECT * FROM application
+      val result = SQL(s"""SELECT $fieldsInSelect FROM application
           |WHERE (creator_user_id = {userId}::uuid OR invited_users ?? {userId}) AND
           |  (closed = FALSE OR DATE_PART('day', {referenceDate} - closed_date) < 30)
           |ORDER BY creation_date DESC""".stripMargin)
@@ -182,10 +186,10 @@ class ApplicationService @Inject() (
     Future {
       db.withConnection { implicit connection =>
         val result = SQL(
-          """SELECT * FROM application
-             WHERE creator_user_id = {userId}::uuid
-             AND closed = false
-             ORDER BY creation_date DESC"""
+          s"""SELECT $fieldsInSelect FROM application
+              WHERE creator_user_id = {userId}::uuid
+              AND closed = false
+              ORDER BY creation_date DESC"""
         ).on("userId" -> userId)
           .as(simpleApplication.*)
         result.map(_.anonymousApplication)
@@ -195,7 +199,11 @@ class ApplicationService @Inject() (
   def allForUserId(userId: UUID, anonymous: Boolean) =
     db.withConnection { implicit connection =>
       val result = SQL(
-        "SELECT * FROM application WHERE creator_user_id = {userId}::uuid OR invited_users ?? {userId} ORDER BY creation_date DESC"
+        s"""SELECT $fieldsInSelect
+            FROM application
+            WHERE creator_user_id = {userId}::uuid
+            OR invited_users ?? {userId}
+            ORDER BY creation_date DESC"""
       ).on("userId" -> userId)
         .as(simpleApplication.*)
       if (anonymous) {
@@ -208,7 +216,13 @@ class ApplicationService @Inject() (
   def allForUserIds(userIds: List[UUID]): Future[List[Application]] =
     Future {
       db.withConnection { implicit connection =>
-        SQL"SELECT * FROM application WHERE ARRAY[$userIds]::uuid[] @> ARRAY[creator_user_id]::uuid[] OR ARRAY(select jsonb_object_keys(invited_users))::uuid[] && ARRAY[$userIds]::uuid[] ORDER BY creation_date DESC"
+        SQL(
+          s"""SELECT $fieldsInSelect
+              FROM application
+              WHERE ARRAY[{userIds}]::uuid[] @> ARRAY[creator_user_id]::uuid[]
+              OR ARRAY(select jsonb_object_keys(invited_users))::uuid[] && ARRAY[{userIds}]::uuid[]
+              ORDER BY creation_date DESC"""
+        ).on("userIds" -> userIds)
           .as(simpleApplication.*)
           .map(_.anonymousApplication)
       }
@@ -217,8 +231,12 @@ class ApplicationService @Inject() (
   def allByArea(areaId: UUID, anonymous: Boolean) =
     db.withConnection { implicit connection =>
       val result =
-        SQL("SELECT * FROM application WHERE area = {areaId}::uuid ORDER BY creation_date DESC")
-          .on("areaId" -> areaId)
+        SQL(
+          s"""SELECT $fieldsInSelect
+              FROM application
+              WHERE area = {areaId}::uuid
+              ORDER BY creation_date DESC"""
+        ).on("areaId" -> areaId)
           .as(simpleApplication.*)
       if (anonymous) {
         result.map(_.anonymousApplication)
@@ -237,7 +255,8 @@ class ApplicationService @Inject() (
               s"interval '$months month'"
           )
           .orEmpty
-        SQL(s"""SELECT * FROM application
+        SQL(s"""SELECT $fieldsInSelect
+                FROM application
                 WHERE ARRAY[{areaIds}]::uuid[] @> ARRAY[area]::uuid[]
                 $additionalFilter
                 ORDER BY creation_date DESC""")
@@ -250,7 +269,9 @@ class ApplicationService @Inject() (
   def all(): Future[List[Application]] =
     Future {
       db.withConnection { implicit connection =>
-        SQL"""SELECT * FROM application""".as(simpleApplication.*).map(_.anonymousApplication)
+        SQL(s"""SELECT $fieldsInSelect FROM application""")
+          .as(simpleApplication.*)
+          .map(_.anonymousApplication)
       }
     }
 

app/services/EventService.scala

@@ -5,6 +5,7 @@ import java.util.UUID
 
 import actions.RequestWithUserData
 import anorm._
+import aplus.macros.Macros
 import cats.syntax.all._
 import helper.Time
 import javax.inject.Inject
@@ -21,7 +22,7 @@ class EventService @Inject() (db: Database, dependencies: ServicesDependencies)
 
   private val logger = Logger(classOf[EventService])
 
-  private val simpleEvent: RowParser[Event] = Macro.parser[Event](
+  private val (simpleEvent, tableFields) = Macros.parserWithFields[Event](
     "id",
     "level",
     "code",
@@ -35,6 +36,8 @@ class EventService @Inject() (db: Database, dependencies: ServicesDependencies)
     "ip_address"
   )
 
+  private val fieldsInSelect: String = tableFields.mkString(", ")
+
   def log(
       event: EventType,
       description: String,
@@ -164,32 +167,36 @@ class EventService @Inject() (db: Database, dependencies: ServicesDependencies)
       db.withConnection { implicit connection =>
         (fromUserId, date) match {
           case (Some(userId), Some(date)) =>
-            SQL"""SELECT *, host(ip_address)::TEXT AS ip_address
-                FROM "event"
-                WHERE (from_user_id = $userId::uuid OR to_user_id = $userId::uuid)
-                AND date_trunc('day',creation_date) = $date
-                ORDER BY creation_date DESC
-                LIMIT $limit"""
+            SQL(s"""SELECT $fieldsInSelect, host(ip_address)::TEXT AS ip_address
+                    FROM "event"
+                    WHERE (from_user_id = {userId}::uuid OR to_user_id = {userId}::uuid)
+                    AND date_trunc('day',creation_date) = {date}
+                    ORDER BY creation_date DESC
+                    LIMIT {limit}""")
+              .on("userId" -> userId, "date" -> date, "limit" -> limit)
               .as(simpleEvent.*)
           case (None, Some(date)) =>
-            SQL"""SELECT *, host(ip_address)::TEXT AS ip_address
-                FROM "event"
-                WHERE date_trunc('day',creation_date) = $date
-                ORDER BY creation_date DESC
-                LIMIT $limit"""
+            SQL(s"""SELECT $fieldsInSelect, host(ip_address)::TEXT AS ip_address
+                    FROM "event"
+                    WHERE date_trunc('day',creation_date) = {date}
+                    ORDER BY creation_date DESC
+                    LIMIT {limit}""")
+              .on("date" -> date, "limit" -> limit)
               .as(simpleEvent.*)
           case (Some(userId), None) =>
-            SQL"""SELECT *, host(ip_address)::TEXT AS ip_address
-                FROM "event"
-                WHERE from_user_id = $userId::uuid OR to_user_id = $userId::uuid
-                ORDER BY creation_date DESC
-                LIMIT $limit"""
+            SQL(s"""SELECT $fieldsInSelect, host(ip_address)::TEXT AS ip_address
+                    FROM "event"
+                    WHERE from_user_id = {userId}::uuid OR to_user_id = {userId}::uuid
+                    ORDER BY creation_date DESC
+                    LIMIT {limit}""")
+              .on("userId" -> userId, "limit" -> limit)
               .as(simpleEvent.*)
           case (None, None) =>
-            SQL"""SELECT *, host(ip_address)::TEXT AS ip_address
-                FROM "event"
-                ORDER BY creation_date DESC
-                LIMIT $limit"""
+            SQL(s"""SELECT $fieldsInSelect, host(ip_address)::TEXT AS ip_address
+                    FROM "event"
+                    ORDER BY creation_date DESC
+                    LIMIT {limit}""")
+              .on("limit" -> limit)
               .as(simpleEvent.*)
         }
       }

app/services/MandatService.scala

@@ -43,7 +43,7 @@ class MandatService @Inject() (
       )
     )
 
-  private val (mandatRowParser, mandatTableFields) = Macros.parserWithFields[Mandat](
+  private val (mandatRowParser, tableFields) = Macros.parserWithFields[Mandat](
     "id",
     "user_id",
     "creation_date",
@@ -57,13 +57,14 @@ class MandatService @Inject() (
     "personal_data_wiped"
   )
 
-  private val fieldsInSelect: String = mandatTableFields.mkString(", ")
+  private val fieldsInSelect: String = tableFields.mkString(", ")
 
   private def byIdNoAuthorizationCheck(id: Mandat.Id): Future[Either[Error, Mandat]] =
     Future(
       Try(
         db.withTransaction { implicit connection =>
-          SQL"""SELECT * FROM mandat WHERE id = ${id.underlying}::uuid"""
+          SQL(s"""SELECT $fieldsInSelect FROM mandat WHERE id = {id}::uuid""")
+            .on("id" -> id.underlying)
             .as(mandatRowParser.singleOpt)
         }
       ).toEither.left
@@ -139,7 +140,8 @@ class MandatService @Inject() (
           )
         """.executeInsert(SqlParser.scalar[UUID].singleOpt)
 
-          SQL"""SELECT * FROM mandat WHERE id = $id::uuid"""
+          SQL(s"""SELECT $fieldsInSelect FROM mandat WHERE id = {id}::uuid""")
+            .on("id" -> id)
             .as(mandatRowParser.singleOpt)
             // `.get` is OK here, we want to rollback if we cannot get back the entity
             .get
@@ -214,11 +216,15 @@ class MandatService @Inject() (
         db.withTransaction { implicit connection =>
           val localPhone = sms.originator.toLocalPhoneFrance
           // Check if a thread is open
-          val allOpenMandats = SQL"""SELECT * FROM mandat
-                                     WHERE usager_phone_local = $localPhone
-                                     AND sms_thread_closed = false
-                             """
-            .as(mandatRowParser.*)
+          val allOpenMandats =
+            SQL(
+              s"""SELECT $fieldsInSelect
+                  FROM mandat
+                  WHERE usager_phone_local = {localPhone}
+                  AND sms_thread_closed = false
+               """
+            ).on("localPhone" -> localPhone)
+              .as(mandatRowParser.*)
           allOpenMandats.headOption match {
             case None =>
               Left(
@@ -256,9 +262,9 @@ class MandatService @Inject() (
     Future(
       Try {
         val before = ZonedDateTime.now().minusMonths(retentionInMonths)
-        val selectFields = mandatTableFields.map(field => s"mandat.$field").mkString(", ")
+        val fields = tableFields.map(field => s"mandat.$field").mkString(", ")
         val mandats = db.withConnection { implicit connection =>
-          SQL(s"""SELECT $selectFields
+          SQL(s"""SELECT $fields
                   FROM mandat
                   LEFT JOIN application ON mandat.application_id = application.id
                   WHERE mandat.personal_data_wiped = false

app/services/SignupService.scala

@@ -1,6 +1,7 @@
 package services
 
 import anorm._
+import aplus.macros.Macros
 import cats.syntax.all._
 import java.time.Instant
 import java.util.UUID
@@ -18,19 +19,21 @@ class SignupService @Inject() (
 ) {
   import dependencies.databaseExecutionContext
 
-  private val signupRequestRowParser: RowParser[SignupRequest] = Macro
-    .parser[SignupRequest](
-      "id",
-      "request_date",
-      "email",
-      "inviting_user_id"
-    )
+  private val (signupRequestRowParser, tableFields) = Macros.parserWithFields[SignupRequest](
+    "id",
+    "request_date",
+    "email",
+    "inviting_user_id"
+  )
+
+  private val fieldsInSelect: String = tableFields.mkString(", ")
 
   def byId(signupId: UUID): Future[Either[Error, Option[SignupRequest]]] =
     Future(
       Try(
         db.withTransaction { implicit connection =>
-          SQL"""SELECT * FROM signup_request WHERE id = $signupId::uuid"""
+          SQL(s"""SELECT $fieldsInSelect FROM signup_request WHERE id = {signupId}::uuid""")
+            .on("signupId" -> signupId)
             .as(signupRequestRowParser.singleOpt)
         }
       ).toEither.left
@@ -47,7 +50,10 @@ class SignupService @Inject() (
     Future(
       Try(
         db.withTransaction { implicit connection =>
-          SQL"""SELECT * FROM signup_request WHERE lower(email) = ${email.toLowerCase}"""
+          SQL(s"""SELECT $fieldsInSelect
+                  FROM signup_request
+                  WHERE lower(email) = {email}""")
+            .on("email" -> email.toLowerCase)
             .as(signupRequestRowParser.singleOpt)
         }
       ).toEither.left
@@ -65,8 +71,9 @@ class SignupService @Inject() (
       Try {
         val lowerCaseEmails = emails.map(_.toLowerCase)
         db.withConnection { implicit connection =>
-          SQL"""SELECT * FROM signup_request
-                WHERE ARRAY[$lowerCaseEmails]::text[] @> ARRAY[lower(email)]::text[]"""
+          SQL(s"""SELECT $fieldsInSelect FROM signup_request
+                  WHERE ARRAY[{emails}]::text[] @> ARRAY[lower(email)]::text[]""")
+            .on("emails" -> lowerCaseEmails)
             .as(signupRequestRowParser.*)
         }
       }.toEither.left
@@ -83,12 +90,14 @@ class SignupService @Inject() (
     Future(
       Try(
         db.withTransaction { implicit connection =>
-          SQL"""SELECT
-                  signup_request.*,
-                  "user".id AS signedup_user_id
-                FROM signup_request
-                LEFT JOIN "user" ON LOWER("user".email) = LOWER(signup_request.email)
-                WHERE request_date >= $afterDate"""
+          val fields = tableFields.map(field => s"signup_request.$field").mkString(", ")
+          SQL(s"""SELECT
+                    $fields,
+                    "user".id AS signedup_user_id
+                  FROM signup_request
+                  LEFT JOIN "user" ON LOWER("user".email) = LOWER(signup_request.email)
+                  WHERE request_date >= {afterDate}""")
+            .on("afterDate" -> afterDate)
             .as((signupRequestRowParser ~ SqlParser.get[Option[UUID]]("signedup_user_id")).*)
             .map { case a ~ b => (a, b) }
         }