Merge pull request #32 from levibostian/task-id-optional

Make task_id optional property in PendingTask.

app/src/main/java/com/levibostian/wendyexample/MainActivity.kt

@@ -58,10 +58,10 @@ class MainActivity : AppCompatActivity(), TaskRunnerListener {
         val recyclerViewAdapter = PendingTasksRecyclerViewAdapter(PendingTasks.sharedInstance().getAllTasks())
         recyclerViewAdapter.listener = object : PendingTasksRecyclerViewAdapter.Listener {
             override fun manuallyRunPressed(task: PendingTask) {
-                PendingTasks.sharedInstance().runTask(task.task_id)
+                PendingTasks.sharedInstance().runTask(task.task_id!!)
             }
             override fun resolveErrorPressed(task: PendingTask) {
-                PendingTasks.shared.resolveError(task.task_id)
+                PendingTasks.shared.resolveError(task.task_id!!)
             }
         }
         activity_main_tasks_recyclerview.adapter = recyclerViewAdapter

app/src/main/java/com/levibostian/wendyexample/PendingTasksRecyclerViewAdapter.kt

@@ -50,12 +50,12 @@ class PendingTasksRecyclerViewAdapter(val data: List<PendingTask>) : RecyclerVie
         holder.createdAtTextView.text = String.format("Created: %s", SimpleDateFormat("yyyy.MM.dd G 'at' HH:mm:ss z", Locale.ENGLISH).format(adapterItem.created_at))
 
         holder.statusTextView.text = "not running"
-        WendyConfig.addTaskStatusListenerForTask(adapterItem.task_id, holder.statusTextView)
+        WendyConfig.addTaskStatusListenerForTask(adapterItem.task_id!!, holder.statusTextView)
 
         holder.runTaskButton.setOnClickListener {
             listener?.manuallyRunPressed(adapterItem)
         }
-        holder.resolveErrorButton.visibility = if (PendingTasks.shared.doesErrorExist(adapterItem.task_id)) View.VISIBLE else View.GONE
+        holder.resolveErrorButton.visibility = if (PendingTasks.shared.doesErrorExist(adapterItem.task_id!!)) View.VISIBLE else View.GONE
         holder.resolveErrorButton.setOnClickListener {
             listener?.resolveErrorPressed(adapterItem)
         }

build.gradle

@@ -8,7 +8,7 @@ buildscript {
         google()
     }
     dependencies {
-        classpath 'com.android.tools.build:gradle:3.0.1'
+        classpath 'com.android.tools.build:gradle:3.1.0'
         classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
         classpath "org.jetbrains.dokka:dokka-android-gradle-plugin:${dokka_version}"
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,6 @@
-#Wed Feb 07 06:43:23 CST 2018
+#Fri Apr 06 13:28:13 CDT 2018
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-4.1-all.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.4-all.zip

wendy/src/main/java/com/levibostian/wendy/WendyConfig.kt

@@ -91,8 +91,8 @@ open class WendyConfig {
 
 internal fun WendyConfig.Companion.logTaskSkipped(task: PendingTask, reasonForSkip: ReasonPendingTaskSkipped) {
     Handler(Looper.getMainLooper()).post({
-        WendyConfig.getTaskStatusListenerForTask(task.task_id).forEach {
-            it.skipped(task.task_id, reasonForSkip)
+        WendyConfig.getTaskStatusListenerForTask(task.task_id ?: 0).forEach {
+            it.skipped(task.task_id!!, reasonForSkip)
         }
         WendyConfig.getTaskRunnerListeners().forEach {
             it.taskSkipped(reasonForSkip, task)
@@ -102,8 +102,8 @@ internal fun WendyConfig.Companion.logTaskSkipped(task: PendingTask, reasonForSk
 
 internal fun WendyConfig.Companion.logTaskRunning(task: PendingTask) {
     Handler(Looper.getMainLooper()).post({
-        WendyConfig.getTaskStatusListenerForTask(task.task_id).forEach {
-            it.running(task.task_id)
+        WendyConfig.getTaskStatusListenerForTask(task.task_id ?: 0).forEach {
+            it.running(task.task_id!!)
         }
         WendyConfig.getTaskRunnerListeners().forEach {
             it.runningTask(task)
@@ -113,8 +113,8 @@ internal fun WendyConfig.Companion.logTaskRunning(task: PendingTask) {
 
 internal fun WendyConfig.Companion.logTaskComplete(task: PendingTask, successful: Boolean, rescheduled: Boolean) {
     Handler(Looper.getMainLooper()).post({
-        WendyConfig.getTaskStatusListenerForTask(task.task_id).forEach {
-            it.complete(task.task_id, successful, rescheduled)
+        WendyConfig.getTaskStatusListenerForTask(task.task_id ?: 0).forEach {
+            it.complete(task.task_id!!, successful, rescheduled)
         }
         WendyConfig.getTaskRunnerListeners().forEach {
             it.taskComplete(successful, task, rescheduled)
@@ -124,8 +124,8 @@ internal fun WendyConfig.Companion.logTaskComplete(task: PendingTask, successful
 
 internal fun WendyConfig.Companion.logErrorRecorded(task: PendingTask, errorMessage: String?, errorId: String?) {
     Handler(Looper.getMainLooper()).post({
-        WendyConfig.getTaskStatusListenerForTask(task.task_id).forEach {
-            it.errorRecorded(task.task_id, errorMessage, errorId)
+        WendyConfig.getTaskStatusListenerForTask(task.task_id ?: 0).forEach {
+            it.errorRecorded(task.task_id!!, errorMessage, errorId)
         }
         WendyConfig.getTaskRunnerListeners().forEach {
             it.errorRecorded(task, errorMessage, errorId)
@@ -135,8 +135,8 @@ internal fun WendyConfig.Companion.logErrorRecorded(task: PendingTask, errorMess
 
 internal fun WendyConfig.Companion.logErrorResolved(task: PendingTask) {
     Handler(Looper.getMainLooper()).post({
-        WendyConfig.getTaskStatusListenerForTask(task.task_id).forEach {
-            it.errorResolved(task.task_id)
+        WendyConfig.getTaskStatusListenerForTask(task.task_id ?: 0).forEach {
+            it.errorResolved(task.task_id!!)
         }
         WendyConfig.getTaskRunnerListeners().forEach {
             it.errorResolved(task)

wendy/src/main/java/com/levibostian/wendy/extension/PendingTaskExtensions.kt

@@ -13,22 +13,46 @@ import com.levibostian.wendy.types.PendingTaskResult
  * @return [PendingTaskResult.FAILED] The extension automatically returns [PendingTaskResult.FAILED] for you so that you can simply call: `return recordError()` in your [PendingTask] to avoid return [PendingTaskResult.SUCCESSFUL] by accident from your [PendingTask].
  */
 fun PendingTask.recordError(humanReadableErrorMessage: String?, errorId: String?): PendingTaskResult {
-    PendingTasks.shared.recordError(this.task_id, humanReadableErrorMessage, errorId)
+    val taskId = assertHasBeenAddedToWendy()
+
+    PendingTasks.shared.recordError(taskId, humanReadableErrorMessage, errorId)
 
     return PendingTaskResult.FAILED
 }
 
 /**
  * Extension to [PendingTasks.resolveError] easily from a [PendingTask] instance.
  */
-fun PendingTask.resolveError() = PendingTasks.shared.resolveError(this.task_id)
+fun PendingTask.resolveError() {
+    val taskId = assertHasBeenAddedToWendy()
+    PendingTasks.shared.resolveError(taskId)
+}
 
 /**
  * Extension to [PendingTasks.getLatestError] easily from a [PendingTask] instance.
  */
-fun PendingTask.getLatestError(): PendingTaskError? = PendingTasks.shared.getLatestError(this.task_id)
+fun PendingTask.getLatestError(): PendingTaskError? {
+    val taskId = assertHasBeenAddedToWendy()
+    return PendingTasks.shared.getLatestError(taskId)
+}
 
 /**
  * Extension to [WendyConfig.addTaskStatusListenerForTask] easily from a [PendingTask] instance.
  */
-fun PendingTask.addTaskStatusListenerForTask(listener: PendingTaskStatusListener) = WendyConfig.addTaskStatusListenerForTask(this.task_id, listener)
+fun PendingTask.addTaskStatusListenerForTask(listener: PendingTaskStatusListener) {
+    val taskId = assertHasBeenAddedToWendy()
+    WendyConfig.addTaskStatusListenerForTask(taskId, listener)
+}
+
+/**
+ * Checks to see if the [PendingTask] has been added to Wendy yet.
+ *
+ * This function simply checks if the [PendingTask.task_id] is null or not.
+ */
+fun PendingTask.hasBeenAddedToWendy(): Boolean = this.task_id != null
+
+internal fun PendingTask.assertHasBeenAddedToWendy(): Long {
+    if (!hasBeenAddedToWendy()) throw RuntimeException("Cannot record error for your task because it has not been added to Wendy (aka: the task id has not been set yet)")
+
+    return this.task_id!!
+}

wendy/src/main/java/com/levibostian/wendy/service/PendingTask.kt

@@ -26,7 +26,7 @@ abstract class PendingTask(override var manually_run: Boolean,
                            override var group_id: String?,
                            override var tag: String): PendingTaskFields {
 
-    var task_id: Long = 0
+    var task_id: Long? = null
     override var created_at: Long = Date().time
 
     /**

wendy/src/main/java/com/levibostian/wendy/service/PendingTasks.kt

@@ -97,11 +97,11 @@ open class PendingTasks private constructor(context: Context, internal val tasks
             throw IllegalArgumentException("Exception thrown while calling ${tasksFactory::class.java.simpleName}'s getTask(). Did you forgot to add ${pendingTask::class.java.simpleName} to your instance of ${tasksFactory::class.java.simpleName}?")
         }
 
-        if (doesErrorExist(pendingTask.task_id) && resolveErrorIfTaskExists) {
-            resolveError(pendingTask.task_id)
-        }
-
         tasksManager.getExistingTask(pendingTask)?.let { existingPersistedPendingTask ->
+            if (doesErrorExist(existingPersistedPendingTask.id) && resolveErrorIfTaskExists) {
+                resolveError(existingPersistedPendingTask.id)
+            }
+
             return existingPersistedPendingTask.id
         }
 
@@ -110,10 +110,10 @@ open class PendingTasks private constructor(context: Context, internal val tasks
 
         if (WendyConfig.automaticallyRunTasks && !addedTask.manually_run) {
             LogUtil.d("Wendy is configured to automatically run tasks. Wendy will now attempt to run newly added task: $addedTask")
-            runTask(addedTask.task_id) // Run task right now in case this newly added task can run right away.
+            runTask(addedTask.task_id!!) // Run task right now in case this newly added task can run right away.
         } else LogUtil.d("Wendy configured to not automatically run tasks. Skipping execution of newly added task: $addedTask")
 
-        return addedTask.task_id
+        return addedTask.task_id!!
     }
 
     /**

wendy/src/main/java/com/levibostian/wendy/service/PendingTasksRunner.kt

@@ -32,15 +32,15 @@ internal class PendingTasksRunner(val context: Context,
             return
         }
 
-        lastSuccessfulOrFailedTaskId = nextTaskToRun.task_id
+        lastSuccessfulOrFailedTaskId = nextTaskToRun.task_id!!
         if (nextTaskToRun.group_id != null && failedTasksGroups.contains(nextTaskToRun.group_id!!)) {
             WendyConfig.logTaskSkipped(nextTaskToRun, ReasonPendingTaskSkipped.PART_OF_FAILED_GROUP)
             LogUtil.d("Task: $nextTaskToRun belongs to a failing group of tasks. Skipping it.")
             runAllTasks()
             return
         }
 
-        val jobRunResult = runTask(nextTaskToRun.task_id)
+        val jobRunResult = runTask(nextTaskToRun.task_id!!)
         jobRunResult.accept(object : PendingTasksRunnerJobRunResult.Visitor<Unit?> {
             override fun visitSkippedUnresolvedRecordedError(): Unit? {
                 nextTaskToRun.group_id?.let { failedTasksGroups.add(it) }
@@ -75,7 +75,7 @@ internal class PendingTasksRunner(val context: Context,
             LogUtil.d("Task: $taskToRun is not ready to run. Skipping it.")
             return PendingTasksRunnerJobRunResult.SKIPPED_NOT_READY
         }
-        if (pendingTasksManager.getLatestError(taskToRun.task_id) != null) {
+        if (pendingTasksManager.getLatestError(taskToRun.task_id!!) != null) {
             WendyConfig.logTaskSkipped(taskToRun, ReasonPendingTaskSkipped.UNRESOLVED_RECORDED_ERROR)
             LogUtil.d("Task: $taskToRun has a unresolved error recorded. Skipping it.")
             return PendingTasksRunnerJobRunResult.SKIPPED_UNRESOLVED_RECORDED_ERROR
@@ -91,7 +91,7 @@ internal class PendingTasksRunner(val context: Context,
 
         when (result) {
             PendingTaskResult.SUCCESSFUL -> {
-                if (PendingTasks.shared.doesErrorExist(taskToRun.task_id)) {
+                if (PendingTasks.shared.doesErrorExist(taskToRun.task_id!!)) {
                     val errorMessage = "You returned ${PendingTaskResult.SUCCESSFUL} for running your ${PendingTask::class.java.simpleName}, but you have unresolved issues for task: $taskToRun. You should resolve the previously recorded error to Wendy, or return ${PendingTaskResult.FAILED}."
                     if (WendyConfig.strict) throw RuntimeException(errorMessage) else LogUtil.w(errorMessage)
                 }