Scala HasDatabaseConfig类代码示例

//设置package包名称以及导入依赖的类
package models

import play.api.Play
import slick.driver.H2Driver.api._

import scala.concurrent.Future
import play.api.db.slick.DatabaseConfigProvider
import play.api.db.slick.HasDatabaseConfig
import slick.driver.JdbcProfile

case class Campaign(id: Option[Int], title: String, content: String)

trait CampaignsTable {
  class Campaigns(tag: Tag) extends Table[Campaign](tag, "CAMPAIGNS") {
    def id = column[Int]("ID", O.PrimaryKey, O.AutoInc)
    def title = column[String]("TITLE")
    def content = column[String]("CONTENT")
    def * = (id.?, title, content) <> (Campaign.tupled, Campaign.unapply)
  }
  val campaigns = TableQuery[Campaigns]
}

object CampaignsDAO extends HasDatabaseConfig[JdbcProfile] with CampaignsTable {
  val dbConfig = DatabaseConfigProvider.get[JdbcProfile](Play.current)

  def findById(id: Int): Future[Option[Campaign]] =
    db.run(campaigns.filter(_.id === id).result.headOption)

  def findAll: Future[Seq[Campaign]] =
    db.run(campaigns.result)

  def insert(newRecord: Campaign): Future[Int] = {
    db.run((campaigns returning campaigns.map(_.id)) += newRecord)
  }

  def update(record: Campaign): Future[Int] = {
    db.run(campaigns.filter(_.id === record.id)
      .map(a => (a.title, a.content))
      .update((record.title, record.content)))
  }

  def getCampaignIds: Future[Seq[Int]] = {
    db.run(campaigns.map(row => (row.id)).result)
  }


} 

//设置package包名称以及导入依赖的类
package models


import play.api.db.slick.DatabaseConfigProvider
import play.api.db.slick.HasDatabaseConfig
import slick.driver.JdbcProfile
import models.dao.PortableJodaSupport._
import driver.api._
import dao._
import org.joda.time.{DateTime, DateTimeZone}
import play.api.Play
import play.api.Play.current

import scala.concurrent.Future

import utils.StringUtils

case class OAuthApp(
    id:            String           = StringUtils.generateUuid,
    created_at:    DateTime         = DateTime.now(DateTimeZone.UTC),
    deleted_at:    Option[DateTime] = None,
    client_id:     String           = StringUtils.generateUuid,
    client_secret: String           = StringUtils.generateUuid,
    name:          String,
    redirect_url:  Option[String]   = None
)

class OAuthAppTable(tag: Tag) extends Table[OAuthApp](tag, "oauth_app") {
  val id = column[String]("id", O.PrimaryKey)
  val created_at = column[DateTime]("created_at")
  val deleted_at = column[Option[DateTime]]("deleted_at")
  val client_id = column[String]("client_id")
  val client_secret = column[String]("client_secret")
  val name = column[String]("name")
  val redirect_url = column[Option[String]]("redirect_url")

  def * = (id, created_at, deleted_at, client_id, client_secret, name, redirect_url) <> ((OAuthApp.apply _).tupled, OAuthApp.unapply _)
}

class OAuthApps extends HasDatabaseConfig[JdbcProfile] {

  protected val dbConfig = DatabaseConfigProvider.get[JdbcProfile](Play.current)
  val tables = TableQuery[OAuthAppTable]

  //---------------
  //Methods
  //---------------

  def findByClientId(client_id: String): Future[Option[OAuthApp]] = {
    db.run(tables.filter(_.client_id === client_id).result.headOption)
  }

}

trait OAuthAppsAware {
  implicit lazy val appManagerDao: OAuthApps = new OAuthApps()
} 

//设置package包名称以及导入依赖的类
package utils

import java.sql.Timestamp

import com.netaporter.uri.Uri
import org.joda.time.DateTime
import slick.driver.JdbcProfile
import play.api.db.slick.DatabaseConfigProvider
import play.api.db.slick.HasDatabaseConfig
import play.api.Play
import repository.user.{Female, Gender, Male}



trait ColumnTypeMapper extends HasDatabaseConfig[JdbcProfile] {
  protected val dbConfig = DatabaseConfigProvider.get[JdbcProfile](Play.current)
  import driver.api._

  implicit def dateTimeMapper = {
    MappedColumnType.base[DateTime, Timestamp] (
      dt => new Timestamp(dt.getMillis),
      ts => new DateTime(ts.getTime)
    )
  }

  implicit def dateTimeOrdering: Ordering[DateTime] = Ordering.fromLessThan(_ isBefore _)

  implicit def uriMapper = MappedColumnType.base[Uri, String] (
    dt => dt.toString(),
    ts => Uri.parse(ts)
  )

  implicit def genderMapper = MappedColumnType.base[Gender, String] (
    {
      case Male => "male"
      case Female => "female"
    },
    {
      case "male" => Male
      case "female" => Female
    }
  )
} 

//设置package包名称以及导入依赖的类
package datalayer.dao

import play.api.Play
import slick.driver.MySQLDriver.api._

import scala.concurrent.Future
import play.api.db.slick.DatabaseConfigProvider
import play.api.db.slick.HasDatabaseConfig
import slick.driver.JdbcProfile

case class Sample(id: Option[Int], name: String)

trait SamplesTable {
  class Samples(tag: Tag) extends Table[Sample](tag, "SAMPLE") {
    def id = column[Int]("ID", O.PrimaryKey, O.AutoInc)
    def name = column[String]("NAME")
    def * = (id.?, name) <> (Sample.tupled, Sample.unapply)
  }
  val samples = TableQuery[Samples]
}

object SamplesDAO extends HasDatabaseConfig[JdbcProfile] with SamplesTable {
  val dbConfig = DatabaseConfigProvider.get[JdbcProfile](Play.current)

  def findById(id: Int): Future[Option[Sample]] =
    db.run(samples.filter(_.id === id).result.headOption)

  def findAll: Future[Seq[Sample]] =
    db.run(samples.result)

  def insert(newRecord: Sample): Future[Int] = {
    db.run((samples returning samples.map(_.id)) += newRecord)
  }

  def update(record: Sample): Future[Int] = {
    db.run(samples.filter(_.id === record.id)
      .map(a => (a.name))
      .update((record.name)))
  }

} 

//设置package包名称以及导入依赖的类
package utils

import java.sql.Timestamp
import com.netaporter.uri.Uri
import org.joda.time.DateTime
import slick.driver.JdbcProfile
import play.api.db.slick.DatabaseConfigProvider
import play.api.db.slick.HasDatabaseConfig
import play.api.Play
import slick.backend.DatabaseConfig


trait ColumnTypeMapper extends HasDatabaseConfig[JdbcProfile] {
  protected val dbConfig: DatabaseConfig[JdbcProfile] = DatabaseConfigProvider.get[JdbcProfile](Play.current)
  import driver.api._

  implicit def dateTimeMapper = {
    MappedColumnType.base[DateTime, Timestamp] (
      dt => new Timestamp(dt.getMillis),
      ts => new DateTime(ts.getTime)
    )
  }

  implicit def dateTimeOrdering: Ordering[DateTime] = Ordering.fromLessThan(_ isBefore _)

  implicit def uriMapper = MappedColumnType.base[Uri, String] (
    dt => dt.toString(),
    ts => Uri.parse(ts)
  )
} 

//设置package包名称以及导入依赖的类
package models

import play.api.Play
import play.api.db.slick.{DatabaseConfigProvider, HasDatabaseConfig}
import slick.driver.MySQLDriver
import scala.concurrent._
import play.api.libs.concurrent.Execution.Implicits.defaultContext


class UserDAO extends HasDatabaseConfig[MySQLDriver]  {

  val dbConfig = DatabaseConfigProvider.get[MySQLDriver](Play.current)

  import slick.driver.MySQLDriver.api._

  def all(): Future[Seq[UserRow]] = db.run(Tables.User.result)

  def findByEmail(email: String): Future[UserRow] = {
    val f = db.run(Tables.User.filter(_.email === email).result.headOption)
    f.map { result => result match {
      case Some(u) => u
      case None => throw new Exception("User not found")
    }}
  }
} 

//设置package包名称以及导入依赖的类
package utils 

import play.api.db.slick.DatabaseConfigProvider
import slick.driver.JdbcProfile
import play.api.db.slick.HasDatabaseConfig
import play.api.Play
import database.tables._

trait DBComponentWithSlickQueryOps extends DBComponent {
 //databaseConfig: HasDatabaseConfig[ JdbcProfile ] =>

  import cats.Apply
  import cats.std.list._
 // import driver.api._
  import dbConfig.driver.api._

  type BooleanOp = ( Rep[ Boolean ], Rep[ Boolean ] ) => Rep[ Boolean ]

  implicit class OptionFilter[ X, Y ]( query: Query[ X, Y, Seq ] ) {

    
    def foundBy[ T ]( ops: List[ ( X ) => Option[ Rep[ Boolean ] ] ] )
                    ( f: BooleanOp ): Query[ X, Y, Seq ] =
      query.filter { q =>
        val res = Apply[ List ].ap( ops )( List( q ) ).collect { 
          case Some( y ) => y 
        } reduceLeftOption f
        res.getOrElse( false: Rep[ Boolean ] )
      } take 1
  }
} 

//设置package包名称以及导入依赖的类
package domain.service

import javax.inject.Inject

import api.ApiRequestHeader
import api.ApiUtil._
import ApiToken._
import domain.models.Tables
import play.api.cache.CacheApi
import play.api.db.slick.{DatabaseConfigProvider, HasDatabaseConfig}
import play.api.libs.json.{JsNull, JsValue, Json}
import play.api.mvc.RequestHeader
import slick.driver.JdbcProfile



class ApiLogService @Inject()(protected val dbConfigProvider: DatabaseConfigProvider) extends Tables with HasDatabaseConfig[JdbcProfile] {

  val dbConfig = dbConfigProvider.get[JdbcProfile]
  val profile = slick.driver.MySQLDriver

  import dbConfig.driver.api._

  def insert[R <: RequestHeader](status: Int, json: JsValue)(implicit cache: CacheApi,request: ApiRequestHeader[R]) = {

    val row = ApilogRow(
      datetime = currentTimestamp,
      ip = request.remoteAddress,
      token = request.maybeAuthToken,
      method = request.method,
      uri = request.uri,
      requestbody = request.maybeBody,
      responsestatus = status,
      responsebody = if (json == JsNull) None else Some(Json.prettyPrint(json)),
      email = getMaybeEmail(request.maybeAuthToken)
    )

    def token(implicit request: ApiRequestHeader[R]): String = {
      request.maybeAuthToken match {
        case Some(t) => t
        case None => EMPTY_STRING
      }
    }
    db.run(Apilog += row)
  }

}