Add opentask properties tests

pull/1340/head
Alex Baker 5 years ago
parent 5110a8ad1f
commit cc09150141

@ -0,0 +1,150 @@
package org.tasks.opentasks
import com.natpryce.makeiteasy.MakeItEasy.with
import dagger.hilt.android.testing.HiltAndroidTest
import dagger.hilt.android.testing.UninstallModules
import kotlinx.coroutines.runBlocking
import org.junit.Assert.assertEquals
import org.junit.Test
import org.tasks.TestUtilities
import org.tasks.injection.ProductionModule
import org.tasks.makers.CaldavTaskMaker
import org.tasks.makers.CaldavTaskMaker.newCaldavTask
import org.tasks.makers.TaskMaker
import org.tasks.makers.TaskMaker.newTask
import org.tasks.time.DateTime
import java.util.*
@UninstallModules(ProductionModule::class)
@HiltAndroidTest
class OpenTasksDueDateTests : OpenTasksTest() {
@Test
fun readDueDatePositiveOffset() = runBlocking {
val (_, list) = withVtodo(ALL_DAY_DUE)
TestUtilities.withTZ(BERLIN) {
synchronizer.sync()
}
val caldavTask = caldavDao.getTaskByRemoteId(list.uuid!!, "3863299529704302692")
val task = taskDao.fetch(caldavTask!!.task)
assertEquals(
DateTime(2021, 2, 1, 12, 0, 0, 0, BERLIN).millis,
task?.dueDate
)
}
@Test
fun writeDueDatePositiveOffset() = TestUtilities.withTZ(BERLIN) {
val (listId, list) = openTaskDao.insertList()
val taskId = taskDao.createNew(newTask(
with(TaskMaker.DUE_DATE, DateTime(2021, 2, 1))
))
caldavDao.insert(newCaldavTask(
with(CaldavTaskMaker.CALENDAR, list.uuid),
with(CaldavTaskMaker.REMOTE_ID, "1234"),
with(CaldavTaskMaker.TASK, taskId)
))
synchronizer.sync()
assertEquals(
1612137600000,
openTaskDao.getTask(listId.toLong(), "1234")?.task?.due?.date?.time
)
}
@Test
fun readDueDateNoOffset() = runBlocking {
val (_, list) = withVtodo(ALL_DAY_DUE)
TestUtilities.withTZ(LONDON) {
synchronizer.sync()
}
val caldavTask = caldavDao.getTaskByRemoteId(list.uuid!!, "3863299529704302692")
val task = taskDao.fetch(caldavTask!!.task)
assertEquals(
DateTime(2021, 2, 1, 12, 0, 0, 0, LONDON).millis,
task?.dueDate
)
}
@Test
fun writeDueDateNoOffset() = TestUtilities.withTZ(LONDON) {
val (listId, list) = openTaskDao.insertList()
val taskId = taskDao.createNew(newTask(
with(TaskMaker.DUE_DATE, DateTime(2021, 2, 1))
))
caldavDao.insert(newCaldavTask(
with(CaldavTaskMaker.CALENDAR, list.uuid),
with(CaldavTaskMaker.REMOTE_ID, "1234"),
with(CaldavTaskMaker.TASK, taskId)
))
synchronizer.sync()
assertEquals(
1612137600000,
openTaskDao.getTask(listId.toLong(), "1234")?.task?.due?.date?.time
)
}
@Test
fun readDueDateNegativeOffset() = runBlocking {
val (_, list) = withVtodo(ALL_DAY_DUE)
TestUtilities.withTZ(NEW_YORK) {
synchronizer.sync()
}
val caldavTask = caldavDao.getTaskByRemoteId(list.uuid!!, "3863299529704302692")
val task = taskDao.fetch(caldavTask!!.task)
assertEquals(
DateTime(2021, 2, 1, 12, 0, 0, 0, NEW_YORK).millis,
task?.dueDate
)
}
@Test
fun writeDueDateNegativeOffset() = TestUtilities.withTZ(NEW_YORK) {
val (listId, list) = openTaskDao.insertList()
val taskId = taskDao.createNew(newTask(
with(TaskMaker.DUE_DATE, DateTime(2021, 2, 1))
))
caldavDao.insert(newCaldavTask(
with(CaldavTaskMaker.CALENDAR, list.uuid),
with(CaldavTaskMaker.REMOTE_ID, "1234"),
with(CaldavTaskMaker.TASK, taskId)
))
synchronizer.sync()
assertEquals(
1612137600000,
openTaskDao.getTask(listId.toLong(), "1234")?.task?.due?.date?.time
)
}
companion object {
private val BERLIN = TimeZone.getTimeZone("Europe/Berlin")
private val LONDON = TimeZone.getTimeZone("Europe/London")
private val NEW_YORK = TimeZone.getTimeZone("America/New_York")
private val ALL_DAY_DUE = """
BEGIN:VCALENDAR
VERSION:2.0
PRODID:+//IDN tasks.org//android-110304//EN
BEGIN:VTODO
DTSTAMP:20210129T155402Z
UID:3863299529704302692
CREATED:20210129T155318Z
LAST-MODIFIED:20210129T155329Z
SUMMARY:Due date
DUE;VALUE=DATE:20210201
END:VTODO
END:VCALENDAR
""".trimIndent()
}
}

@ -0,0 +1,199 @@
package org.tasks.opentasks
import com.natpryce.makeiteasy.MakeItEasy.with
import com.todoroo.astrid.data.Task
import dagger.hilt.android.testing.HiltAndroidTest
import dagger.hilt.android.testing.UninstallModules
import kotlinx.coroutines.runBlocking
import org.junit.Assert.assertEquals
import org.junit.Test
import org.tasks.caldav.iCalendar.Companion.getParent
import org.tasks.caldav.iCalendar.Companion.order
import org.tasks.data.TagDao
import org.tasks.data.TagDataDao
import org.tasks.injection.ProductionModule
import org.tasks.makers.CaldavTaskMaker
import org.tasks.makers.CaldavTaskMaker.CALENDAR
import org.tasks.makers.CaldavTaskMaker.REMOTE_ID
import org.tasks.makers.CaldavTaskMaker.REMOTE_ORDER
import org.tasks.makers.CaldavTaskMaker.newCaldavTask
import org.tasks.makers.TagDataMaker.NAME
import org.tasks.makers.TagDataMaker.newTagData
import org.tasks.makers.TagMaker.TAGDATA
import org.tasks.makers.TagMaker.TASK
import org.tasks.makers.TagMaker.newTag
import org.tasks.makers.TaskMaker
import org.tasks.makers.TaskMaker.newTask
import javax.inject.Inject
@UninstallModules(ProductionModule::class)
@HiltAndroidTest
class OpenTasksPropertiesTests : OpenTasksTest() {
@Inject lateinit var tagDataDao: TagDataDao
@Inject lateinit var tagDao: TagDao
@Test
fun loadRemoteParentInfo() = runBlocking {
val (_, list) = withVtodo(SUBTASK)
synchronizer.sync()
val task = caldavDao.getTaskByRemoteId(list.uuid!!, "dfede1b0-435b-4bba-9708-2422e781747c")
assertEquals("7daa4a5c-cc76-4ddf-b4f8-b9d3a9cb00e7", task?.remoteParent)
}
@Test
fun pushParentInfo() = runBlocking {
val (listId, list) = openTaskDao.insertList()
val taskId = taskDao.createNew(newTask(with(TaskMaker.PARENT, 594)))
caldavDao.insert(newCaldavTask(
with(CALENDAR, list.uuid),
with(CaldavTaskMaker.TASK, taskId),
with(REMOTE_ID, "abcd"),
with(CaldavTaskMaker.REMOTE_PARENT, "1234")
))
synchronizer.sync()
assertEquals("1234", openTaskDao.getTask(listId, "abcd")?.task?.getParent())
}
@Test
fun createNewTags() = runBlocking {
val (_, list) = withVtodo(TWO_TAGS)
synchronizer.sync()
assertEquals(
setOf("Tag1", "Tag2"),
caldavDao.getTaskByRemoteId(list.uuid!!, "3076145036806467726")
?.task
?.let { tagDao.getTagsForTask(it) }
?.map { it.name }
?.toSet()
)
}
@Test
fun matchExistingTag() = runBlocking {
val (_, list) = withVtodo(ONE_TAG)
val tag = newTagData(with(NAME, "Tag1"))
tagDataDao.createNew(tag)
synchronizer.sync()
assertEquals(
listOf(tag),
caldavDao.getTaskByRemoteId(list.uuid!!, "3076145036806467726")
?.task
?.let { tagDataDao.getTagDataForTask(it)}
)
}
@Test
fun uploadTags() = runBlocking {
val (listId, list) = openTaskDao.insertList()
val task = newTask().apply { taskDao.createNew(this) }
caldavDao.insert(newCaldavTask(
with(CALENDAR, list.uuid),
with(REMOTE_ID, "1234"),
with(CaldavTaskMaker.TASK, task.id)
))
insertTag(task, "Tag1")
insertTag(task, "Tag2")
synchronizer.sync()
assertEquals(
setOf("Tag1", "Tag2"),
openTaskDao.getTask(listId, "1234")?.task?.categories?.toSet()
)
}
@Test
fun loadOrder() = runBlocking {
val (_, list) = withVtodo(ONE_TAG)
synchronizer.sync()
assertEquals(
633734058L,
caldavDao.getTaskByRemoteId(list.uuid!!, "3076145036806467726")?.order
)
}
@Test
fun pushOrder() = runBlocking {
val (listId, list) = openTaskDao.insertList()
val task = newTask().apply { taskDao.createNew(this) }
caldavDao.insert(newCaldavTask(
with(CALENDAR, list.uuid),
with(REMOTE_ID, "1234"),
with(REMOTE_ORDER, 5678L),
with(CaldavTaskMaker.TASK, task.id)
))
synchronizer.sync()
assertEquals(
5678L,
openTaskDao.getTask(listId, "1234")?.task?.order
)
}
private suspend fun insertTag(task: Task, name: String) =
newTagData(with(NAME, name))
.apply { tagDataDao.createNew(this) }
.let { tagDao.insert(newTag(with(TASK, task), with(TAGDATA, it))) }
companion object {
private val SUBTASK = """
BEGIN:VCALENDAR
VERSION:2.0
PRODID:-//Nextcloud Tasks v0.13.6
BEGIN:VTODO
UID:dfede1b0-435b-4bba-9708-2422e781747c
CREATED:20210128T150333
LAST-MODIFIED:20210128T150338
DTSTAMP:20210128T150338
SUMMARY:Child
RELATED-TO:7daa4a5c-cc76-4ddf-b4f8-b9d3a9cb00e7
END:VTODO
END:VCALENDAR
""".trimIndent()
private val ONE_TAG = """
BEGIN:VCALENDAR
VERSION:2.0
PRODID:+//IDN tasks.org//android-110304//EN
BEGIN:VTODO
DTSTAMP:20210201T204211Z
UID:3076145036806467726
CREATED:20210201T204143Z
LAST-MODIFIED:20210201T204209Z
SUMMARY:Tags
CATEGORIES:Tag1
X-APPLE-SORT-ORDER:633734058
END:VTODO
END:VCALENDAR
""".trimIndent()
private val TWO_TAGS = """
BEGIN:VCALENDAR
VERSION:2.0
PRODID:+//IDN tasks.org//android-110304//EN
BEGIN:VTODO
DTSTAMP:20210201T204211Z
UID:3076145036806467726
CREATED:20210201T204143Z
LAST-MODIFIED:20210201T204209Z
SUMMARY:Tags
CATEGORIES:Tag1,Tag2
X-APPLE-SORT-ORDER:633734058
END:VTODO
END:VCALENDAR
""".trimIndent()
}
}

@ -6,48 +6,22 @@ import dagger.hilt.android.testing.HiltAndroidTest
import dagger.hilt.android.testing.UninstallModules import dagger.hilt.android.testing.UninstallModules
import kotlinx.coroutines.runBlocking import kotlinx.coroutines.runBlocking
import org.junit.Assert.* import org.junit.Assert.*
import org.junit.Before
import org.junit.Test import org.junit.Test
import org.tasks.R import org.tasks.R
import org.tasks.TestUtilities.withTZ
import org.tasks.caldav.iCalendar.Companion.getParent
import org.tasks.data.CaldavAccount import org.tasks.data.CaldavAccount
import org.tasks.data.CaldavAccount.Companion.TYPE_OPENTASKS import org.tasks.data.CaldavAccount.Companion.TYPE_OPENTASKS
import org.tasks.data.CaldavCalendar import org.tasks.data.CaldavCalendar
import org.tasks.data.CaldavDao
import org.tasks.data.TaskDao
import org.tasks.injection.InjectingTestCase
import org.tasks.injection.ProductionModule import org.tasks.injection.ProductionModule
import org.tasks.makers.CaldavTaskMaker.CALENDAR import org.tasks.makers.CaldavTaskMaker.CALENDAR
import org.tasks.makers.CaldavTaskMaker.REMOTE_ID import org.tasks.makers.CaldavTaskMaker.REMOTE_ID
import org.tasks.makers.CaldavTaskMaker.REMOTE_PARENT
import org.tasks.makers.CaldavTaskMaker.TASK import org.tasks.makers.CaldavTaskMaker.TASK
import org.tasks.makers.CaldavTaskMaker.newCaldavTask import org.tasks.makers.CaldavTaskMaker.newCaldavTask
import org.tasks.makers.TaskMaker
import org.tasks.makers.TaskMaker.PARENT
import org.tasks.makers.TaskMaker.RRULE import org.tasks.makers.TaskMaker.RRULE
import org.tasks.makers.TaskMaker.newTask import org.tasks.makers.TaskMaker.newTask
import org.tasks.preferences.Preferences
import org.tasks.time.DateTime
import java.util.*
import javax.inject.Inject
@UninstallModules(ProductionModule::class) @UninstallModules(ProductionModule::class)
@HiltAndroidTest @HiltAndroidTest
class OpenTasksSynchronizerTest : InjectingTestCase() { class OpenTasksSynchronizerTest : OpenTasksTest() {
@Inject lateinit var openTaskDao: TestOpenTaskDao
@Inject lateinit var caldavDao: CaldavDao
@Inject lateinit var synchronizer: OpenTasksSynchronizer
@Inject lateinit var preferences: Preferences
@Inject lateinit var taskDao: TaskDao
@Before
override fun setUp() {
super.setUp()
openTaskDao.reset()
preferences.setBoolean(R.string.p_debug_pro, true)
}
@Test @Test
fun createNewAccounts() = runBlocking { fun createNewAccounts() = runBlocking {
@ -144,178 +118,4 @@ class OpenTasksSynchronizerTest : InjectingTestCase() {
val task = openTaskDao.getTasks().first() val task = openTaskDao.getTasks().first()
assertEquals("FREQ=WEEKLY", task.rRule?.value) assertEquals("FREQ=WEEKLY", task.rRule?.value)
} }
@Test
fun loadRemoteParentInfo() = runBlocking {
val (listId, list) = openTaskDao.insertList()
openTaskDao.insertTask(listId, SUBTASK)
synchronizer.sync()
val task = caldavDao.getTaskByRemoteId(list.uuid!!, "dfede1b0-435b-4bba-9708-2422e781747c")
assertEquals("7daa4a5c-cc76-4ddf-b4f8-b9d3a9cb00e7", task?.remoteParent)
}
@Test
fun pushParentInfo() = runBlocking {
val (listId, list) = openTaskDao.insertList()
val taskId = taskDao.createNew(newTask(with(PARENT, 594)))
caldavDao.insert(newCaldavTask(
with(CALENDAR, list.uuid),
with(TASK, taskId),
with(REMOTE_ID, "abcd"),
with(REMOTE_PARENT, "1234")
))
synchronizer.sync()
assertEquals("1234", openTaskDao.getTask(listId.toLong(), "abcd")?.task?.getParent())
}
@Test
fun readDueDatePositiveOffset() = runBlocking {
val (listId, list) = openTaskDao.insertList()
openTaskDao.insertTask(listId, ALL_DAY_DUE)
withTZ(BERLIN) {
synchronizer.sync()
}
val caldavTask = caldavDao.getTaskByRemoteId(list.uuid!!, "3863299529704302692")
val task = taskDao.fetch(caldavTask!!.task)
assertEquals(
DateTime(2021, 2, 1, 12, 0, 0, 0, BERLIN).millis,
task?.dueDate
)
}
@Test
fun writeDueDatePositiveOffset() = withTZ(BERLIN) {
val (listId, list) = openTaskDao.insertList()
val taskId = taskDao.createNew(newTask(
with(TaskMaker.DUE_DATE, DateTime(2021, 2, 1))
))
caldavDao.insert(newCaldavTask(
with(CALENDAR, list.uuid),
with(REMOTE_ID, "1234"),
with(TASK, taskId)
))
synchronizer.sync()
assertEquals(
1612137600000,
openTaskDao.getTask(listId.toLong(), "1234")?.task?.due?.date?.time
)
}
@Test
fun readDueDateNoOffset() = runBlocking {
val (listId, list) = openTaskDao.insertList()
openTaskDao.insertTask(listId, ALL_DAY_DUE)
withTZ(LONDON) {
synchronizer.sync()
}
val caldavTask = caldavDao.getTaskByRemoteId(list.uuid!!, "3863299529704302692")
val task = taskDao.fetch(caldavTask!!.task)
assertEquals(
DateTime(2021, 2, 1, 12, 0, 0, 0, LONDON).millis,
task?.dueDate
)
}
@Test
fun writeDueDateNoOffset() = withTZ(LONDON) {
val (listId, list) = openTaskDao.insertList()
val taskId = taskDao.createNew(newTask(
with(TaskMaker.DUE_DATE, DateTime(2021, 2, 1))
))
caldavDao.insert(newCaldavTask(
with(CALENDAR, list.uuid),
with(REMOTE_ID, "1234"),
with(TASK, taskId)
))
synchronizer.sync()
assertEquals(
1612137600000,
openTaskDao.getTask(listId.toLong(), "1234")?.task?.due?.date?.time
)
}
@Test
fun readDueDateNegativeOffset() = runBlocking {
val (listId, list) = openTaskDao.insertList()
openTaskDao.insertTask(listId, ALL_DAY_DUE)
withTZ(NEW_YORK) {
synchronizer.sync()
}
val caldavTask = caldavDao.getTaskByRemoteId(list.uuid!!, "3863299529704302692")
val task = taskDao.fetch(caldavTask!!.task)
assertEquals(
DateTime(2021, 2, 1, 12, 0, 0, 0, NEW_YORK).millis,
task?.dueDate
)
}
@Test
fun writeDueDateNegativeOffset() = withTZ(NEW_YORK) {
val (listId, list) = openTaskDao.insertList()
val taskId = taskDao.createNew(newTask(
with(TaskMaker.DUE_DATE, DateTime(2021, 2, 1))
))
caldavDao.insert(newCaldavTask(
with(CALENDAR, list.uuid),
with(REMOTE_ID, "1234"),
with(TASK, taskId)
))
synchronizer.sync()
assertEquals(
1612137600000,
openTaskDao.getTask(listId.toLong(), "1234")?.task?.due?.date?.time
)
}
companion object {
val BERLIN = TimeZone.getTimeZone("Europe/Berlin")
val LONDON = TimeZone.getTimeZone("Europe/London")
val NEW_YORK = TimeZone.getTimeZone("America/New_York")
val SUBTASK = """
BEGIN:VCALENDAR
VERSION:2.0
PRODID:-//Nextcloud Tasks v0.13.6
BEGIN:VTODO
UID:dfede1b0-435b-4bba-9708-2422e781747c
CREATED:20210128T150333
LAST-MODIFIED:20210128T150338
DTSTAMP:20210128T150338
SUMMARY:Child
RELATED-TO:7daa4a5c-cc76-4ddf-b4f8-b9d3a9cb00e7
END:VTODO
END:VCALENDAR
""".trimIndent()
val ALL_DAY_DUE = """
BEGIN:VCALENDAR
VERSION:2.0
PRODID:+//IDN tasks.org//android-110304//EN
BEGIN:VTODO
DTSTAMP:20210129T155402Z
UID:3863299529704302692
CREATED:20210129T155318Z
LAST-MODIFIED:20210129T155329Z
SUMMARY:Due date
DUE;VALUE=DATE:20210201
END:VTODO
END:VCALENDAR
""".trimIndent()
}
} }

@ -0,0 +1,34 @@
package org.tasks.opentasks
import org.junit.Before
import org.tasks.R
import org.tasks.data.CaldavCalendar
import org.tasks.data.CaldavDao
import org.tasks.data.TaskDao
import org.tasks.injection.InjectingTestCase
import org.tasks.preferences.Preferences
import javax.inject.Inject
abstract class OpenTasksTest : InjectingTestCase() {
@Inject lateinit var openTaskDao: TestOpenTaskDao
@Inject lateinit var preferences: Preferences
@Inject lateinit var caldavDao: CaldavDao
@Inject lateinit var synchronizer: OpenTasksSynchronizer
@Inject lateinit var taskDao: TaskDao
@Before
override fun setUp() {
super.setUp()
openTaskDao.reset()
preferences.setBoolean(R.string.p_debug_pro, true)
}
protected suspend fun withVtodo(vtodo: String): Pair<Long, CaldavCalendar> =
openTaskDao
.insertList()
.let { (listId, list) ->
openTaskDao.insertTask(listId, vtodo)
Pair(listId, list)
}
}

@ -23,7 +23,7 @@ class TestOpenTaskDao @Inject constructor(
type: String = DEFAULT_TYPE, type: String = DEFAULT_TYPE,
account: String = DEFAULT_ACCOUNT, account: String = DEFAULT_ACCOUNT,
url: String = UUIDHelper.newUUID(), url: String = UUIDHelper.newUUID(),
): Pair<String, CaldavCalendar> { ): Pair<Long, CaldavCalendar> {
val uri = taskLists.buildUpon() val uri = taskLists.buildUpon()
.appendQueryParameter(TaskContract.CALLER_IS_SYNCADAPTER, "true") .appendQueryParameter(TaskContract.CALLER_IS_SYNCADAPTER, "true")
.appendQueryParameter(TaskContract.TaskLists.ACCOUNT_NAME, account) .appendQueryParameter(TaskContract.TaskLists.ACCOUNT_NAME, account)
@ -35,7 +35,7 @@ class TestOpenTaskDao @Inject constructor(
.withValue(TaskContract.TaskListColumns.LIST_NAME, name) .withValue(TaskContract.TaskListColumns.LIST_NAME, name)
.withValue(TaskContract.TaskLists.SYNC_ENABLED, "1") .withValue(TaskContract.TaskLists.SYNC_ENABLED, "1")
) )
return Pair(result.uri!!.lastPathSegment!!, CaldavCalendar().apply { return Pair(result.uri!!.lastPathSegment!!.toLong(), CaldavCalendar().apply {
uuid = UUIDHelper.newUUID() uuid = UUIDHelper.newUUID()
this.name = name this.name = name
this.account = "$type:$account" this.account = "$type:$account"
@ -44,7 +44,7 @@ class TestOpenTaskDao @Inject constructor(
}) })
} }
fun insertTask(listId: String, vtodo: String) { fun insertTask(listId: Long, vtodo: String) {
val ops = ArrayList<BatchOperation.CpoBuilder>() val ops = ArrayList<BatchOperation.CpoBuilder>()
val task = MyAndroidTask(TestUtilities.fromString(vtodo)) val task = MyAndroidTask(TestUtilities.fromString(vtodo))
ops.add(task.toBuilder(tasks).withValue(TaskContract.TaskColumns.LIST_ID, listId)) ops.add(task.toBuilder(tasks).withValue(TaskContract.TaskColumns.LIST_ID, listId))

@ -12,6 +12,7 @@ object CaldavTaskMaker {
val TASK: Property<CaldavTask, Long> = newProperty() val TASK: Property<CaldavTask, Long> = newProperty()
val REMOTE_ID: Property<CaldavTask, String?> = newProperty() val REMOTE_ID: Property<CaldavTask, String?> = newProperty()
val REMOTE_PARENT: Property<CaldavTask, String?> = newProperty() val REMOTE_PARENT: Property<CaldavTask, String?> = newProperty()
val REMOTE_ORDER: Property<CaldavTask, Long?> = newProperty()
val VTODO: Property<CaldavTask, String?> = newProperty() val VTODO: Property<CaldavTask, String?> = newProperty()
private val instantiator = Instantiator<CaldavTask> { private val instantiator = Instantiator<CaldavTask> {
@ -19,6 +20,7 @@ object CaldavTaskMaker {
task.remoteId = it.valueOf(REMOTE_ID, task.remoteId) task.remoteId = it.valueOf(REMOTE_ID, task.remoteId)
task.remoteParent = it.valueOf(REMOTE_PARENT, null as String?) task.remoteParent = it.valueOf(REMOTE_PARENT, null as String?)
task.vtodo = it.valueOf(VTODO, null as String?) task.vtodo = it.valueOf(VTODO, null as String?)
task.order = it.valueOf(REMOTE_ORDER, null as Long?)
task task
} }

@ -47,6 +47,9 @@ class Tag {
this.taskUid = taskUid this.taskUid = taskUid
} }
override fun toString(): String =
"Tag(id=$id, task=$task, name=$name, tagUid=$tagUid, taskUid=$taskUid)"
companion object { companion object {
const val KEY = "tags-tag" // $NON-NLS-1$ const val KEY = "tags-tag" // $NON-NLS-1$
@JvmField val TABLE = Table("tags") @JvmField val TABLE = Table("tags")

Loading…
Cancel
Save