Advertisement
Not a member of Pastebin yet?
Sign Up,
it unlocks many cool features!
- import slick.dbio.Effect.Write
- import slick.lifted.{CanBeQueryCondition, Rep, Tag}
- import slick.jdbc.PostgresProfile.api._
- import slick.sql.FixedSqlAction
- import scala.concurrent.Future
- import scala.reflect._
- trait BaseEntity {
- val id: Long
- val isDeleted: Boolean
- }
- abstract class BaseTable[E: ClassTag](tag: Tag, schemaName: Option[String], tableName: String)
- extends Table[E](tag, schemaName, tableName) {
- val classOfEntity = classTag[E].runtimeClass
- val id: Rep[Long] = column[Long]("Id", O.PrimaryKey, O.AutoInc)
- val isDeleted: Rep[Boolean] = column[Boolean]("IsDeleted", O.Default(false))
- }
- trait BaseRepositoryComponent[T <: BaseTable[E], E <: BaseEntity] {
- def getById(id: Long): Future[Option[E]]
- def getAll: Future[Seq[E]]
- def filter[C <: Rep[_]](expr: T => C)(implicit wt: CanBeQueryCondition[C]): Future[Seq[E]]
- def save(row: E): Future[E]
- def deleteById(id: Long): Future[Int]
- def updateById(id: Long, row: E): Future[Int]
- }
- trait BaseRepositoryQuery[T <: BaseTable[E], E <: BaseEntity] {
- val query: slick.jdbc.PostgresProfile.api.type#TableQuery[T]
- def getByIdQuery(id: Long): Query[T, E, Seq] = {
- query.filter(_.id === id).filter(_.isDeleted === false)
- }
- def getAllQuery: Query[T, E, Seq] = {
- query.filter(_.isDeleted === false)
- }
- def filterQuery[C <: Rep[_]](expr: T => C)(implicit wt: CanBeQueryCondition[C]): Query[T, E, Seq] = {
- query.filter(expr).filter(_.isDeleted === false)
- }
- def saveQuery(row: E): FixedSqlAction[E, NoStream, Write] = {
- query returning query += row
- }
- def deleteByIdQuery(id: Long): FixedSqlAction[Int, NoStream, Write]={
- query.filter(_.id === id).map(_.isDeleted).update(true)
- }
- def updateByIdQuery(id: Long, row: E): FixedSqlAction[Int, NoStream, Write] = {
- query.filter(_.id === id).filter(_.isDeleted === false).update(row)
- }
- }
- abstract class BaseRepository[T <: BaseTable[E], E <: BaseEntity : ClassTag](clazz: TableQuery[T])
- extends BaseRepositoryQuery[T, E]
- with BaseRepositoryComponent[T, E] {
- val clazzTable: TableQuery[T] = clazz
- lazy val clazzEntity = classTag[E].runtimeClass
- val query: slick.jdbc.PostgresProfile.api.type#TableQuery[T] = clazz
- val user = "postgres"
- val url = "jdbc:postgresql://localhost:5432/learning"
- val password = "admin"
- val driver = "org.postgresql.Driver"
- val db = Database.forURL(url, user = user, password = password, driver = driver)
- def getAll: Future[Seq[E]] = {
- db.run(getAllQuery.result)
- }
- def getById(id: Long): Future[Option[E]] = {
- db.run(getByIdQuery(id).result.headOption)
- }
- def filter[C <: Rep[_]](expr: T => C)(implicit wt: CanBeQueryCondition[C]): Future[Seq[E]] = {
- db.run(filterQuery(expr).result)
- }
- def save(row: E): Future[E] = {
- db.run(saveQuery(row))
- }
- def updateById(id: Long, row: E): Future[Int] = {
- db.run(updateByIdQuery(id, row))
- }
- def deleteById(id: Long): Future[Int] = {
- db.run(deleteByIdQuery(id))
- }
- }
- import slick.jdbc.PostgresProfile.api._
- import slick.lifted.ProvenShape.proveShapeOf
- import slick.lifted.{Rep, Tag}
- class EmployeeTable(_tableTag: Tag) extends BaseTable[Employee] (_tableTag, Some("learning"), "Employee") {
- def * = (id, firstName, isDeleted) <>(Employee.tupled, Employee.unapply)
- def ? = (Rep.Some(id), Rep.Some(firstName), Rep.Some(isDeleted)).shaped.<>({ r => import r._; _1.map(_ => Employee.tupled((_1.get, _2.get, _3.get))) }, (_: Any) => throw new Exception("Inserting into ? projection not supported."))
- override val id: Rep[Long] = column[Long]("EmployeeId", O.AutoInc, O.PrimaryKey)
- val firstName: Rep[String] = column[String]("FirstName")
- override val isDeleted: Rep[Boolean] = column[Boolean]("IsDeleted")
- lazy val employeeTable = new TableQuery(tag => new EmployeeTable(tag))
- }
- case class Employee(id: Long, firstName: String, isDeleted: Boolean) extends BaseEntity
- name := "SlickAkka"
- version := "1.0"
- scalaVersion := "2.12.0"
- libraryDependencies ++= Seq(
- "com.typesafe.slick" % "slick_2.11" % "3.2.0-M1",
- "org.postgresql" % "postgresql" % "9.4.1211"
- )
- import slick.lifted.TableQuery
- import scala.concurrent.ExecutionContext.Implicits.global
- abstract class EmployeeRepository
- extends BaseRepository[EmployeeTable, Employee](TableQuery[EmployeeTable]){
- def insertItem(row: Employee) = {
- super.save(row)
- }
- }
- object ImplEmployeeRepository extends EmployeeRepository
- object TestEmp extends App {
- val emp = Employee(0L, "aamir", false)
- for {
- result <- ImplEmployeeRepository.insertItem(emp)
- _ = println(result)
- } yield result
- Thread.sleep(5000)
- }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement