From 480be48e6db8c86f9c97f2961c4624c05a867a7a Mon Sep 17 00:00:00 2001 From: Laurent Date: Fri, 15 Feb 2019 12:20:43 +0100 Subject: [PATCH 1/5] Timeframes update on date change --- .../android/model/realm/TimeFrame.kt | 69 ++++++++++++------- 1 file changed, 43 insertions(+), 26 deletions(-) diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt index 784bdb00..e515da67 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt +++ b/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 @@ -46,10 +35,29 @@ open class TimeFrame : RealmObject() { var paused: Boolean = false @LinkingObjects("timeFrame") - private val session: RealmResults? = null + private val sessions: RealmResults? = null @LinkingObjects("timeFrame") - private val group: RealmResults? = null + private val groups: RealmResults? = null + + @Ignore + var session: Session? = null + get() = this.sessions?.first() + + @Ignore + var group: SessionGroup? = null + get() = this.groups?.first() + + fun setDate(startDate: Date, endDate: Date?) { + this.startDate = startDate + this.endDate = endDate + + this.computeDuration() + + if (this.sessions != null) { + this.notifySessionDateChange() + } + } private fun computeDuration() { @@ -96,6 +104,7 @@ open class TimeFrame : RealmObject() { // update if (sessionGroups.size == 1) { + // we are sure that the timeframe is not null from the realm query val groupTimeFrame: TimeFrame = sessionGroups.first()?.timeFrame!! if (this.startDate.before(groupTimeFrame.startDate)) { @@ -108,6 +117,12 @@ open class TimeFrame : RealmObject() { groupTimeFrame.endDate = null } + // Realm Update + val realm = Realm.getDefaultInstance() + realm.beginTransaction() + realm.copyToRealmOrUpdate(groupTimeFrame) + realm.commitTransaction() + } else if (sessionGroups.size > 1) { var startDate: Date = this.startDate @@ -132,14 +147,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 { - sessionGroups.deleteAllFromRealm() - } + realm.beginTransaction() + + // delete all groups + sessionGroups.deleteAllFromRealm() + // Create a new groups val group: SessionGroup = SessionGroup.newInstance() group.timeFrame?.let { it.startDate = startDate @@ -148,17 +165,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() } From 9e45ef4b5f9fcd3ca5d07afeacd6ebc61b5e77af Mon Sep 17 00:00:00 2001 From: Laurent Date: Fri, 15 Feb 2019 12:36:52 +0100 Subject: [PATCH 2/5] Added SessionGroup creation + refactoring --- .../android/model/realm/TimeFrame.kt | 156 ++++++++++-------- 1 file changed, 88 insertions(+), 68 deletions(-) diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt index e515da67..ac80a8e9 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt @@ -34,16 +34,18 @@ open class TimeFrame : RealmObject() { // indicates a state of pause var paused: Boolean = false + // Session @LinkingObjects("timeFrame") - private val sessions: RealmResults? = null - - @LinkingObjects("timeFrame") - private val groups: RealmResults? = null + private val sessions: RealmResults? = null // we should have only one session @Ignore var session: Session? = null get() = this.sessions?.first() + // Group + @LinkingObjects("timeFrame") + private val groups: RealmResults? = null // we should have only one group + @Ignore var group: SessionGroup? = null get() = this.groups?.first() @@ -60,13 +62,7 @@ open class TimeFrame : RealmObject() { } private fun computeDuration() { - - var endDate: Date - if (this.endDate != null) { - endDate = this.endDate!! - } else { - endDate = Date() - } + var endDate: Date = this.endDate ?: Date() this.duration = endDate.time - startDate.time - this.breakDuration } @@ -102,83 +98,107 @@ open class TimeFrame : RealmObject() { */ private fun updateTimeFrames(sessionGroups: RealmResults) { - // update - if (sessionGroups.size == 1) { + when (sessionGroups.size) { + 0 -> this.createSessionGroup() + 1 -> this.updateSingleSessionGroup(sessionGroups.first()?.timeFrame!!) + else -> this.mergeSessionGroups(sessionGroups) + } - // we are sure that the timeframe is not null from the realm query - val groupTimeFrame: TimeFrame = sessionGroups.first()?.timeFrame!! - 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 - } + } - // Realm Update - val realm = Realm.getDefaultInstance() - realm.beginTransaction() - realm.copyToRealmOrUpdate(groupTimeFrame) - realm.commitTransaction() + private fun createSessionGroup() { - } else if (sessionGroups.size > 1) { + 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") + } - 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 - } + /** + * Single session group update + * Changes the group timeframe using the current timeframe dates + */ + private fun updateSingleSessionGroup(groupTimeFrame: TimeFrame) { - endDate?.let { ed -> - tf.endDate?.let { tfed -> - if (tfed.after(ed)) { - endDate = tfed - } - } - } ?: run { - endDate = tf.endDate - } + 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 + } - } + // Realm Update + val realm = Realm.getDefaultInstance() + realm.beginTransaction() + realm.copyToRealmOrUpdate(groupTimeFrame) + realm.commitTransaction() - // get all sessions from groups - var sessions = sessionGroups.flatMap { it.sessions } + } - // Start Realm updates - val realm = Realm.getDefaultInstance() - realm.beginTransaction() + /** + * Multiple session groups update: + * Merges all groups into one (delete all then create a new one) + */ + private fun mergeSessionGroups(sessionGroups: RealmResults) { - // delete all groups - sessionGroups.deleteAllFromRealm() + var startDate: Date = this.startDate + var endDate: Date? = this.endDate - // 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") + val timeFrames = sessionGroups.mapNotNull { it.timeFrame } + timeFrames.forEach { tf -> + if (tf.startDate.before(startDate)) { + startDate = tf.startDate } - // Add the session linked to this timeframe to the new group - this.sessions?.first()?.let { - group.sessions.add(it) + endDate?.let { ed -> + tf.endDate?.let { tfed -> + if (tfed.after(ed)) { + endDate = tfed + } + } } ?: run { - throw ModelException("TimeFrame should never be null here") + endDate = tf.endDate } - // Add all orphan sessions - group.sessions.addAll(sessions) + } + + // get all sessions from groups + var sessions = sessionGroups.flatMap { it.sessions } - realm.commitTransaction() + // 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() } } From f0d853057623334d3e32e17346466cfc824845bd Mon Sep 17 00:00:00 2001 From: Laurent Date: Fri, 15 Feb 2019 12:37:31 +0100 Subject: [PATCH 3/5] Added comment --- .../java/net/pokeranalytics/android/model/realm/TimeFrame.kt | 3 +++ 1 file changed, 3 insertions(+) diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt index ac80a8e9..fa5a426a 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt @@ -106,6 +106,9 @@ open class TimeFrame : RealmObject() { } + /** + * Creates the session group when the session has none + */ private fun createSessionGroup() { val group: SessionGroup = SessionGroup.newInstance() From e4c2b4edaef9fc7040771475af50616757ca98df Mon Sep 17 00:00:00 2001 From: Laurent Date: Fri, 15 Feb 2019 14:01:03 +0100 Subject: [PATCH 4/5] Fix build issue --- .../java/net/pokeranalytics/android/model/realm/Session.kt | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt index bb10b2f8..4839fc7b 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/Session.kt @@ -3,7 +3,7 @@ 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.DisplayableData +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 @@ -12,7 +12,7 @@ import java.util.* import kotlin.collections.ArrayList -open class Session(comment: String = "") : RealmObject(), DynamicRowDelegate, DisplayableData { +open class Session(comment: String = "") : RealmObject(), DynamicRowDelegate, DisplayableDataSource { @PrimaryKey var id = UUID.randomUUID().toString() From 073835b8074bdbffe81a70f0b9ed954cedc9d956 Mon Sep 17 00:00:00 2001 From: Laurent Date: Fri, 15 Feb 2019 14:01:49 +0100 Subject: [PATCH 5/5] Timeframe date changes manages Session belonging to SessionGroups --- .../android/model/realm/TimeFrame.kt | 17 +++++++++++++---- 1 file changed, 13 insertions(+), 4 deletions(-) diff --git a/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt b/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt index fa5a426a..8f0eb411 100644 --- a/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt +++ b/app/src/main/java/net/pokeranalytics/android/model/realm/TimeFrame.kt @@ -56,7 +56,7 @@ open class TimeFrame : RealmObject() { this.computeDuration() - if (this.sessions != null) { + if (this.session != null) { this.notifySessionDateChange() } } @@ -100,7 +100,7 @@ open class TimeFrame : RealmObject() { when (sessionGroups.size) { 0 -> this.createSessionGroup() - 1 -> this.updateSingleSessionGroup(sessionGroups.first()?.timeFrame!!) + 1 -> this.updateSingleSessionGroup(sessionGroups.first()!!) else -> this.mergeSessionGroups(sessionGroups) } @@ -111,6 +111,9 @@ open class TimeFrame : RealmObject() { */ private fun createSessionGroup() { + val realm = Realm.getDefaultInstance() + realm.beginTransaction() + val group: SessionGroup = SessionGroup.newInstance() group.timeFrame?.let { it.startDate = this.startDate @@ -118,14 +121,17 @@ open class TimeFrame : RealmObject() { } ?: 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(groupTimeFrame: TimeFrame) { + private fun updateSingleSessionGroup(sessionGroup: SessionGroup) { + + var groupTimeFrame: TimeFrame = sessionGroup.timeFrame!! // tested in the query if (this.startDate.before(groupTimeFrame.startDate)) { groupTimeFrame.startDate = this.startDate @@ -140,6 +146,9 @@ open class TimeFrame : RealmObject() { // Realm Update val realm = Realm.getDefaultInstance() realm.beginTransaction() + if (!sessionGroup.sessions.contains(this.session)) { + sessionGroup.sessions.add(this.session) + } realm.copyToRealmOrUpdate(groupTimeFrame) realm.commitTransaction()