Scala Index类代码示例

//设置package包名称以及导入依赖的类
package io.soheila.um.daos.activities

import javax.inject.Inject

import io.soheila.commons.crud.MongoCRUDDAO
import io.soheila.commons.entities.Page
import io.soheila.commons.exceptions.MongoDAOException
import io.soheila.um.entities.UserActivity
import io.soheila.um.vos.activities.UserActivityQuery
import play.api.libs.json.{ JsObject, Json }
import play.modules.reactivemongo.ReactiveMongoApi
import reactivemongo.api.indexes.{ Index, IndexType }
import reactivemongo.play.json.collection.JSONCollection

import scala.concurrent.{ ExecutionContext, Future }


class MongoUserActivityDAO @Inject() (val reactiveMongoApi: ReactiveMongoApi)(implicit override val ec: ExecutionContext)
    extends MongoCRUDDAO[UserActivity, String] with UserActivityDAO {

  override def collection: Future[JSONCollection] = reactiveMongoApi.database.map(_.collection[JSONCollection]("user_activity"))

  override def find(userActivityQuery: UserActivityQuery, page: Int, limit: Int, sortFilter: Option[(String, Int)]): Future[Either[MongoDAOException, Page[UserActivity]]] = {
    Json.toJson(userActivityQuery)
    find(Json.toJson(userActivityQuery).as[JsObject], page, limit, sortFilter)
  }

  override def indexSet: Set[Index] = Set(
    Index(Seq("userUUID" -> IndexType.Ascending)),
    Index(Seq("activityType" -> IndexType.Ascending)),
    Index(Seq("userIP" -> IndexType.Ascending)),
    Index(Seq("userDevice" -> IndexType.Ascending)),
    Index(Seq("timestamp" -> IndexType.Ascending))
  )
} 

//设置package包名称以及导入依赖的类
package io.soheila.um.daos.accounts

import javax.inject.Inject

import com.mohiva.play.silhouette.api.LoginInfo
import io.soheila.um.entities.User
import io.soheila.um.exceptions.UMDAOException
import io.soheila.commons.crud.MongoCRUDDAO
import play.api.libs.json._
import play.modules.reactivemongo.ReactiveMongoApi
import play.modules.reactivemongo.json._
import reactivemongo.api.indexes.IndexType.Geo2DSpherical
import reactivemongo.api.indexes.{ Index, IndexType }
import reactivemongo.play.json.collection.JSONCollection

import scala.concurrent.{ ExecutionContext, Future }


class MongoUserDAO @Inject() (val reactiveMongoApi: ReactiveMongoApi)(implicit override val ec: ExecutionContext)
    extends MongoCRUDDAO[User, String] with UserDAO {

  override def collection: Future[JSONCollection] = reactiveMongoApi.database.map(_.collection[JSONCollection]("users"))

  def find(loginInfo: LoginInfo): Future[Option[User]] = {
    collection.flatMap(_.find(Json.obj("loginInfo" -> loginInfo)).one[User])
  }

  override def archive(uuid: String): Future[Either[UMDAOException, Boolean]] = {
    archive(uuid, archived = true)
  }

  override def restore(uuid: String): Future[Either[UMDAOException, Boolean]] = {
    archive(uuid, archived = false)
  }

  private def archive(uuid: String, archived: Boolean): Future[Either[UMDAOException, Boolean]] = {
    collection.flatMap(col => {
      val updateOp = col.updateModifier(Json.obj("$set" -> Json.obj("archived" -> archived)), fetchNewObject = true)

      col.findAndModify(Json.obj("uuid" -> uuid), updateOp) map {
        entity => Right(true)
      }
    }).recover {
      case err =>
        Left(UMDAOException(err.getMessage, err))
    }
  }

  override def indexSet: Set[Index] = Set(
    Index(Seq("uuid" -> IndexType.Ascending), unique = true),
    Index(Seq("email" -> IndexType.Ascending), unique = true),
    Index(Seq("roles" -> IndexType.Ascending)),
    Index(List("firstName" -> IndexType.Ascending, "lastName" -> IndexType.Ascending, "fullName" -> IndexType.Text)),
    Index(Seq("createdOn" -> IndexType.Descending, "updatedOn" -> IndexType.Descending)),
    Index(Seq(("coordinate", Geo2DSpherical)), Some("geo2DSphericalIdx")),
    Index(List("attributes.key" -> IndexType.Ascending, "attributes.value" -> IndexType.Ascending))
  )
} 

//设置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 com.clemble.loveit.common.mongo

import akka.stream.Materializer
import akka.stream.scaladsl.Source
import com.clemble.loveit.common.model.UserID
import com.clemble.loveit.user.model.UserAware
import com.clemble.loveit.user.service.repository.UserAwareRepository
import play.api.libs.json.{Format, Json}
import reactivemongo.akkastream.cursorProducer
import reactivemongo.api.ReadPreference
import reactivemongo.api.indexes.{Index, IndexType}
import reactivemongo.play.json._
import reactivemongo.play.json.collection.JSONCollection

import scala.concurrent.ExecutionContext

trait MongoUserAwareRepository[T <: UserAware] extends UserAwareRepository[T] {

  val collection: JSONCollection
  implicit val m: Materializer
  implicit val ec: ExecutionContext
  implicit val format: Format[T]

  MongoSafeUtils.ensureIndexes(
    collection,
    Index(
      key = Seq("user" -> IndexType.Ascending, "created" -> IndexType.Ascending),
      name = Some("user_created_asc")
    ),
    Index(
      key = Seq("user" -> IndexType.Ascending),
      name = Some("user_asc")
    )
  )

  override def findByUser(user: UserID): Source[T, _] = {
    collection.find(Json.obj("user" -> user)).sort(Json.obj("created" -> 1)).cursor[T](ReadPreference.nearest).documentSource()
  }


}