* Support for Dot notation in documents

* extend Document functions with getValue. updateValue, getIntValue ... (with dot support)

Author: sfxcode

CHANGES.md

@@ -2,6 +2,10 @@
 
 ## Versions
 
+### 1.9.5
+* Support for Dot notation in documents
+* extend Document functions with getValue. updateValue, getIntValue ... (with dot support)
+
 ### 1.9.4
 * Rewrite Docs and Samples
 * Specs Setup Redesign

src/main/scala/com/sfxcode/nosql/mongo/bson/BsonConverter.scala

@@ -7,12 +7,84 @@ import java.util.Date
 import org.mongodb.scala.Document
 import org.mongodb.scala.bson.BsonArray.fromIterable
 import org.mongodb.scala.bson._
+import org.mongodb.scala.bson.{ObjectId, _}
 
 import scala.collection.JavaConverters._
 import scala.collection.mutable
 import scala.util.matching.Regex
 
 object BsonConverter {
+  val DocumentKeyDivider = "."
+
+  def hasRelation(key: String): Boolean = key.indexOf(DocumentKeyDivider) != -1
+
+  def relationKey(key: String): String = key.substring(0, key.indexOf(DocumentKeyDivider))
+
+  def newKeyFromRelation(key: String): String = key.substring(key.indexOf(DocumentKeyDivider) + 1)
+
+  def lastKeyFromRelation(key: String): String = key.substring(key.lastIndexOf(DocumentKeyDivider) + 1)
+
+  def documentValueOption(document: Document, key: String): Option[Any] =
+    if (hasRelation(key)) {
+      val newKey   = newKeyFromRelation(key)
+      val relation = relationKey(key)
+
+      if (document.contains(relation) && documentValueOption(document, relation)
+            .isInstanceOf[Option[Document]]) {
+        val relatedDocument = documentValueOption(document, relation).asInstanceOf[Option[Document]].get
+        documentValueOption(relatedDocument, newKey)
+      }
+      else {
+        None
+      }
+    }
+    else {
+      if (document.contains(key)) {
+        Some(fromBson(document(key)))
+      }
+      else {
+        None
+      }
+    }
+
+  def updateDocumentValue(document: Document, key: String, value: Any): Document = {
+    val doc    = org.mongodb.scala.bson.collection.mutable.Document(document)
+    val result = updateDocumentValueInternal(doc, key, value)
+    Document(result)
+  }
+
+  private def updateDocumentValueInternal(
+      document: org.mongodb.scala.bson.collection.mutable.Document,
+      key: String,
+      value: Any,
+      root: Option[org.mongodb.scala.bson.collection.mutable.Document] = None
+  ): org.mongodb.scala.bson.collection.mutable.Document =
+    if (hasRelation(key)) {
+      val newKey   = newKeyFromRelation(key)
+      val relation = relationKey(key)
+
+      var relatedDocument = Document()
+      val relationValue   = documentValueOption(Document(document), relation)
+      if (relationValue.isDefined && relationValue.isInstanceOf[Option[Document]]) {
+        relatedDocument = relationValue.asInstanceOf[Option[Document]].get
+      }
+      val mutableDoc = org.mongodb.scala.bson.collection.mutable.Document(relatedDocument)
+      document.put(relation, mutableDoc)
+      if (root.isEmpty)
+        updateDocumentValueInternal(mutableDoc, newKey, value, Some(document))
+      else
+        updateDocumentValueInternal(mutableDoc, newKey, value, root)
+
+    }
+    else {
+      document.put(key, toBson(value))
+      if (root.isEmpty) {
+        document
+      }
+      else {
+        root.get
+      }
+    }
 
   var converterPlugin: AbstractConverterPlugin = new BaseConverterPlugin()
 

src/main/scala/com/sfxcode/nosql/mongo/package.scala

@@ -1,5 +1,7 @@
 package com.sfxcode.nosql
 
+import java.util.Date
+
 import com.sfxcode.nosql.mongo.Converter
 import com.sfxcode.nosql.mongo.bson.BsonConverter
 import com.sfxcode.nosql.mongo.bson.convert.JsonDateTimeConverter
@@ -29,6 +31,46 @@ package object mongo extends MongoIncludes with DocumentIncludes {
         .outputMode(JsonMode.RELAXED)
       document.toJson(builder.build())
     }
+
+    def getValueOption(key: String): Option[Any] = BsonConverter.documentValueOption(document, key)
+
+    def getValue(key: String): Any = getValueOption(key).orNull
+
+    def getStringValue(key: String): String =
+      getValue(key) match {
+        case n: Any => n.toString
+        case _      => ""
+      }
+
+    def getLongValue(key: String): Long = {
+      val value = getValue(key)
+      value match {
+        case n: Number => n.longValue()
+        case s: String => s.toLongOption.getOrElse(0)
+        case _         => 0
+      }
+    }
+
+    def getIntValue(key: String): Int = getLongValue(key).intValue()
+
+    def getDoubleValue(key: String): Double =
+      getValue(key) match {
+        case n: Number => n.doubleValue()
+        case s: String => s.toDoubleOption.getOrElse(0)
+        case _         => 0
+      }
+
+    def getDateValue(key: String): Date = {
+      val value = getValue(key)
+      value match {
+        case date: Date => date
+        case _          => null
+      }
+    }
+
+    def getFloatValue(key: String): Float = getDoubleValue(key).floatValue()
+
+    def updateValue(key: String, value: Any): Any = BsonConverter.updateDocumentValue(document, key, value)
   }
 }
 

src/test/scala/com/sfxcode/nosql/mongo/bson/BsonConverterSpec.scala

@@ -1,9 +1,11 @@
 package com.sfxcode.nosql.mongo.bson
 
+import org.mongodb.scala.bson.collection.mutable
 import org.mongodb.scala.bson.{ObjectId, _}
 import org.specs2.mutable.Specification
 
 import scala.collection.mutable.ArrayBuffer
+import com.sfxcode.nosql.mongo._
 
 /**
   * Created by tom on 22.01.17.
@@ -59,6 +61,49 @@ class BsonConverterSpec extends Specification {
 
     }
 
+    "evaluate dot notation" in {
+      val document: mutable.Document = mutable.Document(Document())
+      val secondLevelDocument        = mutable.Document()
+      secondLevelDocument.put("test", 42)
+      document.put("secondLevelDocument", secondLevelDocument)
+
+      document.get("secondLevelDocument") must beSome
+
+      document.get("secondLevelDocument.test") must beNone
+
+      val v = BsonConverter.documentValueOption(Document(document), "secondLevelDocument.test")
+
+      true must beTrue
+    }
+
+    "evaluate get with dot notation" in {
+      val document: mutable.Document = mutable.Document(Document())
+      val secondLevelDocument        = mutable.Document()
+      secondLevelDocument.put("test", 42)
+      document.put("secondLevelDocument", secondLevelDocument)
+
+      document.get("secondLevelDocument") must beSome
+
+      document.get("secondLevelDocument.test") must beNone
+
+      val v = BsonConverter.documentValueOption(Document(document), "secondLevelDocument.test")
+
+      true must beTrue
+    }
+
+    "evaluate put with dot notation" in {
+      val document = Document()
+
+      var updated: Document = BsonConverter.updateDocumentValue(document, "test", 42)
+
+      updated.getIntValue("test") mustEqual (42)
+
+      updated = BsonConverter.updateDocumentValue(document, "test.test.test.test", 42)
+
+      updated.getIntValue("test.test.test.test") mustEqual 42
+      true must beTrue
+    }
+
   }
 
 }