sudoxreboot/habitica-android
1
0
Fork 0
mirror of https://github.com/sudoxnym/habitica-android.git synced 2026-05-22 21:57:11 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

Fix various realm errors

Browse source
This commit is contained in:
Phillip Thelen 2019-09-18 13:23:06 +02:00
parent 7a4d0aaff4
commit 74c1397987
14 changed files with 93 additions and 79 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Habitica/src/main/java/com/habitrpg/android/habitica/data/TaskRepository.kt
View file

@ -56,7 +56,7 @@ interface TaskRepository : BaseRepository {
fun getTaskCopies(tasks: List<Task>): Flowable<List<Task>>
fun updateDailiesIsDue(date: Date): Flowable<TaskList>
fun retrieveDailiesFromDate(date: Date): Flowable<TaskList>
fun retrieveCompletedTodos(userId: String): Flowable<TaskList>
fun syncErroredTasks(): Single<List<Task>>
}

38
Habitica/src/main/java/com/habitrpg/android/habitica/data/implementation/TaskRepositoryImpl.kt
View file

@ -117,34 +117,35 @@ class TaskRepositoryImpl(localRepository: TaskLocalRepository, apiClient: ApiCli
}
private fun handleTaskResponse(user: User, res: TaskDirectionData, task: Task, up: Boolean, localDelta: Float) {
val stats = user.stats
this.localRepository.executeTransaction {
if (!task.isValid) {
return@executeTransaction
}
if (task.type != "reward" && (task.value - localDelta) + res.delta != task.value) {
task.value = (task.value - localDelta) + res.delta
if (Task.TYPE_DAILY == task.type || Task.TYPE_TODO == task.type) {
task.completed = up
if (Task.TYPE_DAILY == task.type && up) {
task.streak = (task.streak ?: 0) + 1
val userID = user.id
val taskID = task.id
this.localRepository.executeTransactionAsync {
val bgTask = it.where(Task::class.java).equalTo("id", taskID).findFirst() ?: return@executeTransactionAsync
val bgUser = it.where(User::class.java).equalTo("id", userID).findFirst() ?: return@executeTransactionAsync
if (bgTask.type != "reward" && (bgTask.value - localDelta) + res.delta != bgTask.value) {
bgTask.value = (bgTask.value - localDelta) + res.delta
if (Task.TYPE_DAILY == bgTask.type || Task.TYPE_TODO == bgTask.type) {
bgTask.completed = up
if (Task.TYPE_DAILY == bgTask.type && up) {
bgTask.streak = (bgTask.streak ?: 0) + 1
}
} else if (Task.TYPE_HABIT == task.type) {
} else if (Task.TYPE_HABIT == bgTask.type) {
if (up) {
task.counterUp = (task.counterUp ?: 0) + 1
bgTask.counterUp = (bgTask.counterUp ?: 0) + 1
} else {
task.counterDown = (task.counterDown ?: 0) + 1
bgTask.counterDown = (bgTask.counterDown ?: 0) + 1
}
}
}
val stats = bgUser.stats
stats?.hp = res.hp
stats?.exp = res.exp
stats?.mp = res.mp
stats?.gp = res.gp
stats?.lvl = res.lvl
user.party?.quest?.progress?.up = (user.party?.quest?.progress?.up
stats?.lvl = res.lvl.toInt()
bgUser.party?.quest?.progress?.up = (bgUser.party?.quest?.progress?.up
?: 0F) + (res._tmp?.quest?.progressDelta?.toFloat() ?: 0F)
user.stats = stats
bgUser.stats = stats
}
}
@ -271,10 +272,9 @@ class TaskRepositoryImpl(localRepository: TaskLocalRepository, apiClient: ApiCli
override fun getTaskCopies(tasks: List<Task>): Flowable<List<Task>> =
Flowable.just(localRepository.getUnmanagedCopy(tasks))
override fun updateDailiesIsDue(date: Date): Flowable<TaskList> {
override fun retrieveDailiesFromDate(date: Date): Flowable<TaskList> {
val formatter = SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ssZZZZZ", Locale.US)
return apiClient.getTasks("dailys", formatter.format(date))
.flatMapMaybe { localRepository.updateIsdue(it) }
}
override fun syncErroredTasks(): Single<List<Task>> {

2
Habitica/src/main/java/com/habitrpg/android/habitica/data/local/BaseLocalRepository.kt
View file

@ -11,6 +11,8 @@ interface BaseLocalRepository {
fun executeTransaction(transaction: (Realm) -> Unit)
fun executeTransaction(transaction: Realm.Transaction)
fun executeTransactionAsync(transaction: (Realm) -> Unit)
fun executeTransactionAsync(transaction: Realm.Transaction)
fun <T : RealmObject> getUnmanagedCopy(managedObject: T): T
fun <T : RealmObject> getUnmanagedCopy(list: List<T>): List<T>

12
Habitica/src/main/java/com/habitrpg/android/habitica/data/local/implementation/RealmBaseLocalRepository.kt
View file

@ -26,6 +26,18 @@ abstract class RealmBaseLocalRepository internal constructor(protected var realm
realm.executeTransaction(transaction)
}
override fun executeTransactionAsync(transaction: (Realm) -> Unit) {
if (isClosed) { return }
realm.executeTransactionAsync {
transaction(it)
}
}
override fun executeTransactionAsync(transaction: Realm.Transaction) {
if (isClosed) { return }
realm.executeTransactionAsync(transaction)
}
override fun <T : RealmObject> getUnmanagedCopy(managedObject: T): T {
return if (managedObject.isManaged && managedObject.isValid) {
realm.copyFromRealm(managedObject)

10
Habitica/src/main/java/com/habitrpg/android/habitica/data/local/implementation/RealmChallengeLocalRepository.kt
View file

@ -81,13 +81,11 @@ class RealmChallengeLocalRepository(realm: Realm) : RealmBaseLocalRepository(rea
override fun setParticipating(userID: String, challengeID: String, isParticipating: Boolean) {
if (isParticipating) {
realm.executeTransaction {
realm.insertOrUpdate(ChallengeMembership(userID, challengeID))
}
save(ChallengeMembership(userID, challengeID))
} else {
val membership = realm.where(ChallengeMembership::class.java).equalTo("userID", userID).equalTo("challengeID", challengeID).findFirst()
if (membership != null) {
realm.executeTransaction {
executeTransaction {
membership.deleteFromRealm()
}
}
@ -103,12 +101,12 @@ class RealmChallengeLocalRepository(realm: Realm) : RealmBaseLocalRepository(rea
challengesToDelete.add(localTask)
}
}
realm.executeTransaction {
executeTransaction {
for (localTask in challengesToDelete) {
localTask.deleteFromRealm()
}
}
}
realm.executeTransaction { realm1 -> realm1.insertOrUpdate(challenges) }
executeTransaction { realm1 -> realm1.insertOrUpdate(challenges) }
}
}

10
Habitica/src/main/java/com/habitrpg/android/habitica/data/local/implementation/RealmInventoryLocalRepository.kt
View file

@ -82,7 +82,7 @@ class RealmInventoryLocalRepository(realm: Realm, private val context: Context)
}
override fun getItems(itemClass: Class<out Item>, keys: Array<String>, user: User?): Flowable<out RealmResults<out Item>> {
return realm.where(itemClass).`in`("key", keys).findAllAsync().asFlowable()
return realm.where(itemClass).`in`("key", keys).findAll().asFlowable()
.filter { it.isLoaded }
}
@ -175,7 +175,7 @@ class RealmInventoryLocalRepository(realm: Realm, private val context: Context)
override fun changeOwnedCount(item: OwnedItem, amountToAdd: Int?) {
amountToAdd?.let { amount ->
realm.executeTransaction { item.numberOwned = item.numberOwned + amount }
executeTransaction { item.numberOwned = item.numberOwned + amount }
}
}
@ -208,7 +208,7 @@ class RealmInventoryLocalRepository(realm: Realm, private val context: Context)
return
}
val item = realm.where(OwnedItem::class.java).equalTo("combinedKey", "${user.id}specialinventory_present").findFirst()
realm.executeTransaction {
executeTransaction {
if (item != null && item.isValid) {
item.numberOwned = item.numberOwned - 1
}
@ -220,14 +220,14 @@ class RealmInventoryLocalRepository(realm: Realm, private val context: Context)
override fun getInAppRewards(): Flowable<RealmResults<ShopItem>> {
return realm.where(ShopItem::class.java)
.findAllAsync()
.findAll()
.asFlowable()
.filter { it.isLoaded }
}
override fun saveInAppRewards(onlineItems: List<ShopItem>) {
val localItems = realm.where(ShopItem::class.java).findAll().createSnapshot()
realm.executeTransaction {
executeTransactionAsync {
for (localItem in localItems) {
if (!onlineItems.contains(localItem)) {
localItem.deleteFromRealm()

46
Habitica/src/main/java/com/habitrpg/android/habitica/data/local/implementation/RealmSocialLocalRepository.kt
View file

@ -36,13 +36,11 @@ class RealmSocialLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm)
override fun updateMembership(userId: String, id: String, isMember: Boolean) {
if (isMember) {
realm.executeTransaction {
realm.insertOrUpdate(GroupMembership(userId, id))
}
save(GroupMembership(userId, id))
} else {
val membership = realm.where(GroupMembership::class.java).equalTo("userID", userId).equalTo("groupID", id).findFirst()
if (membership != null) {
realm.executeTransaction {
executeTransaction {
membership.deleteFromRealm()
}
}
@ -51,7 +49,7 @@ class RealmSocialLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm)
override fun saveInboxMessages(userID: String, recipientID: String, messages: List<ChatMessage>, page: Int) {
messages.forEach { it.userID = userID }
realm.executeTransaction { realm.insertOrUpdate(messages) }
save(messages)
if (page != 0) return
val existingMessages = realm.where(ChatMessage::class.java).equalTo("isInboxMessage", true).equalTo("uuid", recipientID).findAll()
val messagesToRemove = ArrayList<ChatMessage>()
@ -61,14 +59,14 @@ class RealmSocialLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm)
messagesToRemove.add(existingMessage)
}
}
realm.executeTransaction {
executeTransaction {
messagesToRemove.forEach { it.deleteFromRealm() }
}
}
override fun saveInboxConversations(userID: String, conversations: List<InboxConversation>) {
conversations.forEach { it.userID = userID }
realm.executeTransaction { realm.insertOrUpdate(conversations) }
save(conversations)
val existingConversations = realm.where(InboxConversation::class.java).findAll()
val conversationsToRemove = ArrayList<InboxConversation>()
for (existingMessage in existingConversations) {
@ -77,13 +75,13 @@ class RealmSocialLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm)
conversationsToRemove.add(existingMessage)
}
}
realm.executeTransaction {
executeTransaction {
conversationsToRemove.forEach { it.deleteFromRealm() }
}
}
override fun saveGroupMemberships(userID: String?, memberships: List<GroupMembership>) {
realm.executeTransaction { realm.insertOrUpdate(memberships) }
save(memberships)
if (userID != null) {
val existingMemberships = realm.where(GroupMembership::class.java).equalTo("userID", userID).findAll()
val membersToRemove = ArrayList<GroupMembership>()
@ -93,7 +91,7 @@ class RealmSocialLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm)
membersToRemove.add(existingMembership)
}
}
realm.executeTransaction {
executeTransaction {
membersToRemove.forEach { it.deleteFromRealm() }
}
}
@ -131,7 +129,7 @@ class RealmSocialLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm)
override fun getGroups(type: String): Flowable<RealmResults<Group>> {
return realm.where(Group::class.java)
.equalTo("type", type)
.findAllAsync()
.findAll()
.asFlowable()
.filter { it.isLoaded }
}
@ -155,19 +153,19 @@ class RealmSocialLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm)
}
override fun deleteMessage(id: String) {
getMessage(id).firstElement().subscribe { chatMessage -> realm.executeTransaction { chatMessage.deleteFromRealm() } }
getMessage(id).firstElement().subscribe { chatMessage -> executeTransaction { chatMessage.deleteFromRealm() } }
}
override fun getGroupMembers(partyId: String): Flowable<RealmResults<Member>> {
return realm.where(Member::class.java)
.equalTo("party.id", partyId)
.findAllAsync()
.findAll()
.asFlowable()
.filter { it.isLoaded }
}
override fun updateRSVPNeeded(user: User?, newValue: Boolean) {
realm.executeTransaction { user?.party?.quest?.RSVPNeeded = newValue }
executeTransaction { user?.party?.quest?.RSVPNeeded = newValue }
}
override fun likeMessage(chatMessage: ChatMessage, userId: String, liked: Boolean) {
@ -175,14 +173,14 @@ class RealmSocialLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm)
return
}
if (liked) {
realm.executeTransaction { chatMessage.likes?.add(ChatMessageLike(userId, chatMessage.id)) }
executeTransaction { chatMessage.likes?.add(ChatMessageLike(userId, chatMessage.id)) }
} else {
chatMessage.likes?.filter { userId == it.id }?.forEach { like -> realm.executeTransaction { like.deleteFromRealm() } }
chatMessage.likes?.filter { userId == it.id }?.forEach { like -> executeTransaction { like.deleteFromRealm() } }
}
}
override fun saveGroupMembers(groupId: String?, members: List<Member>) {
realm.executeTransaction { realm.insertOrUpdate(members) }
save(members)
if (groupId != null) {
val existingMembers = realm.where(Member::class.java).equalTo("party.id", groupId).findAll()
val membersToRemove = ArrayList<Member>()
@ -192,7 +190,7 @@ class RealmSocialLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm)
membersToRemove.add(existingMember)
}
}
realm.executeTransaction {
executeTransaction {
membersToRemove.forEach { it.deleteFromRealm() }
}
}
@ -200,7 +198,7 @@ class RealmSocialLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm)
override fun rejectGroupInvitation(userID: String, groupID: String) {
val user = realm.where(User::class.java).equalTo("id", userID).findFirst()
realm.executeTransaction {
executeTransaction {
user?.invitations?.removeInvitation(groupID)
}
}
@ -208,18 +206,18 @@ class RealmSocialLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm)
override fun removeQuest(partyId: String) {
val party = realm.where(Group::class.java).equalTo("id", partyId).findFirst()
if (party != null) {
realm.executeTransaction { party.quest = null }
executeTransaction { party.quest = null }
}
}
override fun setQuestActivity(party: Group?, active: Boolean) {
realm.executeTransaction {
executeTransaction {
party?.quest?.active = active
}
}
override fun saveChatMessages(groupId: String?, chatMessages: List<ChatMessage>) {
realm.executeTransaction { realm.insertOrUpdate(chatMessages) }
save(chatMessages)
if (groupId != null) {
val existingMessages = realm.where(ChatMessage::class.java).equalTo("groupId", groupId).findAll()
val messagesToRemove = ArrayList<ChatMessage>()
@ -232,7 +230,7 @@ class RealmSocialLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm)
val idsToRemove = messagesToRemove.map { it.id }
val userStylestoRemove = realm.where(UserStyles::class.java).`in`("id", idsToRemove.toTypedArray()).findAll()
val contributorToRemove = realm.where(ContributorInfo::class.java).`in`("userId", idsToRemove.toTypedArray()).findAll()
realm.executeTransaction {
executeTransaction {
for (member in messagesToRemove) {
member.deleteFromRealm()
}
@ -245,7 +243,7 @@ class RealmSocialLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm)
private fun getMessage(id: String): Flowable<ChatMessage> {
return realm.where(ChatMessage::class.java).equalTo("id", id)
.findAllAsync()
.findAll()
.asFlowable()
.filter { messages -> messages.isLoaded && messages.isValid && !messages.isEmpty() }
.map { messages -> messages.first() }

2
Habitica/src/main/java/com/habitrpg/android/habitica/data/local/implementation/RealmTagLocalRepository.kt
View file

@ -10,7 +10,7 @@ import io.realm.RealmResults
class RealmTagLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm), TagLocalRepository {
override fun deleteTag(tagID: String) {
val tag = realm.where(Tag::class.java).equalTo("id", tagID).findFirst()
realm.executeTransaction { tag?.deleteFromRealm() }
executeTransaction { tag?.deleteFromRealm() }
}
override fun getTags(userId: String): Flowable<RealmResults<Tag>> {

19
Habitica/src/main/java/com/habitrpg/android/habitica/data/local/implementation/RealmTaskLocalRepository.kt
View file

@ -82,6 +82,7 @@ class RealmTaskLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
}
private fun removeOldTasks(userID: String, onlineTaskList: List<Task>) {
if (realm.isClosed) return
val localTasks = realm.where(Task::class.java)
.equalTo("userId", userID)
.beginGroup()
@ -95,7 +96,7 @@ class RealmTaskLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
.findAll()
.createSnapshot()
val tasksToDelete = localTasks.filterNot { onlineTaskList.contains(it) }
realm.executeTransaction {
executeTransaction {
for (localTask in tasksToDelete) {
localTask.checklist?.deleteAllFromRealm()
localTask.reminders?.deleteAllFromRealm()
@ -112,7 +113,7 @@ class RealmTaskLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
.findAll()
.createSnapshot()
val tasksToDelete = localTasks.filterNot { onlineTaskList.contains(it) }
realm.executeTransaction {
executeTransaction {
for (localTask in tasksToDelete) {
localTask.checklist?.deleteAllFromRealm()
localTask.reminders?.deleteAllFromRealm()
@ -124,7 +125,7 @@ class RealmTaskLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
private fun removeOldChecklists(onlineItems: List<ChecklistItem>) {
val localItems = realm.where(ChecklistItem::class.java).findAll().createSnapshot()
val itemsToDelete = localItems.filterNot { onlineItems.contains(it) }
realm.executeTransaction {
executeTransaction {
for (item in itemsToDelete) {
item.deleteFromRealm()
}
@ -134,7 +135,7 @@ class RealmTaskLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
private fun removeOldReminders(onlineReminders: List<RemindersItem>) {
val localReminders = realm.where(RemindersItem::class.java).findAll().createSnapshot()
val itemsToDelete = localReminders.filterNot { onlineReminders.contains(it) }
realm.executeTransaction {
executeTransaction {
for (item in itemsToDelete) {
item.deleteFromRealm()
}
@ -143,7 +144,7 @@ class RealmTaskLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
override fun deleteTask(taskID: String) {
val task = realm.where(Task::class.java).equalTo("id", taskID).findFirstAsync()
realm.executeTransaction {
executeTransaction {
if (task.isManaged) {
task.deleteFromRealm()
}
@ -172,18 +173,18 @@ class RealmTaskLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
override fun markTaskCompleted(taskId: String, isCompleted: Boolean) {
val task = realm.where(Task::class.java).equalTo("id", taskId).findFirstAsync()
realm.executeTransaction { task.completed = true }
executeTransaction { task.completed = true }
}
override fun saveReminder(remindersItem: RemindersItem) {
realm.executeTransaction { it.insertOrUpdate(remindersItem) }
executeTransaction { it.insertOrUpdate(remindersItem) }
}
override fun swapTaskPosition(firstPosition: Int, secondPosition: Int) {
val firstTask = realm.where(Task::class.java).equalTo("position", firstPosition).findFirst()
val secondTask = realm.where(Task::class.java).equalTo("position", secondPosition).findFirst()
if (firstTask != null && secondTask != null && firstTask.isValid && secondTask.isValid) {
realm.executeTransaction {
executeTransaction {
firstTask.position = secondPosition
secondTask.position = firstPosition
}
@ -210,7 +211,7 @@ class RealmTaskLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
override fun updateTaskPositions(taskOrder: List<String>) {
if (taskOrder.isNotEmpty()) {
val tasks = realm.where(Task::class.java).`in`("id", taskOrder.toTypedArray()).findAll()
realm.executeTransaction { _ ->
executeTransaction { _ ->
tasks.filter { taskOrder.contains(it.id) }.forEach { it.position = taskOrder.indexOf(it.id) }
}
}

2
Habitica/src/main/java/com/habitrpg/android/habitica/data/local/implementation/RealmTutorialLocalRepository.kt
View file

@ -12,7 +12,7 @@ class RealmTutorialLocalRepository(realm: Realm) : RealmBaseLocalRepository(real
override fun getTutorialStep(key: String): Flowable<TutorialStep> {
if (realm.isClosed) return Flowable.empty()
return realm.where(TutorialStep::class.java).equalTo("identifier", key)
.findAllAsync()
.findAll()
.asFlowable()
.filter { realmObject -> realmObject.isLoaded && realmObject.isValid && realmObject.isNotEmpty() }
.map { steps ->

13
Habitica/src/main/java/com/habitrpg/android/habitica/data/local/implementation/RealmUserLocalRepository.kt
View file

@ -58,6 +58,7 @@ class RealmUserLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
}
override fun saveUser(user: User) {
if (realm.isClosed) return
val oldUser = realm.where(User::class.java)
.equalTo("id", user.id)
.findFirst()
@ -72,7 +73,7 @@ class RealmUserLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
}
}
}
realm.executeTransaction { realm1 -> realm1.insertOrUpdate(user) }
executeTransaction { realm1 -> realm1.insertOrUpdate(user) }
removeOldTags(user.id ?: "", user.tags)
if (user.challenges != null) {
removeOldChallenges(user.id ?: "", user.challenges ?: emptyList())
@ -82,7 +83,7 @@ class RealmUserLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
}
override fun saveMessages(messages: List<ChatMessage>) {
realm.executeTransaction {
executeTransaction {
it.insertOrUpdate(messages)
}
}
@ -90,7 +91,7 @@ class RealmUserLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
private fun removeOldTags(userId: String, onlineTags: List<Tag>) {
val tags = realm.where(Tag::class.java).equalTo("userId", userId).findAll().createSnapshot()
val tagsToDelete = tags.filterNot { onlineTags.contains(it) }
realm.executeTransaction {
executeTransaction {
for (tag in tagsToDelete) {
tag.deleteFromRealm()
}
@ -100,7 +101,7 @@ class RealmUserLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
private fun removeOldChallenges(userID: String, onlineChallenges: List<ChallengeMembership>) {
val memberships = realm.where(ChallengeMembership::class.java).equalTo("userID", userID).findAll().createSnapshot()
val membershipsToDelete = memberships.filterNot { onlineChallenges.contains(it) }
realm.executeTransaction {
executeTransaction {
membershipsToDelete.forEach {
it.deleteFromRealm()
}
@ -110,7 +111,7 @@ class RealmUserLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
private fun removeOldPets(userID: String, onlinePets: List<OwnedPet>) {
val pets = realm.where(OwnedPet::class.java).equalTo("userID", userID).findAll().createSnapshot()
val petsToDelete = pets.filterNot { onlinePets.contains(it) }
realm.executeTransaction {
executeTransaction {
petsToDelete.forEach {
it.deleteFromRealm()
}
@ -120,7 +121,7 @@ class RealmUserLocalRepository(realm: Realm) : RealmBaseLocalRepository(realm),
private fun removeOldMounts(userID: String, onlineMounts: List<OwnedMount>) {
val mount = realm.where(OwnedMount::class.java).equalTo("userID", userID).findAll().createSnapshot()
val mountsToDelete = mount.filterNot { onlineMounts.contains(it) }
realm.executeTransaction {
executeTransaction {
mountsToDelete.forEach {
it.deleteFromRealm()
}

4
Habitica/src/main/java/com/habitrpg/android/habitica/interactors/ScoreTaskLocallyInteractor.kt
View file

@ -75,10 +75,10 @@ class ScoreTaskLocallyInteractor {
}
if (result.exp >= stats.toNextLevel?.toDouble() ?: 0.0) {
result.exp = result.exp - (stats.toNextLevel?.toDouble() ?: 0.0)
result.lvl = user.stats?.lvl ?: 0 + 1
result.lvl = (user.stats?.lvl ?: 0 + 1).toLong()
result.hp = 50.0
} else {
result.lvl = user.stats?.lvl ?: 0
result.lvl = (user.stats?.lvl ?: 0).toLong()
}
result

2
Habitica/src/main/java/com/habitrpg/android/habitica/ui/viewmodels/NotificationsViewModel.kt
View file

@ -175,7 +175,7 @@ open class NotificationsViewModel : BaseViewModel() {
}
fun isPartyMessage(data: NewChatMessageData?): Boolean {
if (party == null || data?.group?.id == null) {
if (party?.isValid != true || data?.group?.id == null) {
return false
}

10
Habitica/src/main/java/com/habitrpg/android/habitica/ui/views/yesterdailies/YesterdailyDialog.kt
View file

@ -156,11 +156,13 @@ class YesterdailyDialog private constructor(context: Context, private val userRe
.flatMapMaybe {
val cal = Calendar.getInstance()
cal.add(Calendar.DATE, -1)
taskRepository.updateDailiesIsDue(cal.time).firstElement()
taskRepository.retrieveDailiesFromDate(cal.time).firstElement()
}
.map {
it.tasks.values.filter { task ->
return@filter task.type == Task.TYPE_DAILY && task.isDue == true && !task.completed && task.yesterDaily
}
}
.flatMapMaybe { taskRepository.getTasks(Task.TYPE_DAILY, userId).firstElement() }
.map { tasks -> tasks.where().equalTo("isDue", true).notEqualTo("completed", true).notEqualTo("yesterDaily", false).findAll() }
.flatMapMaybe<List<Task>> { tasks -> taskRepository.getTaskCopies(tasks).firstElement() }
.retry(1)
.throttleFirst(2, TimeUnit.SECONDS)
.subscribe(Consumer { tasks ->