merge

app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt

@@ -3,7 +3,10 @@ package net.pokeranalytics.android.model.realm
 import io.realm.*
 import io.realm.annotations.Ignore
 import io.realm.annotations.PrimaryKey
-import net.pokeranalytics.android.ui.adapter.components.*
+import net.pokeranalytics.android.ui.adapter.components.DisplayableDataSource
+import net.pokeranalytics.android.ui.adapter.components.DynamicRowDelegate
+import net.pokeranalytics.android.ui.adapter.components.DynamicRowInterface
+import net.pokeranalytics.android.ui.adapter.components.SessionRow
 import net.pokeranalytics.android.util.data.sessionDao
 import java.util.*
 import kotlin.collections.ArrayList

app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt

@@ -4,6 +4,7 @@ import io.realm.Realm
 import io.realm.RealmObject
 import io.realm.RealmQuery
 import io.realm.RealmResults
+import io.realm.annotations.Ignore
 import io.realm.annotations.LinkingObjects
 import net.pokeranalytics.android.exceptions.ModelException
 import java.util.*
@@ -13,23 +14,11 @@ open class TimeFrame : RealmObject() {
 
     // A start date
     var startDate: Date = Date()
-        set(value) {
-            field = value
-            this.computeDuration()
-            if (this.session != null) {
-                this.notifySessionDateChange()
-            }
-        }
+        private set
 
     // An end date
     var endDate: Date? = null
-        set(value) {
-            field = value
-            this.computeDuration()
-            if (this.session != null) {
-                this.notifySessionDateChange()
-            }
-        }
+        private set
 
     // The break duration
     var breakDuration: Long = 0L
@@ -45,20 +34,35 @@ open class TimeFrame : RealmObject() {
     // indicates a state of pause
     var paused: Boolean = false
 
+    // Session
     @LinkingObjects("timeFrame")
-    private val session: RealmResults<Session>? = null
+    private val sessions: RealmResults<Session>? = null // we should have only one session
 
+    @Ignore
+    var session: Session? = null
+        get() = this.sessions?.first()
+
+    // Group
     @LinkingObjects("timeFrame")
-    private val group: RealmResults<SessionGroup>? = null
+    private val groups: RealmResults<SessionGroup>? = null // we should have only one group
 
-    private fun computeDuration() {
+    @Ignore
+    var group: SessionGroup? = null
+        get() = this.groups?.first()
 
-        var endDate: Date
-        if (this.endDate != null) {
-            endDate = this.endDate!!
-        } else {
-            endDate = Date()
+    fun setDate(startDate: Date, endDate: Date?) {
+        this.startDate = startDate
+        this.endDate = endDate
+
+        this.computeDuration()
+
+        if (this.session != null) {
+            this.notifySessionDateChange()
         }
+    }
+
+    private fun computeDuration() {
+        var endDate: Date = this.endDate ?: Date()
         this.duration = endDate.time - startDate.time - this.breakDuration
     }
 
@@ -94,10 +98,41 @@ open class TimeFrame : RealmObject() {
      */
     private fun updateTimeFrames(sessionGroups: RealmResults<SessionGroup>) {
 
-        // update
-        if (sessionGroups.size == 1) {
-            // we are sure that the timeframe is not null from the realm query
-            val groupTimeFrame: TimeFrame = sessionGroups.first()?.timeFrame!!
+        when (sessionGroups.size) {
+            0 -> this.createSessionGroup()
+            1 -> this.updateSingleSessionGroup(sessionGroups.first()!!)
+            else -> this.mergeSessionGroups(sessionGroups)
+        }
+
+    }
+
+    /**
+     * Creates the session group when the session has none
+     */
+    private fun createSessionGroup() {
+
+        val realm = Realm.getDefaultInstance()
+        realm.beginTransaction()
+
+        val group: SessionGroup = SessionGroup.newInstance()
+        group.timeFrame?.let {
+            it.startDate = this.startDate
+            it.endDate = this.endDate
+        } ?: run {
+            throw ModelException("TimeFrame should never be null here")
+        }
+        group.sessions.add(this.session)
+        realm.commitTransaction()
+    }
+
+    /**
+     * Single session group update
+     * Changes the group timeframe using the current timeframe dates
+     */
+    private fun updateSingleSessionGroup(sessionGroup: SessionGroup) {
+
+        var groupTimeFrame: TimeFrame = sessionGroup.timeFrame!! // tested in the query
+
         if (this.startDate.before(groupTimeFrame.startDate)) {
             groupTimeFrame.startDate = this.startDate
         }
@@ -108,7 +143,22 @@ open class TimeFrame : RealmObject() {
             groupTimeFrame.endDate = null
         }
 
-        } else if (sessionGroups.size > 1) {
+        // Realm Update
+        val realm = Realm.getDefaultInstance()
+        realm.beginTransaction()
+        if (!sessionGroup.sessions.contains(this.session)) {
+            sessionGroup.sessions.add(this.session)
+        }
+        realm.copyToRealmOrUpdate(groupTimeFrame)
+        realm.commitTransaction()
+
+    }
+
+    /**
+     * Multiple session groups update:
+     * Merges all groups into one (delete all then create a new one)
+     */
+    private fun mergeSessionGroups(sessionGroups: RealmResults<SessionGroup>) {
 
         var startDate: Date = this.startDate
         var endDate: Date? = this.endDate
@@ -132,14 +182,16 @@ open class TimeFrame : RealmObject() {
         }
 
         // get all sessions from groups
-            val sessions = sessionGroups.flatMap { it.sessions }
+        var sessions = sessionGroups.flatMap { it.sessions }
 
-            // delete all groups
+        // Start Realm updates
         val realm = Realm.getDefaultInstance()
-            realm.executeTransaction {
+        realm.beginTransaction()
+
+        // delete all groups
         sessionGroups.deleteAllFromRealm()
-            }
 
+        // Create a new groups
         val group: SessionGroup = SessionGroup.newInstance()
         group.timeFrame?.let {
             it.startDate = startDate
@@ -148,20 +200,17 @@ open class TimeFrame : RealmObject() {
             throw ModelException("TimeFrame should never be null here")
         }
 
-            this.session?.first()?.let {
+        // Add the session linked to this timeframe to the new group
+        this.sessions?.first()?.let {
             group.sessions.add(it)
         } ?: run {
             throw ModelException("TimeFrame should never be null here")
         }
 
+        // Add all orphan sessions
+        group.sessions.addAll(sessions)
 
-
-            //@todo delete all timeframes, create a new one
-
-
-
-        }
-
+        realm.commitTransaction()
     }
 
 }