Change agreement history model to support the new respective avro message

[aquarium] / src / main / scala / gr / grnet / aquarium / charging / state / UserAgreementHistoryModel.scala

diff --git a/src/main/scala/gr/grnet/aquarium/charging/state/UserAgreementHistoryModel.scala b/src/main/scala/gr/grnet/aquarium/charging/state/UserAgreementHistoryModel.scala
index d570eef..f92ca9a 100644 (file)
--- a/src/main/scala/gr/grnet/aquarium/charging/state/UserAgreementHistoryModel.scala
+++ b/src/main/scala/gr/grnet/aquarium/charging/state/UserAgreementHistoryModel.scala
@@ -39,65 +39,75 @@ import gr.grnet.aquarium.logic.accounting.dsl.Timeslot
 import gr.grnet.aquarium.policy.UserAgreementModel
 import gr.grnet.aquarium.util.json.JsonSupport
 import scala.collection.immutable
-import gr.grnet.aquarium.message.avro.gen.UserAgreementHistoryMsg
-import gr.grnet.aquarium.message.avro.ModelFactory
+import gr.grnet.aquarium.message.avro.gen.{UserAgreementMsg, IMEventMsg, UserAgreementHistoryMsg}
+import gr.grnet.aquarium.message.avro.{MessageFactory, MessageHelpers, ModelFactory}
 
 /**
  *
  * @author Christos KK Loverdos <loverdos@gmail.com>
  */
 
-final case class UserAgreementHistoryModel(
-    msg: UserAgreementHistoryMsg
-) {
+final class UserAgreementHistoryModel(msg: UserAgreementHistoryMsg) {
 
-  private var _userAgreementModels: immutable.SortedSet[UserAgreementModel] = {
+  private[this] var _latestIMEventOccurredMillis = 0L
+
+  private[this] var (_userAgreementModels, _userCreationIMEventMsgOpt): (immutable.SortedSet[UserAgreementModel], Option[IMEventMsg]) = {
     var userAgreementModels = immutable.SortedSet[UserAgreementModel]()
+    var userCreationIMEventMsg: Option[IMEventMsg] = None
     val userAgreements = msg.getAgreements.iterator()
     while(userAgreements.hasNext) {
       val userAgreement = userAgreements.next()
       val userAgreementModel = ModelFactory.newUserAgreementModel(userAgreement)
       userAgreementModels += userAgreementModel
+
+      userAgreement.getRelatedIMEventMsg match {
+        case null ⇒
+
+        case msg ⇒
+          if(MessageHelpers.isIMEventCreate(msg)) {
+            userCreationIMEventMsg = Some(msg)
+          }
+      }
+
+      checkLatestIMEventOccurredMillis(userAgreement.getRelatedIMEventMsg)
     }
 
-    userAgreementModels
+    (userAgreementModels, userCreationIMEventMsg)
   }
 
+  private[this] def checkLatestIMEventOccurredMillis(imEvent: IMEventMsg) {
+    if(imEvent ne null) {
+      if(this._latestIMEventOccurredMillis < imEvent.getOccurredMillis) {
+        this._latestIMEventOccurredMillis = imEvent.getOccurredMillis
+      }
+    }
+  }
+
+  def latestIMEventOccurredMillis = this._latestIMEventOccurredMillis
+
+  def hasUserCreationEvent = this._userCreationIMEventMsgOpt.isDefined
+
+  def userCreationIMEvent = this._userCreationIMEventMsgOpt
+
   def size: Int = msg.getAgreements.size()
 
   def agreementByTimeslot: immutable.SortedMap[Timeslot, UserAgreementModel] = {
     immutable.TreeMap(_userAgreementModels.map(ag ⇒ (ag.timeslot, ag)).toSeq: _*)
   }
 
-  def setFrom(that: UserAgreementHistoryModel): this.type = {
-    this._userAgreementModels = that._userAgreementModels
-    this
-  }
-
-  def +(userAgreement: UserAgreementModel): this.type = {
-    msg.getAgreements.add(userAgreement.msg)
-    _userAgreementModels += userAgreement
-    this
+  def insertUserAgreementModel(userAgreement: UserAgreementModel) {
+    MessageHelpers.insertUserAgreement(this.msg, userAgreement.msg)
+    this._userAgreementModels += userAgreement
+    checkLatestIMEventOccurredMillis(userAgreement.msg.getRelatedIMEventMsg)
   }
 
-  def +=(userAgreement: UserAgreementModel): Unit = {
-    msg.getAgreements.add(userAgreement.msg)
-    _userAgreementModels += userAgreement
+  def insertUserAgreementMsg(userAgreementMsg: UserAgreementMsg) {
+    insertUserAgreementModel(ModelFactory.newUserAgreementModel(userAgreementMsg))
   }
 
-  def ++(userAgreements: Traversable[UserAgreementModel]): this.type = {
-    for(userAgreement ← userAgreements) {
-      msg.getAgreements.add(userAgreement.msg)
-    }
-    _userAgreementModels ++= userAgreements
-    this
-  }
-
-  def ++=(userAgreements: Traversable[UserAgreementModel]): Unit = {
-    for(userAgreement ← userAgreements) {
-      msg.getAgreements.add(userAgreement.msg)
-    }
-    _userAgreementModels ++= userAgreements
+  def insertUserAgreementMsgFromIMEvent(imEvent: IMEventMsg) {
+    val userAgreementMsg = MessageFactory.newUserAgreementFromIMEventMsg(imEvent)
+    insertUserAgreementMsg(userAgreementMsg)
   }
 
   def oldestAgreementModel: Option[UserAgreementModel] = {
@@ -108,7 +118,7 @@ final case class UserAgreementHistoryModel(
     _userAgreementModels.lastOption
   }
 
-  def toJsonString = msg.toString
+  override def toString = msg.toString
 
 //  def agreementInEffectWhen(whenMillis: Long): Option[UserAgreementModel] = {
 //    agreements.to(