diff --git a/app/src/main/java/com/example/data/local/AppDatabase.kt b/app/src/main/java/com/example/data/local/AppDatabase.kt index ec83fc7..7542057 100644 --- a/app/src/main/java/com/example/data/local/AppDatabase.kt +++ b/app/src/main/java/com/example/data/local/AppDatabase.kt @@ -12,7 +12,7 @@ import com.example.data.model.UserAccess @Database( entities = [MaintenanceActivity::class, OSUpdateHistory::class, SyncConflictLog::class, UserAccess::class, AppLog::class], - version = 6, + version = 7, exportSchema = false ) abstract class AppDatabase : RoomDatabase() { diff --git a/app/src/main/java/com/example/data/model/MaintenanceActivity.kt b/app/src/main/java/com/example/data/model/MaintenanceActivity.kt index ef55af1..75d9942 100644 --- a/app/src/main/java/com/example/data/model/MaintenanceActivity.kt +++ b/app/src/main/java/com/example/data/model/MaintenanceActivity.kt @@ -1,13 +1,21 @@ package com.example.data.model import androidx.room.Entity +import androidx.room.Index import androidx.room.PrimaryKey import java.text.SimpleDateFormat import java.util.Calendar import java.util.Date import java.util.Locale -@Entity(tableName = "maintenance_activities") +@Entity( + tableName = "maintenance_activities", + indices = [ + Index("equipe"), + Index("setor"), + Index("synced") + ] +) data class MaintenanceActivity( @PrimaryKey val numeroOs: String, val descricao: String, @@ -29,6 +37,16 @@ data class MaintenanceActivity( percentualExecucao >= 100 -> ActivityStatus.CONCLUIDO 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) { @@ -56,6 +74,17 @@ data class GoogleUser( val photoUrl: String? = null ) +// ThreadLocal map for formatters to prevent continuous instantiation of SimpleDateFormat +private val threadLocalFormatters = object : ThreadLocal>() { + override fun initialValue(): MutableMap = 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 { val clean = dataStr.trim() @@ -89,22 +118,23 @@ fun adjustTwoDigitYear(date: Date?): 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? { val clean = extractDateOnly(dateStr).trim() - val formats = 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" - ) - for (format in formats) { + if (clean == "N/A" || clean.isBlank()) return null + for (format in dateOnlyFormats) { try { - val sdf = SimpleDateFormat(format, Locale.US) - sdf.isLenient = false + val sdf = getFormatter(format) val parsed = sdf.parse(clean) if (parsed != null) { return adjustTwoDigitYear(parsed) @@ -116,6 +146,29 @@ fun parseDateOnly(dateStr: String): Date? { 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? { var clean = dateTimeStr.trim() 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. clean = clean.replace(Regex("^[a-zA-zA-ZáàâãéèêíóôõúçÁÀÂÃÉÈÍÓÔÕÚÇ]{2,4}\\.?\\s+"), "").trim() - val formats = 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" - ) - for (format in formats) { + for (format in fullDateTimeFormats) { try { - val sdf = SimpleDateFormat(format, Locale.US) - sdf.isLenient = false + val sdf = getFormatter(format) val parsed = sdf.parse(clean) if (parsed != null) { return adjustTwoDigitYear(parsed) @@ -166,13 +196,23 @@ fun formatToShortDate(dataStr: String): String { val extracted = extractDateOnly(clean) val parsed = parseDateOnly(extracted) ?: return extracted return try { - val sdf = SimpleDateFormat("dd/MM/yy", Locale.US) + val sdf = getFormatter("dd/MM/yy") sdf.format(parsed) } catch (e: Exception) { 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 { val cleanSelected = selectedDateStr.trim() 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 endDate = parseDateOnly(dataFimStr) ?: parseFullDateTime(dataFimStr) ?: startDate - val selCal = Calendar.getInstance().apply { - time = selDate - set(Calendar.HOUR_OF_DAY, 0) - 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) - } + val selTime = truncateToStartOfDay(selDate.time) + val startTime = truncateToStartOfDay(startDate.time) + val endTime = truncateToStartOfDay(endDate.time) - return !selCal.before(startCal) && !selCal.after(endCal) + return selTime in startTime..endTime } + diff --git a/app/src/main/java/com/example/ui/screens/MaintenanceDashboardScreen.kt b/app/src/main/java/com/example/ui/screens/MaintenanceDashboardScreen.kt index 6a1cb2d..ee255ec 100644 --- a/app/src/main/java/com/example/ui/screens/MaintenanceDashboardScreen.kt +++ b/app/src/main/java/com/example/ui/screens/MaintenanceDashboardScreen.kt @@ -198,46 +198,10 @@ fun MaintenanceDashboardScreen( } } - val uniqueDates = remember(allActivities) { - val datesOnly = allActivities - .flatMap { listOf(extractDateOnly(it.dataInicio), extractDateOnly(it.dataFim)) } - .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 - } - - 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 - } + val uniqueDates by viewModel.uniqueDates.collectAsStateWithLifecycle() + val uniqueRecursos by viewModel.uniqueRecursos.collectAsStateWithLifecycle() + val uniqueSectors by viewModel.uniqueSectors.collectAsStateWithLifecycle() + val uniqueEquipes by viewModel.uniqueEquipes.collectAsStateWithLifecycle() // Launcher for file picking (CSV Spreadsheet) val filePickerLauncher = rememberLauncherForActivityResult( @@ -615,7 +579,7 @@ fun MaintenanceDashboardScreen( .fillMaxWidth(), contentPadding = PaddingValues(bottom = 16.dp) ) { - items(activities, key = { it.numeroOs }) { activity -> + items(activities, key = { it.numeroOs }, contentType = { "OSListItem" }) { activity -> OSListItemCard( activity = activity, onClick = { viewModel.selectActivity(activity) } diff --git a/app/src/main/java/com/example/ui/viewmodel/MaintenanceViewModel.kt b/app/src/main/java/com/example/ui/viewmodel/MaintenanceViewModel.kt index 296b062..e101cd3 100644 --- a/app/src/main/java/com/example/ui/viewmodel/MaintenanceViewModel.kt +++ b/app/src/main/java/com/example/ui/viewmodel/MaintenanceViewModel.kt @@ -20,6 +20,7 @@ import kotlinx.coroutines.Dispatchers import kotlinx.coroutines.flow.flowOn import java.util.Calendar import java.util.Date +import kotlinx.coroutines.flow.map import kotlinx.coroutines.flow.MutableStateFlow import kotlinx.coroutines.flow.SharingStarted import kotlinx.coroutines.flow.StateFlow @@ -109,6 +110,59 @@ class MaintenanceViewModel(private val repository: MaintenanceRepository) : View } } + val uniqueSectors: StateFlow> = 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> = 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> = 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> = 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 = combine( repository.allActivities, repository.allHistory @@ -187,33 +241,29 @@ class MaintenanceViewModel(private val repository: MaintenanceRepository) : View 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 -> - val p1 = parseFullDateTime(a1.dataFim) - val p2 = parseFullDateTime(a2.dataFim) + val p1 = a1.dataFimMillis + val p2 = a2.dataFimMillis when { - p1 == null && p2 == null -> a1.numeroOs.compareTo(a2.numeroOs) - p1 == null -> 1 // Keep null/invalid date at the end - p2 == null -> -1 + p1 == Long.MAX_VALUE && p2 == Long.MAX_VALUE -> a1.numeroOs.compareTo(a2.numeroOs) + p1 == Long.MAX_VALUE -> 1 + p2 == Long.MAX_VALUE -> -1 else -> { val comp = p1.compareTo(p2) if (comp != 0) { comp } else { - val s1 = parseFullDateTime(a1.dataInicio) - val s2 = parseFullDateTime(a2.dataInicio) - val startComp = when { - s1 == null && s2 == null -> 0 - s1 == null -> 1 - s2 == null -> -1 - else -> s1.compareTo(s2) - } + val s1 = a1.dataInicioMillis + val s2 = a2.dataInicioMillis + val startComp = s1.compareTo(s2) if (startComp != 0) startComp else a1.numeroOs.compareTo(a2.numeroOs) } } } } - }.stateIn( + }.flowOn(Dispatchers.Default) + .stateIn( scope = viewModelScope, started = SharingStarted.WhileSubscribed(5000), initialValue = emptyList() @@ -544,32 +594,31 @@ class MaintenanceViewModel(private val repository: MaintenanceRepository) : View team to ratio } - // 2. S-Curve bounds and steps - val parsedDates = activities.flatMap { - listOfNotNull( - 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 + // 2. S-Curve bounds and steps using dataInicioMillis & dataFimMillis + val startTimes = activities.map { it.dataInicioMillis }.filter { it > 0 } + val endTimes = activities.map { it.dataFimMillis }.filter { it < Long.MAX_VALUE } - 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 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 + val totalActivities = activities.size val plannedProgressPoints = timelineDates.map { date -> val dayTime = date.time - val totalActivities = activities.size if (totalActivities == 0) 0f else { val sum = activities.sumOf { act -> - val start = (parseFullDateTime(act.dataInicio) ?: parseDateOnly(act.dataInicio))?.time ?: dayTime - val end = (parseFullDateTime(act.dataFim) ?: parseDateOnly(act.dataFim))?.time ?: dayTime + val start = if (act.dataInicioMillis > 0) act.dataInicioMillis else dayTime + val end = if (act.dataFimMillis < Long.MAX_VALUE) act.dataFimMillis else dayTime when { dayTime <= start -> 0 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 dayTime = date.time - val totalActivities = activities.size if (totalActivities == 0) 0f else { 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()) { osLogs.last().percentualNovo } 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) - val referenceDate = referenceDateOverride ?: Date() + val referenceDateMs = (referenceDateOverride ?: Date()).time val overdueActivities = activities.filter { act -> val isNotCompleted = act.percentualExecucao < 100 - val endDate = parseFullDateTime(act.dataFim) ?: parseDateOnly(act.dataFim) - isNotCompleted && endDate != null && endDate.before(referenceDate) + val endMs = act.dataFimMillis + isNotCompleted && endMs < Long.MAX_VALUE && endMs < referenceDateMs } val overdueByTag = overdueActivities