UserRepositoryComponentImpl.scala

package org.photon.login

import com.twitter.util.Future
import org.photon.common.Async
import java.sql.{PreparedStatement, Timestamp, ResultSet}
import org.joda.time.Instant

trait RepositoryComponentImpl[T, RepoT] {
  implicit def timestamp2instant(t: java.sql.Timestamp) = new Instant(t.getTime)
  implicit def instant2timestamp(i: org.joda.time.Instant) = new Timestamp(i.getMillis)
  
  def createRecord(rset: ResultSet): T
  def setValues(rset: ResultSet, record: T)
  
  override val tableName: String
  override val columns: Seq[String]
  
  def selectQuery(query: String) = s"SELECT ${columns.mkString(", ")} FROM $tableName $query"
  val updateQuery = s"UPDATE $tableName SET ${columns.tail.mkString("=?, ")} WHERE id=?}"
  val insertQuery = s"INSERT INTO $tableName(${columns.tail.mkString(", ")}}) VALUES(${columns.tail.map(_ => "?").mkString(", ")}) RETURNING id"
  val deleteQuery = "DELETE FROM $tableName WHERE id=?"
  
  class RepositoryImpl extends UserRepository {
    def find(id: PrimaryKey): Future[T] = Async {
      statement(selectQuery("WHERE id=?")) { s =>
        s.setLong(1, id)

        resultsOf(s)(createRecord).headOption getOrElse (throw UnknownRecordException[T]())
      }
    }

    def persist(record: T): Future[T] = Async {
      if (record.persisted) {
        statement(updateQuery) { s =>
          setValues(s, record)
          s.setLong(8, record.id)
          
          s.executeUpdate()
          user
        }
      } else {
        statement(insertQuery) { s =>
          setUserValues(s, record)

          resultOf(s) { rset =>
            record.copy(id = rset.getLong("id"), persisted = true)
          }.head
        }
      }
    }

    def remove(record: T): Future[Unit] = Async {
      statement(deleteQuery) { s =>
        s.setLong(1, o.id)
        s.executeUpdate()
      }
    }
  }

}

trait UserRepositoryComponentImpl extends UserRepositoryComponent
 with RepositoryComponentImpl[User, UserRepository] { self: DatabaseComponent with ExecutorComponent =>

  override def createRecord(rset: ResultSet) = User(
    rset.getLong("id"),
    rset.getString("name"),
    rset.getString("password"),
    rset.getString("nickname"),
    rset.getString("secret_question"),
    rset.getString("secret_answer"),
    rset.getInt("community_id"),
    rset.getTimestamp("subscription_end"),
    persisted = true
  )

  override def setValues(s: PreparedStatement, user: User) {
    s.setString(1, user.name)
    s.setString(2, user.password)
    s.setString(3, user.nickname)
    s.setString(4, user.secretQuestion)
    s.setString(5, user.secretAnswer)
    s.setInt(6, user.communityId)
    s.setTimestamp(7, user.subscriptionEnd)
  }

  override val tableName = "users"
  override val columns = Seq("id", "name", "nickname", "secret_question", "secret_answer", "community_id", "subscription_end")

  val users = new UserRepositoryImpl

  // where to ?
  
    def find(name: String): Future[T] = Async {
      statement(selectUserQuery("WHERE name=?")) { s =>
        s.setString(1, name)

        resultsOf(s)(createUser).headOption getOrElse (throw UnknownUserException())
      }
    }
}