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



import com.github.tminglei.slickpg.{PgArraySupport, PgDate2Support, PgPlayJsonSupport, _}
import slick.driver.PostgresDriver

trait PvPostgresDriver extends PostgresDriver
  with PgArraySupport
  with PgPlayJsonSupport
  with PgDate2Support
with PgPostGISSupport
with PgSearchSupport {

override val pgjson = "jsonb"
override val api = MyAPI

trait MyImplicits extends JsonImplicits {
  implicit val intListTypeMapper = new SimpleArrayJdbcType[Int]("int4").to(_.toVector)
  implicit val longListTypeMapper = new SimpleArrayJdbcType[Long]("bigint").to(_.toVector)
  implicit val stringListTypeMapper = new SimpleArrayJdbcType[String]("text").to(_.toVector)

}

object MyAPI extends API
  with ArrayImplicits
  with DateTimeImplicits
  with PostGISImplicits
  with PostGISAssistants
  with PlayJsonImplicits
  with SimpleArrayPlainImplicits
  with PostGISPlainImplicits
  with PlayJsonPlainImplicits
  with Date2DateTimePlainImplicits
with SearchImplicits
with SearchAssistants
with MyImplicits {}

}

object PvPostgresDriver extends PvPostgresDriver 

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

import com.netaporter.uri.Uri
import slick.driver.PostgresDriver
import dao.BaseTable
import repository.story.{Environment, Scenario, Situation}
import utils.ColumnTypeMapper
import org.joda.time.DateTime



object StoryTables extends {
  val profile = PostgresDriver
} with StoryTables

trait StoryTables extends ColumnTypeMapper {
  val profile: PostgresDriver
  import profile.api._

  class ScenarioTable(tag: Tag) extends BaseTable[Scenario](tag, "scenario") {
    val name: Rep[String] = column[String]("name")
    val description: Rep[String] = column[String]("description")
    val img: Rep[Uri] = column[Uri]("img_src")
    val rating: Rep[Float] = column[Float]("rating")

    def * = (id.?, name, description, img, rating) <> ((Scenario.apply _).tupled, Scenario.unapply)
  }

  lazy val scenarioTable = new TableQuery(tag => new ScenarioTable(tag))

  class SituationTable(tag: Tag) extends BaseTable[Situation](tag, "situation") {
    val idScenario: Rep[Long] = column[Long]("id_scenario")
    val name: Rep[String] = column[String]("name")
    val description: Rep[String] = column[String]("description")
    val place: Rep[String] = column[String]("place")
    val time: Rep[DateTime] = column[DateTime]("time")
    val rating: Rep[Float] = column[Float]("rating")

    def * = (id.?, idScenario, name, description, place, time, rating) <> ((Situation.apply _).tupled, Situation.unapply)
    def userFk = foreignKey("situation_to_scenario_fk", idScenario, scenarioTable)(_.id)
  }

  lazy val situationTable = new TableQuery(tag => new SituationTable(tag))

  class EnvironmentTable(tag: Tag) extends BaseTable[Environment](tag, "environment") {
    val idSituation: Rep[Long] = column[Long]("id_situation")
    val name: Rep[String] = column[String]("name")
    val friendly: Rep[Int] = column[Int]("friendly")
    val unfriendly: Rep[Int] = column[Int]("unfriendly")
    val neutral: Rep[Int] = column[Int]("neutral")
    val rating: Rep[Float] = column[Float]("rating")

    def * = (id.?, idSituation, name, friendly, unfriendly, neutral, rating) <> ((Environment.apply _).tupled, Environment.unapply)
    def userFk = foreignKey("environment_to_situation_fk", idSituation, situationTable)(_.id)
  }

  lazy val environmentTableTable = new TableQuery(tag => new EnvironmentTable(tag))
} 

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

import dao.BaseTable
import repository.user.{Gender, User}
import slick.driver.PostgresDriver
import utils.ColumnTypeMapper


object UserTables extends {
  val profile = PostgresDriver
} with UserTables

trait UserTables extends ColumnTypeMapper {
  val profile: PostgresDriver
  import profile.api._

  class UserTable(tag: Tag) extends BaseTable[User](tag, "user") {
    val username: Rep[String] = column[String]("username")
    val gender: Rep[Gender] = column[Gender]("gender")
    val oauthProvider: Rep[String] = column[String]("oauth_provider")
    val oauthUid: Rep[String] = column[String]("oauth_uid")

    def * = (id.?, username, gender, oauthProvider, oauthUid) <> ((User.apply _).tupled, User.unapply)
  }

  lazy val userTable = new TableQuery(tag => new UserTable(tag))
} 

//设置package包名称以及导入依赖的类
package org.bitcoins.spvnode.constant

import slick.backend.DatabaseConfig
import slick.driver.PostgresDriver
import slick.driver.PostgresDriver.api._


  def database: Database = dbConfig.db
}

trait MainNetDbConfig extends DbConfig {
  override def dbConfig: DatabaseConfig[PostgresDriver] = DatabaseConfig.forConfig("databaseUrl")
}
object MainNetDbConfig extends MainNetDbConfig

trait TestNet3DbConfig extends DbConfig {
  override def dbConfig: DatabaseConfig[PostgresDriver] = DatabaseConfig.forConfig("testNet3DatabaseUrl")
}
object TestNet3DbConfig extends TestNet3DbConfig


trait RegTestDbConfig extends DbConfig {
  override def dbConfig: DatabaseConfig[PostgresDriver] = DatabaseConfig.forConfig("regTestDatabaseUrl")
}
object RegTestDbConfig extends RegTestDbConfig 

//设置package包名称以及导入依赖的类
package au.com.agiledigital.dao.slick

import slick.driver.{ DerbyDriver, H2Driver, HsqldbDriver, JdbcProfile, MySQLDriver, PostgresDriver, SQLiteDriver }

trait JdbcProfileProvider {
  type JP <: JdbcProfile
  val driver: JP
}

object JdbcProfileProvider {

  trait H2ProfileProvider extends JdbcProfileProvider {
    type JP = H2Driver
    val driver: H2Driver = H2Driver
  }

  trait PostgresProfileProvider extends JdbcProfileProvider {
    type JP = PostgresDriver
    val driver = PostgresDriver
  }

  trait DerbyProfileProvider extends JdbcProfileProvider {
    type JP = DerbyDriver
    val driver = DerbyDriver
  }

  trait HsqlProfileProvider extends JdbcProfileProvider {
    type JP = HsqldbDriver
    val driver = HsqldbDriver
  }

  trait MySQLProfileProvider extends JdbcProfileProvider {
    type JP = MySQLDriver
    val driver = MySQLDriver
  }

  trait SQLLiteProfileProvider extends JdbcProfileProvider {
    type JP = SQLiteDriver
    val driver = SQLiteDriver
  }

}