MongoIndex add properties

Author: sfxcode

src/main/scala/com/sfxcode/nosql/mongo/database/CollectionInfo.scala

@@ -3,19 +3,20 @@ package com.sfxcode.nosql.mongo.database
 import java.util.Date
 
 import org.mongodb.scala.bson.Document
+import com.sfxcode.nosql.mongo._
 
 case class CollectionInfo(
     name: String,
     collectionType: String,
     fetched: Date,
-    document: Document
+    map: Map[String, Any]
 )
 
 object CollectionInfo {
 
   def apply(document: Document): CollectionInfo = {
     val name           = document.getString("name")
     val collectionType = document.getString("type")
-    CollectionInfo(name, collectionType, new Date(), document)
+    CollectionInfo(name, collectionType, new Date(), document.asPlainMap)
   }
 }

src/main/scala/com/sfxcode/nosql/mongo/database/CollectionStatus.scala

@@ -4,6 +4,7 @@ import java.util.Date
 
 import com.sfxcode.nosql.mongo._
 import org.mongodb.scala.bson.Document
+import com.sfxcode.nosql.mongo._
 
 case class CollectionStatus(
     ns: String,
@@ -18,7 +19,7 @@ case class CollectionStatus(
     totalIndexSize: Int,
     ok: Int,
     fetched: Date,
-    document: Document
+    map: Map[String, Any]
 )
 
 object CollectionStatus {
@@ -37,7 +38,7 @@ object CollectionStatus {
       map.getOrElse("totalIndexSize", 0).asInstanceOf[Int],
       map.getOrElse("ok", 0).asInstanceOf[Double].toInt,
       new Date(),
-      document
+      map
     )
   }
 }

src/main/scala/com/sfxcode/nosql/mongo/database/DatabaseInfo.scala

@@ -1,18 +1,19 @@
 package com.sfxcode.nosql.mongo.database
 
 import java.util.Date
+import com.sfxcode.nosql.mongo._
 
 import org.mongodb.scala.bson.Document
 
-case class DatabaseInfo(name: String, sizeOnDisk: Double, empty: Boolean, fetched: Date, document: Document)
+case class DatabaseInfo(name: String, sizeOnDisk: Double, empty: Boolean, fetched: Date, map: Map[String, Any])
 
 object DatabaseInfo {
 
   def apply(document: Document): DatabaseInfo = {
     val name       = document.getString("name")
     val sizeOnDisk = document.getDouble("sizeOnDisk")
     val empty      = document.getBoolean("empty")
-    DatabaseInfo(name, sizeOnDisk, empty, new Date(), document)
+    DatabaseInfo(name, sizeOnDisk, empty, new Date(), document.asPlainMap)
 
   }
 }

src/main/scala/com/sfxcode/nosql/mongo/database/MongoIndex.scala

@@ -1,19 +1,24 @@
 package com.sfxcode.nosql.mongo.database
 
+import java.util.Date
+
 import com.sfxcode.nosql.mongo.operation.ObservableIncludes
 import org.mongodb.scala.ListIndexesObservable
 import org.mongodb.scala.model.IndexOptions
 
 case class MongoIndex(
     name: String,
-    key: String,
-    ascending: Int,
+    fields: List[String],
+    unique: Boolean,
     version: Int,
     namespace: String,
-    keys: Map[String, Any] = Map(),
+    keys: Map[String, Any],
+    weights: Map[String, Any],
     expire: Boolean,
-    expireAfterSeconds: Long = -1,
-    text: Boolean
+    expireAfterSeconds: Long,
+    text: Boolean,
+    fetched: Date,
+    map: Map[String, Any]
 )
 
 object MongoIndex extends ObservableIncludes {
@@ -31,48 +36,38 @@ object MongoIndex extends ObservableIncludes {
       fieldName: String,
       maxWait: Int = DefaultMaxWait
   ): Boolean =
-    convertIndexDocumentsToMongoIndexList(listIndexesObservable, maxWait).exists(index => index.key == fieldName)
+    convertIndexDocumentsToMongoIndexList(listIndexesObservable, maxWait).exists(index =>
+      index.fields.contains(fieldName)
+    )
 
   def convertIndexDocumentsToMongoIndexList(
       listIndexesObservable: ListIndexesObservable[Map[String, Any]],
       maxWait: Int = DefaultMaxWait
   ): List[MongoIndex] = {
     var result = List[MongoIndex]()
-    try {
-      result = listIndexesObservable
-        .resultList(maxWait)
-        .map(indexOptions =>
-          MongoIndex(
-            indexOptions("name").toString, {
-              if (indexOptions.contains("textIndexVersion")) {
-                indexOptions("name").toString.substring(0, indexOptions("name").toString.indexOf("_"))
-              }
-              else {
-                indexOptions("key").asInstanceOf[Map[String, _]].head.asInstanceOf[(String, Int)]._1
-              }
-            }, {
-              if (indexOptions.contains("textIndexVersion")) {
-                indexOptions("textIndexVersion").toString.toInt
-              }
-              else {
-                val value = indexOptions("key").asInstanceOf[Map[String, _]].head._2.toString
-                if (value.matches("[0-9]")) {
-                  value.toInt
-                }
-                else {
-                  0
-                }
-              }
-            },
-            indexOptions("v").toString.toInt,
-            indexOptions("ns").toString,
-            indexOptions("key").asInstanceOf[Map[String, _]],
-            indexOptions.get("expireAfterSeconds").isDefined,
-            indexOptions.getOrElse("expireAfterSeconds", -1).toString.toLong,
-            indexOptions.contains("textIndexVersion")
-          )
+    try result = listIndexesObservable
+      .resultList(maxWait)
+      .map(indexOptions =>
+        MongoIndex(
+          indexOptions("name").toString,
+          if (indexOptions.contains("textIndexVersion")) {
+            indexOptions.getOrElse("weights", Map()).asInstanceOf[Map[String, _]].keys.toList
+          }
+          else {
+            indexOptions.getOrElse("key", Map).asInstanceOf[Map[String, _]].keys.toList
+          },
+          indexOptions.getOrElse("unique", false).asInstanceOf[Boolean],
+          indexOptions.getOrElse("v", -1).asInstanceOf[Int],
+          indexOptions.getOrElse("ns", "").toString,
+          indexOptions.getOrElse("key", Map).asInstanceOf[Map[String, _]],
+          indexOptions.getOrElse("weights", Map()).asInstanceOf[Map[String, _]],
+          indexOptions.contains("expireAfterSeconds"),
+          indexOptions.getOrElse("expireAfterSeconds", -1).toString.toLong,
+          indexOptions.contains("textIndexVersion"),
+          new Date(),
+          indexOptions
         )
-    }
+      )
     result
   }
 

src/main/scala/com/sfxcode/nosql/mongo/operation/Base.scala

@@ -78,6 +78,6 @@ abstract class Base[A]()(implicit ct: ClassTag[A]) extends LazyLogging {
 
   def indexForName(name: String): Option[MongoIndex] = indexList.find(_.name.equals(name))
 
-  def hasIndexForField(fieldName: String): Boolean = indexList().exists(index => index.key.equals(fieldName))
+  def hasIndexForField(fieldName: String): Boolean = indexList().exists(index => index.fields.contains(fieldName))
 
 }

src/test/scala/com/sfxcode/nosql/mongo/operation/IndexSpec.scala

@@ -20,8 +20,7 @@ class IndexSpec extends PersonSpecification {
 
       val mongoIndex: MongoIndex = list.head
       mongoIndex.name mustEqual "_id_"
-      mongoIndex.key mustEqual "_id"
-      mongoIndex.ascending mustEqual 1
+      mongoIndex.fields must contain("_id")
       mongoIndex.namespace mustEqual "simple-mongo-unit-test.people"
       mongoIndex.version mustEqual 2
       mongoIndex.keys must haveSize(1)
@@ -117,8 +116,8 @@ class IndexSpec extends PersonSpecification {
 
       PersonDAO.indexList must haveSize(2)
 
-      val indes: MongoIndex = PersonDAO.indexForName("email_1").get
-      indes.expire must beTrue
+      val index: MongoIndex = PersonDAO.indexForName("email_1").get
+      index.expire must beTrue
 
       PersonDAO.dropIndexForName(createIndexResult).result()