#111

pending completion

Build # #111

Build Type

push

github-actions

Committed by

web-flow

Commit Message

Implementing settings UI for preferred number of tasks per day.  (#176)

Run Details

1500 of 2154 relevant lines covered (69.64%)

0.7 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

94.87

app/src/main/java/com/adammcneilly/toa/addtask/domain/usecases/ProdAddTaskUseCase.kt

package com.adammcneilly.toa.addtask.domain.usecases

import com.adammcneilly.toa.addtask.domain.model.AddTaskResult
import com.adammcneilly.toa.core.models.Task
import com.adammcneilly.toa.preferences.UserPreferences
import com.adammcneilly.toa.task.api.TaskRepository
import kotlinx.coroutines.flow.first
import java.time.Instant
import java.time.LocalDate
import java.time.ZoneId
import javax.inject.Inject

class ProdAddTaskUseCase @Inject constructor(
    private val taskRepository: TaskRepository,
    private val userPreferences: UserPreferences,
) : AddTaskUseCase {

    @Suppress("ReturnCount")
    override suspend fun invoke(
        task: Task,
        ignoreTaskLimits: Boolean,
    ): AddTaskResult {
        val sanitizedTask = task.copy(
            description = task.description.trim(),
        )

        val validationResult = validateInput(sanitizedTask)

        if (validationResult != null) {
            return validationResult
        }

        if (!ignoreTaskLimits) {
            val preferenceCheckResult = ensureNumTasksWithinPreferences(task, taskRepository, userPreferences)

            if (preferenceCheckResult != null) {
                return preferenceCheckResult
            }
        }

        val result = taskRepository.addTask(sanitizedTask)

        return result.fold(
            onSuccess = {
                AddTaskResult.Success
            },
            onFailure = {
                AddTaskResult.Failure.Unknown
            },
        )
    }

    private suspend fun ensureNumTasksWithinPreferences(
        task: Task,
        taskRepository: TaskRepository,
        userPreferences: UserPreferences,
    ): AddTaskResult.Failure.MaxTasksPerDayExceeded? {
        if (!userPreferences.getPreferredNumTasksPerDayEnabled()) {
            return null
        }

        val preferredNumTasks = userPreferences.getPreferredNumTasksPerDay() ?: return null

        val incompleteTaskList = taskRepository.fetchTasksForDate(
            dateMillis = task.scheduledDateMillis,
            completed = false,
        ).first().getOrNull()

        val numIncompleteTasks = incompleteTaskList?.size ?: 0

        return if (numIncompleteTasks >= preferredNumTasks) {
            AddTaskResult.Failure.MaxTasksPerDayExceeded
        } else {
            null
        }
    }

    /**
     * Since it's no longer possible to select a date in the past (our date picker validates this),
     * we can simplify this to only validate that the description is not empty.
     */
    private fun validateInput(task: Task): AddTaskResult.Failure.InvalidInput? {
        val emptyDescription = task.description.isBlank()

        val scheduledDate = Instant
            .ofEpochMilli(task.scheduledDateMillis)
            .atZone(ZoneId.systemDefault())
            .toLocalDate()
        val scheduledDateInPast = scheduledDate.isBefore(LocalDate.now())

        return if (emptyDescription || scheduledDateInPast) {
            AddTaskResult.Failure.InvalidInput(
                emptyDescription = emptyDescription,
                scheduledDateInPast = scheduledDateInPast,
            )
        } else {
            null
        }
    }
}

1	package com.adammcneilly.toa.addtask.domain.usecases
2
3	import com.adammcneilly.toa.addtask.domain.model.AddTaskResult
4	import com.adammcneilly.toa.core.models.Task
5	import com.adammcneilly.toa.preferences.UserPreferences
6	import com.adammcneilly.toa.task.api.TaskRepository
7	import kotlinx.coroutines.flow.first
8	import java.time.Instant
9	import java.time.LocalDate
10	import java.time.ZoneId
11	import javax.inject.Inject
12
13	class ProdAddTaskUseCase @Inject constructor(	1✔
14	private val taskRepository: TaskRepository,	1✔
15	private val userPreferences: UserPreferences,	1✔
16	) : AddTaskUseCase {
17
18	@Suppress("ReturnCount")
19	override suspend fun invoke(	1✔
20	task: Task,
21	ignoreTaskLimits: Boolean,
22	): AddTaskResult {
23	val sanitizedTask = task.copy(	1✔
24	description = task.description.trim(),	1✔
25	)
26
27	val validationResult = validateInput(sanitizedTask)	1✔
28
29	if (validationResult != null) {	1✔
30	return validationResult	1✔
31	}
32
33	if (!ignoreTaskLimits) {	1✔
34	val preferenceCheckResult = ensureNumTasksWithinPreferences(task, taskRepository, userPreferences)	1✔
35
36	if (preferenceCheckResult != null) {	1✔
37	return preferenceCheckResult	1✔
38	}
39	}
40
41	val result = taskRepository.addTask(sanitizedTask)	1✔
42
43	return result.fold(	1✔
44	onSuccess = {
45	AddTaskResult.Success	1✔
46	},
47	onFailure = {
48	AddTaskResult.Failure.Unknown	×
49	},
50	)
51	}
52
53	private suspend fun ensureNumTasksWithinPreferences(
54	task: Task,
55	taskRepository: TaskRepository,
56	userPreferences: UserPreferences,
57	): AddTaskResult.Failure.MaxTasksPerDayExceeded? {
58	if (!userPreferences.getPreferredNumTasksPerDayEnabled()) {	1✔
59	return null	1✔
60	}
61
62	val preferredNumTasks = userPreferences.getPreferredNumTasksPerDay() ?: return null	1✔
63
64	val incompleteTaskList = taskRepository.fetchTasksForDate(	1✔
65	dateMillis = task.scheduledDateMillis,	1✔
66	completed = false,	1✔
67	).first().getOrNull()	1✔
68
69	val numIncompleteTasks = incompleteTaskList?.size ?: 0	1✔
70
71	return if (numIncompleteTasks >= preferredNumTasks) {	1✔
72	AddTaskResult.Failure.MaxTasksPerDayExceeded	1✔
73	} else {
74	null	×
75	}
76	}
77
78	/**
79	* Since it's no longer possible to select a date in the past (our date picker validates this),
80	* we can simplify this to only validate that the description is not empty.
81	*/
82	private fun validateInput(task: Task): AddTaskResult.Failure.InvalidInput? {
83	val emptyDescription = task.description.isBlank()	1✔
84
85	val scheduledDate = Instant	1✔
86	.ofEpochMilli(task.scheduledDateMillis)	1✔
87	.atZone(ZoneId.systemDefault())	1✔
88	.toLocalDate()	1✔
89	val scheduledDateInPast = scheduledDate.isBefore(LocalDate.now())	1✔
90
91	return if (emptyDescription \|\| scheduledDateInPast) {	1✔
92	AddTaskResult.Failure.InvalidInput(	1✔
93	emptyDescription = emptyDescription,	1✔
94	scheduledDateInPast = scheduledDateInPast,	1✔
95	)
96	} else {
97	null	1✔
98	}
99	}
100	}

AdamMc331 / TOA / #111

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous