rewrite team DB code

modules/game/src/main/GameRepo.scala

@@ -5,8 +5,8 @@ import scala.util.Random
 import chess.format.Forsyth
 import chess.{ Color, Status }
 import org.joda.time.DateTime
-import reactivemongo.bson.BSONBinary
 import reactivemongo.api.ReadPreference
+import reactivemongo.bson.BSONBinary
 
 import lila.db.BSON.BSONJodaDateTimeHandler
 import lila.db.ByteArray
@@ -81,9 +81,17 @@ object GameRepo {
  .cursor[Game]()
  .collect[List](nb)
 
- def cursor(selector: Bdoc, readPreference: ReadPreference = ReadPreference.secondaryPreferred) =
+ def cursor(
+ selector: Bdoc,
+ readPreference: ReadPreference = ReadPreference.secondaryPreferred) =
  coll.find(selector).cursor[Game](readPreference)
 
+ def sortedCursor(
+ selector: Bdoc,
+ sort: Bdoc,
+ readPreference: ReadPreference = ReadPreference.secondaryPreferred) =
+ coll.find(selector).sort(sort).cursor[Game](readPreference)
+
  def unrate(gameId: String) =
  coll.update($id(gameId), $doc("$unset" -> $doc(
  F.rated -> true,

modules/gameSearch/src/main/GameSearchApi.scala

@@ -7,6 +7,7 @@ import play.api.libs.json._
 import scala.util.{ Try, Success, Failure }
 
 import lila.common.PimpedJson._
+import lila.db.dsl._
 import lila.game.actorApi._
 import lila.game.{ Game, GameRepo }
 import lila.search._
@@ -17,9 +18,7 @@ final class GameSearchApi(client: ESClient) extends SearchReadApi[Game, Query] {
 
  def search(query: Query, from: From, size: Size) =
  client.search(query, from, size) flatMap { res =>
- import lila.db.dsl.$find
- import lila.game.tube.gameTube
- $find.byOrderedIds[lila.game.Game](res.ids)
+ GameRepo games res.ids
  }
 
  def count(query: Query) =
@@ -106,10 +105,10 @@ final class GameSearchApi(client: ESClient) extends SearchReadApi[Game, Query] {
  val maxGames = Int.MaxValue
  // val maxGames = 10 * 1000 * 1000
 
- lila.game.tube.gameTube.coll.find(BSONDocument(
- "ca" -> BSONDocument("$gt" -> since)
- )).sort(BSONDocument("ca" -> 1))
- .cursor[Game](ReadPreference.secondaryPreferred)
+ GameRepo.sortedCursor(
+ selector = $doc("ca" $gt since),
+  sort = $doc("ca" -> 1),
+ readPreference = ReadPreference.secondaryPreferred)
  .enumerate(maxGames, stopOnError = true) &>
  Enumeratee.grouped(Iteratee takeUpTo batchSize) |>>>
  Enumeratee.mapM[Seq[Game]].apply[(Seq[Game], Set[String])] { games =>

modules/qa/src/main/QaApi.scala

@@ -8,9 +8,8 @@ import org.joda.time.DateTime
 import spray.caching.{ LruCache, Cache }
 
 import lila.common.paginator._
-import lila.db.BSON._
 import lila.db.paginator._
-import lila.db.Types.Coll
+import lila.db.dsl._
 import lila.user.{ User, UserRepo }
 
 final class QaApi(
@@ -75,7 +74,7 @@ final class QaApi(
 
  private def paginator(selector: BSONDocument, sort: BSONDocument, page: Int, perPage: Int): Fu[Paginator[Question]] =
  Paginator(
- adapter = new BSONAdapter[Question](
+ adapter = new Adapter[Question](
  collection = questionColl,
  selector = selector,
  projection = BSONDocument(),

modules/qa/src/main/Search.scala

@@ -3,8 +3,7 @@ package lila.qa
 import reactivemongo.bson._
 import reactivemongo.core.commands._
 
-import lila.db.BSON.BSONJodaDateTimeHandler
-import lila.db.Types.Coll
+import lila.db.dsl._
 
 final class Search(collection: Coll) {
 

modules/team/src/main/BSONHandlers.scala

@@ -0,0 +1,9 @@
+package lila.team
+
+private object BSONHandlers {
+
+ import lila.db.dsl.BSONJodaDateTimeHandler
+ implicit val TeamBSONHandler = reactivemongo.bson.Macros.handler[Team]
+ implicit val RequestBSONHandler = reactivemongo.bson.Macros.handler[Request]
+ implicit val MemberBSONHandler = reactivemongo.bson.Macros.handler[Member]
+}

modules/team/src/main/Cli.scala

@@ -1,10 +1,11 @@
 package lila.team
 
-import lila.db.dsl.$find
+import lila.db.dsl._
 import lila.user.{ User, UserRepo }
-import tube.teamTube
 
-private[team] final class Cli(api: TeamApi) extends lila.common.Cli {
+private[team] final class Cli(api: TeamApi, coll: Colls) extends lila.common.Cli {
+
+ import BSONHandlers._
 
  def process = {
 
@@ -21,12 +22,12 @@ private[team] final class Cli(api: TeamApi) extends lila.common.Cli {
  }
 
  private def perform(teamId: String)(op: Team => Funit): Fu[String] =
- $find byId teamId flatMap {
+ coll.team.byId[Team](teamId) flatMap {
  _.fold(fufail[String]("Team not found")) { u => op(u) inject "Success" }
  }
 
  private def perform(teamId: String, userIds: List[String])(op: (Team, String) => Funit): Fu[String] =
- $find byId teamId flatMap {
+ coll.team.byId[Team](teamId) flatMap {
  _.fold(fufail[String]("Team not found")) { team =>
  UserRepo nameds userIds flatMap { users =>
  users.map(user => {

modules/team/src/main/Colls.scala

@@ -0,0 +1,8 @@
+package lila.team
+
+import lila.db.dsl.Coll
+
+private final class Colls(
+ val team: Coll,
+ val request: Coll,
+ val member: Coll)

modules/team/src/main/DataForm.scala

@@ -4,10 +4,11 @@ import play.api.data._
 import play.api.data.Forms._
 import play.api.data.validation.Constraints._
 
-import lila.db.dsl.{ $count, $select }
-import tube.teamTube
+import lila.db.dsl._
 
-private[team] final class DataForm(val captcher: akka.actor.ActorSelection) extends lila.hub.CaptchedForm {
+private[team] final class DataForm(
+ teamColl: Coll,
+ val captcher: akka.actor.ActorSelection) extends lila.hub.CaptchedForm {
 
  import lila.common.Form._
 
@@ -61,7 +62,7 @@ private[team] final class DataForm(val captcher: akka.actor.ActorSelection) exte
  def createWithCaptcha = withCaptcha(create)
 
  private def teamExists(setup: TeamSetup) =
- $count.exists[Team]($select(Team nameToId setup.trim.name))
+ teamColl.exists($id(Team nameToId setup.trim.name))
 }
 
 private[team] case class TeamSetup(

modules/team/src/main/Env.scala

@@ -16,27 +16,30 @@ final class Env(config: Config, hub: lila.hub.Env, db: lila.db.Env) {
  }
  import settings._
 
- lazy val forms = new DataForm(hub.actor.captcher)
+ private[team] lazy val colls = new Colls(
+ team = db(CollectionTeam),
+ request = db(CollectionRequest),
+ member = db(CollectionMember))
+
+ lazy val forms = new DataForm(colls.team, hub.actor.captcher)
 
  lazy val api = new TeamApi(
+ coll = colls,
  cached = cached,
  notifier = notifier,
  forum = hub.actor.forum,
  indexer = hub.actor.teamSearch,
  timeline = hub.actor.timeline)
 
  lazy val paginator = new PaginatorBuilder(
+ coll = colls,
  maxPerPage = PaginatorMaxPerPage,
  maxUserPerPage = PaginatorMaxUserPerPage)
 
- lazy val cli = new Cli(api)
+ lazy val cli = new Cli(api, colls)
 
  lazy val cached = new Cached
 
- private[team] lazy val teamColl = db(CollectionTeam)
- private[team] lazy val requestColl = db(CollectionRequest)
- private[team] lazy val memberColl = db(CollectionMember)
-
  private lazy val notifier = new Notifier(
  sender = NotifierSender,
  messenger = hub.actor.messenger,

modules/team/src/main/Member.scala

@@ -5,32 +5,26 @@ import org.joda.time.DateTime
 import lila.user.User
 
 private[team] case class Member(
- id: String, 
+ _id: String,
  team: String,
  user: String,
  date: DateTime) {
 
  def is(userId: String): Boolean = user == userId
  def is(user: User): Boolean = is(user.id)
+
+ def id = _id
 }
 
 private[team] object Member {
 
  def makeId(team: String, user: String) = user + "@" + team
 
  def make(team: String, user: String): Member = new Member(
- id = makeId(team, user),
- user = user, 
- team = team, 
+ _id = makeId(team, user),
+ user = user,
+ team = team,
  date = DateTime.now)
-
- import lila.db.JsTube, JsTube.Helpers._
- import play.api.libs.json._
-
- private[team] lazy val tube = JsTube(
- (__.json update readDate('date)) andThen Json.reads[Member],
- Json.writes[Member] andThen (__.json update writeDate('date))
- ) 
 }
 
 case class MemberWithUser(member: Member, user: User) {

modules/team/src/main/MemberRepo.scala

@@ -1,41 +1,44 @@
 package lila.team
 
-import play.api.libs.json.Json
 import reactivemongo.api._
 import reactivemongo.bson._
 
 import lila.db.dsl._
-import tube.memberTube
 
 object MemberRepo {
 
+ // dirty
+ private val coll = Env.current.colls.member
+
+ import BSONHandlers._
+
  type ID = String
 
  def userIdsByTeam(teamId: ID): Fu[Set[ID]] =
- memberTube.coll.distinct("user", BSONDocument("team" -> teamId).some) map lila.db.BSON.asStringSet
+ coll.distinct("user", $doc("team" -> teamId).some) map lila.db.BSON.asStringSet
 
  def teamIdsByUser(userId: ID): Fu[Set[ID]] =
- memberTube.coll.distinct("team", BSONDocument("user" -> userId).some) map lila.db.BSON.asStringSet
+ coll.distinct("team", $doc("user" -> userId).some) map lila.db.BSON.asStringSet
 
  def removeByteam(teamId: ID): Funit =
- $remove(teamQuery(teamId))
+ coll.remove(teamQuery(teamId)).void
 
  def removeByUser(userId: ID): Funit =
- $remove(userQuery(userId))
+ coll.remove(userQuery(userId)).void
 
  def exists(teamId: ID, userId: ID): Fu[Boolean] =
- $count.exists(selectId(teamId, userId))
+ coll.exists(selectId(teamId, userId))
 
  def add(teamId: String, userId: String): Funit =
- $insert(Member.make(team = teamId, user = userId))
+ coll.insert(Member.make(team = teamId, user = userId)).void
 
  def remove(teamId: String, userId: String): Funit =
- $remove(selectId(teamId, userId))
+ coll.remove(selectId(teamId, userId)).void
 
  def countByTeam(teamId: String): Fu[Int] =
- $count(teamQuery(teamId))
+ coll.countSel(teamQuery(teamId))
 
- def selectId(teamId: ID, userId: ID) = $select(Member.makeId(teamId, userId))
- def teamQuery(teamId: ID) = Json.obj("team" -> teamId)
- def userQuery(userId: ID) = Json.obj("user" -> userId)
+ def selectId(teamId: ID, userId: ID) = $id(Member.makeId(teamId, userId))
+ def teamQuery(teamId: ID) = $doc("team" -> teamId)
+ def userQuery(userId: ID) = $doc("user" -> userId)
 }

modules/team/src/main/PaginatorBuilder.scala

@@ -2,20 +2,22 @@ package lila.team
 
 import lila.common.paginator._
 import lila.db.dsl._
-import lila.db.Implicits._
 import lila.db.paginator._
-import lila.user.tube.userTube
-import lila.user.User
-import tube._
+import lila.user.{ User, UserRepo }
 
 private[team] final class PaginatorBuilder(
+ coll: Colls,
  maxPerPage: Int,
  maxUserPerPage: Int) {
 
+ import BSONHandlers._
+
  def popularTeams(page: Int): Fu[Paginator[Team]] = Paginator(
- adapter = new Adapter[Team](
+ adapter = new Adapter(
+ collection = coll.team,
  selector = TeamRepo.enabledQuery,
- sort = Seq(TeamRepo.sortPopular)),
+ projection = $empty,
+ sort = TeamRepo.sortPopular),
  page,
  maxPerPage)
 
@@ -29,8 +31,9 @@ private[team] final class PaginatorBuilder(
  val nbResults = fuccess(team.nbMembers)
 
  def slice(offset: Int, length: Int): Fu[Seq[MemberWithUser]] = for {
- members ← $find[Member]($query[Member](selector) sort sorting skip offset, length)
- users ← $find.byOrderedIds[User](members.map(_.user))
+ members ← coll.member.find(selector)
+ .sort(sorting).skip(offset).cursor[Member]().collect[List](length)
+ users ← UserRepo byOrderedIds members.map(_.user)
  } yield members zip users map {
  case (member, user) => MemberWithUser(member, user)
  }

modules/team/src/main/Request.scala

@@ -5,31 +5,25 @@ import org.joda.time.DateTime
 import lila.user.User
 
 case class Request(
- id: String,
+ _id: String,
  team: String,
  user: String,
  message: String,
  date: DateTime) {
+
+ def id = _id
 }
 
 object Request {
 
  def makeId(team: String, user: String) = user + "@" + team
 
  def make(team: String, user: String, message: String): Request = new Request(
- id = makeId(team, user),
+ _id = makeId(team, user),
  user = user,
  team = team,
  message = message.trim,
  date = DateTime.now)
-
- import lila.db.JsTube, JsTube.Helpers._
- import play.api.libs.json._
-
- private[team] lazy val tube = JsTube(
- (__.json update readDate('date)) andThen Json.reads[Request],
- Json.writes[Request] andThen (__.json update writeDate('date))
- ) 
 }
 
 case class RequestWithUser(request: Request, user: User) {