Scala ReactiveMongoComponents类代码示例

OGeek|极客世界-中国程序员成长平台 › 门户 › 编程› Scala›Scala教程

原作者: [db:作者] 来自: [db:来源] 收藏邀请

本文整理汇总了Scala中play.modules.reactivemongo.ReactiveMongoComponents类的典型用法代码示例。如果您正苦于以下问题：Scala ReactiveMongoComponents类的具体用法？Scala ReactiveMongoComponents怎么用？Scala ReactiveMongoComponents使用的例子？那么恭喜您, 这里精选的类代码示例或许可以为您提供帮助。

在下文中一共展示了ReactiveMongoComponents类的20个代码示例，这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞，您的评价将有助于我们的系统推荐出更棒的Scala代码示例。

示例1: MyApplicationLoader

//设置package包名称以及导入依赖的类
import dao.CroissantDAO
import jobs.GmailJob
import play.api._
import play.api.ApplicationLoader.Context
import router.Routes
import play.api.libs.ws.ahc.AhcWSComponents
import play.api.libs.mailer._
import play.api.i18n.I18nComponents
import play.modules.reactivemongo.{ReactiveMongoApiFromContext, ReactiveMongoComponents}
import services.OauthProvider
import utils.{Mailer, Settings}


class MyApplicationLoader extends ApplicationLoader {
  def load(context: Context) = {
    LoggerConfigurator(context.environment.classLoader).foreach(_.configure(context.environment))
    new MyComponents(context).application
  }
}

class MyComponents(context: Context) extends ReactiveMongoApiFromContext(context)
  with I18nComponents
  with AhcWSComponents
  with MailerComponents
  with ReactiveMongoComponents {

  implicit val ec = actorSystem.dispatcher

  val settings = new Settings(configuration)
  val mailer = new Mailer(settings, mailerClient)

  val croissantDAO = new CroissantDAO(settings, mailer, reactiveMongoApi)
  val oauthProvider = new OauthProvider(settings, wsClient)
  //val gmailJob = new GmailJob(wsClient, actorSystem, settings, mailer, croissantDAO)

  lazy val router = new Routes(
    httpErrorHandler,
    new controllers.CroissantController(settings, messagesApi, mailer, croissantDAO),
    new controllers.AdminCroissantController(settings, messagesApi, mailer, croissantDAO),
    new controllers.OauthController(oauthProvider),
    new controllers.Assets(httpErrorHandler)
  )
}

开发者ID:denis-mludek，项目名称:zencroissants，代码行数:44，代码来源:MyApplicationLoader.scala

示例2: Users

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

import javax.inject.Inject

import org.joda.time.DateTime
import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.json._
import play.api.mvc.{Action, BodyParsers, Controller}
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.bson.{BSONDocument, BSONObjectID}
import repos.UserRepoImpl



class Users @Inject()(val reactiveMongoApi: ReactiveMongoApi) extends Controller
  with MongoController with ReactiveMongoComponents{

  import models.UserFields._

  def userRepo = new UserRepoImpl(reactiveMongoApi)

  def create = Action.async(BodyParsers.parse.json) { // TODO: Prüfen dass name und email eindeutig sind beim Anlegen
    implicit request =>
      val name = (request.body \ Name).as[String]
      val password = (request.body \ Password).as[String]
      val email = (request.body \ EMail).as[String]
      userRepo.save(BSONDocument(
        Name -> name,
        Password -> password,
        EMail -> email,
        CreatedAt -> DateTime.now.toString
      )).map(result => Created("Created"))
  }

  def read(id: String) = Action.async{ implicit request =>
    userRepo.select(BSONDocument(Id -> BSONObjectID(id))).map(exercise => Ok(Json.toJson(exercise)))
  }


  def update(id: String) = Action.async(BodyParsers.parse.json) { // TODO: Prüfen dass name und email eindeutig sind beim updaten
    implicit request =>
      val name = (request.body \ Name).asOpt[String]
      val password = (request.body \ Password).asOpt[String]
      val email = (request.body \ EMail).asOpt[String]
      userRepo.update(BSONDocument( Id -> BSONObjectID(id)),
        BSONDocument("$set" -> BSONDocument(
          Name -> name,
          Password -> password,
          EMail -> EMail
      ))).map(result => Accepted)
  }

  def delete(id: String) = Action.async{
    userRepo.remove(BSONDocument(Id -> BSONObjectID(id))).map(result => Accepted("Deleted: "+ id ))
  }

}

开发者ID:NorbertEbenhoeh，项目名称:projectX，代码行数:58，代码来源:Users.scala

示例3: Application

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

import javax.inject.{Inject, Singleton}

import play.api.Logger
import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.json.Json
import play.api.mvc.{Action, Controller}
import play.modules.reactivemongo.json.collection.JSONCollection
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.api.collections.bson.BSONCollection
import reactivemongo.api.commands.bson.BSONCountCommand.{Count, CountResult}
import reactivemongo.api.commands.bson.BSONCountCommandImplicits._
import reactivemongo.bson.BSONDocument

import scala.concurrent.Future

@Singleton
class Application @Inject()(val reactiveMongoApi: ReactiveMongoApi) extends Controller
  with MongoController with ReactiveMongoComponents {

  def index = Action {
    Logger.info("Application startup...")

    val posts = List(
      Json.obj(
        "name" -> "Widget One",
        "description" -> "My first widget",
        "author" -> "Justin"
      ),
      Json.obj(
        "name" -> "Widget Two: The Return",
        "description" -> "My second widget",
        "author" -> "Justin"
      ))

    val query = BSONDocument("name" -> BSONDocument("$exists" -> true))
    val command = Count(query)
    val result: Future[CountResult] = bsonCollection.runCommand(command)

    result.map { res =>
      val numberOfDocs: Int = res.value
      if (numberOfDocs < 1) {
        jsonCollection.bulkInsert(posts.toStream, ordered = true).foreach(i => Logger.info("Record added."))
      }
    }

    Ok("Your database is ready.")
  }

  def jsonCollection = reactiveMongoApi.db.collection[JSONCollection]("widgets")

  def bsonCollection = reactiveMongoApi.db.collection[BSONCollection]("widgets")

  def cleanup = Action {
    jsonCollection.drop().onComplete {
      case _ => Logger.info("Database collection dropped")
    }
    Ok("Your database is clean.")
  }
}

开发者ID:aphexcx，项目名称:iconoclast-api，代码行数:62，代码来源:Application.scala

示例4: Application

//设置package包名称以及导入依赖的类
package controllers
import javax.inject.Inject
import play.api.mvc.{ Action, Controller }
import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.json._
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.play.json._
import play.modules.reactivemongo.json.collection._
import models._
import models.JsonFormats._

class Application @Inject() (val reactiveMongoApi: ReactiveMongoApi)
  extends Controller with MongoController with ReactiveMongoComponents {

  def getHotels = Action.async {
    db.collection("hotels").find(Json.obj()).cursor[Hotel]()
      .collect[List]().map {hotels => Ok(Json.toJson(hotels))}
  }

  def findByCityName(cityName : String) = Action.async {
    db.collection("hotels").find(Json.obj("city" -> cityName)).cursor[Hotel]()
        .collect[List]().map (hotels => Ok(Json.toJson(hotels)))
  }
}

开发者ID:EmrysMyrddin，项目名称:WSHotels，代码行数:25，代码来源:Application.scala

示例5: MasterActor

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

import java.util.Date
import javax.inject.Inject

import akka.actor.Actor
import models.HourlyMessage
import play.api.libs.mailer.MailerClient
import play.api.libs.ws.WSClient
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.play.json.collection.JSONCollection
import play.api.libs.json.Json
import play.modules.reactivemongo.json._
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.api.ReadPreference
import reactivemongo.play.json.collection.JSONCollection
import services.Counter

import scala.concurrent.{ExecutionContext, Future}
import scala.util.{Failure, Success}
import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future


class MasterActor @Inject()(mailerClient: MailerClient, val reactiveMongoApi: ReactiveMongoApi, ws: WSClient,counter: Counter) extends Actor  with MongoController with ReactiveMongoComponents {
  override val database = reactiveMongoApi.connection.database("dummy")

  def receive = {

    case HourlyMessage(message) => {

      def patternFuture: Future[JSONCollection] = database.map(_.collection[JSONCollection]("testdb"))
      val date = new Date()
      val _count = counter.nextCount().toString
      val _date = date.toString
      for{
        pattern <- patternFuture
        lastError <- pattern.insert(Json.obj("count"-> _count,"date" -> _date))
      }yield{
        //Ok("Mongo LastError: %s".format(lastError))
        println("count "+_count)
        var status = 0
        if(lastError.hasErrors){
          status = 0
        } else{
          status = 1
        }
        status
      }
     }

    }
}

开发者ID:rahulkumar-aws，项目名称:akka-quartz-scheduler-example，代码行数:54，代码来源:MasterActor.scala

示例6: Application

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

import javax.inject.{Inject, Singleton}

import models._
import models.JsonFormats._
import org.slf4j.{Logger, LoggerFactory}
import play.api.libs.json.Json
import play.api.mvc._
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import play.modules.reactivemongo.json._
import reactivemongo.api.Cursor
import reactivemongo.play.json.collection.JSONCollection
import services.{UUIDGenerator,SimpleUUIDGenerator}

import scala.concurrent.ExecutionContext.Implicits.global
import scala.concurrent.Future


@Singleton
class Application @Inject() (
                              val uuidGenerator: UUIDGenerator,
                              val reactiveMongoApi: ReactiveMongoApi
                            )
  extends Controller
    with MongoController
    with ReactiveMongoComponents
{

  private final val logger: Logger = LoggerFactory.getLogger(classOf[Application])

  def collection: JSONCollection = db.collection[JSONCollection]("greek")

  def index = Action.async {
    logger.info("Serving index page...")

    val cursor: Cursor[Sentence] = collection.
      // find all people with name `name`
      find(Json.obj("_id.scheme" -> "urn", "_id.namespace"->"cts", "_id.domain"->"greekLit", "_id.textgroup"->"tlg0003", "_id.work"->"tlg001", "_id.edition"->"perseus-grc1")).
      // perform the query and get a cursor of JsObject
      cursor[Sentence]

    // gather all the JsObjects in a list
    val futureUsersList: Future[List[Sentence]] = cursor.collect[List]()

    // everything's ok! Let's reply with the array
    futureUsersList.map { persons =>
      Ok(Json.toJson(persons))
    }
  }

  def randomUUID = Action {
    logger.info("calling UUIDGenerator...")
    Ok(uuidGenerator.generate.toString)
  }

}

开发者ID:fbaumgardt，项目名称:manifold_，代码行数:58，代码来源:Application.scala

示例7: AuthController

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

import javax.inject._

import pdi.jwt.{Jwt, JwtSession}
import play.api.libs.json.Json
import play.api.mvc.{Action, Controller}
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import play.api.libs.concurrent.Execution.Implicits.defaultContext
import services.MongoAuthService

import scala.concurrent.Future


@Singleton
class AuthController @Inject()(val reactiveMongoApi: ReactiveMongoApi, val authService: MongoAuthService) extends Controller with MongoController with ReactiveMongoComponents {

  def get_token = Action.async(parse.json) { implicit request =>
    val emailOpt = (request.body \ "email").asOpt[String]
    val passwordOpt = (request.body \ "password").asOpt[String]
    (emailOpt, passwordOpt) match {
      case (Some(email), Some(password)) if !email.trim.isEmpty && !password.isEmpty =>
        for {
          idOpt <- authService.authenticate(email, password)
        } yield {
          idOpt.map {
            id =>
              var session = JwtSession()
              val user = Json.obj("user" -> Json.obj("_id" -> id, "email" -> email))
              session = session + user
              val token = session.serialize
              Ok(Json.obj("token" -> token))
          }.getOrElse(Ok(Json.obj()))
        }
      case _ => Future.successful(Ok(Json.obj()))
    }
  }

}

开发者ID:sdor，项目名称:labnotes-server，代码行数:40，代码来源:AuthController.scala

示例8: PubmedController

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


import javax.inject._

import play.api.libs.json.{JsObject, Json}
import play.api.mvc.{Action, Controller}
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import play.api.libs.concurrent.Execution.Implicits.defaultContext
import services.PubmedService
import models.pubmed.SearchResult
import models.pubmed.schema.PubmedArticleSet

import scala.concurrent.Future

@Singleton
class PubmedController @Inject() (val reactiveMongoApi: ReactiveMongoApi,val pubmedService: PubmedService) extends Controller with MongoController with ReactiveMongoComponents with SecuredApi {

    def create_search_result = IfAuthentic.async(parse.json) { implicit request =>
      for {
        articleSetOpt <- pubmedService.createSearchResult(request.user.get,request.body.as[JsObject])
      } yield {
        Ok(Json.obj("article_set"->articleSetOpt))
      }
    }

    def find_search_result = IfAuthentic.async(parse.json) { implicit request =>
      val searchResultOpt = Json.fromJson[SearchResult](request.body).asOpt
      searchResultOpt.map {
        searchResult =>
          searchResult match {
            case SearchResult(Some(req),_,_,Some(year),Some(month),Some(day)) if req.isValid =>
              for {
                searchResultOpt <- pubmedService.findSearchResult(request.user.get,req,year,month,day)
              } yield {
                val articleSetOpt: Option[PubmedArticleSet] = searchResultOpt.map {
                  sr =>
                    sr.data.get.data.map {
                      xml =>
                        PubmedArticleSet.fromXML(scala.xml.XML.loadString(xml))
                    }
                }.flatten
                Ok(Json.obj(
                  "resp"->searchResultOpt.map(_.resp),
                  "article_set"->articleSetOpt
                ))
              }
            case _ =>  Future.successful(Ok(Json.obj()))
          }
      }.getOrElse{
        Future.successful(Ok(Json.obj()))
      }
    }
}

开发者ID:sdor，项目名称:labnotes-server，代码行数:55，代码来源:PubmedController.scala

示例9: TranslatorController

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

import javax.inject.Inject

import Repositories.{TranslatorRepository, UserRepository}
import models.{Translator, User}
import play.api.libs.json.Json
import play.api.mvc.{Action, BodyParsers, Controller}
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.bson.{BSONDocument, BSONObjectID}
import utils.Pagination

import scala.concurrent.Await
import scala.concurrent.duration.Duration
import scala.concurrent.ExecutionContext.Implicits.global


class TranslatorController @Inject()(val translatorService: TranslatorRepository, val reactiveMongoApi: ReactiveMongoApi) extends Controller
  with MongoController with ReactiveMongoComponents {

  def getAllTranslators(page:Int, limit:Int, sort: String) = Action.async {implicit request =>

    val totalCount = Await.result(translatorService.count(), Duration.Inf)
    val pagination = new Pagination(page, limit, totalCount)
    translatorService.getAllTranslators(pagination, sort).map(translators => Ok(Json.obj("DATA" -> Json.toJson(translators), "PAGINATION" -> Json.toJson(pagination))))
  }

  def insertTranslator = Action.async(BodyParsers.parse.json) { implicit request =>
    val translatorObj = (request.body).as[Translator]
    translatorService.insertTranslator(translatorObj).map(result => Created)
  }
}

开发者ID:sopheakreth，项目名称:rest-api-play-scala-mongodb，代码行数:33，代码来源:TranslatorController.scala

示例10: UserController

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

import javax.inject.Inject

import Repositories.UserRepository
import models.User
import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.json.Json
import play.api.mvc._
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.bson.{BSONDocument, BSONObjectID}
import utils.Pagination

import scala.concurrent.Await
import scala.concurrent.duration._



class UserController @Inject()(val userService: UserRepository, val reactiveMongoApi: ReactiveMongoApi) extends Controller
  with MongoController with ReactiveMongoComponents {

  def getAllUsers(page:Int, limit:Int, sort: String) = Action.async {implicit request =>

    val totalCount = Await.result(userService.count(), Duration.Inf)
    val pagination = new Pagination(page, limit, totalCount)
    userService.getAllUsers(pagination, sort).map(users => Ok(Json.obj("DATA" -> Json.toJson(users), "PAGINATION" -> Json.toJson(pagination))))
  }

  def getUserId(id: String) = Action.async { implicit request =>
    userService.getUserId(BSONDocument("_id" -> BSONObjectID(id))).map(user => Ok(Json.prettyPrint(Json.toJson(user))))
  }

  def insertUser = Action.async(BodyParsers.parse.json) { implicit request =>
    val userObj = (request.body).as[User]
    userService.insertUser(userObj).map(result => Created)
  }

  def updateUser(id: String) = Action.async(BodyParsers.parse.json) { implicit request =>
    val userObj = (request.body).as[User]
    userService.updateUser(BSONDocument("_id" -> BSONObjectID(id)), userObj).map(result => Accepted)
  }

  def deleteUser(id: String) = Action.async(BodyParsers.parse.json) { implicit request =>
    userService.deleteUser(BSONDocument("_id" -> BSONObjectID(id))).map(result => Accepted)
  }
}

开发者ID:sopheakreth，项目名称:rest-api-play-scala-mongodb，代码行数:47，代码来源:UserController.scala

示例11: BalanceInfoController

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

import javax.inject.{Inject, Singleton}

import models.BalanceInfo
import play.api.libs.json.Json
import play.api.mvc.{Action, Controller}
import play.modules.reactivemongo.json._
import play.modules.reactivemongo.json.collection.JSONCollection
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.api.{Cursor, ReadPreference}

import scala.concurrent.{ExecutionContext, Future}


@Singleton
class BalanceInfoController @Inject()(val reactiveMongoApi: ReactiveMongoApi)(implicit exec: ExecutionContext)
  extends Controller with MongoController with ReactiveMongoComponents {

  val balances: JSONCollection = db.collection[JSONCollection]("balance_info")

  def get(name: String) = Action.async {
    val balanceCursor: Cursor[BalanceInfo] =
      balances.find(Json.obj("name" -> name)).cursor[BalanceInfo](ReadPreference.primary)
    val balanceFuture: Future[List[BalanceInfo]] = balanceCursor.collect[List]()
    balanceFuture.map { data => Ok(Json.toJson(data)) }
  }

}

开发者ID:qza，项目名称:balance-service-play，代码行数:30，代码来源:BalanceInfoController.scala

示例12: TweetController

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

import javax.inject._

import play.api.libs.json.{JsValue, Json}
import play.api.mvc._
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import play.modules.reactivemongo.json._
import reactivemongo.api.Cursor
import reactivemongo.api.collections.bson.BSONCollection
import reactivemongo.bson.BSONDocument
import reactivemongo.play.json.collection.JSONCollection
import reactivemongo.api.commands.bson.BSONCountCommand.{Count, CountResult}

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import reactivemongo.api.commands.bson.BSONCountCommandImplicits._

@Singleton
class TweetController @Inject() (val reactiveMongoApi: ReactiveMongoApi)
  extends Controller with MongoController with ReactiveMongoComponents {

  def jsonCollection: JSONCollection = reactiveMongoApi.db.collection[JSONCollection]("tweets")
  def bsonCollection: BSONCollection = reactiveMongoApi.db.collection[BSONCollection]("tweets")

  import models._
  import models.TweetFormats._

  def findAll = Action.async {
    val cursor: Cursor[Tweet] = jsonCollection.find(Json.obj()).cursor[Tweet]()

    val futureTweetsList: Future[List[Tweet]] = cursor.collect[List]()

    val futureTweetsJsonArray: Future[JsValue] = futureTweetsList.map { tweets =>
      Json.toJson(tweets)
    }
    futureTweetsJsonArray.map { tweets =>
      Ok(tweets)
    }
  }

  def count = Action.async {
    val command = Count(BSONDocument.empty)
    val resultF: Future[CountResult] = bsonCollection.runCommand(command)
    resultF.map { res =>
      val numOfDocuments: Int = res.value
      Ok(Json.obj("numOfTweets" -> numOfDocuments))
    }
  }

}

开发者ID:kkrzys，项目名称:presidential-elections-data-analysis-restapi，代码行数:52，代码来源:TweetController.scala

示例13: UserController

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

import javax.inject._

import play.api.libs.json.{JsValue, Json}
import play.api.mvc._
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import play.modules.reactivemongo.json._
import reactivemongo.api.Cursor
import reactivemongo.api.collections.bson.BSONCollection
import reactivemongo.bson.BSONDocument
import reactivemongo.play.json.collection.JSONCollection
import reactivemongo.api.commands.bson.BSONCountCommand.{Count, CountResult}

import scala.concurrent.Future
import scala.concurrent.ExecutionContext.Implicits.global
import reactivemongo.api.commands.bson.BSONCountCommandImplicits._

@Singleton
class UserController @Inject() (val reactiveMongoApi: ReactiveMongoApi)
  extends Controller with MongoController with ReactiveMongoComponents {

  def jsonCollection: JSONCollection = reactiveMongoApi.db.collection[JSONCollection]("users")
  def bsonCollection: BSONCollection = reactiveMongoApi.db.collection[BSONCollection]("users")

  import models._
  import models.UserFormats._

  def findAll = Action.async {
    val cursor: Cursor[User] = jsonCollection.find(Json.obj()).cursor[User]()

    val futureUsersList: Future[List[User]] = cursor.collect[List]()

    val futureUsersJsonArray: Future[JsValue] = futureUsersList.map { users =>
      Json.toJson(users)
    }
    futureUsersJsonArray.map { users =>
      Ok(users)
    }
  }

  def count = Action.async {
    val command = Count(BSONDocument.empty)
    val resultF: Future[CountResult] = bsonCollection.runCommand(command)
    resultF.map { res =>
      val numOfDocuments: Int = res.value
      Ok(Json.obj("numOfUsers" -> numOfDocuments))
    }
  }

}

开发者ID:kkrzys，项目名称:presidential-elections-data-analysis-restapi，代码行数:52，代码来源:UserController.scala

示例14: MemoController

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

import javax.inject.{Inject, Singleton}

import model.Memo
import org.joda.time.LocalDateTime
import play.api.libs.json.Json
import play.api.mvc.{BodyParsers, Action, Controller}
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.bson.BSONObjectID

import scala.concurrent.{Future, ExecutionContext}

@Singleton
class MemoController @Inject()(val reactiveMongoApi: ReactiveMongoApi)
                              (implicit ec: ExecutionContext)
  extends Controller with MongoController with ReactiveMongoComponents {

  def memoRepo = new backend.MemoMongoRepo(reactiveMongoApi)

  //import reactivemongo.play.json._
  import util.ReactiveMongoFormats._
  implicit val memoFormat = Json.format[Memo]

  def list = Action.async {
    val memos: Future[List[Memo]] = memoRepo.find()
    memos.map(list => Ok(Json.toJson(list)))
  }

  def post = Action.async(BodyParsers.parse.json) { implicit request =>
    val memo: Memo = Memo(Some(BSONObjectID.generate()),
      (request.body \ "text").as[String],
      new LocalDateTime((request.body \ "date").as[Long]))
    memoRepo.save(memo).map(_ => Created(memo._id.get.stringify))
  }
}

开发者ID:dturbay，项目名称:memo-rest，代码行数:37，代码来源:MemoController.scala

示例15: Application

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

import javax.inject.{Inject, Singleton}

import play.api.Logger
import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.json.Json
import play.api.mvc.{Action, Controller}
import play.modules.reactivemongo.json.collection.JSONCollection
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.api.collections.bson.BSONCollection
import reactivemongo.api.commands.bson.BSONCountCommand.{ Count, CountResult }
import reactivemongo.api.commands.bson.BSONCountCommandImplicits._
import reactivemongo.bson.BSONDocument

import scala.concurrent.Future

@Singleton
class Application @Inject()(val reactiveMongoApi: ReactiveMongoApi) extends Controller
    with MongoController with ReactiveMongoComponents {

  def jsonCollection = reactiveMongoApi.db.collection[JSONCollection]("widgets");
  def bsonCollection = reactiveMongoApi.db.collection[BSONCollection]("widgets");

  def index = Action {
    Logger.info("Application startup...")

    val posts = List(
      Json.obj(
        "name" -> "Widget One",
        "description" -> "My first widget",
        "author" -> "Justin"
      ),
      Json.obj(
        "name" -> "Widget Two: The Return",
        "description" -> "My second widget",
        "author" -> "Justin"
      ))

    val query = BSONDocument("name" -> BSONDocument("$exists" -> true))
    val command = Count(query)
    val result: Future[CountResult] = bsonCollection.runCommand(command)

    result.map { res =>
      val numberOfDocs: Int = res.value
      if(numberOfDocs < 1) {
        jsonCollection.bulkInsert(posts.toStream, ordered = true).foreach(i => Logger.info("Record added."))
      }
    }

    Ok("Your database is ready.")
  }

  def cleanup = Action {
    jsonCollection.drop().onComplete {
      case _ => Logger.info("Database collection dropped")
    }
    Ok("Your database is clean.")
  }
}

开发者ID:jrodenbostel，项目名称:getting-started-play-scala，代码行数:61，代码来源:Application.scala

示例16: Widgets

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

import javax.inject.Inject

import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.json.Json
import play.api.mvc._
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.api.commands.WriteResult
import reactivemongo.bson.{BSONObjectID, BSONDocument}
import repos.WidgetRepoImpl

class Widgets @Inject()(val reactiveMongoApi: ReactiveMongoApi) extends Controller
    with MongoController with ReactiveMongoComponents {

  import controllers.WidgetFields._

  def index = Action.async { implicit request =>
    widgetRepo.find().map(widgets => Ok(Json.toJson(widgets)))
  }

  def create = Action.async(BodyParsers.parse.json) { implicit request =>
    val name = (request.body \ Name).as[String]
    val description = (request.body \ Description).as[String]
    val author = (request.body \ Author).as[String]
    widgetRepo.save(BSONDocument(
      Name -> name,
      Description -> description,
      Author -> author
    )).map(result => Created)
  }

  def read(id: String) = Action.async { implicit request =>
    widgetRepo.select(BSONDocument(Id -> BSONObjectID(id))).map(widget => Ok(Json.toJson(widget)))
  }

  def update(id: String) = Action.async(BodyParsers.parse.json) { implicit request =>
    val name = (request.body \ Name).as[String]
    val description = (request.body \ Description).as[String]
    val author = (request.body \ Author).as[String]
    widgetRepo.update(BSONDocument(Id -> BSONObjectID(id)),
      BSONDocument("$set" -> BSONDocument(Name -> name, Description -> description, Author -> author)))
        .map(result => Accepted)
  }

  def delete(id: String) = Action.async {
    widgetRepo.remove(BSONDocument(Id -> BSONObjectID(id)))
        .map(result => Accepted)
  }

  def widgetRepo = new WidgetRepoImpl(reactiveMongoApi)
}

object WidgetFields {
  val Id = "_id"
  val Name = "name"
  val Description = "description"
  val Author = "author"
}

开发者ID:jrodenbostel，项目名称:getting-started-play-scala，代码行数:60，代码来源:Widgets.scala

示例17: Application

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

import javax.inject.Inject

import models.PlaceData
import play.api.data.Form
import play.api.i18n.{I18nSupport, MessagesApi}
import play.api.mvc.{Action, Controller}
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}

import scala.concurrent.ExecutionContext


class Application @Inject() (val messagesApi: MessagesApi, val reactiveMongoApi: ReactiveMongoApi)
                            (implicit ec: ExecutionContext)
    extends Controller with MongoController with ReactiveMongoComponents with I18nSupport {

  val placeDAO = new PlaceDAO(reactiveMongoApi)

  def index() = Action.async{implicit request =>
    placeDAO.all().map(placesList => Ok(views.html.main(placesList, PlaceDAO.createPlaceForm)))}


  def uploadPlace() = Action.async(parse.multipartFormData) { implicit request =>
    def failure(formWithErrors: Form[PlaceData]) = {
      placeDAO.all().map(placesList => BadRequest(views.html.main(placesList, formWithErrors)))
    }

    def success(placeData: PlaceData) = {
        placeDAO.create(placeData, request.body.file("picture").get).map {
        case w if w.ok => Redirect(routes.Application.index()).flashing("success" -> "Added place")
        case _ => Redirect(routes.Application.index()).flashing("error" -> "Could not add place to database")
      }
    }

    PlaceDAO.createPlaceForm.bindFromRequest().fold(failure, success)
  }
}

开发者ID:test410，项目名称:picture-gallery，代码行数:39，代码来源:Application.scala

示例18: PlaceDAO

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

import javax.inject.Inject

import com.google.common.io.Files
import models.{Place, PlaceData}
import play.api.data.Form
import play.api.data.Forms._
import play.api.libs.Files.TemporaryFile
import play.api.libs.json.Json
import play.api.mvc.Controller
import play.api.mvc.MultipartFormData.FilePart
import play.modules.reactivemongo.json._
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.api.commands.WriteResult
import reactivemongo.api.{Cursor, ReadPreference}
import reactivemongo.play.json.collection.JSONCollection

import scala.concurrent.{ExecutionContext, Future}

class PlaceDAO @Inject() (val reactiveMongoApi: ReactiveMongoApi)
                         (implicit ec: ExecutionContext)
    extends Controller with MongoController with ReactiveMongoComponents{
  def create(placeData: PlaceData, picture: FilePart[TemporaryFile]): Future[WriteResult] = {
    placesCollection.flatMap(_.insert(Place(placeData.name, placeData.country, placeData.description,
      Files.toByteArray(picture.ref.file))))
  }

  def all(): Future[List[Place]] = placesCollection.flatMap(_.find(Json.obj())
        .cursor[Place](ReadPreference.primaryPreferred).collect[List](Int.MaxValue, Cursor.FailOnError[List[Place]]()))

  def placesCollection: Future[JSONCollection] = database.map(_.collection[JSONCollection]("places"))
}


object PlaceDAO {
  val createPlaceForm = Form(
    mapping(
      "name" -> nonEmptyText,
      "country" -> nonEmptyText,
      "description" -> nonEmptyText
    )(PlaceData.apply)(PlaceData.unapply)
  )
}

开发者ID:test410，项目名称:picture-gallery，代码行数:45，代码来源:PlaceDAO.scala

示例19: WebSocketController

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

import javax.inject.Singleton

import actors.{ActorManager, WebSocketActor}
import akka.actor.{ActorSystem, Props}
import akka.stream.Materializer
import com.google.inject.Inject
import play.api.Configuration
import play.api.libs.json.JsValue
import play.api.libs.streams.ActorFlow
import play.api.mvc.{Action, Controller, WebSocket}
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}

import scala.concurrent.ExecutionContext


@Singleton
class WebSocketController @Inject() (val reactiveMongoApi: ReactiveMongoApi)
                                    (implicit executionContext: ExecutionContext,
                                     configuration: Configuration,
                                     system: ActorSystem,
                                     materializer: Materializer)
  extends Controller with MongoController with ReactiveMongoComponents  {

  lazy final val actorManager = system.actorOf(Props[ActorManager],"actor-manager")

  def socket = WebSocket.accept[JsValue,JsValue] { request =>
    //request.session.get(Id).map { id =>
      ActorFlow.actorRef(out => WebSocketActor.props(actorManager,out,"10"))
    //}.getOrElse(throw new Exception("connection error"))
  }

  def index = Action { implicit request =>
    Ok(views.html.websocket("test"))
  }

}

开发者ID:tictactoki，项目名称:Immutaskable，代码行数:39，代码来源:WebSocketController.scala

示例20: Widgets

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


import javax.inject.Inject

import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.json.Json
import play.api.mvc._
import play.modules.reactivemongo.{MongoController, ReactiveMongoApi, ReactiveMongoComponents}
import reactivemongo.api.commands.WriteResult
import reactivemongo.bson.{BSONObjectID, BSONDocument}
import repos.WidgetRepoImpl


class Widgets @Inject()(val reactiveMongoApi: ReactiveMongoApi) extends Controller
with MongoController with ReactiveMongoComponents {

  import controllers.WidgetFields._

  def widgetRepo = new WidgetRepoImpl(reactiveMongoApi)

  def index = Action.async { implicit request =>
    widgetRepo.find().map(widgets => Ok(Json.toJson(widgets)))
  }

  def create = Action.async(BodyParsers.parse.json) { implicit request =>
    val name = (request.body \ Name).as[String]
    val description = (request.body \ Description).as[String]
    val author = (request.body \ Author).as[String]
    widgetRepo.save(BSONDocument(
      Name -> name,
      Description -> description,
      Author -> author
    )).map(result => Created)
  }

  def read(id: String) = Action.async { implicit request =>
    widgetRepo.select(BSONDocument(Id -> BSONObjectID(id))).map(widget => Ok(Json.toJson(widget)))
  }

  def update(id: String) = Action.async(BodyParsers.parse.json) { implicit request =>
    val name = (request.body \ Name).as[String]
    val description = (request.body \ Description).as[String]
    val author = (request.body \ Author).as[String]
    widgetRepo.update(BSONDocument(Id -> BSONObjectID(id)),
    BSONDocument("$set" -> BSONDocument(Name -> name, Description -> description, Author -> author)))
    .map(result => Accepted)
  }

  def delete(id: String) = Action.async {
    widgetRepo.remove(BSONDocument(Id -> BSONObjectID(id)))
    .map(result => Accepted)
  }
}

object WidgetFields {
  val Id = "_id"
  val Name = "name"
  val Description = "description"
  val Author = "author"
}

开发者ID:dougbeasley，项目名称:my-play-app，代码行数:62，代码来源:Widgets.scala

注：本文中的play.modules.reactivemongo.ReactiveMongoComponents类示例整理自Github/MSDocs等源码及文档管理平台，相关代码片段筛选自各路编程大神贡献的开源项目，源码版权归原作者所有，传播和使用请参考对应项目的License；未经允许，请勿转载。

鲜花

握手

雷人

路过

鸡蛋

该文章已有0人参与评论

请发表评论

全部评论

专题导读

More+

10-27 六六分期app的软件客服如何联系？(六六分期

11-06 可心卡盟:win10系统火狐flash插件崩溃怎么

11-06 亲亲特价:怎么删除回收站图标

11-06 济南大学虚拟社区:鲁大师节能降温的具体办

11-06 xlueops.exe:无线网络安装向导

11-06 女斗合众国:win7系统cf与主机连接不稳定怎

11-06 0xc000022-[cf烟雾头]cf怎么调烟雾头

11-06 qizideyouhuo:应用程序无法正常启动0xc0000

11-06 ipz-185:win7系统vcf文件怎么打开

11-06 傻哥蹦迪:win10系统s4怎么打开usb调试

11-06 八神浩树gtaste:回收站清空了怎么恢复

11-06 妖尾之黑色守护:win10系统电脑没有1440x900

11-06 校园至尊魔王小说:win7系统浏览网页时字体

11-06 女斗合众国:win10系统访问共享文件夹提示请

11-06 tokyo hot n0654:恢复win7系统默认字体一招

11-06 雨酷仙境:设置win7系统转移临时文件夹腾出

11-06 阿穆纳伊之杖:win7系统开始菜单在右边还原

11-06 tunespotting:win10系统火狐flash插件总是

11-06 甘尔葛分析师：计谋网站seo关键词暴涨有什

11-06 蔡贵霖: 计谋网站seo关键词暴涨有什么秘密

11-06 博益网首页:ao3网页版进入不了解决方法

11-06 漏斗子专栏: 网站数据分析小白易懂精华篇

11-06 见证双虹怎么做:win7系统开启telnet命令的

11-06 颾狐蝶蜋:系统资源不足无法完成请求的服务

11-06 国光中学校歌:提交网站到alexa查询详细步骤

11-06 西安有情天:静态网页和动态网页的区别

11-06 红木雅尚斋:外部链接构造对网站的好处

11-06 前官礼遇：防止域名劫持–增强域安全性的10

11-06 密传二转答案: 中文分词算法有哪些

11-06 金泉家园邮编:百度快照劫持的表现及应对方

Scala Invalid类代码示例发布时间：2022-05-23

Scala PasswordInfo类代码示例发布时间：2022-05-23

剪的笔顺,诠释剪的笔画,认识剪的部首

1 六六分期app的软件客服如何联系？(六六分期

六六分期app的软件客服如何联系？不知道吗？加qq群【895510560】即可！标题：六六分期

阅读：17909|2023-10-27

2 可心卡盟:win10系统火狐flash插件崩溃怎么

今天小编告诉大家如何处理win10系统火狐flash插件总是崩溃的问题，可能很多用户都不知

阅读：9548|2022-11-06

3 亲亲特价:怎么删除回收站图标

今天小编告诉大家如何对win10系统删除桌面回收站图标进行设置，可能很多用户都不知道

阅读：8116|2022-11-06

4 济南大学虚拟社区:鲁大师节能降温的具体办

今天小编告诉大家如何对win10系统电脑设置节能降温的设置方法，想必大家都遇到过需要

阅读：8495|2022-11-06

5 xlueops.exe:无线网络安装向导

我们在使用xp系统的过程中,经常需要对xp系统无线网络安装向导设置进行设置，可能很多

阅读：8401|2022-11-06

6 女斗合众国:win7系统cf与主机连接不稳定怎

今天小编告诉大家如何处理win7系统玩cf老是与主机连接不稳定的问题，可能很多用户都不

阅读：9286|2022-11-06

7 0xc000022-[cf烟雾头]cf怎么调烟雾头

电脑对日常生活的重要性小编就不多说了，可是一旦碰到win7系统设置cf烟雾头的问题，很

阅读：8365|2022-11-06

8 qizideyouhuo:应用程序无法正常启动0xc0000

我们在日常使用电脑的时候，有的小伙伴们可能在打开应用的时候会遇见提示应用程序无法

阅读：7793|2022-11-06

9 ipz-185:win7系统vcf文件怎么打开

今天小编告诉大家如何对win7系统打开vcf文件进行设置，可能很多用户都不知道怎么对win

阅读：8346|2022-11-06

10 傻哥蹦迪:win10系统s4怎么打开usb调试

今天小编告诉大家如何对win10系统s4开启USB调试模式进行设置，可能很多用户都不知道怎

阅读：7352|2022-11-06

客服电话

电子邮件

Scala ReactiveMongoComponents类代码示例

示例1: MyApplicationLoader

示例2: Users

示例3: Application

示例4: Application

示例5: MasterActor

示例6: Application

示例7: AuthController

示例8: PubmedController

示例9: TranslatorController

示例10: UserController

示例11: BalanceInfoController

示例12: TweetController

示例13: UserController

示例14: MemoController

示例15: Application

示例16: Widgets

示例17: Application

示例18: PlaceDAO

示例19: WebSocketController

示例20: Widgets

请发表评论

全部评论

上一篇：

下一篇：

微信小程序开发三：js文件中的内置函数的生

GaloyMoney/galoy-mobile

swcarpentry/matlab-novice-inflammation:

美国三一学院字怎么样？专业特色有哪些？

Twzy/MarkWord: a markdown editer

剪的笔顺,诠释剪的笔画,认识剪的部首

六六分期app的软件客服如何联系？(六六分期

florent37/ViewAnimator: A fluent Android

florent37/Shrine-MaterialDesign2: implem

CVE-2020-36276

SimpleSoftwareIO/simple-sms: Send and re

关于我们

产品与服务

解决方案

139-2527-9053