archive
/
tasks
mirror of https://github.com/tasks/tasks
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Disable alarm sync for synology calendar

Browse Source
pull/1811/head
Alex Baker 4 years ago
parent e8f231b288
commit 494c449fe6
5 changed files with 103 additions and 66 deletions
Show Stats Download Patch File Download Diff File

21
app/src/main/java/org/tasks/caldav/CaldavSynchronizer.kt
Unescape Escape View File

@ -199,9 +199,9 @@ class CaldavSynchronizer @Inject constructor(
resource resource
.principals(account, calendar) .principals(account, calendar)
.let { principalDao.deleteRemoved(calendar.id, it.map(PrincipalAccess::id)) } .let { principalDao.deleteRemoved(calendar.id, it.map(PrincipalAccess::id)) }
fetchChanges(calendar, resource, caldavClient.httpClient) fetchChanges(account, calendar, resource, caldavClient.httpClient)
if (calendar.access != ACCESS_READ_ONLY) { if (calendar.access != ACCESS_READ_ONLY) {
pushLocalChanges(calendar, caldavClient.httpClient, resource.href) pushLocalChanges(account, calendar, caldavClient.httpClient, resource.href)
} }
} }
setError(account, "") setError(account, "")
@ -225,9 +225,11 @@ class CaldavSynchronizer @Inject constructor(
} }
private suspend fun fetchChanges( private suspend fun fetchChanges(
account: CaldavAccount,
caldavCalendar: CaldavCalendar, caldavCalendar: CaldavCalendar,
resource: Response, resource: Response,
httpClient: OkHttpClient) { httpClient: OkHttpClient
) {
val httpUrl = resource.href val httpUrl = resource.href
val remoteCtag = resource.ctag val remoteCtag = resource.ctag
if (caldavCalendar.ctag?.equals(remoteCtag) == true) { if (caldavCalendar.ctag?.equals(remoteCtag) == true) {
@ -275,7 +277,7 @@ class CaldavSynchronizer @Inject constructor(
return return
} }
val caldavTask = caldavDao.getTask(caldavCalendar.uuid!!, fileName) val caldavTask = caldavDao.getTask(caldavCalendar.uuid!!, fileName)
iCal.fromVtodo(caldavCalendar, caldavTask, remote, vtodo, fileName, eTag) iCal.fromVtodo(account, caldavCalendar, caldavTask, remote, vtodo, fileName, eTag)
} }
} }
caldavDao caldavDao
@ -294,13 +296,17 @@ class CaldavSynchronizer @Inject constructor(
} }
private suspend fun pushLocalChanges( private suspend fun pushLocalChanges(
caldavCalendar: CaldavCalendar, httpClient: OkHttpClient, httpUrl: HttpUrl) { account: CaldavAccount,
caldavCalendar: CaldavCalendar,
httpClient: OkHttpClient,
httpUrl: HttpUrl
) {
for (task in caldavDao.getMoved(caldavCalendar.uuid!!)) { for (task in caldavDao.getMoved(caldavCalendar.uuid!!)) {
deleteRemoteResource(httpClient, httpUrl, caldavCalendar, task) deleteRemoteResource(httpClient, httpUrl, caldavCalendar, task)
} }
for (task in taskDao.getCaldavTasksToPush(caldavCalendar.uuid!!)) { for (task in taskDao.getCaldavTasksToPush(caldavCalendar.uuid!!)) {
try { try {
pushTask(caldavCalendar, task, httpClient, httpUrl) pushTask(account, caldavCalendar, task, httpClient, httpUrl)
} catch (e: IOException) { } catch (e: IOException) {
Timber.e(e) Timber.e(e)
} }
@ -334,6 +340,7 @@ class CaldavSynchronizer @Inject constructor(
} }
private suspend fun pushTask( private suspend fun pushTask(
account: CaldavAccount,
calendar: CaldavCalendar, calendar: CaldavCalendar,
task: Task, task: Task,
httpClient: OkHttpClient, httpClient: OkHttpClient,
@ -347,7 +354,7 @@ class CaldavSynchronizer @Inject constructor(
} }
return return
} }
val data = iCal.toVtodo(calendar, caldavTask, task) val data = iCal.toVtodo(account, calendar, caldavTask, task)
val requestBody = RequestBody.create(MIME_ICALENDAR, data) val requestBody = RequestBody.create(MIME_ICALENDAR, data)
try { try {
val remote = DavResource( val remote = DavResource(

20
app/src/main/java/org/tasks/caldav/iCalendar.kt
Unescape Escape View File

@ -36,6 +36,8 @@ import org.tasks.data.Alarm
import org.tasks.data.Alarm.Companion.TYPE_RANDOM import org.tasks.data.Alarm.Companion.TYPE_RANDOM
import org.tasks.data.Alarm.Companion.TYPE_SNOOZE import org.tasks.data.Alarm.Companion.TYPE_SNOOZE
import org.tasks.data.AlarmDao import org.tasks.data.AlarmDao
import org.tasks.data.CaldavAccount
import org.tasks.data.CaldavAccount.Companion.SERVER_SYNOLOGY_CALENDAR
import org.tasks.data.CaldavCalendar import org.tasks.data.CaldavCalendar
import org.tasks.data.CaldavDao import org.tasks.data.CaldavDao
import org.tasks.data.CaldavTask import org.tasks.data.CaldavTask
@ -129,6 +131,7 @@ class iCalendar @Inject constructor(
} }
suspend fun toVtodo( suspend fun toVtodo(
account: CaldavAccount,
calendar: CaldavCalendar, calendar: CaldavCalendar,
caldavTask: CaldavTask, caldavTask: CaldavTask,
task: com.todoroo.astrid.data.Task task: com.todoroo.astrid.data.Task
@ -146,10 +149,15 @@ class iCalendar @Inject constructor(
remoteModel = Task() remoteModel = Task()
} }
return toVtodo(caldavTask, task, remoteModel) return toVtodo(account, caldavTask, task, remoteModel)
} }
suspend fun toVtodo(caldavTask: CaldavTask, task: com.todoroo.astrid.data.Task, remoteModel: Task): ByteArray { suspend fun toVtodo(
account: CaldavAccount,
caldavTask: CaldavTask,
task: com.todoroo.astrid.data.Task,
remoteModel: Task
): ByteArray {
remoteModel.applyLocal(caldavTask, task) remoteModel.applyLocal(caldavTask, task)
val categories = remoteModel.categories val categories = remoteModel.categories
categories.clear() categories.clear()
@ -166,16 +174,19 @@ class iCalendar @Inject constructor(
if (localGeo == null || !localGeo.equalish(remoteModel.geoPosition)) { if (localGeo == null || !localGeo.equalish(remoteModel.geoPosition)) {
remoteModel.geoPosition = localGeo remoteModel.geoPosition = localGeo
} }
if (account.reminderSync) {
remoteModel.alarms.removeAll(remoteModel.alarms.filtered) remoteModel.alarms.removeAll(remoteModel.alarms.filtered)
val alarms = alarmDao.getAlarms(task.id) val alarms = alarmDao.getAlarms(task.id)
remoteModel.snooze = alarms.find { it.type == TYPE_SNOOZE }?.time remoteModel.snooze = alarms.find { it.type == TYPE_SNOOZE }?.time
remoteModel.alarms.addAll(alarms.toVAlarms()) remoteModel.alarms.addAll(alarms.toVAlarms())
}
val os = ByteArrayOutputStream() val os = ByteArrayOutputStream()
remoteModel.write(os) remoteModel.write(os)
return os.toByteArray() return os.toByteArray()
} }
suspend fun fromVtodo( suspend fun fromVtodo(
account: CaldavAccount,
calendar: CaldavCalendar, calendar: CaldavCalendar,
existing: CaldavTask?, existing: CaldavTask?,
remote: Task, remote: Task,
@ -209,6 +220,7 @@ class iCalendar @Inject constructor(
tagDao.applyTags(task, tagDataDao, getTags(remote.categories)) tagDao.applyTags(task, tagDataDao, getTags(remote.categories))
} }
if (account.reminderSync) {
val alarms = alarmDao.getAlarms(task.id).onEach { val alarms = alarmDao.getAlarms(task.id).onEach {
it.id = 0 it.id = 0
it.task = 0 it.task = 0
@ -218,11 +230,13 @@ class iCalendar @Inject constructor(
local?.reminders?.plus(randomReminders) ?: randomReminders local?.reminders?.plus(randomReminders) ?: randomReminders
if (alarms.toSet() == localReminders.toSet()) { if (alarms.toSet() == localReminders.toSet()) {
val remoteReminders = remote.reminders.plus(randomReminders) val remoteReminders = remote.reminders.plus(randomReminders)
val changed = alarmService.synchronizeAlarms(caldavTask.task, remoteReminders.toMutableSet()) val changed =
alarmService.synchronizeAlarms(caldavTask.task, remoteReminders.toMutableSet())
if (changed) { if (changed) {
task.modificationDate = DateUtilities.now() task.modificationDate = DateUtilities.now()
} }
} }
}
task.suppressSync() task.suppressSync()
task.suppressRefresh() task.suppressRefresh()

3
app/src/main/java/org/tasks/data/CaldavAccount.kt
Unescape Escape View File

@ -122,6 +122,9 @@ class CaldavAccount : Parcelable {
else -> false else -> false
} }
val reminderSync: Boolean
get() = serverType != SERVER_SYNOLOGY_CALENDAR
override fun describeContents() = 0 override fun describeContents() = 0
override fun writeToParcel(dest: Parcel, flags: Int) { override fun writeToParcel(dest: Parcel, flags: Int) {

18
app/src/main/java/org/tasks/etebase/EtebaseSynchronizer.kt
Unescape Escape View File

@ -98,8 +98,8 @@ class EtebaseSynchronizer @Inject constructor(
caldavDao.update(calendar) caldavDao.update(calendar)
localBroadcastManager.broadcastRefreshList() localBroadcastManager.broadcastRefreshList()
} }
fetchChanges(client, calendar, collection) fetchChanges(account, client, calendar, collection)
pushLocalChanges(client, calendar, collection) pushLocalChanges(account, client, calendar, collection)
} }
setError(account, "") setError(account, "")
} }
@ -117,6 +117,7 @@ class EtebaseSynchronizer @Inject constructor(
} }
private suspend fun fetchChanges( private suspend fun fetchChanges(
account: CaldavAccount,
client: EtebaseClient, client: EtebaseClient,
caldavCalendar: CaldavCalendar, caldavCalendar: CaldavCalendar,
collection: Collection collection: Collection
@ -127,7 +128,7 @@ class EtebaseSynchronizer @Inject constructor(
} }
Timber.d("updating $caldavCalendar") Timber.d("updating $caldavCalendar")
client.fetchItems(collection, caldavCalendar) { (stoken, items) -> client.fetchItems(collection, caldavCalendar) { (stoken, items) ->
applyEntries(caldavCalendar, items, stoken) applyEntries(account, caldavCalendar, items, stoken)
client.updateCache(collection, items) client.updateCache(collection, items)
} }
Timber.d("UPDATE %s", caldavCalendar) Timber.d("UPDATE %s", caldavCalendar)
@ -137,6 +138,7 @@ class EtebaseSynchronizer @Inject constructor(
} }
private suspend fun pushLocalChanges( private suspend fun pushLocalChanges(
account: CaldavAccount,
client: EtebaseClient, client: EtebaseClient,
caldavCalendar: CaldavCalendar, caldavCalendar: CaldavCalendar,
collection: Collection collection: Collection
@ -163,23 +165,25 @@ class EtebaseSynchronizer @Inject constructor(
client.updateItem( client.updateItem(
collection, collection,
caldavTask, caldavTask,
iCal.toVtodo(caldavCalendar, caldavTask, task) iCal.toVtodo(account, caldavCalendar, caldavTask, task)
) )
) )
} }
} }
if (changes.isNotEmpty()) { if (changes.isNotEmpty()) {
client.uploadChanges(collection, changes) client.uploadChanges(collection, changes)
applyEntries(caldavCalendar, changes, isLocalChange = true) applyEntries(account, caldavCalendar, changes, isLocalChange = true)
client.updateCache(collection, changes) client.updateCache(collection, changes)
} }
} }
private suspend fun applyEntries( private suspend fun applyEntries(
account: CaldavAccount,
caldavCalendar: CaldavCalendar, caldavCalendar: CaldavCalendar,
items: List<Item>, items: List<Item>,
stoken: String? = null, stoken: String? = null,
isLocalChange: Boolean = false) { isLocalChange: Boolean = false
) {
for (item in items) { for (item in items) {
val vtodo = item.contentString val vtodo = item.contentString
val task = fromVtodo(vtodo) ?: continue val task = fromVtodo(vtodo) ?: continue
@ -202,7 +206,7 @@ class EtebaseSynchronizer @Inject constructor(
} }
} else { } else {
caldavTask?.`object` = item.uid caldavTask?.`object` = item.uid
iCal.fromVtodo(caldavCalendar, caldavTask, task, vtodo, item.uid, null) iCal.fromVtodo(account, caldavCalendar, caldavTask, task, vtodo, item.uid, null)
} }
} }
stoken?.let { stoken?.let {

33
app/src/main/java/org/tasks/opentasks/OpenTasksSynchronizer.kt
Unescape Escape View File

@ -90,9 +90,8 @@ class OpenTasksSynchronizer @Inject constructor(
.forEach { taskDeleter.delete(it) } .forEach { taskDeleter.delete(it) }
lists.forEach { lists.forEach {
val calendar = toLocalCalendar(it) val calendar = toLocalCalendar(it)
val isEteSync = account.uuid?.isEteSync() == true pushChanges(account, calendar, it.id)
pushChanges(isEteSync, calendar, it.id) fetchChanges(account, calendar, it.ctag, it.id)
fetchChanges(isEteSync, calendar, it.ctag, it.id)
} }
} }
@ -113,7 +112,11 @@ class OpenTasksSynchronizer @Inject constructor(
return local return local
} }
private suspend fun pushChanges(isEteSync: Boolean, calendar: CaldavCalendar, listId: Long) { private suspend fun pushChanges(
account: CaldavAccount,
calendar: CaldavCalendar,
listId: Long
) {
val moved = caldavDao.getMoved(calendar.uuid!!) val moved = caldavDao.getMoved(calendar.uuid!!)
val (deleted, updated) = taskDao val (deleted, updated) = taskDao
.getCaldavTasksToPush(calendar.uuid!!) .getCaldavTasksToPush(calendar.uuid!!)
@ -127,12 +130,12 @@ class OpenTasksSynchronizer @Inject constructor(
taskDeleter.delete(deleted.map { it.id }) taskDeleter.delete(deleted.map { it.id })
updated.forEach { updated.forEach {
push(it, listId, isEteSync) push(account, it, listId)
} }
} }
private suspend fun fetchChanges( private suspend fun fetchChanges(
isEteSync: Boolean, account: CaldavAccount,
calendar: CaldavCalendar, calendar: CaldavCalendar,
ctag: String?, ctag: String?,
listId: Long listId: Long
@ -146,9 +149,9 @@ class OpenTasksSynchronizer @Inject constructor(
val etags = openTaskDao.getEtags(listId) val etags = openTaskDao.getEtags(listId)
etags.forEach { (uid, sync1, version) -> etags.forEach { (uid, sync1, version) ->
val caldavTask = caldavDao.getTaskByRemoteId(calendar.uuid!!, uid) val caldavTask = caldavDao.getTaskByRemoteId(calendar.uuid!!, uid)
val etag = if (isEteSync) version else sync1 val etag = if (account.isEteSync) version else sync1
if (caldavTask?.etag == null || caldavTask.etag != etag) { if (caldavTask?.etag == null || caldavTask.etag != etag) {
applyChanges(calendar, listId, uid, etag, caldavTask) applyChanges(account, calendar, listId, uid, etag, caldavTask)
} }
} }
removeDeleted(calendar.uuid!!, etags.map { it.first }) removeDeleted(calendar.uuid!!, etags.map { it.first })
@ -180,16 +183,16 @@ class OpenTasksSynchronizer @Inject constructor(
} }
} }
private suspend fun push(task: Task, listId: Long, isEteSync: Boolean) { private suspend fun push(account: CaldavAccount, task: Task, listId: Long) {
val caldavTask = caldavDao.getTask(task.id) ?: return val caldavTask = caldavDao.getTask(task.id) ?: return
val uid = caldavTask.remoteId!! val uid = caldavTask.remoteId!!
val androidTask = openTaskDao.getTask(listId, uid) val androidTask = openTaskDao.getTask(listId, uid)
?: MyAndroidTask(at.bitfire.ical4android.Task()) ?: MyAndroidTask(at.bitfire.ical4android.Task())
iCalendar.toVtodo(caldavTask, task, androidTask.task!!) iCalendar.toVtodo(account, caldavTask, task, androidTask.task!!)
val operations = ArrayList<BatchOperation.CpoBuilder>() val operations = ArrayList<BatchOperation.CpoBuilder>()
val builder = androidTask.toBuilder(openTaskDao.tasks) val builder = androidTask.toBuilder(openTaskDao.tasks)
val idxTask = if (androidTask.isNew) { val idxTask = if (androidTask.isNew) {
if (isEteSync) { if (account.isEteSync) {
builder.withValue(Tasks.SYNC2, uid) builder.withValue(Tasks.SYNC2, uid)
} }
builder.withValue(Tasks.LIST_ID, listId) builder.withValue(Tasks.LIST_ID, listId)
@ -216,6 +219,7 @@ class OpenTasksSynchronizer @Inject constructor(
} }
private suspend fun applyChanges( private suspend fun applyChanges(
account: CaldavAccount,
calendar: CaldavCalendar, calendar: CaldavCalendar,
listId: Long, listId: Long,
uid: String, uid: String,
@ -223,7 +227,12 @@ class OpenTasksSynchronizer @Inject constructor(
existing: CaldavTask? existing: CaldavTask?
) { ) {
openTaskDao.getTask(listId, uid)?.let { openTaskDao.getTask(listId, uid)?.let {
iCalendar.fromVtodo(calendar, existing, it.task!!, null, null, etag) iCalendar.fromVtodo(account, calendar, existing, it.task!!, null, null, etag)
} }
} }
companion object {
private val CaldavAccount.isEteSync: Boolean
get() = uuid?.isEteSync() == true
}
} }
Write Preview
Loading…
Cancel
Save