Scala Cursor类代码示例

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

import javax.inject._

import org.slf4j.LoggerFactory
import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.json.{JsObject, JsValue, Json}
import play.api.mvc._
import play.modules.reactivemongo._
import play.modules.reactivemongo.json._
import play.modules.reactivemongo.json.collection.{JSONCollection, _}
import reactivemongo.api.Cursor

import scala.concurrent.Future

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

  val logger = LoggerFactory.getLogger(this.getClass)

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

  def index = Action {
    Ok(views.html.index(""))
  }

  def query = Action.async { request =>
    val body = request.body
    val query = body.asFormUrlEncoded.get("query")

    val querySet = query.toSet[String]

    val keywords = querySet.flatMap({ string: String =>
      string.split(" ")
    })

    val searchQuery = Json.obj("keywords" -> Json.obj("$in" -> Json.toJson(keywords)))
    logger.info(s"Internal query from client: $searchQuery")
    val cursor: Cursor[JsObject] = collection.find(searchQuery).cursor[JsObject]

    val result: Future[List[JsObject]] = cursor.collect[List]()

    val resultJson: Future[JsValue] =
      result.map { persons => Json.toJson(persons) }

    resultJson.map { results =>
      val title = results \\ "title"
      val url = results \\ "url"
      val description = results \\ "body"
      val queryData: Seq[((JsValue, JsValue), JsValue)] = title.zip(url).zip(description)
      Ok(views.html.result(queryData))
    }
  }
} 

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

import reactivemongo.api.Cursor
import play.api.libs.json._
import scala.concurrent.{ExecutionContext, Future}
import reactivemongo.bson.BSONObjectID

object ReactiveMongoExtensions {

  implicit class ListExtensions[T](val futureList: Future[List[T]]) extends AnyVal {
    def toJsArray(implicit ec: ExecutionContext, writes: Writes[T]): Future[JsArray] = {
      futureList.map { futureList =>
        futureList.foldLeft(JsArray(List()))( (obj, item) => obj ++ Json.arr(item))
      }
    }
  }

  implicit class CursorExtensions[T](val cursor: Cursor[T]) extends AnyVal {
    def toJsArray(implicit ec: ExecutionContext, writes: Writes[T]): Future[JsArray] = {
      cursor.toList.toJsArray
    }
  }

  implicit class BSONObjectIdExtensions(val string: String) extends AnyVal {
    def toObjectID: BSONObjectID = BSONObjectID(string)
  }

} 

//设置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)
  }

} 

//设置package包名称以及导入依赖的类
package io.soheila.commons.geospatials

import grizzled.slf4j.Logger
import io.soheila.commons.crud.MongoCRUDDAO
import io.soheila.commons.entities.{ Locatable, Page }
import io.soheila.commons.exceptions.{ ErrorCode, MongoDAOException, MongoExceptionBuilder }
import play.api.libs.json.{ Json, Reads }
import play.modules.reactivemongo.json._
import reactivemongo.api.indexes.Index
import reactivemongo.api.indexes.IndexType.Geo2DSpherical
import reactivemongo.api.{ Cursor, ReadPreference }

import scala.concurrent.{ ExecutionContext, Future }

trait Geospatial[T <: Locatable, ID] {
  self: MongoCRUDDAO[T, ID] =>

  private val logger = Logger[this.type]

  lazy val LocationField = "coordinate"

  lazy val geo2DSphericalIndex = Index(Seq((LocationField, Geo2DSpherical)), Some("geo2DSphericalIdx"))

  
  def nearPoint(lon: Double, lat: Double, minDistance: Double = 1, maxDistance: Double = 10000, page: Int = 0, limit: Int = 100, readPreference: ReadPreference = ReadPreference.primaryPreferred)(implicit ec: ExecutionContext, reads: Reads[T]): Future[Either[MongoDAOException, Page[T]]] = {
    val offset = page * limit

    val totalCount = collection.flatMap(_.count())

    val searchResult = collection.flatMap(_.find(
      Json.obj(
        LocationField -> Json.toJson(Json.obj(
          "$geoNear" -> Json.toJson(Json.obj(
            "$geometry" -> Json.toJson(Json.obj(
              "type" -> "Point",
              "coordinates" -> Json.arr(lon, lat)
            )),
            "$maxDistance" -> Json.toJson(maxDistance),
            "$minDistance" -> Json.toJson(minDistance)
          ))
        ))
      )
    ).cursor[T](readPreference).collect[Seq](limit, Cursor.FailOnError((seq: Seq[T], err) => logger.error("Error finding locations.", err))))

    totalCount.zip(searchResult).map {
      case (total, entities) =>
        Right(Page(entities, page, offset, total))
    }.recover {
      case e => Left(MongoExceptionBuilder.buildException(e))
    }
  }

} 

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

import java.util.UUID
import javax.inject.{ Inject, Singleton }

import mikanMessages.InternalMsg
import play.api.Configuration
import play.api.libs.json.Json
import play.modules.reactivemongo.ReactiveMongoApi
import reactivemongo.api.{ Cursor, ReadPreference }
import reactivemongo.play.json._
import reactivemongo.play.json.collection.JSONCollection

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


@Singleton
class MsgDAOImpl @Inject() (playConf: Configuration, val reactiveMongoApi: ReactiveMongoApi) extends MsgDAO {

  private val msgCol: String = playConf.getString("mongo.collection.clientmsg").getOrElse("clientmsg")

  def collection: Future[JSONCollection] = reactiveMongoApi.database.map(_.collection(msgCol))

  def find(userID: UUID): Future[Option[InternalMsg]] =
    collection.flatMap(_.find(Json.obj("userID" -> userID)).one[InternalMsg])

  def save(msg: InternalMsg): Future[InternalMsg] = {
    collection.flatMap(_.insert(msg))
    Future.successful(msg)
  }
  // get all current msg filtered by topicList and userId
  // note: if userId="" all objects will be retrieved, otherwise
  // all msg BUT NOT those with the given userId
  def findAll(topicList: List[String], userID: UUID): Future[List[InternalMsg]] = {
    val qry = Json.obj("userID" -> Json.obj("$ne" -> userID), "topic" -> Json.obj("$in" -> topicList))
    for {
      colection <- collection
      theList <- colection.find(qry).
        cursor[InternalMsg](ReadPreference.nearest).
        collect[List](-1, Cursor.FailOnError[List[InternalMsg]]())
    } yield theList
  }

} 

//设置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)) }
  }

} 

//设置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))
    }
  }

} 

//设置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))
    }
  }

} 

//设置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)
  )
} 

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

import model.{OcrEntity, OcrTextOnly}
import reactivemongo.api.Cursor
import reactivemongo.api.collections.bson.BSONCollection
import reactivemongo.api.commands.WriteResult
import reactivemongo.bson.{BSONDocument, BSONRegex}

import scala.concurrent.Future

class OcrRepository extends MongoDao[OcrEntity] {

  lazy val collectionFuture: Future[BSONCollection] = dbFuture.map(db => db[BSONCollection]("ocr"))

  def save(ocrEntity: OcrEntity): Future[OcrEntity] = save(collectionFuture, ocrEntity)

  def deleteById(id: String): Future[WriteResult] = deleteById(collectionFuture, id)

  def findById(id: String): Future[Option[OcrEntity]] = find(collectionFuture, queryById(id))

  def findTextOnlyForUserId(userId: String, query: String): Future[List[OcrTextOnly]] =
    collectionFuture.flatMap(
      _.find(BSONDocument(
               "userId"      -> userId,
               "result.text" -> BSONRegex(query, "i")
             ),
             BSONDocument("result.text" -> 1))
        .cursor[OcrTextOnly]()
        .collect[List](-1, Cursor.FailOnError[List[OcrTextOnly]]()))
} 

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

import reactivemongo.api.{Cursor, DefaultDB}
import reactivemongo.api.collections.bson.BSONCollection
import reactivemongo.api.commands.UpdateWriteResult
import reactivemongo.api.commands.WriteConcern
import reactivemongo.bson.{BSONDocument, BSONDocumentReader, BSONDocumentWriter}

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

class DatabaseAccessor[T](db: DefaultDB, collectionName: String) {

  def getCollection: BSONCollection = db[BSONCollection](collectionName)

  def getItems(query: BSONDocument = BSONDocument(), sort: BSONDocument = BSONDocument(), maxItems: Int = -1)(implicit reader: BSONDocumentReader[T]): Future[List[T]] = {
    getCollection.find(query).sort(sort).cursor[T]().collect[List](maxDocs = maxItems, Cursor.DoneOnError[List[T]]())
  }

  def getItem(query: BSONDocument)(implicit reader: BSONDocumentReader[T]): Future[Option[T]] = {
    getCollection.find(query).one[T]
  }

  def upsertItem(selector: BSONDocument, item: T)(implicit writer: BSONDocumentWriter[T]): Future[UpdateWriteResult] = {
    getCollection.update(selector, item, WriteConcern.Acknowledged, upsert = true)
  }

  def updateItem(selector: BSONDocument, item: T)(implicit writer: BSONDocumentWriter[T]): Future[UpdateWriteResult] = {
    getCollection.update(selector, item, WriteConcern.Acknowledged, upsert = false)
  }
} 

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

import scala.annotation.implicitNotFound
import scala.concurrent.Await
import scala.concurrent.ExecutionContext
import scala.concurrent.Future
import scala.concurrent.duration.Duration

import FileDAO.JSONReadFile
import javax.inject.Inject
import play.api.libs.json.JsObject
import play.api.libs.json.JsString
import play.api.libs.json.Json
import play.api.libs.json.Json.toJsFieldJsValueWrapper
import play.modules.reactivemongo.MongoController.readFileReads
import play.modules.reactivemongo.ReactiveMongoApi
import play.modules.reactivemongo.ReactiveMongoComponents
import reactivemongo.api.Cursor
import reactivemongo.api.gridfs.GridFS
import reactivemongo.play.json._
import play.api.libs.iteratee.Enumerator
import play.modules.reactivemongo.JSONFileToSave
import reactivemongo.api.gridfs.ReadFile
import play.api.Logger
import reactivemongo.api.commands.WriteResult
import models.AmlFiles
import reactivemongo.play.json.collection.JSONCollection


class FileDAOImpl @Inject() (val reactiveMongoApi: ReactiveMongoApi)(implicit exec: ExecutionContext) 
  extends FileDAO with ReactiveMongoComponents {
      
  private val asyncGridFS = reactiveMongoApi.asyncGridFS
  
  private def syncGridFS = Await.result(asyncGridFS, Duration("5s"))

  override def remove(uuid: String): Future[Boolean] = 
    asyncGridFS.flatMap(_.remove(JsString(uuid)).map { wr => wr.n == 1 })
        
  override def findByQuery(query: JsObject): Future[Cursor[JSONReadFile]] =
    asyncGridFS.map(_.find[JsObject, JSONReadFile](query))
    
  override def find(uuid: String): Future[Cursor[JSONReadFile]] = 
    asyncGridFS.map(_.find[JsObject, JSONReadFile](Json.obj("_id" -> JsString(uuid))))
    
  override def updateMetadata(fileUuid:String, metadata: JsObject): Future[Boolean] = 
    asyncGridFS.flatMap(_.files.update(Json.obj("_id" -> JsString(fileUuid)), 
        Json.obj("$set" -> Json.obj(AmlFiles.KeyMetadata -> metadata))).map(ur => ur.ok))
               
    
  override def save(enumerator: Enumerator[Array[Byte]], fileToSave: JSONFileToSave): Future[JSONReadFile] = {
    asyncGridFS.flatMap(_.save(enumerator, fileToSave))
  }
    
  override def withAsyncGfs[T](func: (GridFS[JSONSerializationPack.type] => Future[T])): Future[T] = asyncGridFS.flatMap(func(_))
  
  override def withSyncGfs[T](func: (GridFS[JSONSerializationPack.type] => T)): T = func(syncGridFS)
} 

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

import models.daos.FileDAO
import models.daos.FileDAO.JSONReadFile
import javax.inject.Inject
import scala.concurrent.Future
import scala.concurrent.ExecutionContext
import reactivemongo.api.Cursor
import reactivemongo.api.gridfs.GridFS
import play.api.mvc.Result
import reactivemongo.play.json.JSONSerializationPack
import play.modules.reactivemongo.JSONFileToSave
import play.api.libs.json.JsObject
import utils.RemoveResult
import play.api.libs.iteratee._

class FileServiceImpl @Inject() (override val dao: FileDAO)(implicit val ec: ExecutionContext) extends FileService {

  override def remove(uuid: String): Future[RemoveResult] =
    dao.remove(uuid).map(success => if (success) {
      RemoveResult(true, None)
    } else {
      RemoveResult(false, Some("DAO refused to remove file: " + uuid))
    })

  override def findByQuery(query: JsObject): Future[Cursor[JSONReadFile]] = dao.findByQuery(query)

  override def find(uuid: String): Future[Cursor[JSONReadFile]] = dao.find(uuid)

  override def save(enumerator: Enumerator[Array[Byte]], fileToSave: JSONFileToSave): Future[JSONReadFile] = dao.save(enumerator, fileToSave)

  override def updateMetadata(fileUuid: String, metadata: JsObject): Future[Boolean] = dao.updateMetadata(fileUuid, metadata)

  override def withAsyncGfs[T](func: (GridFS[JSONSerializationPack.type] => Future[T])): Future[T] = dao.withAsyncGfs(func)

  override def withSyncGfs[T](func: (GridFS[JSONSerializationPack.type] => T)): T = dao.withSyncGfs(func)

  override def imageExists(uuid: String): Future[Boolean] = dao.findByQuery(models.Images.getQueryAllImages(uuid)).
    flatMap { cursor => cursor.headOption }.flatMap { opt =>
      opt.map(file => Future.successful(true)).
        getOrElse(Future.successful(false))
    }

  def videoExists(uuid: String): Future[Boolean] = dao.findByQuery(models.Videos.getQueryAllVideos(uuid)).
    flatMap { cursor => cursor.headOption }.flatMap { opt =>
      opt.map(file => Future.successful(true)).
        getOrElse(Future.successful(false))
    }
    
  def amlFiles(uuid: String): Future[List[JSONReadFile]] = {
    dao.findByQuery(models.AmlFiles.getQueryAllAmlFiles(uuid)).flatMap { c => c.toList(100, true) }
  }
} 

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

import com.google.inject.Singleton
import play.api.inject.Injector
import play.modules.reactivemongo.ReactiveMongoComponents
import reactivemongo.api.ReadPreference
import reactivemongo.play.json.collection.JSONCollection

import scala.util.parsing.json.JSONArray
import scala.util.{Failure, Success, Try}

// Reactive Mongo imports
import javax.inject.Inject

import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.json._

import scala.concurrent.Future

// Reactive Mongo imports
import play.modules.reactivemongo.ReactiveMongoApi
import reactivemongo.api.Cursor

// BSON-JSON conversions/collection
import reactivemongo.play.json._

class Category @Inject()(implicit val reactiveMongoApi: ReactiveMongoApi) extends MechanicCollection {

  private def collection: Future[JSONCollection] = {
    reactiveMongoApi.database.map(_.collection[JSONCollection]("categories"))
  }

  def getAll: Future[JsArray] = {
    collection flatMap { c: JSONCollection =>
      val cursor: Cursor[JsObject] = c.find(Json.obj()).cursor[JsObject](ReadPreference.primary)
      val list = cursor.collect[List]()
      list map { l => Json.arr(l) }
    }
  }

  
} 

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

import reactivemongo.api.ReadPreference
import reactivemongo.play.json.collection.JSONCollection

// Reactive Mongo imports
import javax.inject.Inject

import play.api.libs.concurrent.Execution.Implicits.defaultContext
import play.api.libs.json._

import scala.concurrent.Future

// Reactive Mongo imports
import play.modules.reactivemongo.ReactiveMongoApi
import reactivemongo.api.Cursor

// BSON-JSON conversions/collection
import reactivemongo.play.json._

class Brand @Inject()(implicit val reactiveMongoApi: ReactiveMongoApi) extends MechanicCollection {

  private def collection: Future[JSONCollection] = {
    reactiveMongoApi.database.map(_.collection[JSONCollection]("brands"))
  }

  def getAll: Future[JsArray] = {
    collection flatMap { c: JSONCollection =>
      val cursor: Cursor[JsObject] = c.find(Json.obj()).cursor[JsObject](ReadPreference.primary)
      val list = cursor.collect[List]()
      list map { l => Json.arr(l) }
    }
  }

}