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) {
+        private set
-            field = value
-            this.computeDuration()
-            if (this.session != null) {
-                this.notifySessionDateChange()
-            }
-        }
 
     // An end date
     var endDate: Date? = null
-        set(value) {
+        private set
-            field = value
-            this.computeDuration()
-            if (this.session != null) {
-                this.notifySessionDateChange()
-            }
-        }
 
     // 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
+    fun setDate(startDate: Date, endDate: Date?) {
-        if (this.endDate != null) {
+        this.startDate = startDate
-            endDate = this.endDate!!
+        this.endDate = endDate
-        } else {
+
-            endDate = Date()
+        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,74 +98,119 @@ open class TimeFrame : RealmObject() {
      */
     private fun updateTimeFrames(sessionGroups: RealmResults<SessionGroup>) {
 
-        // update
+        when (sessionGroups.size) {
-        if (sessionGroups.size == 1) {
+            0 -> this.createSessionGroup()
-            // we are sure that the timeframe is not null from the realm query
+            1 -> this.updateSingleSessionGroup(sessionGroups.first()!!)
-            val groupTimeFrame: TimeFrame = sessionGroups.first()?.timeFrame!!
+            else -> this.mergeSessionGroups(sessionGroups)
-            if (this.startDate.before(groupTimeFrame.startDate)) {
+        }
-                groupTimeFrame.startDate = this.startDate
-            }
-            val endDate = this.endDate
-            if (endDate != null && groupTimeFrame.endDate != null && endDate.after(groupTimeFrame.endDate)) {
-                groupTimeFrame.endDate = endDate
-            } else if (endDate == null) {
-                groupTimeFrame.endDate = null
-            }
 
-        } else if (sessionGroups.size > 1) {
+    }
 
-            var startDate: Date = this.startDate
+    /**
-            var endDate: Date? = this.endDate
+     * Creates the session group when the session has none
+     */
+    private fun createSessionGroup() {
 
-            val timeFrames = sessionGroups.mapNotNull { it.timeFrame }
+        val realm = Realm.getDefaultInstance()
-            timeFrames.forEach { tf ->
+        realm.beginTransaction()
-                if (tf.startDate.before(startDate)) {
+
-                    startDate = tf.startDate
+        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()
+    }
 
-                endDate?.let { ed ->
+    /**
-                    tf.endDate?.let { tfed ->
+     * Single session group update
-                        if (tfed.after(ed)) {
+     * Changes the group timeframe using the current timeframe dates
-                            endDate = tfed
+     */
-                        }
+    private fun updateSingleSessionGroup(sessionGroup: SessionGroup) {
-                    }
-                } ?: run {
-                    endDate = tf.endDate
-                }
 
-            }
+        var groupTimeFrame: TimeFrame = sessionGroup.timeFrame!! // tested in the query
 
-            // get all sessions from groups
+        if (this.startDate.before(groupTimeFrame.startDate)) {
-            val sessions = sessionGroups.flatMap { it.sessions }
+            groupTimeFrame.startDate = this.startDate
+        }
+        val endDate = this.endDate
+        if (endDate != null && groupTimeFrame.endDate != null && endDate.after(groupTimeFrame.endDate)) {
+            groupTimeFrame.endDate = endDate
+        } else if (endDate == null) {
+            groupTimeFrame.endDate = null
+        }
 
-            // delete all groups
+        // Realm Update
-            val realm = Realm.getDefaultInstance()
+        val realm = Realm.getDefaultInstance()
-            realm.executeTransaction {
+        realm.beginTransaction()
-                sessionGroups.deleteAllFromRealm()
+        if (!sessionGroup.sessions.contains(this.session)) {
-            }
+            sessionGroup.sessions.add(this.session)
+        }
+        realm.copyToRealmOrUpdate(groupTimeFrame)
+        realm.commitTransaction()
 
-            val group: SessionGroup = SessionGroup.newInstance()
+    }
-            group.timeFrame?.let {
+
-                it.startDate = startDate
+    /**
-                it.endDate = endDate
+     * Multiple session groups update:
-            } ?: run {
+     * Merges all groups into one (delete all then create a new one)
-                throw ModelException("TimeFrame should never be null here")
+     */
+    private fun mergeSessionGroups(sessionGroups: RealmResults<SessionGroup>) {
+
+        var startDate: Date = this.startDate
+        var endDate: Date? = this.endDate
+
+        val timeFrames = sessionGroups.mapNotNull { it.timeFrame }
+        timeFrames.forEach { tf ->
+            if (tf.startDate.before(startDate)) {
+                startDate = tf.startDate
             }
 
-            this.session?.first()?.let {
+            endDate?.let { ed ->
-                group.sessions.add(it)
+                tf.endDate?.let { tfed ->
+                    if (tfed.after(ed)) {
+                        endDate = tfed
+                    }
+                }
             } ?: run {
-                throw ModelException("TimeFrame should never be null here")
+                endDate = tf.endDate
             }
 
+        }
 
+        // get all sessions from groups
+        var sessions = sessionGroups.flatMap { it.sessions }
 
-            //@todo delete all timeframes, create a new one
+        // Start Realm updates
-
+        val realm = Realm.getDefaultInstance()
-
+        realm.beginTransaction()
+
+        // delete all groups
+        sessionGroups.deleteAllFromRealm()
+
+        // Create a new groups
+        val group: SessionGroup = SessionGroup.newInstance()
+        group.timeFrame?.let {
+            it.startDate = startDate
+            it.endDate = endDate
+        } ?: run {
+            throw ModelException("TimeFrame should never be null here")
+        }
 
+        // 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)
+
+        realm.commitTransaction()
     }
 
 }