Snapshot: Filtro de data corrigido para dd/mm/aa

This commit is contained in:
Gabriel Pizzinatto
2026-07-15 17:11:40 +00:00
commit 928ca5ec70
49 changed files with 4048 additions and 0 deletions

View File

@@ -0,0 +1,44 @@
package com.example
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.activity.enableEdgeToEdge
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.padding
import androidx.compose.material3.Scaffold
import androidx.compose.ui.Modifier
import androidx.lifecycle.ViewModelProvider
import com.example.data.local.AppDatabase
import com.example.data.repository.MaintenanceRepository
import com.example.ui.screens.MaintenanceDashboardScreen
import com.example.ui.theme.MyApplicationTheme
import com.example.ui.viewmodel.MaintenanceViewModel
import com.example.ui.viewmodel.MaintenanceViewModelFactory
class MainActivity : ComponentActivity() {
override fun onCreate(savedInstanceState: Bundle?) {
super.onCreate(savedInstanceState)
enableEdgeToEdge()
// Initialize Database, Repository, and ViewModel using standard provider factory
val database = AppDatabase.getDatabase(applicationContext)
val repository = MaintenanceRepository(database.maintenanceDao(), applicationContext)
val viewModel = ViewModelProvider(
this,
MaintenanceViewModelFactory(repository)
)[MaintenanceViewModel::class.java]
setContent {
MyApplicationTheme {
Scaffold(modifier = Modifier.fillMaxSize()) { innerPadding ->
MaintenanceDashboardScreen(
viewModel = viewModel,
modifier = Modifier.padding(innerPadding)
)
}
}
}
}
}

View File

@@ -0,0 +1,36 @@
package com.example.data.local
import android.content.Context
import androidx.room.Database
import androidx.room.Room
import androidx.room.RoomDatabase
import com.example.data.model.MaintenanceActivity
import com.example.data.model.OSUpdateHistory
@Database(
entities = [MaintenanceActivity::class, OSUpdateHistory::class],
version = 1,
exportSchema = false
)
abstract class AppDatabase : RoomDatabase() {
abstract fun maintenanceDao(): MaintenanceDao
companion object {
@Volatile
private var INSTANCE: AppDatabase? = null
fun getDatabase(context: Context): AppDatabase {
return INSTANCE ?: synchronized(this) {
val instance = Room.databaseBuilder(
context.applicationContext,
AppDatabase::class.java,
"cargill_maintenance_db"
)
.fallbackToDestructiveMigration()
.build()
INSTANCE = instance
instance
}
}
}
}

View File

@@ -0,0 +1,52 @@
package com.example.data.local
import androidx.room.Dao
import androidx.room.Insert
import androidx.room.OnConflictStrategy
import androidx.room.Query
import androidx.room.Update
import com.example.data.model.MaintenanceActivity
import com.example.data.model.OSUpdateHistory
import kotlinx.coroutines.flow.Flow
@Dao
interface MaintenanceDao {
@Query("SELECT * FROM maintenance_activities ORDER BY numeroOs ASC")
fun getAllActivities(): Flow<List<MaintenanceActivity>>
@Query("SELECT * FROM maintenance_activities WHERE numeroOs = :numeroOs LIMIT 1")
fun getActivityByOs(numeroOs: String): Flow<MaintenanceActivity?>
@Query("SELECT * FROM maintenance_activities WHERE numeroOs = :numeroOs LIMIT 1")
suspend fun getActivityByOsOneShot(numeroOs: String): MaintenanceActivity?
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertActivities(activities: List<MaintenanceActivity>)
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertActivity(activity: MaintenanceActivity)
@Update
suspend fun updateActivity(activity: MaintenanceActivity)
@Query("SELECT * FROM os_update_history WHERE numeroOs = :numeroOs ORDER BY timestamp DESC")
fun getHistoryForOs(numeroOs: String): Flow<List<OSUpdateHistory>>
@Insert(onConflict = OnConflictStrategy.REPLACE)
suspend fun insertHistory(history: OSUpdateHistory)
@Query("SELECT * FROM maintenance_activities WHERE synced = 0")
suspend fun getUnsyncedActivities(): List<MaintenanceActivity>
@Query("SELECT * FROM maintenance_activities")
suspend fun getAllActivitiesList(): List<MaintenanceActivity>
@Query("SELECT * FROM os_update_history")
suspend fun getAllHistoryList(): List<OSUpdateHistory>
@Query("DELETE FROM maintenance_activities")
suspend fun clearAllActivities()
@Query("DELETE FROM os_update_history")
suspend fun clearAllHistory()
}

View File

@@ -0,0 +1,160 @@
package com.example.data.model
import androidx.room.Entity
import androidx.room.PrimaryKey
import java.text.SimpleDateFormat
import java.util.Calendar
import java.util.Date
import java.util.Locale
@Entity(tableName = "maintenance_activities")
data class MaintenanceActivity(
@PrimaryKey val numeroOs: String,
val descricao: String,
val setor: String,
val equipe: String,
val responsavel: String,
val dataInicio: String,
val dataFim: String,
val percentualExecucao: Int, // 0 to 100
val observacoes: String? = null,
val fotoPath: String? = null,
val synced: Boolean = false,
val lastUpdated: Long = System.currentTimeMillis()
) {
val status: ActivityStatus
get() = when {
percentualExecucao == 0 -> ActivityStatus.NAO_INICIADO
percentualExecucao >= 100 -> ActivityStatus.CONCLUIDO
else -> ActivityStatus.EM_ANDAMENTO
}
}
enum class ActivityStatus(val displayName: String) {
NAO_INICIADO("Não iniciado"),
EM_ANDAMENTO("Em andamento"),
CONCLUIDO("Concluído")
}
@Entity(tableName = "os_update_history")
data class OSUpdateHistory(
@PrimaryKey(autoGenerate = true) val id: Long = 0,
val numeroOs: String,
val timestamp: Long = System.currentTimeMillis(),
val percentualAnterior: Int,
val percentualNovo: Int,
val observacao: String? = null,
val fotoPath: String? = null,
val responsavel: String
)
fun extractDateOnly(dataStr: String): String {
val clean = dataStr.trim()
if (clean == "N/A" || clean.isBlank()) return "N/A"
// Split by whitespace or 'T'
val parts = clean.split(Regex("[\\sT]+"))
for (part in parts) {
val trimmedPart = part.trim()
if (trimmedPart.contains('/') || trimmedPart.contains('-')) {
return trimmedPart
}
}
val tIndex = clean.indexOf('T')
if (tIndex != -1) return clean.substring(0, tIndex).trim()
val spaceIndex = clean.indexOf(' ')
if (spaceIndex != -1) return clean.substring(0, spaceIndex).trim()
return clean
}
fun adjustTwoDigitYear(date: Date?): Date? {
if (date == null) return null
val cal = Calendar.getInstance(Locale.US)
cal.time = date
val year = cal.get(Calendar.YEAR)
if (year < 2000) {
cal.set(Calendar.YEAR, 2000 + (year % 100))
return cal.time
}
return date
}
fun parseDateOnly(dateStr: String): Date? {
val clean = 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) {
try {
val sdf = SimpleDateFormat(format, Locale.US)
sdf.isLenient = false
val parsed = sdf.parse(clean)
if (parsed != null) {
return adjustTwoDigitYear(parsed)
}
} catch (e: Exception) {
// Try next
}
}
return null
}
fun parseFullDateTime(dateTimeStr: String): Date? {
val clean = dateTimeStr.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) {
try {
val sdf = SimpleDateFormat(format, Locale.US)
sdf.isLenient = false
val parsed = sdf.parse(clean)
if (parsed != null) {
return adjustTwoDigitYear(parsed)
}
} catch (e: Exception) {
// Try next
}
}
return null
}
fun formatToShortDate(dataStr: String): String {
val clean = dataStr.trim()
if (clean == "N/A" || clean.isBlank() || clean == "Todas") return clean
val extracted = extractDateOnly(clean)
val parsed = parseDateOnly(extracted) ?: return extracted
return try {
val sdf = SimpleDateFormat("dd/MM/yy", Locale.US)
sdf.format(parsed)
} catch (e: Exception) {
extracted
}
}

View File

@@ -0,0 +1,602 @@
package com.example.data.remote
import android.content.Context
import android.util.Log
import com.example.data.model.MaintenanceActivity
import com.example.data.model.OSUpdateHistory
import com.squareup.moshi.JsonClass
import com.squareup.moshi.Moshi
import com.google.auth.oauth2.GoogleCredentials
import okhttp3.MediaType.Companion.toMediaType
import okhttp3.OkHttpClient
import okhttp3.Request
import okhttp3.RequestBody.Companion.toRequestBody
import java.io.IOException
@JsonClass(generateAdapter = true)
data class SheetValuesResponse(
val range: String,
val majorDimension: String,
val values: List<List<String>>? = null
)
@JsonClass(generateAdapter = true)
data class BatchUpdateBody(
val valueInputOption: String = "RAW",
val data: List<ValueRange>
)
@JsonClass(generateAdapter = true)
data class ValueRange(
val range: String,
val values: List<List<String>>,
val majorDimension: String = "ROWS"
)
@JsonClass(generateAdapter = true)
data class AppendBody(
val range: String,
val majorDimension: String = "ROWS",
val values: List<List<String>>
)
class GoogleSheetsSyncService(private val context: Context) {
private val tag = "GoogleSheetsSync"
private val spreadsheetId = "1sbFovBl-RMMY6lIVdhze_ZOA9cZK01y3vPLCMWLnfpo"
private val client = OkHttpClient.Builder()
.addInterceptor(okhttp3.logging.HttpLoggingInterceptor().apply {
level = okhttp3.logging.HttpLoggingInterceptor.Level.BASIC
})
.build()
private val moshi = Moshi.Builder()
.add(com.squareup.moshi.kotlin.reflect.KotlinJsonAdapterFactory())
.build()
private var googleCredentials: GoogleCredentials? = null
@Synchronized
private fun getCredentials(): GoogleCredentials {
if (googleCredentials == null) {
val jsonFromEnv = try {
com.example.BuildConfig.SHEETS_CREDENTIALS_JSON
} catch (e: Throwable) {
""
}
val hasValidEnvJson = jsonFromEnv.isNotBlank() &&
jsonFromEnv != "SHEETS_CREDENTIALS_JSON" &&
jsonFromEnv.trim().startsWith("{")
val stream = if (hasValidEnvJson) {
Log.d(tag, "Carregando credenciais do Google Sheets da variável de ambiente SHEETS_CREDENTIALS_JSON")
java.io.ByteArrayInputStream(jsonFromEnv.toByteArray())
} else {
Log.d(tag, "Carregando credenciais do Google Sheets da pasta assets (chaveacesso_sheets.apikey.json)")
try {
context.assets.open("chaveacesso_sheets.apikey.json")
} catch (e: Exception) {
val msg = "Arquivo de credenciais 'chaveacesso_sheets.apikey.json' não encontrado na pasta 'assets' e chave 'SHEETS_CREDENTIALS_JSON' não configurada nos Secrets do AI Studio."
Log.e(tag, msg, e)
throw IOException(msg, e)
}
}
googleCredentials = GoogleCredentials.fromStream(stream)
.createScoped(listOf("https://www.googleapis.com/auth/spreadsheets"))
}
googleCredentials!!.refreshIfExpired()
return googleCredentials!!
}
private fun getAccessToken(): String {
val creds = getCredentials()
val token = creds.accessToken?.tokenValue
if (token != null) return token
// Force refresh if the token is null for any reason
creds.refresh()
return creds.accessToken?.tokenValue
?: throw IOException("Falha ao obter token de acesso para a Sheets API.")
}
/**
* Helper to perform GET request on sheet values
*/
fun fetchValues(range: String): List<List<String>> {
val accessToken = getAccessToken()
val url = "https://sheets.googleapis.com/v4/spreadsheets/$spreadsheetId/values/$range"
val request = Request.Builder()
.url(url)
.addHeader("Authorization", "Bearer $accessToken")
.get()
.build()
client.newCall(request).execute().use { response ->
if (!response.isSuccessful) {
val errBody = response.body?.string() ?: ""
Log.e(tag, "Fetch failed for range $range: Code ${response.code}, Msg: $errBody")
throw IOException("Erro ao ler dados da planilha ($range): ${response.message}")
}
val bodyString = response.body?.string() ?: ""
val adapter = moshi.adapter(SheetValuesResponse::class.java)
val result = adapter.fromJson(bodyString)
return result?.values ?: emptyList()
}
}
/**
* Helper to perform PUT request to update sheet values
*/
private fun updateValues(range: String, values: List<List<String>>) {
val accessToken = getAccessToken()
val url = "https://sheets.googleapis.com/v4/spreadsheets/$spreadsheetId/values/$range?valueInputOption=RAW"
val bodyObj = ValueRange(range = range, values = values)
val json = moshi.adapter(ValueRange::class.java).toJson(bodyObj)
val requestBody = json.toRequestBody("application/json".toMediaType())
val request = Request.Builder()
.url(url)
.addHeader("Authorization", "Bearer $accessToken")
.put(requestBody)
.build()
client.newCall(request).execute().use { response ->
if (!response.isSuccessful) {
val errBody = response.body?.string() ?: ""
Log.e(tag, "Update failed for range $range: Code ${response.code}, Msg: $errBody")
throw IOException("Erro ao atualizar dados na planilha ($range): ${response.message}")
}
}
}
/**
* Helper to perform POST request to append sheet values
*/
fun appendValues(range: String, values: List<List<String>>) {
if (values.isEmpty()) return
val accessToken = getAccessToken()
val url = "https://sheets.googleapis.com/v4/spreadsheets/$spreadsheetId/values/$range:append?valueInputOption=RAW"
val bodyObj = AppendBody(range = range, values = values)
val json = moshi.adapter(AppendBody::class.java).toJson(bodyObj)
val requestBody = json.toRequestBody("application/json".toMediaType())
val request = Request.Builder()
.url(url)
.addHeader("Authorization", "Bearer $accessToken")
.post(requestBody)
.build()
client.newCall(request).execute().use { response ->
if (!response.isSuccessful) {
val errBody = response.body?.string() ?: ""
Log.e(tag, "Append failed for range $range: Code ${response.code}, Msg: $errBody")
throw IOException("Erro ao anexar dados na planilha ($range): ${response.message}")
}
}
}
/**
* Helper to perform POST request for batch updating multiple cells/rows
*/
private fun batchUpdateValues(data: List<ValueRange>) {
if (data.isEmpty()) return
val accessToken = getAccessToken()
val url = "https://sheets.googleapis.com/v4/spreadsheets/$spreadsheetId/values:batchUpdate"
val bodyObj = BatchUpdateBody(data = data)
val json = moshi.adapter(BatchUpdateBody::class.java).toJson(bodyObj)
val requestBody = json.toRequestBody("application/json".toMediaType())
val request = Request.Builder()
.url(url)
.addHeader("Authorization", "Bearer $accessToken")
.post(requestBody)
.build()
client.newCall(request).execute().use { response ->
if (!response.isSuccessful) {
val errBody = response.body?.string() ?: ""
Log.e(tag, "Batch update failed: Code ${response.code}, Msg: $errBody")
throw IOException("Erro ao sincronizar lote de dados com a planilha: ${response.message}")
}
}
}
/**
* Creates a new sheet tab in the spreadsheet if it does not exist.
*/
fun createSheet(sheetName: String) {
val accessToken = getAccessToken()
val url = "https://sheets.googleapis.com/v4/spreadsheets/$spreadsheetId:batchUpdate"
val jsonPayload = """
{
"requests": [
{
"addSheet": {
"properties": {
"title": "$sheetName"
}
}
}
]
}
""".trimIndent()
val requestBody = jsonPayload.toRequestBody("application/json".toMediaType())
val request = Request.Builder()
.url(url)
.addHeader("Authorization", "Bearer $accessToken")
.post(requestBody)
.build()
client.newCall(request).execute().use { response ->
if (response.isSuccessful) {
Log.d(tag, "Sheet '$sheetName' created successfully.")
} else {
val errBody = response.body?.string() ?: ""
Log.e(tag, "Failed to create sheet '$sheetName': Code ${response.code}, Msg: $errBody")
// If it already exists, we can safely ignore the error
if (!errBody.contains("already exists") && !errBody.contains("já existe")) {
throw IOException("Erro ao criar aba '$sheetName' na planilha: ${response.message}")
}
}
}
}
/**
* Ensure the sheet is initialized with a header row if it is empty.
*/
fun ensureHeaders(sheetName: String, defaultHeaders: List<String>) {
try {
val existingRows = fetchValues("$sheetName!A1:A2")
if (existingRows.isEmpty()) {
Log.d(tag, "Sheet $sheetName is empty, initializing headers...")
updateValues("$sheetName!A1:${getColumnLetter(defaultHeaders.size)}1", listOf(defaultHeaders))
}
} catch (e: Exception) {
Log.e(tag, "Failed to ensure headers for $sheetName, attempting to create sheet and write them...", e)
try {
createSheet(sheetName)
updateValues("$sheetName!A1:${getColumnLetter(defaultHeaders.size)}1", listOf(defaultHeaders))
} catch (e2: Exception) {
Log.e(tag, "Critical fail initializing headers for $sheetName", e2)
}
}
}
private fun getColumnLetter(count: Int): String {
return if (count <= 26) ('A'.code + count - 1).toChar().toString() else "Z"
}
private fun normalizeOutlineNum(outline: String): String {
var s = outline.trim()
while (s.endsWith(".")) {
s = s.substring(0, s.length - 1).trim()
}
return s
}
/**
* Fetches remote activities and returns a list of activities along with their 1-based sheet row numbers.
*/
fun fetchRemoteActivities(): Pair<List<MaintenanceActivity>, Map<String, Int>> {
val rows = fetchValues("project!A:Z")
val activities = mutableListOf<MaintenanceActivity>()
val rowMap = mutableMapOf<String, Int>()
Log.d(tag, "fetchRemoteActivities: Fetched ${rows.size} total rows from 'project' sheet.")
if (rows.isEmpty()) {
return Pair(activities, rowMap)
}
val headers = rows[0].map { it.trim().lowercase() }
Log.d(tag, "Headers found: $headers")
// 1. Task Name: Match specific task name header first, then fall back
val taskNameIdx = headers.indexOfFirst {
it.contains("nome da tarefa") || it.contains("nome_da_tarefa")
}.let { idx ->
if (idx != -1) idx else headers.indexOfFirst {
it.contains("tarefa") || it.contains("descrição") || it.contains("descricao") || it.contains("atividade") || it.contains("nome")
}
}
// 2. Resource Group (Equipe): Match resource group/team
val groupIdx = headers.indexOfFirst {
it.contains("grupo de recursos") || it.contains("grupo_de_recursos")
}.let { idx ->
if (idx != -1) idx else headers.indexOfFirst {
it.contains("grupo") || it.contains("equipe") || it.contains("disciplina") || it.contains("setor")
}
}
// 3. Resource Names (Responsável)
val resourceIdx = headers.indexOfFirst {
it.contains("nomes dos recursos") || it.contains("nomes_dos_recursos")
}.let { idx ->
if (idx != -1) idx else headers.indexOfFirst {
it.contains("recurso") || it.contains("responsável") || it.contains("responsavel") || it.contains("executor")
}
}
// 4. Start Date (Início)
val inicioIdx = headers.indexOfFirst {
it.contains("início") || it.contains("inicio")
}.let { idx ->
if (idx != -1) idx else headers.indexOfFirst {
it.contains("start") || it.contains("data")
}
}
// 5. End Date (Término)
val fimIdx = headers.indexOfFirst {
it.contains("término") || it.contains("termino")
}.let { idx ->
if (idx != -1) idx else headers.indexOfFirst {
it.contains("end") || it.contains("conclusão") || it.contains("conclusao")
}
}
// 6. Outline Structure (Estrutura de Tópicos): Highly specific first, then fall back to "número" (avoiding "id" / "os")
val outlineIdx = headers.indexOfFirst {
it.contains("estrutura de tópicos") || it.contains("topicos") || it.contains("tópicos")
}.let { idx ->
if (idx != -1) idx else headers.indexOfFirst {
(it.contains("número") || it.contains("numero")) &&
!it.contains("id") && !it.contains(" os") && !it.startsWith("os") && it != "os" && !it.contains("resumo")
}
}
// 7. Exclusive ID (Id exclusiva): Highly specific first, then fallback to "id"
val idIdx = headers.indexOfFirst {
it.contains("id exclusiva") || it.contains("idexclusiva")
}.let { idx ->
if (idx != -1) idx else headers.indexOfFirst {
it == "id" || it == "id_exclusiva" || it.contains("id")
}
}
// 8. Resumo: column mapping to filter service orders (only Resumo = Não)
val resumoIdx = headers.indexOfFirst {
it.contains("resumo")
}
Log.d(tag, "Mapped Column Indices: taskName=$taskNameIdx, group=$groupIdx, resource=$resourceIdx, inicio=$inicioIdx, fim=$fimIdx, outline=$outlineIdx, id=$idIdx, resumo=$resumoIdx")
// Step 1: Pre-build outline-to-name lookup map to extract Sector name from grandparent outline
val outlineMap = mutableMapOf<String, String>()
val allOutlineNums = mutableSetOf<String>()
for (i in 1 until rows.size) {
val row = rows[i]
val rawOutline = if (outlineIdx != -1 && outlineIdx < row.size) row[outlineIdx] else ""
val outlineNum = normalizeOutlineNum(rawOutline)
val taskName = if (taskNameIdx != -1 && taskNameIdx < row.size) row[taskNameIdx].trim() else ""
if (outlineNum.isNotBlank()) {
allOutlineNums.add(outlineNum)
if (taskName.isNotBlank()) {
outlineMap[outlineNum] = taskName
}
}
}
// Identify parent outlines. An outline num is a parent if another outline starts with "outlineNum."
val parentOutlines = allOutlineNums.filter { outline ->
allOutlineNums.any { other -> other.startsWith("$outline.") }
}.toSet()
Log.d(tag, "Found ${allOutlineNums.size} unique outline numbers. ${parentOutlines.size} identified as structural/parent headings.")
// Step 2: Build actual leaf activities
for (i in 1 until rows.size) {
val row = rows[i]
val rawOutline = if (outlineIdx != -1 && outlineIdx < row.size) row[outlineIdx] else ""
val outlineNum = normalizeOutlineNum(rawOutline)
val idExclusiva = if (idIdx != -1 && idIdx < row.size) row[idIdx].trim() else ""
if (outlineNum.isBlank() || idExclusiva.isBlank()) continue
// Filter out if 'resumo' column is present and value is NOT 'não'/'nao' (as instructed: only count as service orders if 'resumo' is 'não')
if (resumoIdx != -1) {
val resumoVal = if (resumoIdx < row.size) row[resumoIdx].trim().lowercase() else ""
if (resumoVal != "não" && resumoVal != "nao") {
continue
}
}
// If this outline number is parent to another task, it is a grouping/structural heading (like Project, Sector or TAG), not a leaf activity
if (outlineNum in parentOutlines) {
continue
}
val outlineParts = outlineNum.split(".")
val osNum = "OS-$idExclusiva"
val desc = if (taskNameIdx != -1 && taskNameIdx < row.size) row[taskNameIdx].trim() else ""
// Reconstruct grandparent Sector name (e.g., outline parts 1.1 -> "UTILIDADES")
val grandparentOutline = if (outlineParts.size >= 2) outlineParts.take(2).joinToString(".") else ""
val setor = outlineMap[grandparentOutline]?.trim() ?: "Geral"
// Reconstruct team (equipe) and technical responsible
val rawEquipe = if (groupIdx != -1 && groupIdx < row.size) row[groupIdx].trim() else ""
val equipe = if (rawEquipe.isNotBlank()) sanitizeEquipe(rawEquipe) else "Mecânica"
val rawResp = if (resourceIdx != -1 && resourceIdx < row.size) row[resourceIdx].trim() else ""
val responsavel = if (rawResp.isNotBlank()) rawResp else "Sem Responsável"
val dataInicio = if (inicioIdx != -1 && inicioIdx < row.size) row[inicioIdx].trim() else "N/A"
val dataFim = if (fimIdx != -1 && fimIdx < row.size) row[fimIdx].trim() else "N/A"
activities.add(
MaintenanceActivity(
numeroOs = osNum,
descricao = desc,
setor = setor,
equipe = equipe,
responsavel = responsavel,
dataInicio = dataInicio,
dataFim = dataFim,
percentualExecucao = 0, // Determined later in repository by merging history logs
observacoes = null,
fotoPath = null,
synced = true,
lastUpdated = 0L
)
)
rowMap[osNum] = i + 1
}
Log.d(tag, "Finished building remote activities. Total leaf activities reconstructed: ${activities.size}.")
return Pair(activities, rowMap)
}
private fun sanitizeEquipe(equipe: String): String {
val s = equipe.trim()
if (s.isBlank()) return "Mecânica"
val e = s.lowercase()
return when {
e.contains("mec") -> "Mecânica"
e.contains("ele") -> "Elétrica"
e.contains("conf") -> "Confiabilidade"
e.contains("lub") -> "Lubrificação"
else -> s
}
}
/**
* Fetches remote history logs to reconstruct OS progress and avoid duplicates.
*/
fun fetchRemoteHistoryKeys(): Set<String> {
val defaultHeaders = listOf(
"id", "numeroOs", "timestamp", "percentualAnterior", "percentualNovo", "observacao", "fotoPath", "responsavel"
)
ensureHeaders("history", defaultHeaders)
val rows = fetchValues("history!A:H")
val keys = mutableSetOf<String>()
if (rows.size <= 1) return keys
val headers = rows[0].map { it.trim().lowercase() }
val osIdx = headers.indexOf("numeroos")
val tsIdx = headers.indexOf("timestamp")
val getCell = { row: List<String>, mapIdx: Int, fallbackIdx: Int ->
val idx = if (mapIdx != -1) mapIdx else fallbackIdx
if (idx < row.size) row[idx].trim() else ""
}
for (i in 1 until rows.size) {
val row = rows[i]
val os = getCell(row, osIdx, 1)
val ts = getCell(row, tsIdx, 2)
if (os.isNotBlank() && ts.isNotBlank()) {
keys.add("${os}_${ts}")
}
}
return keys
}
/**
* Fetches all remote history logs to reconstruct latest state.
*/
fun fetchRemoteHistoryList(): List<OSUpdateHistory> {
val defaultHeaders = listOf(
"id", "numeroOs", "timestamp", "percentualAnterior", "percentualNovo", "observacao", "fotoPath", "responsavel"
)
ensureHeaders("history", defaultHeaders)
val rows = fetchValues("history!A:H")
val historyList = mutableListOf<OSUpdateHistory>()
if (rows.size <= 1) return historyList
val headers = rows[0].map { it.trim().lowercase() }
val idIdx = headers.indexOf("id")
val osIdx = headers.indexOf("numeroos")
val tsIdx = headers.indexOf("timestamp")
val prevIdx = headers.indexOf("percentualanterior")
val newIdx = headers.indexOf("percentualnovo")
val obsIdx = headers.indexOf("observacao")
val fotoIdx = headers.indexOf("fotopath")
val respIdx = headers.indexOf("responsavel")
val getCell = { row: List<String>, mapIdx: Int, fallbackIdx: Int ->
val idx = if (mapIdx != -1) mapIdx else fallbackIdx
if (idx < row.size) row[idx].trim() else ""
}
for (i in 1 until rows.size) {
val row = rows[i]
val idStr = getCell(row, idIdx, 0)
val id = idStr.toLongOrNull() ?: 0L
val os = getCell(row, osIdx, 1)
if (os.isBlank()) continue
val tsStr = getCell(row, tsIdx, 2)
val ts = tsStr.toLongOrNull() ?: 0L
val prevStr = getCell(row, prevIdx, 3)
val prev = prevStr.toIntOrNull() ?: 0
val newStr = getCell(row, newIdx, 4)
val new = newStr.toIntOrNull() ?: 0
val obs = getCell(row, obsIdx, 5).takeIf { it.isNotBlank() }
val foto = getCell(row, fotoIdx, 6).takeIf { it.isNotBlank() }
val resp = getCell(row, respIdx, 7)
historyList.add(
OSUpdateHistory(
id = id,
numeroOs = os,
timestamp = ts,
percentualAnterior = prev,
percentualNovo = new,
observacao = obs,
fotoPath = foto,
responsavel = resp
)
)
}
return historyList
}
/**
* Stubs out direct activities editing since 'project' is now read-only.
*/
fun pushActivitiesToSheet(
toUpdateRemote: List<Pair<MaintenanceActivity, Int>>,
toAppendRemote: List<MaintenanceActivity>
) {
// No-op to respect read-only project sheets requirement
}
/**
* Appends history entries that do not already exist on the remote sheet.
*/
fun pushHistoryToSheet(historyToAppend: List<OSUpdateHistory>) {
if (historyToAppend.isEmpty()) return
val headerIndices = mapOf(
"id" to 0, "numeroos" to 1, "timestamp" to 2, "percentualanterior" to 3, "percentualnovo" to 4,
"observacao" to 5, "fotopath" to 6, "responsavel" to 7
)
val appendRows = historyToAppend.map { history ->
val row = MutableList(8) { "" }
row[headerIndices["id"] ?: 0] = history.id.toString()
row[headerIndices["numeroos"] ?: 1] = history.numeroOs
row[headerIndices["timestamp"] ?: 2] = history.timestamp.toString()
row[headerIndices["percentualanterior"] ?: 3] = history.percentualAnterior.toString()
row[headerIndices["percentualnovo"] ?: 4] = history.percentualNovo.toString()
row[headerIndices["observacao"] ?: 5] = history.observacao ?: ""
row[headerIndices["fotopath"] ?: 6] = history.fotoPath ?: ""
row[headerIndices["responsavel"] ?: 7] = history.responsavel
row
}
appendValues("history!A:H", appendRows)
Log.d(tag, "Successfully appended ${historyToAppend.size} logs to 'history' sheet.")
}
}

View File

@@ -0,0 +1,296 @@
package com.example.data.repository
import android.content.Context
import android.net.Uri
import com.example.data.local.MaintenanceDao
import com.example.data.model.MaintenanceActivity
import com.example.data.model.OSUpdateHistory
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.delay
import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.withContext
import java.io.BufferedReader
import java.io.InputStreamReader
class MaintenanceRepository(
private val dao: MaintenanceDao,
private val context: Context
) {
private val sheetsSyncService = com.example.data.remote.GoogleSheetsSyncService(context)
val allActivities: Flow<List<MaintenanceActivity>> = dao.getAllActivities()
fun getActivityByOs(numeroOs: String): Flow<MaintenanceActivity?> = dao.getActivityByOs(numeroOs)
fun getHistoryForOs(numeroOs: String): Flow<List<OSUpdateHistory>> = dao.getHistoryForOs(numeroOs)
/**
* Updates progress of an OS, auto-generates a history record, and marks as unsynced (offline-first).
*/
suspend fun updateProgress(
numeroOs: String,
novoPercentual: Int,
observacao: String?,
fotoPath: String?,
responsavel: String
) = withContext(Dispatchers.IO) {
val currentActivity = dao.getActivityByOsOneShot(numeroOs) ?: return@withContext
val updatedActivity = currentActivity.copy(
percentualExecucao = novoPercentual.coerceIn(0, 100),
observacoes = observacao ?: currentActivity.observacoes,
fotoPath = fotoPath ?: currentActivity.fotoPath,
synced = false, // Must sync later
lastUpdated = System.currentTimeMillis()
)
dao.updateActivity(updatedActivity)
// Log to history
val historyEntry = OSUpdateHistory(
numeroOs = numeroOs,
percentualAnterior = currentActivity.percentualExecucao,
percentualNovo = novoPercentual,
observacao = observacao,
fotoPath = fotoPath,
responsavel = responsavel
)
dao.insertHistory(historyEntry)
}
/**
* Parses an Excel CSV file from a Uri, supporting comma (,) or semicolon (;) separators,
* Portuguese headers, and auto-mapping columns.
*/
suspend fun importCsvFromUri(context: Context, uri: Uri): Result<Int> = withContext(Dispatchers.IO) {
try {
val contentResolver = context.contentResolver
val inputStream = contentResolver.openInputStream(uri) ?: return@withContext Result.failure(Exception("Não foi possível abrir o arquivo."))
val reader = BufferedReader(InputStreamReader(inputStream, "UTF-8"))
val lines = mutableListOf<String>()
var line: String? = reader.readLine()
while (line != null) {
if (line.isNotBlank()) {
lines.add(line)
}
line = reader.readLine()
}
inputStream.close()
if (lines.isEmpty()) {
return@withContext Result.failure(Exception("O arquivo está vazio."))
}
// Determine separator by checking first line
val firstLine = lines.first()
val separator = if (firstLine.contains(";")) ";" else ","
// Split headers and clean up quotes/spaces
val headers = firstLine.split(separator).map { it.replace("\"", "").trim().lowercase() }
// Find column indexes based on keywords
val osIdx = headers.indexOfFirst { it.contains("os") || it.contains("numero") || it.contains("número") }
val descIdx = headers.indexOfFirst { it.contains("desc") || it.contains("atividade") || it.contains("ação") }
val setorIdx = headers.indexOfFirst { it.contains("setor") || it.contains("area") || it.contains("área") }
val eqIdx = headers.indexOfFirst { it.contains("equipe") || it.contains("eq") || it.contains("disc") || it.contains("tipo") }
val respIdx = headers.indexOfFirst { it.contains("resp") || it.contains("encarregado") || it.contains("dono") }
val inicioIdx = headers.indexOfFirst { it.contains("inicio") || it.contains("início") || it.contains("start") }
val fimIdx = headers.indexOfFirst { it.contains("fim") || it.contains("end") || it.contains("termino") || it.contains("término") }
val pctIdx = headers.indexOfFirst { it.contains("pct") || it.contains("%") || it.contains("percent") || it.contains("exec") }
if (osIdx == -1 || descIdx == -1) {
return@withContext Result.failure(Exception("Colunas obrigatórias não encontradas. Certifique-se de ter ao menos 'Número da OS' e 'Descrição'."))
}
val importedActivities = mutableListOf<MaintenanceActivity>()
val now = System.currentTimeMillis()
for (i in 1 until lines.size) {
val rowCells = lines[i].split(separator).map { it.replace("\"", "").trim() }
if (rowCells.size <= osIdx || rowCells.size <= descIdx) continue
val osNum = rowCells[osIdx]
if (osNum.isBlank()) continue
val desc = rowCells[descIdx]
val setor = if (setorIdx != -1 && setorIdx < rowCells.size) rowCells[setorIdx] else "Geral"
val equipe = if (eqIdx != -1 && eqIdx < rowCells.size) rowCells[eqIdx] else "Mecânica"
val responsavel = if (respIdx != -1 && respIdx < rowCells.size) rowCells[respIdx] else "Sem Responsável"
val dataInicio = if (inicioIdx != -1 && inicioIdx < rowCells.size) rowCells[inicioIdx] else "N/A"
val dataFim = if (fimIdx != -1 && fimIdx < rowCells.size) rowCells[fimIdx] else "N/A"
val pctStr = if (pctIdx != -1 && pctIdx < rowCells.size) rowCells[pctIdx].replace("%", "").trim() else "0"
val pct = pctStr.toIntOrNull() ?: 0
importedActivities.add(
MaintenanceActivity(
numeroOs = osNum,
descricao = desc,
setor = sanitizeSetor(setor),
equipe = sanitizeEquipe(equipe),
responsavel = responsavel,
dataInicio = dataInicio,
dataFim = dataFim,
percentualExecucao = pct.coerceIn(0, 100),
synced = false,
lastUpdated = now
)
)
}
if (importedActivities.isEmpty()) {
return@withContext Result.failure(Exception("Nenhuma linha válida pôde ser importada."))
}
dao.insertActivities(importedActivities)
Result.success(importedActivities.size)
} catch (e: Exception) {
Result.failure(e)
}
}
/**
* Inserts a static sample dataset for quick testing and demonstration.
*/
suspend fun loadSampleData() = withContext(Dispatchers.IO) {
val now = System.currentTimeMillis()
val sampleActivities = listOf(
MaintenanceActivity("OS-2", "SUBSTITUIÇÃO DO EIXO E ROTOR DO EXAUSTOR", "UTILIDADES", "Mecânica", "Carlos Silva", "14/08/2026", "18/08/2026", 0, lastUpdated = now),
MaintenanceActivity("OS-5", "REVISÃO NO FLAP DE ENTRADA DO EXAUSTOR DA CALDEIRA", "UTILIDADES", "Mecânica", "Carlos Silva", "14/08/2026", "20/08/2026", 0, lastUpdated = now),
MaintenanceActivity("OS-6", "REFORÇAR ESTRUTURA DO MANCAL DO VENTILADOR", "UTILIDADES", "Mecânica", "Carlos Silva", "15/08/2026", "17/08/2026", 0, lastUpdated = now),
MaintenanceActivity("OS-8", "TROCA DOS EMBUCHAMENTOS DOS DUMPERS DO VENTILADOR PRIMARIO", "UTILIDADES", "Mecânica", "João Pedro", "14/08/2026", "14/08/2026", 0, lastUpdated = now),
MaintenanceActivity("OS-10", "TROCA DA ROSCA CV-111014", "UTILIDADES", "Mecânica", "Marcos Rocha", "14/08/2026", "14/08/2026", 0, lastUpdated = now),
MaintenanceActivity("OS-11", "ALINHAMENTO DA FIXAÇÃO DA BOBINA ENRROLADORA", "UTILIDADES", "Mecânica", "Marcos Rocha", "14/08/2026", "14/08/2026", 0, lastUpdated = now),
MaintenanceActivity("OS-1024", "SUBSTITUIÇÃO DA CHAPA DE FIXAÇÃO DOS APARADORES", "UTILIDADES", "Mecânica", "GTEC 1", "17/08/2026", "18/08/2026", 50, "Iniciada a desmontagem da chapa antiga.", lastUpdated = now),
MaintenanceActivity("OS-16", "ADEQUAÇÃO NA ALIMENTAÇÃO DA CORREIA", "UTILIDADES", "Mecânica", "GTEC 1", "19/08/2026", "21/08/2026", 10, lastUpdated = now)
)
dao.clearAllActivities()
dao.insertActivities(sampleActivities)
// Pre-populate some history
for (activity in sampleActivities) {
if (activity.percentualExecucao > 0) {
dao.insertHistory(
OSUpdateHistory(
numeroOs = activity.numeroOs,
percentualAnterior = 0,
percentualNovo = activity.percentualExecucao,
observacao = activity.observacoes,
responsavel = activity.responsavel,
timestamp = now - 3600000 // 1 hour ago
)
)
}
}
}
/**
* Performs a fully functional bidirectional synchronization with the central Google Sheet.
* Uses 'project' sheet as the read-only source of OS definitions and reconciles progress
* dynamically using event-sourcing with the 'history' logs sheet.
*/
suspend fun synchronizeWithBackend(): SyncResult = withContext(Dispatchers.IO) {
try {
android.util.Log.d("MaintenanceRepository", "Starting Google Sheets synchronization...")
// 1. Fetch remote OS definitions from the "project" sheet
val (remoteActivities, _) = sheetsSyncService.fetchRemoteActivities()
// 2. Fetch remote history logs from the "history" sheet
val remoteHistory = sheetsSyncService.fetchRemoteHistoryList()
val remoteHistoryKeys = remoteHistory.map { "${it.numeroOs}_${it.timestamp}" }.toSet()
// 3. Fetch local history logs from Room DB
val localHistory = dao.getAllHistoryList()
// 4. Reconcile and merge all history logs
val allHistories = (remoteHistory + localHistory)
.distinctBy { "${it.numeroOs}_${it.timestamp}" }
.sortedByDescending { it.timestamp }
// 5. Update local Room DB with any remote history logs we don't have
val localHistoryKeys = localHistory.map { "${it.numeroOs}_${it.timestamp}" }.toSet()
val missingLocalHistory = remoteHistory.filter { "${it.numeroOs}_${it.timestamp}" !in localHistoryKeys }
if (missingLocalHistory.isNotEmpty()) {
for (hist in missingLocalHistory) {
dao.insertHistory(hist)
}
android.util.Log.d("MaintenanceRepository", "Inserted ${missingLocalHistory.size} missing history logs locally.")
}
// 6. For each remote activity, determine its current state based on the latest history log
val reconciledActivities = remoteActivities.map { activity ->
val osHistory = allHistories.filter { it.numeroOs == activity.numeroOs }
if (osHistory.isNotEmpty()) {
val latestLog = osHistory.first() // sorted descending, so first is latest
activity.copy(
percentualExecucao = latestLog.percentualNovo,
observacoes = latestLog.observacao ?: activity.observacoes,
fotoPath = latestLog.fotoPath ?: activity.fotoPath,
synced = true,
lastUpdated = latestLog.timestamp
)
} else {
activity.copy(synced = true)
}
}
// 7. Save updated OS activities to local Room DB
if (reconciledActivities.isNotEmpty()) {
dao.clearAllActivities() // Clear old ones since project sheet is the unique source of truth
dao.insertActivities(reconciledActivities)
android.util.Log.d("MaintenanceRepository", "Reconciled and saved ${reconciledActivities.size} OS activities from Google Sheet.")
}
// 8. Upload any local history logs that are not on Google Sheets yet
val historyToUpload = localHistory.filter { "${it.numeroOs}_${it.timestamp}" !in remoteHistoryKeys }
if (historyToUpload.isNotEmpty()) {
sheetsSyncService.pushHistoryToSheet(historyToUpload)
android.util.Log.d("MaintenanceRepository", "Uploaded ${historyToUpload.size} new local history logs to Google Sheet.")
}
SyncResult.Success(
syncedItems = reconciledActivities.size,
conflictsResolved = 0
)
} catch (e: Exception) {
android.util.Log.e("MaintenanceRepository", "Synchronization failed", e)
SyncResult.Error(e.message ?: "Erro de comunicação de rede com o Google Sheets.")
}
}
private fun sanitizeSetor(setor: String): String {
val s = setor.trim()
if (s.isBlank()) return "Preparação"
val lower = s.lowercase()
return when {
lower.contains("prepar") -> "Preparação"
lower.contains("extra") -> "Extração"
lower.contains("calde") -> "Caldeira"
lower.contains("coger") || lower.contains("gira") -> "Cogeração"
lower.contains("refin") -> "Refinaria"
lower.contains("envas") -> "Envase"
lower.contains("utilid") -> "Utilidades"
else -> s
}
}
private fun sanitizeEquipe(equipe: String): String {
val s = equipe.trim()
if (s.isBlank()) return "Mecânica"
val e = s.lowercase()
return when {
e.contains("mec") -> "Mecânica"
e.contains("ele") -> "Elétrica"
e.contains("conf") -> "Confiabilidade"
e.contains("lub") -> "Lubrificação"
else -> s
}
}
}
sealed interface SyncResult {
data class Success(val syncedItems: Int, val conflictsResolved: Int) : SyncResult
data class Error(val message: String) : SyncResult
}

View File

@@ -0,0 +1,85 @@
package com.example.ui.components
import androidx.compose.foundation.Canvas
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxHeight
import androidx.compose.foundation.layout.height
import androidx.compose.foundation.layout.padding
import androidx.compose.foundation.layout.width
import androidx.compose.material3.Text
import androidx.compose.runtime.Composable
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.graphics.Path
import androidx.compose.ui.graphics.drawscope.Fill
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontStyle
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.dp
import androidx.compose.ui.unit.sp
// Official Cargill Colors for Theme Integration
val CargillGreen = Color(0xFF005F40) // Beautiful forest/leaf green
val CargillBlack = Color(0xFF1A1A1A) // High contrast premium charcoal-black
@Composable
fun CargillLogo(
modifier: Modifier = Modifier,
showText: Boolean = true,
lightMode: Boolean = true
) {
Row(
modifier = modifier.height(48.dp),
horizontalArrangement = Arrangement.Start,
verticalAlignment = Alignment.CenterVertically
) {
// Draw the iconic curved leaf logo using Compose Canvas
Canvas(
modifier = Modifier
.width(52.dp)
.fillMaxHeight()
.padding(vertical = 4.dp)
) {
val w = size.width
val h = size.height
// High precision path modeling Cargill's leaf swoosh
val path = Path().apply {
// Outer arch
moveTo(w * 0.05f, h * 0.85f)
cubicTo(
w * 0.20f, h * 0.05f, // Control 1
w * 0.80f, h * 0.05f, // Control 2
w * 0.95f, h * 0.85f // End
)
// Bottom inner curve to create a leaf shape thickness
cubicTo(
w * 0.75f, h * 0.35f, // Control 1 (tighter)
w * 0.25f, h * 0.35f, // Control 2 (tighter)
w * 0.05f, h * 0.85f // Back to start
)
close()
}
drawPath(
path = path,
color = CargillGreen,
style = Fill
)
}
if (showText) {
Text(
text = "Cargill",
color = if (lightMode) CargillBlack else Color.White,
fontSize = 24.sp,
fontFamily = FontFamily.SansSerif,
fontWeight = FontWeight.Black,
fontStyle = FontStyle.Italic,
modifier = Modifier.padding(start = 4.dp, bottom = 2.dp)
)
}
}
}

File diff suppressed because it is too large Load Diff

View File

@@ -0,0 +1,12 @@
package com.example.ui.theme
import androidx.compose.ui.graphics.Color
val CargillGreen = Color(0xFF005F40)
val CargillBlack = Color(0xFF1A1A1A)
val CargillLightGreen = Color(0xFFE8F5E9)
val DarkGreen = Color(0xFF003D28)
val Charcoal = Color(0xFF2C2C2C)
val LightGrey = Color(0xFFF5F7F6)

View File

@@ -0,0 +1,51 @@
package com.example.ui.theme
import android.os.Build
import androidx.compose.foundation.isSystemInDarkTheme
import androidx.compose.material3.MaterialTheme
import androidx.compose.material3.darkColorScheme
import androidx.compose.material3.dynamicDarkColorScheme
import androidx.compose.material3.dynamicLightColorScheme
import androidx.compose.material3.lightColorScheme
import androidx.compose.runtime.Composable
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.platform.LocalContext
private val DarkColorScheme =
darkColorScheme(
primary = CargillGreen,
secondary = Charcoal,
tertiary = CargillLightGreen,
background = CargillBlack,
surface = Charcoal
)
private val LightColorScheme =
lightColorScheme(
primary = CargillGreen,
secondary = CargillBlack,
tertiary = CargillLightGreen,
background = LightGrey,
surface = Color.White
)
@Composable
fun MyApplicationTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
// Set dynamic color to false by default to strictly preserve our Cargill green identity
dynamicColor: Boolean = false,
content: @Composable () -> Unit,
) {
val colorScheme =
when {
dynamicColor && Build.VERSION.SDK_INT >= Build.VERSION_CODES.S -> {
val context = LocalContext.current
if (darkTheme) dynamicDarkColorScheme(context) else dynamicLightColorScheme(context)
}
darkTheme -> DarkColorScheme
else -> LightColorScheme
}
MaterialTheme(colorScheme = colorScheme, typography = Typography, content = content)
}

View File

@@ -0,0 +1,36 @@
package com.example.ui.theme
import androidx.compose.material3.Typography
import androidx.compose.ui.text.TextStyle
import androidx.compose.ui.text.font.FontFamily
import androidx.compose.ui.text.font.FontWeight
import androidx.compose.ui.unit.sp
// Set of Material typography styles to start with
val Typography =
Typography(
bodyLarge =
TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 16.sp,
lineHeight = 24.sp,
letterSpacing = 0.5.sp,
)
/* Other default text styles to override
titleLarge = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Normal,
fontSize = 22.sp,
lineHeight = 28.sp,
letterSpacing = 0.sp
),
labelSmall = TextStyle(
fontFamily = FontFamily.Default,
fontWeight = FontWeight.Medium,
fontSize = 11.sp,
lineHeight = 16.sp,
letterSpacing = 0.5.sp
)
*/
)

View File

@@ -0,0 +1,297 @@
package com.example.ui.viewmodel
import android.content.Context
import android.net.Uri
import androidx.lifecycle.ViewModel
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.viewModelScope
import com.example.data.model.ActivityStatus
import com.example.data.model.MaintenanceActivity
import com.example.data.model.OSUpdateHistory
import com.example.data.model.extractDateOnly
import com.example.data.model.formatToShortDate
import com.example.data.model.parseFullDateTime
import com.example.data.repository.MaintenanceRepository
import com.example.data.repository.SyncResult
import kotlinx.coroutines.flow.MutableStateFlow
import kotlinx.coroutines.flow.SharingStarted
import kotlinx.coroutines.flow.StateFlow
import kotlinx.coroutines.flow.asStateFlow
import kotlinx.coroutines.flow.combine
import kotlinx.coroutines.flow.flatMapLatest
import kotlinx.coroutines.flow.flowOf
import kotlinx.coroutines.flow.first
import kotlinx.coroutines.flow.stateIn
import kotlinx.coroutines.launch
class MaintenanceViewModel(private val repository: MaintenanceRepository) : ViewModel() {
// Filtering inputs
private val _selectedSetor = MutableStateFlow("Todos")
val selectedSetor = _selectedSetor.asStateFlow()
private val _selectedEquipe = MutableStateFlow("Todas")
val selectedEquipe = _selectedEquipe.asStateFlow()
private val _selectedStatus = MutableStateFlow("Todos")
val selectedStatus = _selectedStatus.asStateFlow()
private val _selectedDataInicio = MutableStateFlow("Todas")
val selectedDataInicio = _selectedDataInicio.asStateFlow()
private val _selectedResponsavel = MutableStateFlow("Todos")
val selectedResponsavel = _selectedResponsavel.asStateFlow()
private val _searchQuery = MutableStateFlow("")
val searchQuery = _searchQuery.asStateFlow()
// UI Operation States
private val _isSyncing = MutableStateFlow(false)
val isSyncing = _isSyncing.asStateFlow()
private val _syncStatusMessage = MutableStateFlow<String?>(null)
val syncStatusMessage = _syncStatusMessage.asStateFlow()
private val _importStatusMessage = MutableStateFlow<String?>(null)
val importStatusMessage = _importStatusMessage.asStateFlow()
// Simulator Toggle: Allows users to simulate online/offline state explicitly in the UI
private val _internetAvailable = MutableStateFlow(true) // Default online to ensure immediate network connectivity on launch
val internetAvailable = _internetAvailable.asStateFlow()
// Selected OS for Detail and Updates
private val _selectedActivity = MutableStateFlow<MaintenanceActivity?>(null)
val selectedActivity = _selectedActivity.asStateFlow()
// All activities from repository
val allActivitiesState: StateFlow<List<MaintenanceActivity>> = repository.allActivities
.stateIn(
scope = viewModelScope,
started = SharingStarted.WhileSubscribed(5000),
initialValue = emptyList()
)
// Filtered activities list
val filteredActivities: StateFlow<List<MaintenanceActivity>> = combine(
repository.allActivities,
_selectedSetor,
_selectedEquipe,
_selectedStatus,
_selectedDataInicio,
_selectedResponsavel,
_searchQuery
) { flowsArray ->
@Suppress("UNCHECKED_CAST")
val activities = flowsArray[0] as List<MaintenanceActivity>
val setor = flowsArray[1] as String
val equipe = flowsArray[2] as String
val status = flowsArray[3] as String
val dataInicio = flowsArray[4] as String
val responsavel = flowsArray[5] as String
val query = flowsArray[6] as String
val filtered = activities.filter { activity ->
val matchSetor = setor == "Todos" || activity.setor == setor
val matchEquipe = equipe == "Todas" || activity.equipe == equipe
val matchStatus = status == "Todos" || when (status) {
"Não iniciado" -> activity.status == ActivityStatus.NAO_INICIADO
"Em andamento" -> activity.status == ActivityStatus.EM_ANDAMENTO
"Concluído" -> activity.status == ActivityStatus.CONCLUIDO
else -> true
}
val matchDataInicio = dataInicio == "Todas" || formatToShortDate(activity.dataInicio) == dataInicio
val matchResponsavel = responsavel == "Todos" || activity.responsavel == responsavel
val matchQuery = query.isBlank() ||
activity.numeroOs.contains(query, ignoreCase = true) ||
activity.descricao.contains(query, ignoreCase = true) ||
activity.responsavel.contains(query, ignoreCase = true)
matchSetor && matchEquipe && matchStatus && matchDataInicio && matchResponsavel && matchQuery
}
if (dataInicio != "Todas") {
filtered.sortedWith { a1, a2 ->
val p1 = parseFullDateTime(a1.dataInicio)
val p2 = parseFullDateTime(a2.dataInicio)
when {
p1 == null && p2 == null -> a1.numeroOs.compareTo(a2.numeroOs)
p1 == null -> 1
p2 == null -> -1
else -> p1.compareTo(p2)
}
}
} else {
filtered
}
}.stateIn(
scope = viewModelScope,
started = SharingStarted.WhileSubscribed(5000),
initialValue = emptyList()
)
// Reactive Flow for the current activity's edit history
val selectedActivityHistory: StateFlow<List<OSUpdateHistory>> = _selectedActivity
.flatMapLatest { activity ->
if (activity != null) {
repository.getHistoryForOs(activity.numeroOs)
} else {
flowOf(emptyList())
}
}
.stateIn(
scope = viewModelScope,
started = SharingStarted.WhileSubscribed(5000),
initialValue = emptyList()
)
init {
// Automatically check and pull service orders from Sheets on first launch. Fall back to local sample data if sync fails.
viewModelScope.launch {
val currentList = repository.allActivities.first()
if (currentList.isEmpty()) {
_internetAvailable.value = true
_isSyncing.value = true
_syncStatusMessage.value = "Conectando ao servidor Cargill para baixar ordens de serviço..."
when (val result = repository.synchronizeWithBackend()) {
is SyncResult.Success -> {
_syncStatusMessage.value = "Sincronização inicial concluída! ${result.syncedItems} OSs sincronizadas."
}
is SyncResult.Error -> {
// Safe offline fallback in case of no connectivity or invalid credentials
_syncStatusMessage.value = "Usando dados modelo: ${result.message}"
repository.loadSampleData()
}
}
_isSyncing.value = false
}
}
}
fun selectActivity(activity: MaintenanceActivity?) {
_selectedActivity.value = activity
}
fun setFilterSetor(setor: String) {
_selectedSetor.value = setor
}
fun setFilterEquipe(equipe: String) {
_selectedEquipe.value = equipe
}
fun setFilterStatus(status: String) {
_selectedStatus.value = status
}
fun setFilterDataInicio(dataInicio: String) {
_selectedDataInicio.value = dataInicio
}
fun setFilterResponsavel(responsavel: String) {
_selectedResponsavel.value = responsavel
}
fun setSearchQuery(query: String) {
_searchQuery.value = query
}
fun toggleInternet(available: Boolean) {
_internetAvailable.value = available
if (!available) {
_syncStatusMessage.value = null
}
}
fun clearMessages() {
_syncStatusMessage.value = null
_importStatusMessage.value = null
}
/**
* Triggers a PCM spreadsheet (CSV) import.
*/
fun importSpreadsheet(context: Context, uri: Uri) {
viewModelScope.launch {
_importStatusMessage.value = "Importando..."
val result = repository.importCsvFromUri(context, uri)
result.onSuccess { count ->
_importStatusMessage.value = "Sucesso: $count ordens de serviço importadas/atualizadas!"
}.onFailure { error ->
_importStatusMessage.value = "Erro na importação: ${error.localizedMessage}"
}
}
}
/**
* Helper to preload sample data on-demand.
*/
fun resetToSampleData() {
viewModelScope.launch {
_importStatusMessage.value = "Carregando planilha modelo..."
repository.loadSampleData()
_importStatusMessage.value = "Ordens de serviço padrão carregadas com sucesso!"
}
}
/**
* Performs synchronized check.
*/
fun syncNow() {
if (!_internetAvailable.value) {
_syncStatusMessage.value = "Sincronização impossível: Sem conectividade de rede na área atual."
return
}
viewModelScope.launch {
_isSyncing.value = true
_syncStatusMessage.value = "Conectando ao servidor central da Cargill..."
when (val result = repository.synchronizeWithBackend()) {
is SyncResult.Success -> {
_syncStatusMessage.value = "Sincronização concluída! ${result.syncedItems} OSs sincronizadas com sucesso. Conflitos resolvidos: ${result.conflictsResolved}."
// Refresh selected activity if active to show sync badge
_selectedActivity.value?.let { active ->
_selectedActivity.value = allActivitiesState.value.find { it.numeroOs == active.numeroOs }
}
}
is SyncResult.Error -> {
_syncStatusMessage.value = "Falha na sincronização: ${result.message}"
}
}
_isSyncing.value = false
}
}
/**
* Submits progress updates and creates log.
*/
fun updateProgress(
numeroOs: String,
novoPercentual: Int,
observacao: String?,
fotoPath: String?,
responsavel: String
) {
viewModelScope.launch {
repository.updateProgress(numeroOs, novoPercentual, observacao, fotoPath, responsavel)
// Update selected activity model in state to refresh UI
_selectedActivity.value?.let { active ->
if (active.numeroOs == numeroOs) {
val updatedList = allActivitiesState.value
_selectedActivity.value = updatedList.find { it.numeroOs == numeroOs }
}
}
}
}
}
class MaintenanceViewModelFactory(private val repository: MaintenanceRepository) : ViewModelProvider.Factory {
override fun <T : ViewModel> create(modelClass: Class<T>): T {
if (modelClass.isAssignableFrom(MaintenanceViewModel::class.java)) {
@Suppress("UNCHECKED_CAST")
return MaintenanceViewModel(repository) as T
}
throw IllegalArgumentException("Unknown ViewModel class")
}
}