Scala ResultSet类代码示例

//设置package包名称以及导入依赖的类
package services.common.demographics.Impl

import com.datastax.driver.core.ResultSet
import domain.common.demographics.Gender
import repositories.common.demographics.GenderRepository
import services.Service
import services.common.demographics.GenderService

import scala.concurrent.Future


class GenderServiceImpl extends GenderService with Service{

  override def createOrUpdate(gender: Gender): Future[ResultSet] = {
    GenderRepository.save(gender)
  }

  override def getGenderById(id: String): Future[Option[Gender]] = {
    GenderRepository.getGenderById(id)
  }

  override def getGenders(id: String): Future[Seq[Gender]] = {
    GenderRepository.getGenders(id)
  }
} 

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

import com.datastax.driver.core.{ResultSet, Row}
import com.websudos.phantom.CassandraTable
import com.websudos.phantom.dsl._
import com.websudos.phantom.iteratee.Iteratee
import com.websudos.phantom.keys.PartitionKey
import conf.connection.DataConnection
import domain.util.ApiKeys

import scala.concurrent.Future


class ApiKeysRepository extends CassandraTable[ApiKeysRepository, ApiKeys] {

  object id extends StringColumn(this) with PartitionKey[String]

  object value extends StringColumn(this)

  override def fromRow(row: Row): ApiKeys = {
    ApiKeys(
      id(row),
      value(row)
    )
  }
}

object ApiKeysRepository extends ApiKeysRepository with RootConnector {
  override lazy val tableName = "apikeys"

  override implicit def space: KeySpace = DataConnection.keySpace

  override implicit def session: Session = DataConnection.session


  def save(key: ApiKeys): Future[ResultSet] = {
    insert
      .value(_.id, key.id)
      .value(_.value, key.value)
      .future()
  }

  def getKeyById(id: String): Future[Option[ApiKeys]] = {
    select.where(_.id eqs id).one()
  }

  def getAllkeys: Future[Seq[ApiKeys]] = {
    select.fetchEnumerator() run Iteratee.collect()
  }

  def deleteKey(id: String): Future[ResultSet] = {
    delete.where(_.id eqs id).future()
  }
} 

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

import com.datastax.driver.core.{ResultSet, Row}
import com.websudos.phantom.CassandraTable
import com.websudos.phantom.dsl._
import com.websudos.phantom.keys.PartitionKey
import conf.connection.DataConnection
import domain.util.Token

import scala.concurrent.Future


class TokenRepository extends CassandraTable[TokenRepository, Token] {

  object id extends StringColumn(this) with PartitionKey[String]

  object tokenValue extends StringColumn(this)

  override def fromRow(row: Row): Token = {
    Token(
      id(row),
      tokenValue(row)
    )
  }
}

object TokenRepository extends TokenRepository with RootConnector {
  override lazy val tableName = "tokens"

  override implicit def space: KeySpace = DataConnection.keySpace

  override implicit def session: Session = DataConnection.session


  def save(token: Token): Future[ResultSet] = {
    insert
      .value(_.id, token.id)
      .value(_.tokenValue, token.tokenValue)
      .ttl(12000)
      .future()
  }

  def getTokenById(id:String):Future[Option[Token]] = {
    select.where(_.id eqs id).one()

  }
  def deleteToken(id:String): Future[ResultSet] = {
    delete.where(_.id eqs id).future()
  }

} 

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

import com.datastax.driver.core.{ResultSet, Row}
import com.websudos.phantom.CassandraTable
import com.websudos.phantom.dsl._
import com.websudos.phantom.iteratee.Iteratee
import com.websudos.phantom.keys.PartitionKey
import conf.connection.DataConnection
import domain.util.Keys

import scala.concurrent.Future


sealed class KeysRepository extends CassandraTable[KeysRepository, Keys] {

  object id extends StringColumn(this) with PartitionKey[String]

  object value extends StringColumn(this)

  override def fromRow(row: Row): Keys = {
    Keys(
      id(row),
      value(row)
    )
  }
}

object KeysRepository extends KeysRepository with RootConnector {
  override lazy val tableName = "tokenkeys"

  override implicit def space: KeySpace = DataConnection.keySpace

  override implicit def session: Session = DataConnection.session


  def save(key: Keys): Future[ResultSet] = {
    insert
      .value(_.id, key.id)
      .value(_.value, key.value)
      .future()
  }
  def getKeyById(id: String): Future[Option[Keys]] = {
    select.where(_.id eqs id).one()
  }
  def getAllkeys: Future[Seq[Keys]] = {
    select.fetchEnumerator() run Iteratee.collect()
  }

  def deleteKey(id:String) : Future[ResultSet]={
    delete.where(_.id eqs id).future()
  }
} 

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

import com.datastax.driver.core.ResultSet
import domain.util.ApiKeys
import repository.util.ApiKeysRepository
import services.Service

import scala.concurrent.Future


object ApiKeysService extends Service{
  def saveOrUpdate(entity: ApiKeys): Future[ResultSet] = {
    ApiKeysRepository.save(entity)
  }
  def get(id:String):Future[Option[ApiKeys]] ={
    ApiKeysRepository.getKeyById(id)
  }

  def getAll:Future[Seq[ApiKeys]] ={
    ApiKeysRepository.getAllkeys
  }

} 

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

import com.datastax.driver.core.ResultSet
import domain.util.Status
import repository.util.StatusRepository
import services.Service

import scala.concurrent.Future


object  StatusService extends Service{
  def saveOrUpdate(entity: Status): Future[ResultSet] = {
    StatusRepository.save(entity)
  }
  def get(id:String):Future[Option[Status]] ={
    StatusRepository.findById(id)
  }

  def getAll:Future[Seq[Status]] ={
    StatusRepository.findAll
  }

} 

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

import com.datastax.driver.core.ResultSet
import domain.persons.PersonEvents
import repository.persons.PersonEventsRepository
import services.Service

import scala.concurrent.Future


object PersonEventsService extends Service{
  def saveOrUpdate(entity: PersonEvents): Future[ResultSet] = {
    PersonEventsRepository.save(entity)
}

  def getValues(personId: String): Future[Seq[PersonEvents]] = {
    PersonEventsRepository.findPersonEvents(personId)
}

  def getPersonValue(personId: String, id: String): Future[Option[PersonEvents]] = {
    PersonEventsRepository.findById(personId, id)
  }
} 

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

import com.datastax.driver.core.ResultSet
import domain.persons.Person
import repository.persons.{UsersRepository, PersonRepository}
import services.Service

import scala.concurrent.Future


object PersonService extends Service{

  def saveOrUpdate(entity: Person): Future[ResultSet] = {

    PersonRepository.save(entity)
  }
  def getPeople(id:String):Future[Seq[Person]] ={
    PersonRepository.findPeople(id)
  }

  def getPerson(orgId:String,id:String):Future[Option[Person]] ={
    PersonRepository.findPerson(orgId,id)
  }
  def getPersonByEmail(email:String):Future[Option[Person]] = {
    UsersRepository.findByEmail(email)
  }

} 

//设置package包名称以及导入依赖的类
package repositories.common.util

import com.datastax.driver.core.{ResultSet, Row}
import com.websudos.phantom.CassandraTable
import com.websudos.phantom.dsl._
import com.websudos.phantom.keys.PartitionKey
import com.websudos.phantom.reactivestreams._
import conf.connection.DataConnection
import domain.common.util.ApiKeys

import scala.concurrent.Future


class ApiKeysRepository extends CassandraTable[ApiKeysRepository, ApiKeys] {

  object id extends StringColumn(this) with PartitionKey[String]

  object value extends StringColumn(this)

  override def fromRow(row: Row): ApiKeys = {
    ApiKeys(
      id(row),
      value(row)
    )
  }
}

object ApiKeysRepository extends ApiKeysRepository with RootConnector {
  override lazy val tableName = "apikeys"

  override implicit def space: KeySpace = DataConnection.keySpace

  override implicit def session: Session = DataConnection.session


  def save(key: ApiKeys): Future[ResultSet] = {
    insert
      .value(_.id, key.id)
      .value(_.value, key.value)
      .future()
  }

  def getKeyById(id: String): Future[Option[ApiKeys]] = {
    select.where(_.id eqs id).one()
  }

  def getAllkeys: Future[Seq[ApiKeys]] = {
    select.fetchEnumerator() run Iteratee.collect()
  }

  def deleteKey(id: String): Future[ResultSet] = {
    delete.where(_.id eqs id).future()
  }
} 

//设置package包名称以及导入依赖的类
package repositories.common.util

import com.datastax.driver.core.{ResultSet, Row}
import com.websudos.phantom.CassandraTable
import com.websudos.phantom.dsl._
import com.websudos.phantom.keys.PartitionKey
import conf.connection.DataConnection
import domain.common.util.Token

import scala.concurrent.Future


class TokenRepository extends CassandraTable[TokenRepository, Token] {

  object id extends StringColumn(this) with PartitionKey[String]

  object tokenValue extends StringColumn(this)

  override def fromRow(row: Row): Token = {
    Token(
      id(row),
      tokenValue(row)
    )
  }
}

object TokenRepository extends TokenRepository with RootConnector {
  override lazy val tableName = "tokens"

  override implicit def space: KeySpace = DataConnection.keySpace

  override implicit def session: Session = DataConnection.session


  def save(token: Token): Future[ResultSet] = {
    insert
      .value(_.id, token.id)
      .value(_.tokenValue, token.tokenValue)
      .ttl(12000)
      .future()
  }

  def getTokenById(id:String):Future[Option[Token]] = {
    select.where(_.id eqs id).one()

  }
  def deleteToken(id:String): Future[ResultSet] = {
    delete.where(_.id eqs id).future()
  }

} 

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

import com.datastax.driver.core.ResultSet
import domain.companycontacts.CompanyContacts
import repository.contacts.ContactsRepository
import services.Service

import scala.concurrent.Future


object CompanyContactsService extends Service {

  def saveOrUpdate(entity: CompanyContacts): Future[ResultSet] = {
    ContactsRepository.save(entity)
  }
  def findById(company: String, entityId:String, id: String):Future[Option[CompanyContacts]] ={
    ContactsRepository.findById(company,entityId,id)
  }

  def getAll(company:String):Future[Seq[CompanyContacts]] ={
    ContactsRepository.findAll(company)
  }

  def findEntityContacts(company: String, entityId:String): Future[Seq[CompanyContacts]] = {
    ContactsRepository.findEntityContacts(company,entityId)
  }

} 

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

import com.datastax.driver.core.ResultSet
import domain.common.demographics.Gender
import domain.people.PersonRole
import repository.common.demographics.GenderRepository
import repository.people.PersonRoleRepository
import services.Service

import scala.concurrent.Future


object PersonRoleService extends Service {
  def saveOrUpdate(entity: PersonRole): Future[ResultSet] = {
    PersonRoleRepository.save(entity)
  }

  def get(id: String, roleId: String): Future[Option[PersonRole]] = {
    PersonRoleRepository.findRole(id, roleId)
  }

  def getAllRoles(personId: String): Future[Seq[PersonRole]] = {
    PersonRoleRepository.findRolesById(personId)
  }

} 

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

import com.datastax.driver.core.ResultSet
import domain.common.demographics.Gender
import domain.people.Person
import repository.common.demographics.GenderRepository
import repository.people.{UsersRepository, PersonRepository}
import services.Service

import scala.concurrent.Future


object PeopleService extends Service{

  def saveOrUpdate(entity: Person): Future[ResultSet] = {
    PersonRepository.save(entity)
  }
  def getPeople(id:String):Future[Seq[Person]] ={
    PersonRepository.findPeople(id)
  }

  def getPerson(company:String,id:String):Future[Option[Person]] ={
    PersonRepository.findPerson(company,id)
  }
  def getPersonByEmail(email:String):Future[Option[Person]] = {
    UsersRepository.findByEmail(email)
  }

} 

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

import com.datastax.driver.core.ResultSet
import domain.common.demographics.Gender
import domain.company.{Department, Company}
import repository.common.demographics.GenderRepository
import repository.company.{DepartmentRepository, CompanyRepository}
import services.Service

import scala.concurrent.Future


object DepartmentService extends Service{

  def saveOrUpdate(entity: Department): Future[ResultSet] = {
    DepartmentRepository.save(entity)
  }
  def get(company:String, id:String):Future[Option[Department]] ={
    DepartmentRepository.findDepartment(company,id)
  }

  def getDepartments(company:String):Future[Seq[Department]] ={
    DepartmentRepository.findDepartments(company)
  }

} 

//设置package包名称以及导入依赖的类
package services.common.location

import com.datastax.driver.core.ResultSet
import domain.common.demographics.Gender
import domain.common.location.AddressType
import repository.common.demographics.GenderRepository
import repository.common.location.AddressTypeRepository
import services.Service

import scala.concurrent.Future


object AddressTypeService extends Service{
  def saveOrUpdate(entity: AddressType): Future[ResultSet] = {
    AddressTypeRepository.save(entity)
  }
  def get(id:String):Future[Option[AddressType]] ={
    AddressTypeRepository.findById(id)
  }

  def getAll:Future[Seq[AddressType]] ={
    AddressTypeRepository.findAll
  }

}