refactor: move filter state generation to ViewModel and optimize sorting using precomputed epoch timestamps

This commit is contained in:
Jhony Cesar
2026-08-05 13:33:52 -04:00
parent 2f4767ce02
commit aeee13a0bd
4 changed files with 176 additions and 140 deletions

View File

@@ -12,7 +12,7 @@ import com.example.data.model.UserAccess
@Database( @Database(
entities = [MaintenanceActivity::class, OSUpdateHistory::class, SyncConflictLog::class, UserAccess::class, AppLog::class], entities = [MaintenanceActivity::class, OSUpdateHistory::class, SyncConflictLog::class, UserAccess::class, AppLog::class],
version = 6, version = 7,
exportSchema = false exportSchema = false
) )
abstract class AppDatabase : RoomDatabase() { abstract class AppDatabase : RoomDatabase() {

View File

@@ -1,13 +1,21 @@
package com.example.data.model package com.example.data.model
import androidx.room.Entity import androidx.room.Entity
import androidx.room.Index
import androidx.room.PrimaryKey import androidx.room.PrimaryKey
import java.text.SimpleDateFormat import java.text.SimpleDateFormat
import java.util.Calendar import java.util.Calendar
import java.util.Date import java.util.Date
import java.util.Locale import java.util.Locale
@Entity(tableName = "maintenance_activities") @Entity(
tableName = "maintenance_activities",
indices = [
Index("equipe"),
Index("setor"),
Index("synced")
]
)
data class MaintenanceActivity( data class MaintenanceActivity(
@PrimaryKey val numeroOs: String, @PrimaryKey val numeroOs: String,
val descricao: String, val descricao: String,
@@ -29,6 +37,16 @@ data class MaintenanceActivity(
percentualExecucao >= 100 -> ActivityStatus.CONCLUIDO percentualExecucao >= 100 -> ActivityStatus.CONCLUIDO
else -> ActivityStatus.EM_ANDAMENTO else -> ActivityStatus.EM_ANDAMENTO
} }
@delegate:Transient
val dataInicioMillis: Long by lazy {
(parseFullDateTime(dataInicio) ?: parseDateOnly(dataInicio))?.time ?: 0L
}
@delegate:Transient
val dataFimMillis: Long by lazy {
(parseFullDateTime(dataFim) ?: parseDateOnly(dataFim))?.time ?: Long.MAX_VALUE
}
} }
enum class ActivityStatus(val displayName: String) { enum class ActivityStatus(val displayName: String) {
@@ -56,6 +74,17 @@ data class GoogleUser(
val photoUrl: String? = null val photoUrl: String? = null
) )
// ThreadLocal map for formatters to prevent continuous instantiation of SimpleDateFormat
private val threadLocalFormatters = object : ThreadLocal<MutableMap<String, SimpleDateFormat>>() {
override fun initialValue(): MutableMap<String, SimpleDateFormat> = mutableMapOf()
}
private fun getFormatter(pattern: String): SimpleDateFormat {
val map = threadLocalFormatters.get()!!
return map.getOrPut(pattern) {
SimpleDateFormat(pattern, Locale.US).apply { isLenient = false }
}
}
fun extractDateOnly(dataStr: String): String { fun extractDateOnly(dataStr: String): String {
val clean = dataStr.trim() val clean = dataStr.trim()
@@ -89,22 +118,23 @@ fun adjustTwoDigitYear(date: Date?): Date? {
return date return date
} }
private val dateOnlyFormats = listOf(
"dd/MM/yyyy",
"dd/MM/yy",
"yyyy-MM-dd",
"yy-MM-dd",
"dd-MM-yyyy",
"dd-MM-yy",
"MM/dd/yyyy",
"MM/dd/yy"
)
fun parseDateOnly(dateStr: String): Date? { fun parseDateOnly(dateStr: String): Date? {
val clean = extractDateOnly(dateStr).trim() val clean = extractDateOnly(dateStr).trim()
val formats = listOf( if (clean == "N/A" || clean.isBlank()) return null
"dd/MM/yyyy", for (format in dateOnlyFormats) {
"dd/MM/yy",
"yyyy-MM-dd",
"yy-MM-dd",
"dd-MM-yyyy",
"dd-MM-yy",
"MM/dd/yyyy",
"MM/dd/yy"
)
for (format in formats) {
try { try {
val sdf = SimpleDateFormat(format, Locale.US) val sdf = getFormatter(format)
sdf.isLenient = false
val parsed = sdf.parse(clean) val parsed = sdf.parse(clean)
if (parsed != null) { if (parsed != null) {
return adjustTwoDigitYear(parsed) return adjustTwoDigitYear(parsed)
@@ -116,6 +146,29 @@ fun parseDateOnly(dateStr: String): Date? {
return null return null
} }
private val fullDateTimeFormats = listOf(
"dd/MM/yyyy HH:mm:ss",
"dd/MM/yyyy HH:mm",
"dd/MM/yy HH:mm:ss",
"dd/MM/yy HH:mm",
"yyyy-MM-dd HH:mm:ss",
"yyyy-MM-dd HH:mm",
"yy-MM-dd HH:mm:ss",
"yy-MM-dd HH:mm",
"yyyy-MM-dd'T'HH:mm:ss",
"yyyy-MM-dd'T'HH:mm",
"yy-MM-dd'T'HH:mm:ss",
"yy-MM-dd'T'HH:mm",
"dd/MM/yyyy",
"dd/MM/yy",
"yyyy-MM-dd",
"yy-MM-dd",
"dd-MM-yyyy",
"dd-MM-yy",
"MM/dd/yyyy",
"MM/dd/yy"
)
fun parseFullDateTime(dateTimeStr: String): Date? { fun parseFullDateTime(dateTimeStr: String): Date? {
var clean = dateTimeStr.trim() var clean = dateTimeStr.trim()
if (clean == "N/A" || clean.isBlank()) return null if (clean == "N/A" || clean.isBlank()) return null
@@ -123,32 +176,9 @@ fun parseFullDateTime(dateTimeStr: String): Date? {
// Strip leading weekday prefixes like "sex.", "seg.", "ter.", "qua.", "qui.", "sáb.", "dom.", "Sex", "Seg", etc. // Strip leading weekday prefixes like "sex.", "seg.", "ter.", "qua.", "qui.", "sáb.", "dom.", "Sex", "Seg", etc.
clean = clean.replace(Regex("^[a-zA-zA-ZáàâãéèêíóôõúçÁÀÂÃÉÈÍÓÔÕÚÇ]{2,4}\\.?\\s+"), "").trim() clean = clean.replace(Regex("^[a-zA-zA-ZáàâãéèêíóôõúçÁÀÂÃÉÈÍÓÔÕÚÇ]{2,4}\\.?\\s+"), "").trim()
val formats = listOf( for (format in fullDateTimeFormats) {
"dd/MM/yyyy HH:mm:ss",
"dd/MM/yyyy HH:mm",
"dd/MM/yy HH:mm:ss",
"dd/MM/yy HH:mm",
"yyyy-MM-dd HH:mm:ss",
"yyyy-MM-dd HH:mm",
"yy-MM-dd HH:mm:ss",
"yy-MM-dd HH:mm",
"yyyy-MM-dd'T'HH:mm:ss",
"yyyy-MM-dd'T'HH:mm",
"yy-MM-dd'T'HH:mm:ss",
"yy-MM-dd'T'HH:mm",
"dd/MM/yyyy",
"dd/MM/yy",
"yyyy-MM-dd",
"yy-MM-dd",
"dd-MM-yyyy",
"dd-MM-yy",
"MM/dd/yyyy",
"MM/dd/yy"
)
for (format in formats) {
try { try {
val sdf = SimpleDateFormat(format, Locale.US) val sdf = getFormatter(format)
sdf.isLenient = false
val parsed = sdf.parse(clean) val parsed = sdf.parse(clean)
if (parsed != null) { if (parsed != null) {
return adjustTwoDigitYear(parsed) return adjustTwoDigitYear(parsed)
@@ -166,13 +196,23 @@ fun formatToShortDate(dataStr: String): String {
val extracted = extractDateOnly(clean) val extracted = extractDateOnly(clean)
val parsed = parseDateOnly(extracted) ?: return extracted val parsed = parseDateOnly(extracted) ?: return extracted
return try { return try {
val sdf = SimpleDateFormat("dd/MM/yy", Locale.US) val sdf = getFormatter("dd/MM/yy")
sdf.format(parsed) sdf.format(parsed)
} catch (e: Exception) { } catch (e: Exception) {
extracted extracted
} }
} }
fun truncateToStartOfDay(millis: Long): Long {
val cal = Calendar.getInstance()
cal.timeInMillis = millis
cal.set(Calendar.HOUR_OF_DAY, 0)
cal.set(Calendar.MINUTE, 0)
cal.set(Calendar.SECOND, 0)
cal.set(Calendar.MILLISECOND, 0)
return cal.timeInMillis
}
fun isDateInExecutionPeriod(selectedDateStr: String, dataInicioStr: String, dataFimStr: String): Boolean { fun isDateInExecutionPeriod(selectedDateStr: String, dataInicioStr: String, dataFimStr: String): Boolean {
val cleanSelected = selectedDateStr.trim() val cleanSelected = selectedDateStr.trim()
if (cleanSelected == "Todas" || cleanSelected.isBlank()) return true if (cleanSelected == "Todas" || cleanSelected.isBlank()) return true
@@ -181,28 +221,11 @@ fun isDateInExecutionPeriod(selectedDateStr: String, dataInicioStr: String, data
val startDate = parseDateOnly(dataInicioStr) ?: parseFullDateTime(dataInicioStr) ?: return false val startDate = parseDateOnly(dataInicioStr) ?: parseFullDateTime(dataInicioStr) ?: return false
val endDate = parseDateOnly(dataFimStr) ?: parseFullDateTime(dataFimStr) ?: startDate val endDate = parseDateOnly(dataFimStr) ?: parseFullDateTime(dataFimStr) ?: startDate
val selCal = Calendar.getInstance().apply { val selTime = truncateToStartOfDay(selDate.time)
time = selDate val startTime = truncateToStartOfDay(startDate.time)
set(Calendar.HOUR_OF_DAY, 0) val endTime = truncateToStartOfDay(endDate.time)
set(Calendar.MINUTE, 0)
set(Calendar.SECOND, 0)
set(Calendar.MILLISECOND, 0)
}
val startCal = Calendar.getInstance().apply {
time = startDate
set(Calendar.HOUR_OF_DAY, 0)
set(Calendar.MINUTE, 0)
set(Calendar.SECOND, 0)
set(Calendar.MILLISECOND, 0)
}
val endCal = Calendar.getInstance().apply {
time = endDate
set(Calendar.HOUR_OF_DAY, 0)
set(Calendar.MINUTE, 0)
set(Calendar.SECOND, 0)
set(Calendar.MILLISECOND, 0)
}
return !selCal.before(startCal) && !selCal.after(endCal) return selTime in startTime..endTime
} }

View File

@@ -198,46 +198,10 @@ fun MaintenanceDashboardScreen(
} }
} }
val uniqueDates = remember(allActivities) { val uniqueDates by viewModel.uniqueDates.collectAsStateWithLifecycle()
val datesOnly = allActivities val uniqueRecursos by viewModel.uniqueRecursos.collectAsStateWithLifecycle()
.flatMap { listOf(extractDateOnly(it.dataInicio), extractDateOnly(it.dataFim)) } val uniqueSectors by viewModel.uniqueSectors.collectAsStateWithLifecycle()
.filter { it.isNotBlank() && it != "N/A" } val uniqueEquipes by viewModel.uniqueEquipes.collectAsStateWithLifecycle()
.distinct()
val sortedDates = datesOnly.sortedWith { d1, d2 ->
val parsed1 = parseDateOnly(d1)
val parsed2 = parseDateOnly(d2)
when {
parsed1 == null && parsed2 == null -> d1.compareTo(d2)
parsed1 == null -> 1
parsed2 == null -> -1
else -> parsed1.compareTo(parsed2)
}
}
val formattedDates = sortedDates.map { formatToShortDate(it) }.distinct()
listOf("Todas") + formattedDates
}
val uniqueRecursos = remember(allActivities) {
val recs = allActivities.flatMap { activity ->
activity.recurso.split(";").map { it.trim() }
}.filter {
it.isNotBlank() &&
it != "Sem Responsável" && it != "Sem responsável" &&
it != "Sem Recurso" && it != "Sem recurso"
}.distinct().sorted()
listOf("Todos") + recs
}
val uniqueSectors = remember(allActivities) {
val sectors = allActivities.map { it.setor }.filter { it.isNotBlank() }.distinct().sorted()
listOf("Todos") + sectors
}
val uniqueEquipes = remember(allActivities) {
val eqList = allActivities.map { it.equipe.trim() }.filter { it.isNotBlank() }.distinct().sorted()
listOf("Todas") + eqList
}
// Launcher for file picking (CSV Spreadsheet) // Launcher for file picking (CSV Spreadsheet)
val filePickerLauncher = rememberLauncherForActivityResult( val filePickerLauncher = rememberLauncherForActivityResult(
@@ -615,7 +579,7 @@ fun MaintenanceDashboardScreen(
.fillMaxWidth(), .fillMaxWidth(),
contentPadding = PaddingValues(bottom = 16.dp) contentPadding = PaddingValues(bottom = 16.dp)
) { ) {
items(activities, key = { it.numeroOs }) { activity -> items(activities, key = { it.numeroOs }, contentType = { "OSListItem" }) { activity ->
OSListItemCard( OSListItemCard(
activity = activity, activity = activity,
onClick = { viewModel.selectActivity(activity) } onClick = { viewModel.selectActivity(activity) }

View File

@@ -20,6 +20,7 @@ import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.flow.flowOn import kotlinx.coroutines.flow.flowOn
import java.util.Calendar import java.util.Calendar
import java.util.Date import java.util.Date
import kotlinx.coroutines.flow.map
import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow import kotlinx.coroutines.flow.StateFlow
@@ -109,6 +110,59 @@ class MaintenanceViewModel(private val repository: MaintenanceRepository) : View
} }
} }
val uniqueSectors: StateFlow<List<String>> = repository.allActivities
.map { activities ->
val sectors = activities.map { it.setor }.filter { it.isNotBlank() }.distinct().sorted()
listOf("Todos") + sectors
}
.flowOn(Dispatchers.Default)
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), listOf("Todos"))
val uniqueEquipes: StateFlow<List<String>> = repository.allActivities
.map { activities ->
val eqList = activities.map { it.equipe.trim() }.filter { it.isNotBlank() }.distinct().sorted()
listOf("Todas") + eqList
}
.flowOn(Dispatchers.Default)
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), listOf("Todas"))
val uniqueRecursos: StateFlow<List<String>> = repository.allActivities
.map { activities ->
val recs = activities.flatMap { activity ->
activity.recurso.split(";").map { it.trim() }
}.filter {
it.isNotBlank() &&
it != "Sem Responsável" && it != "Sem responsável" &&
it != "Sem Recurso" && it != "Sem recurso"
}.distinct().sorted()
listOf("Todos") + recs
}
.flowOn(Dispatchers.Default)
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), listOf("Todos"))
val uniqueDates: StateFlow<List<String>> = repository.allActivities
.map { activities ->
val datesOnly = activities
.map { extractDateOnly(it.dataInicio) }
.filter { it.isNotBlank() && it != "N/A" }
.distinct()
val sortedDates = datesOnly.sortedWith { d1, d2 ->
val parsed1 = parseDateOnly(d1)
val parsed2 = parseDateOnly(d2)
when {
parsed1 == null && parsed2 == null -> d1.compareTo(d2)
parsed1 == null -> 1
parsed2 == null -> -1
else -> parsed1.compareTo(parsed2)
}
}
val formattedDates = sortedDates.map { formatToShortDate(it) }.distinct()
listOf("Todas") + formattedDates
}
.flowOn(Dispatchers.Default)
.stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), listOf("Todas"))
val analyticsState: StateFlow<AnalyticsState> = combine( val analyticsState: StateFlow<AnalyticsState> = combine(
repository.allActivities, repository.allActivities,
repository.allHistory repository.allHistory
@@ -187,33 +241,29 @@ class MaintenanceViewModel(private val repository: MaintenanceRepository) : View
result result
} }
// Always sort by dataFim (predicted completion date) ascending, oldest first // Always sort by dataFim (predicted completion date) ascending, oldest first using dataFimMillis O(1)
filtered.sortedWith { a1, a2 -> filtered.sortedWith { a1, a2 ->
val p1 = parseFullDateTime(a1.dataFim) val p1 = a1.dataFimMillis
val p2 = parseFullDateTime(a2.dataFim) val p2 = a2.dataFimMillis
when { when {
p1 == null && p2 == null -> a1.numeroOs.compareTo(a2.numeroOs) p1 == Long.MAX_VALUE && p2 == Long.MAX_VALUE -> a1.numeroOs.compareTo(a2.numeroOs)
p1 == null -> 1 // Keep null/invalid date at the end p1 == Long.MAX_VALUE -> 1
p2 == null -> -1 p2 == Long.MAX_VALUE -> -1
else -> { else -> {
val comp = p1.compareTo(p2) val comp = p1.compareTo(p2)
if (comp != 0) { if (comp != 0) {
comp comp
} else { } else {
val s1 = parseFullDateTime(a1.dataInicio) val s1 = a1.dataInicioMillis
val s2 = parseFullDateTime(a2.dataInicio) val s2 = a2.dataInicioMillis
val startComp = when { val startComp = s1.compareTo(s2)
s1 == null && s2 == null -> 0
s1 == null -> 1
s2 == null -> -1
else -> s1.compareTo(s2)
}
if (startComp != 0) startComp else a1.numeroOs.compareTo(a2.numeroOs) if (startComp != 0) startComp else a1.numeroOs.compareTo(a2.numeroOs)
} }
} }
} }
} }
}.stateIn( }.flowOn(Dispatchers.Default)
.stateIn(
scope = viewModelScope, scope = viewModelScope,
started = SharingStarted.WhileSubscribed(5000), started = SharingStarted.WhileSubscribed(5000),
initialValue = emptyList() initialValue = emptyList()
@@ -544,32 +594,31 @@ class MaintenanceViewModel(private val repository: MaintenanceRepository) : View
team to ratio team to ratio
} }
// 2. S-Curve bounds and steps // 2. S-Curve bounds and steps using dataInicioMillis & dataFimMillis
val parsedDates = activities.flatMap { val startTimes = activities.map { it.dataInicioMillis }.filter { it > 0 }
listOfNotNull( val endTimes = activities.map { it.dataFimMillis }.filter { it < Long.MAX_VALUE }
parseFullDateTime(it.dataInicio) ?: parseDateOnly(it.dataInicio),
parseFullDateTime(it.dataFim) ?: parseDateOnly(it.dataFim)
)
}
val projectStart = parsedDates.minOrNull() ?: Calendar.getInstance().apply { set(2026, Calendar.AUGUST, 1) }.time
val projectEnd = parsedDates.maxOrNull() ?: Calendar.getInstance().apply { set(2026, Calendar.AUGUST, 29) }.time
val durationMs = projectEnd.time - projectStart.time val minStartMs = startTimes.minOrNull() ?: Calendar.getInstance().apply { set(2026, Calendar.AUGUST, 1) }.timeInMillis
val maxEndMs = endTimes.maxOrNull() ?: Calendar.getInstance().apply { set(2026, Calendar.AUGUST, 29) }.timeInMillis
val projectStart = Date(minStartMs)
val projectEnd = Date(maxEndMs)
val durationMs = maxEndMs - minStartMs
val timelineSteps = 5 val timelineSteps = 5
val timelineDates = (0 until timelineSteps).map { i -> val timelineDates = (0 until timelineSteps).map { i ->
Date(projectStart.time + (durationMs * i / (timelineSteps - 1))) Date(minStartMs + if (timelineSteps > 1) (durationMs * i / (timelineSteps - 1)) else 0)
} }
// Calculate Planned progress points // Calculate Planned progress points
val totalActivities = activities.size
val plannedProgressPoints = timelineDates.map { date -> val plannedProgressPoints = timelineDates.map { date ->
val dayTime = date.time val dayTime = date.time
val totalActivities = activities.size
if (totalActivities == 0) 0f if (totalActivities == 0) 0f
else { else {
val sum = activities.sumOf { act -> val sum = activities.sumOf { act ->
val start = (parseFullDateTime(act.dataInicio) ?: parseDateOnly(act.dataInicio))?.time ?: dayTime val start = if (act.dataInicioMillis > 0) act.dataInicioMillis else dayTime
val end = (parseFullDateTime(act.dataFim) ?: parseDateOnly(act.dataFim))?.time ?: dayTime val end = if (act.dataFimMillis < Long.MAX_VALUE) act.dataFimMillis else dayTime
when { when {
dayTime <= start -> 0 dayTime <= start -> 0
dayTime >= end -> 100 dayTime >= end -> 100
@@ -584,14 +633,14 @@ class MaintenanceViewModel(private val repository: MaintenanceRepository) : View
} }
} }
// Calculate Realized progress points // Calculate Realized progress points using Map index for O(1) history access
val historyByOs = history.groupBy { it.numeroOs }
val realizedProgressPoints = timelineDates.map { date -> val realizedProgressPoints = timelineDates.map { date ->
val dayTime = date.time val dayTime = date.time
val totalActivities = activities.size
if (totalActivities == 0) 0f if (totalActivities == 0) 0f
else { else {
val sum = activities.sumOf { act -> val sum = activities.sumOf { act ->
val osLogs = history.filter { it.numeroOs == act.numeroOs && it.timestamp <= dayTime } val osLogs = historyByOs[act.numeroOs]?.filter { it.timestamp <= dayTime } ?: emptyList()
if (osLogs.isNotEmpty()) { if (osLogs.isNotEmpty()) {
osLogs.last().percentualNovo osLogs.last().percentualNovo
} else { } else {
@@ -603,12 +652,12 @@ class MaintenanceViewModel(private val repository: MaintenanceRepository) : View
} }
// 3. Overdue tags and sectors (OSs em atraso consideram a data/hora atual real ou override de testes) // 3. Overdue tags and sectors (OSs em atraso consideram a data/hora atual real ou override de testes)
val referenceDate = referenceDateOverride ?: Date() val referenceDateMs = (referenceDateOverride ?: Date()).time
val overdueActivities = activities.filter { act -> val overdueActivities = activities.filter { act ->
val isNotCompleted = act.percentualExecucao < 100 val isNotCompleted = act.percentualExecucao < 100
val endDate = parseFullDateTime(act.dataFim) ?: parseDateOnly(act.dataFim) val endMs = act.dataFimMillis
isNotCompleted && endDate != null && endDate.before(referenceDate) isNotCompleted && endMs < Long.MAX_VALUE && endMs < referenceDateMs
} }
val overdueByTag = overdueActivities val overdueByTag = overdueActivities