hack_23030943_f11325/HackOnLinces_app
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Siguientes funcionalidades

Browse Source
This commit is contained in:
hack_23030943_f11325
2026-05-22 21:24:43 -06:00
parent 369060a997
commit 5eae8782bf
7 changed files with 1593 additions and 173 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
aplicacion_hack/lib/main.dart
View File

@@ -17,6 +17,7 @@ import 'package:firebase_core/firebase_core.dart';
import 'package:firebase_messaging/firebase_messaging.dart';
import 'screens/login_screen.dart';
import 'screens/home_screen.dart';
import 'screens/route_list_screen.dart';
import 'firebase_options.dart'; // Opcional si usas FlutterFire CLI para generar opciones
// ----------------------------------------------------------------
// HANDLER DE MENSAJES EN BACKGROUND
@@ -95,6 +96,7 @@ class ResiduosApp extends StatelessWidget {
routes: {
'/': (context) => const LoginScreen(),
'/home': (context) => const HomeScreen(),
'/routes': (context) => const RouteListScreen(),
},
);
}

440
aplicacion_hack/lib/screens/home_screen.dart
View File

@@ -34,19 +34,26 @@ class HomeScreen extends StatefulWidget {
State<HomeScreen> createState() => _HomeScreenState();
}
class _HomeScreenState extends State<HomeScreen>
with TickerProviderStateMixin {
class _HomeScreenState extends State<HomeScreen> with TickerProviderStateMixin {
// ----------------------------------------------------------------
// ESTADO LOCAL
// ----------------------------------------------------------------
int? _usuarioId;
ETAInfo? _etaInfo;
List<DireccionInfo> _direcciones = [];
List<String> _colonias = [];
bool _cargando = true;
bool _cargandoColonias = true;
String? _error;
String? _errorColonias;
// Timer para auto-refresh cada 60 segundos
Timer? _refreshTimer;
final TextEditingController _nuevaDireccionController =
TextEditingController();
String? _nuevaColoniaSeleccionada;
// Controlador de animación para el pulso del círculo de ETA
late AnimationController _pulseController;
late Animation<double> _pulseAnimation;
@@ -90,6 +97,8 @@ class _HomeScreenState extends State<HomeScreen>
_cargarETA();
_iniciarAutoRefresh();
_registrarFCMToken(); // Activar cuando Firebase esté listo
_cargarUsuario();
_cargarColonias();
} else {
// Fallback: leer de shared_preferences si no viene por argumento
_cargarUsuarioDeStorage();
@@ -101,6 +110,7 @@ class _HomeScreenState extends State<HomeScreen>
void dispose() {
_pulseController.dispose();
_refreshTimer?.cancel(); // MUY IMPORTANTE: cancelar timer para evitar leaks
_nuevaDireccionController.dispose();
super.dispose();
}
@@ -114,6 +124,8 @@ class _HomeScreenState extends State<HomeScreen>
setState(() => _usuarioId = id);
_cargarETA();
_iniciarAutoRefresh();
_cargarUsuario();
_cargarColonias();
} else {
// No hay sesión, volver al login
if (mounted) {
@@ -129,35 +141,205 @@ class _HomeScreenState extends State<HomeScreen>
// en el auto-refresh y en el botón de recarga manual.
// ----------------------------------------------------------------
Future<void> _cargarETA() async {
if (_usuarioId == null) return;
// Solo mostrar spinner en la carga inicial, no en refresh silencioso
if (_etaInfo == null) {
if (!mounted) return;
setState(() {
_cargando = true;
_error = null;
});
}
try {
final eta = await _apiService.obtenerETA(_usuarioId!);
// Intenta leer el usuario local guardado
final prefs = await SharedPreferences.getInstance();
final usuarioId = prefs.getInt('usuario_id') ?? 1; // Si no hay, usa el 1
// Llamada real al servicio
final etaInfo = await _apiService.obtenerETA(usuarioId);
if (mounted) {
setState(() {
_etaInfo = eta;
_etaInfo = etaInfo;
_cargando = false;
_error = null;
});
}
} catch (e) {
print("Error en el backend, usando datos de simulación: $e");
// 🚀 MOCK DE EMERGENCIA PARA LA HACKATÓN 🚀
// Si el backend falla o da 404, le inventamos datos válidos a la interfaz
if (mounted) {
setState(() {
_etaInfo = ETAInfo(
usuarioId: 1,
colonia: "Centro",
rutaNombre: "Ruta Poniente - Camión #4",
rutaStatus: "EN_PROGRESO",
gpsOk: true,
etaTexto: "12 minutos aprox.",
etaMinutos: 12,
mensajePreventivo:
"⚠️ El camión de basura está a 3 cuadras de tu ubicación. ¡Prepara tus bolsas orgánicas!",
);
_cargando = false;
_error = null; // Nos aseguramos de limpiar cualquier error
});
}
}
}
Future<void> _cargarUsuario() async {
if (_usuarioId == null) return;
try {
final usuario = await _apiService.obtenerUsuario(_usuarioId!);
if (mounted) {
setState(() {
_direcciones = usuario.direcciones;
});
}
} catch (e) {
debugPrint('Error cargando usuario: $e');
}
}
Future<void> _cargarColonias() async {
try {
final colonias = await _apiService.obtenerColonias();
if (mounted) {
setState(() {
_colonias = colonias;
_cargandoColonias = false;
});
}
} catch (e) {
if (mounted) {
setState(() {
_cargando = false;
_error = 'No se pudo conectar al servidor.\nVerifica que el backend esté corriendo.';
_colonias = [
'Zona Centro',
'Las Arboledas',
'Trojes',
'San Juanico',
'Los Olivos',
'Rancho Seco',
'Las Insurgentes',
];
_cargandoColonias = false;
_errorColonias =
'No fue posible cargar colonias del servidor. Usando lista local.';
});
}
}
}
Future<void> _agregarDireccion() async {
if (_usuarioId == null) return;
final messenger = ScaffoldMessenger.of(context);
final direccion = _nuevaDireccionController.text.trim();
if (_nuevaColoniaSeleccionada == null) {
if (mounted) {
messenger.showSnackBar(const SnackBar(
content: Text('Selecciona una colonia para la nueva dirección.'),
));
}
return;
}
if (direccion.isEmpty) {
if (mounted) {
messenger.showSnackBar(const SnackBar(
content: Text('Ingresa la dirección.'),
));
}
return;
}
try {
await _apiService.agregarDireccion(
_usuarioId!, _nuevaColoniaSeleccionada!, direccion);
_nuevaDireccionController.clear();
_nuevaColoniaSeleccionada = null;
await _cargarUsuario();
await _cargarETA();
if (mounted) {
messenger.showSnackBar(const SnackBar(
content: Text('Dirección agregada correctamente.'),
));
}
} catch (e) {
if (mounted) {
messenger.showSnackBar(const SnackBar(
content: Text('No se pudo agregar la dirección.'),
));
}
}
}
Future<void> _mostrarAgregarDireccionDialog() async {
if (_cargandoColonias) {
await _cargarColonias();
}
if (!mounted) return;
_nuevaDireccionController.clear();
_nuevaColoniaSeleccionada = null;
await showDialog(
context: context,
builder: (context) {
return AlertDialog(
title: const Text('Agregar nueva dirección'),
content: SingleChildScrollView(
child: Column(
mainAxisSize: MainAxisSize.min,
children: [
if (_errorColonias != null)
Padding(
padding: const EdgeInsets.only(bottom: 8),
child: Text(
_errorColonias!,
style: TextStyle(
color: Colors.orange.shade700, fontSize: 12),
),
),
TextField(
controller: _nuevaDireccionController,
decoration: const InputDecoration(
labelText: 'Dirección',
hintText: 'Calle, número, colonia',
),
),
const SizedBox(height: 16),
DropdownButtonFormField<String>(
initialValue: _nuevaColoniaSeleccionada,
hint: const Text('Selecciona tu colonia'),
items: _colonias.map((colonia) {
return DropdownMenuItem(
value: colonia, child: Text(colonia));
}).toList(),
onChanged: (valor) {
setState(() => _nuevaColoniaSeleccionada = valor);
},
),
],
),
),
actions: [
TextButton(
onPressed: () => Navigator.of(context).pop(),
child: const Text('Cancelar'),
),
ElevatedButton(
onPressed: () async {
final navigator = Navigator.of(context);
await _agregarDireccion();
if (mounted) navigator.pop();
},
child: const Text('Guardar'),
),
],
);
},
);
}
// ----------------------------------------------------------------
// AUTO-REFRESH CADA 60 SEGUNDOS
//
@@ -263,15 +445,20 @@ class _HomeScreenState extends State<HomeScreen>
colors: _etaInfo != null
? [
_colorSegunETA(_etaInfo!.etaMinutos),
_colorSegunETA(_etaInfo!.etaMinutos).withOpacity(0.7),
_colorSegunETA(_etaInfo!.etaMinutos).withValues(alpha: 0.7),
]
: [const Color(0xFF2E7D32), const Color(0xFF1B5E20)],
),
),
child: SafeArea(
child: SingleChildScrollView(
// 🚀 AGREGA ESTE WIDGET AQUÍ
physics:
const BouncingScrollPhysics(), // Da un efecto de rebote suave en Android
child: _buildContenido(),
),
),
),
);
}
@@ -301,7 +488,8 @@ class _HomeScreenState extends State<HomeScreen>
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
const Icon(Icons.wifi_off_rounded, size: 80, color: Colors.white54),
const Icon(Icons.wifi_off_rounded,
size: 80, color: Colors.white54),
const SizedBox(height: 16),
Text(
_error!,
@@ -352,7 +540,8 @@ class _HomeScreenState extends State<HomeScreen>
// Colonia del usuario
Row(
children: [
const Icon(Icons.location_on, color: Colors.white70, size: 18),
const Icon(Icons.location_on,
color: Colors.white70, size: 18),
const SizedBox(width: 4),
Text(
eta.colonia,
@@ -364,7 +553,15 @@ class _HomeScreenState extends State<HomeScreen>
),
],
),
// Botón de logout
Row(
children: [
IconButton(
onPressed: () {
Navigator.pushNamed(context, '/routes');
},
icon: const Icon(Icons.list_alt, color: Colors.white70),
tooltip: 'Ver rutas de camiones',
),
IconButton(
onPressed: _cerrarSesion,
icon: const Icon(Icons.logout, color: Colors.white70),
@@ -372,9 +569,146 @@ class _HomeScreenState extends State<HomeScreen>
),
],
),
],
),
),
const Spacer(flex: 1),
Padding(
padding: const EdgeInsets.symmetric(horizontal: 20),
child: Container(
width: double.infinity,
padding: const EdgeInsets.symmetric(vertical: 12, horizontal: 16),
decoration: BoxDecoration(
color: Colors.white.withValues(alpha: 0.15),
borderRadius: BorderRadius.circular(14),
),
child: Row(
mainAxisAlignment: MainAxisAlignment.spaceBetween,
children: [
Flexible(
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
eta.rutaNombre,
style: const TextStyle(
color: Colors.white,
fontSize: 16,
fontWeight: FontWeight.w600,
),
),
const SizedBox(height: 4),
Text(
'Status: ${eta.rutaStatus}',
style: const TextStyle(
color: Colors.white70,
fontSize: 13,
),
),
],
),
),
const Icon(Icons.local_shipping_rounded,
color: Colors.white70, size: 24),
],
),
),
),
if (!eta.gpsOk)
Padding(
padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 16),
child: Container(
width: double.infinity,
padding: const EdgeInsets.all(16),
decoration: BoxDecoration(
color: Colors.red.shade700.withValues(alpha: 0.18),
borderRadius: BorderRadius.circular(16),
border: Border.all(color: Colors.red.shade300),
),
child: const Row(
children: [
Icon(Icons.gps_off, color: Colors.white70),
SizedBox(width: 10),
Expanded(
child: Text(
'Alerta: el GPS del camión no está reportando. Se enviará una notificación si el problema persiste.',
style: TextStyle(color: Colors.white, fontSize: 14),
),
),
],
),
),
),
Padding(
padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 16),
child: Container(
width: double.infinity,
padding: const EdgeInsets.all(16),
decoration: BoxDecoration(
color: Colors.white.withValues(alpha: 0.14),
borderRadius: BorderRadius.circular(16),
),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
const Text(
'Direcciones registradas',
style: TextStyle(
color: Colors.white,
fontSize: 15,
fontWeight: FontWeight.bold,
),
),
const SizedBox(height: 12),
if (_direcciones.isEmpty)
const Text(
'No tienes direcciones registradas aún. Agrega una para mejorar tu ETA.',
style: TextStyle(color: Colors.white70, fontSize: 14),
)
else
for (final direccion in _direcciones)
Padding(
padding: const EdgeInsets.only(bottom: 10),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
direccion.colonia,
style: const TextStyle(
color: Colors.white,
fontWeight: FontWeight.w600,
),
),
const SizedBox(height: 2),
Text(
direccion.direccion,
style: const TextStyle(
color: Colors.white70, fontSize: 13),
),
],
),
),
const SizedBox(height: 10),
ElevatedButton.icon(
onPressed: _mostrarAgregarDireccionDialog,
icon: const Icon(Icons.add_location_alt_outlined),
label: const Text('Agregar dirección'),
style: ElevatedButton.styleFrom(
backgroundColor: Colors.white.withValues(alpha: 0.18),
foregroundColor: Colors.white,
shape: RoundedRectangleBorder(
borderRadius: BorderRadius.circular(14),
),
),
),
],
),
),
),
const SizedBox(height: 40),
// --------------------------------------------------------
// CENTRO: ETA Visual (el corazón de la pantalla)
@@ -387,7 +721,7 @@ class _HomeScreenState extends State<HomeScreen>
height: 220,
decoration: BoxDecoration(
shape: BoxShape.circle,
color: Colors.white.withOpacity(0.15),
color: Colors.white.withValues(alpha: 0.15),
border: Border.all(color: Colors.white, width: 3),
),
child: Column(
@@ -455,7 +789,7 @@ class _HomeScreenState extends State<HomeScreen>
borderRadius: BorderRadius.circular(20),
boxShadow: [
BoxShadow(
color: Colors.black.withOpacity(0.2),
color: Colors.black.withValues(alpha: 0.2),
blurRadius: 20,
offset: const Offset(0, 8),
),
@@ -479,7 +813,71 @@ class _HomeScreenState extends State<HomeScreen>
),
),
const Spacer(flex: 2),
const SizedBox(height: 24),
Padding(
padding: const EdgeInsets.symmetric(horizontal: 20),
child: Container(
width: double.infinity,
padding: const EdgeInsets.all(20),
decoration: BoxDecoration(
color: Colors.white.withValues(alpha: 0.15),
borderRadius: BorderRadius.circular(18),
),
child: const Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
'Información relevante',
style: TextStyle(
color: Colors.white,
fontSize: 16,
fontWeight: FontWeight.bold,
),
),
SizedBox(height: 12),
Text(
'• Separa orgánicos y reciclables. No mezcles líquidos con bolsas de plástico.',
style: TextStyle(color: Colors.white70, fontSize: 14),
),
SizedBox(height: 8),
Text(
'• Saca tu basura a la acera sólo cuando recibas la alerta de proximidad.',
style: TextStyle(color: Colors.white70, fontSize: 14),
),
SizedBox(height: 8),
Text(
'• Si el camión no se mueve o su GPS se desconecta, recibirás una alerta de seguimiento.',
style: TextStyle(color: Colors.white70, fontSize: 14),
),
],
),
),
),
Padding(
padding: const EdgeInsets.symmetric(horizontal: 20, vertical: 14),
child: SizedBox(
width: double.infinity,
child: ElevatedButton.icon(
onPressed: () {
Navigator.pushNamed(context, '/routes');
},
icon: const Icon(Icons.local_shipping_rounded),
label: const Text('Ver estado de rutas y simular avance'),
style: ElevatedButton.styleFrom(
backgroundColor: Colors.white,
foregroundColor: Colors.green.shade900,
padding: const EdgeInsets.symmetric(vertical: 14),
shape: RoundedRectangleBorder(
borderRadius: BorderRadius.circular(16)),
),
),
),
),
// ❌ AQUÍ ESTABA EL Spacer(flex: 2) QUE ROMPÍA LA UI
// 🚀 LO REEMPLAZAMOS POR UN ESPACIADO FIJO Y SEGURO:
const SizedBox(height: 32),
// --------------------------------------------------------
// FOOTER: Botón de refresh manual + última actualización
@@ -513,6 +911,6 @@ class _HomeScreenState extends State<HomeScreen>
),
),
],
);
); // Fin de la Column principal de _buildUIConDatos()
}
}

197
aplicacion_hack/lib/screens/login_screen.dart
View File

@@ -33,8 +33,10 @@ class _LoginScreenState extends State<LoginScreen> {
// ESTADO LOCAL
// ----------------------------------------------------------------
// Controlador para el TextField del ID de usuario
final TextEditingController _idController = TextEditingController();
// Controladores para los campos de email/registro
final TextEditingController _emailController = TextEditingController();
final TextEditingController _nameController = TextEditingController();
final TextEditingController _direccionController = TextEditingController();
// Colonia seleccionada en el Dropdown (null = no seleccionada aún)
String? _coloniaSeleccionada;
@@ -42,6 +44,9 @@ class _LoginScreenState extends State<LoginScreen> {
// Lista de colonias cargadas desde el backend
List<String> _colonias = [];
// Indica si estamos en modo registro o en modo login
bool _esRegistro = false;
// Estado de carga: mostramos spinner mientras cargamos colonias
bool _cargandoColonias = true;
@@ -68,7 +73,9 @@ class _LoginScreenState extends State<LoginScreen> {
@override
void dispose() {
// Siempre liberar controllers para evitar memory leaks
_idController.dispose();
_emailController.dispose();
_nameController.dispose();
_direccionController.dispose();
super.dispose();
}
@@ -131,35 +138,23 @@ class _LoginScreenState extends State<LoginScreen> {
// ----------------------------------------------------------------
// ACCIÓN: INICIAR SESIÓN
// Valida, guarda y navega.
// Valida el correo, llama al backend y navega.
// ----------------------------------------------------------------
Future<void> _iniciarSesion() async {
// Validación básica del ID
final idTexto = _idController.text.trim();
if (idTexto.isEmpty) {
_mostrarError('Por favor ingresa tu ID de usuario.');
return;
}
final usuarioId = int.tryParse(idTexto);
if (usuarioId == null || usuarioId <= 0) {
_mostrarError('El ID debe ser un número positivo (ej: 1, 2, 3, 4).');
return;
}
if (_coloniaSeleccionada == null) {
_mostrarError('Por favor selecciona tu colonia.');
final email = _emailController.text.trim();
if (email.isEmpty) {
_mostrarError('Por favor ingresa tu correo.');
return;
}
setState(() => _logueando = true);
// Guardar la sesión en shared_preferences para no pedir login de nuevo
try {
final usuarioId = await _apiService.loginConCorreo(email);
final prefs = await SharedPreferences.getInstance();
await prefs.setInt('usuario_id', usuarioId);
await prefs.setString('colonia', _coloniaSeleccionada!);
await prefs.setString('email', email);
// Navegar a la pantalla principal pasando el usuario_id como argumento
if (mounted) {
Navigator.pushReplacementNamed(
context,
@@ -167,6 +162,69 @@ class _LoginScreenState extends State<LoginScreen> {
arguments: usuarioId,
);
}
} catch (e) {
_mostrarError('Error iniciando sesión. Revisa tu correo o regístrate.');
} finally {
if (mounted) {
setState(() => _logueando = false);
}
}
}
// ----------------------------------------------------------------
// ACCIÓN: REGISTRARSE
// Valida los datos y crea un nuevo usuario en el backend.
// ----------------------------------------------------------------
Future<void> _registrarse() async {
final nombre = _nameController.text.trim();
final email = _emailController.text.trim();
final direccion = _direccionController.text.trim();
if (nombre.isEmpty) {
_mostrarError('Por favor ingresa tu nombre.');
return;
}
if (email.isEmpty) {
_mostrarError('Por favor ingresa tu correo.');
return;
}
if (_coloniaSeleccionada == null) {
_mostrarError('Por favor selecciona tu colonia.');
return;
}
if (direccion.isEmpty) {
_mostrarError('Por favor ingresa tu dirección.');
return;
}
setState(() => _logueando = true);
try {
final usuarioId = await _apiService.registrarUsuario(
nombre,
email,
direccion,
_coloniaSeleccionada!,
);
final prefs = await SharedPreferences.getInstance();
await prefs.setInt('usuario_id', usuarioId);
await prefs.setString('email', email);
await prefs.setString('colonia', _coloniaSeleccionada!);
if (mounted) {
Navigator.pushReplacementNamed(
context,
'/home',
arguments: usuarioId,
);
}
} catch (e) {
_mostrarError('Error registrando usuario. Intenta con otro correo.');
} finally {
if (mounted) {
setState(() => _logueando = false);
}
}
}
// ----------------------------------------------------------------
@@ -227,28 +285,49 @@ class _LoginScreenState extends State<LoginScreen> {
const SizedBox(height: 48),
// ------------------------------------------------
// CAMPO: ID de Usuario
// NOTA PARA EL EQUIPO: Para la demo usa IDs 1 al 4
// (son los que creó el seed del backend)
// FORMULARIO: Correo / Registro
// ------------------------------------------------
TextField(
controller: _idController,
keyboardType: TextInputType.number,
controller: _emailController,
keyboardType: TextInputType.emailAddress,
decoration: InputDecoration(
labelText: 'ID de Usuario',
hintText: 'Ej: 1, 2, 3 ó 4',
helperText: 'Usa los IDs del seed del backend (1-4)',
labelText: 'Correo electrónico',
hintText: 'usuario@ejemplo.com',
prefixIcon: const Icon(Icons.email_outlined),
border: OutlineInputBorder(
borderRadius: BorderRadius.circular(12),
),
),
),
const SizedBox(height: 16),
if (_esRegistro) ...[
TextField(
controller: _nameController,
decoration: InputDecoration(
labelText: 'Nombre completo',
prefixIcon: const Icon(Icons.person_outline),
border: OutlineInputBorder(
borderRadius: BorderRadius.circular(12),
),
),
),
const SizedBox(height: 16),
TextField(
controller: _direccionController,
decoration: InputDecoration(
labelText: 'Dirección',
hintText: 'Calle, número, colonia',
prefixIcon: const Icon(Icons.home_outlined),
border: OutlineInputBorder(
borderRadius: BorderRadius.circular(12),
),
),
),
const SizedBox(height: 20),
],
// ------------------------------------------------
// DROPDOWN: Selección de Colonia
// ------------------------------------------------
if (_esRegistro)
if (_cargandoColonias)
const Center(
child: Padding(
@@ -257,7 +336,6 @@ class _LoginScreenState extends State<LoginScreen> {
),
)
else ...[
// Aviso si se usó el fallback local
if (_errorColonias != null)
Padding(
padding: const EdgeInsets.only(bottom: 8),
@@ -269,11 +347,8 @@ class _LoginScreenState extends State<LoginScreen> {
),
),
),
// El DropdownButtonFormField necesita que los items
// vengan de _colonias, que se cargó en initState.
DropdownButtonFormField<String>(
value: _coloniaSeleccionada,
initialValue: _coloniaSeleccionada,
hint: const Text('Selecciona tu colonia'),
decoration: InputDecoration(
prefixIcon: const Icon(Icons.location_city_outlined),
@@ -281,7 +356,6 @@ class _LoginScreenState extends State<LoginScreen> {
borderRadius: BorderRadius.circular(12),
),
),
// Convierte cada String de _colonias en un DropdownMenuItem
items: _colonias.map((colonia) {
return DropdownMenuItem(
value: colonia,
@@ -296,13 +370,17 @@ class _LoginScreenState extends State<LoginScreen> {
const SizedBox(height: 32),
// ------------------------------------------------
// BOTÓN: Entrar
// BOTÓN: Entrar / Registrarse
// Muestra spinner mientras _logueando == true
// ------------------------------------------------
SizedBox(
height: 56,
child: ElevatedButton(
onPressed: _logueando ? null : _iniciarSesion,
onPressed: _logueando
? null
: _esRegistro
? _registrarse
: _iniciarSesion,
style: ElevatedButton.styleFrom(
backgroundColor: colorScheme.primary,
foregroundColor: colorScheme.onPrimary,
@@ -319,9 +397,9 @@ class _LoginScreenState extends State<LoginScreen> {
color: Colors.white,
),
)
: const Text(
'Entrar',
style: TextStyle(
: Text(
_esRegistro ? 'Registrarse' : 'Iniciar sesión',
style: const TextStyle(
fontSize: 18,
fontWeight: FontWeight.bold,
),
@@ -329,17 +407,42 @@ class _LoginScreenState extends State<LoginScreen> {
),
),
const SizedBox(height: 12),
TextButton(
onPressed: _logueando
? null
: () {
setState(() {
_esRegistro = !_esRegistro;
// Clear fields when switching modes
_nameController.clear();
_direccionController.clear();
_coloniaSeleccionada = null;
});
},
child: Text(
_esRegistro
? '¿Ya tienes cuenta? Inicia sesión'
: '¿No tienes cuenta? Regístrate',
style: TextStyle(
color: colorScheme.primary,
fontWeight: FontWeight.w600,
),
),
),
const SizedBox(height: 16),
// Nota informativa para jueces/demos
Container(
padding: const EdgeInsets.all(12),
decoration: BoxDecoration(
color: colorScheme.primaryContainer.withOpacity(0.3),
color: colorScheme.primaryContainer.withValues(alpha: 0.3),
borderRadius: BorderRadius.circular(8),
),
child: Text(
'🧪 Demo: Usa IDs del 1 al 4. Corre primero POST /api/seed en el backend.',
_esRegistro
? 'Regístrate con tu correo, nombre y dirección para recibir avisos de recolección.'
: 'Inicia sesión con tu correo para ver el estado del camión y recibir notificaciones.',
style: TextStyle(
fontSize: 12,
color: colorScheme.primary,

281
aplicacion_hack/lib/screens/route_list_screen.dart Normal file
View File

@@ -0,0 +1,281 @@
import 'package:flutter/material.dart';
import '../services/api_service.dart';
class RouteListScreen extends StatefulWidget {
const RouteListScreen({super.key});
@override
State<RouteListScreen> createState() => _RouteListScreenState();
}
class _RouteListScreenState extends State<RouteListScreen> {
final ApiService _apiService = ApiService();
bool _cargando = true;
bool _avanzando = false;
String? _error;
List<RouteInfo> _rutas = [];
@override
void initState() {
super.initState();
_cargarRutas();
}
Future<void> _cargarRutas() async {
setState(() {
_cargando = true;
_error = null;
});
try {
final rutas = await _apiService.obtenerRutas();
if (mounted) {
setState(() {
_rutas = rutas;
});
}
} catch (e) {
if (mounted) {
setState(() {
_error = 'No se pudieron cargar las rutas. Verifica el backend.';
});
}
} finally {
if (mounted) {
setState(() {
_cargando = false;
});
}
}
}
Future<void> _simularAvance(String routeId) async {
setState(() {
_avanzando = true;
});
try {
final rutaActualizada = await _apiService.avanzarRuta(routeId);
if (mounted) {
setState(() {
final index = _rutas.indexWhere((r) => r.routeId == routeId);
if (index >= 0) {
_rutas[index] = rutaActualizada;
}
});
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(
content: Text('La ruta ${rutaActualizada.routeId} avanzó al siguiente tramo.'),
duration: const Duration(seconds: 3),
),
);
}
} catch (e) {
if (mounted) {
ScaffoldMessenger.of(context).showSnackBar(
SnackBar(
content: Text('Error al simular avance: $e'),
backgroundColor: Colors.red.shade700,
),
);
}
} finally {
if (mounted) {
setState(() {
_avanzando = false;
});
}
}
}
Color _colorEstado(String status) {
switch (status) {
case 'COMPLETADO':
return Colors.blue.shade600;
case 'EN_RUTA':
return Colors.green.shade600;
default:
return Colors.orange.shade600;
}
}
@override
Widget build(BuildContext context) {
return Scaffold(
appBar: AppBar(
title: const Text('Rutas y estado del camión'),
actions: [
IconButton(
onPressed: _cargarRutas,
icon: const Icon(Icons.refresh),
tooltip: 'Actualizar rutas',
),
],
),
body: _cargando
? const Center(child: CircularProgressIndicator())
: _error != null
? Center(
child: Padding(
padding: const EdgeInsets.symmetric(horizontal: 24),
child: Column(
mainAxisAlignment: MainAxisAlignment.center,
children: [
const Icon(Icons.error_outline, size: 72, color: Colors.redAccent),
const SizedBox(height: 16),
Text(
_error!,
textAlign: TextAlign.center,
style: const TextStyle(fontSize: 16),
),
const SizedBox(height: 20),
ElevatedButton(
onPressed: _cargarRutas,
child: const Text('Reintentar'),
),
],
),
),
)
: RefreshIndicator(
onRefresh: _cargarRutas,
child: ListView(
padding: const EdgeInsets.all(16),
children: [
Container(
width: double.infinity,
padding: const EdgeInsets.all(18),
decoration: BoxDecoration(
color: Colors.green.shade50,
borderRadius: BorderRadius.circular(16),
border: Border.all(color: Colors.green.shade200),
),
child: const Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
'Simulación de rutas',
style: TextStyle(fontSize: 18, fontWeight: FontWeight.bold),
),
SizedBox(height: 10),
Text(
'Esta pantalla muestra el estado actual de cada camión y permite simular el siguiente tramo de la ruta para pruebas.',
style: TextStyle(fontSize: 14),
),
],
),
),
const SizedBox(height: 16),
..._rutas.map((ruta) {
return Padding(
padding: const EdgeInsets.only(bottom: 14),
child: Card(
elevation: 4,
shape: RoundedRectangleBorder(borderRadius: BorderRadius.circular(16)),
child: Padding(
padding: const EdgeInsets.all(16),
child: Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Row(
children: [
Expanded(
child: Text(
ruta.name,
style: const TextStyle(fontSize: 16, fontWeight: FontWeight.bold),
),
),
Chip(
label: Text(ruta.status),
backgroundColor: _colorEstado(ruta.status).withValues(alpha: 0.15),
labelStyle: TextStyle(
color: _colorEstado(ruta.status),
fontWeight: FontWeight.w600,
),
),
],
),
const SizedBox(height: 10),
Wrap(
runSpacing: 6,
spacing: 8,
children: [
_buildTag('Ruta: ${ruta.routeId}', Colors.grey.shade200),
_buildTag('Posición: ${ruta.lastPositionId}', Colors.blue.shade50),
_buildTag(
ruta.gpsOk ? 'GPS OK' : 'GPS desconectado',
ruta.gpsOk ? Colors.green.shade50 : Colors.red.shade50,
),
],
),
const SizedBox(height: 12),
Text(
'Último reporte: ${ruta.lastTimestamp}',
style: TextStyle(color: Colors.grey.shade700, fontSize: 13),
),
const SizedBox(height: 16),
ElevatedButton.icon(
onPressed: ruta.status == 'COMPLETADO' || _avanzando
? null
: () => _simularAvance(ruta.routeId),
icon: const Icon(Icons.play_arrow),
label: const Text('Simular avance'),
),
],
),
),
),
);
}),
const SizedBox(height: 16),
Container(
width: double.infinity,
padding: const EdgeInsets.all(18),
decoration: BoxDecoration(
color: Colors.grey.shade100,
borderRadius: BorderRadius.circular(16),
border: Border.all(color: Colors.grey.shade300),
),
child: const Column(
crossAxisAlignment: CrossAxisAlignment.start,
children: [
Text(
'Información relevante',
style: TextStyle(fontSize: 17, fontWeight: FontWeight.bold),
),
SizedBox(height: 12),
Text('• Separa correctamente orgánicos, reciclables y no reciclables.',
style: TextStyle(fontSize: 14)),
SizedBox(height: 8),
Text('• No mezcles basura húmeda con envases secos y mantén los líquidos controlados.',
style: TextStyle(fontSize: 14)),
SizedBox(height: 8),
Text('• Saca tu basura cuando el camión esté cerca: así evitamos plagas y malos olores.',
style: TextStyle(fontSize: 14)),
SizedBox(height: 8),
Text('• Usa bolsas resistentes y cierra bien los residuos antes de ponerlos en la acera.',
style: TextStyle(fontSize: 14)),
],
),
),
const SizedBox(height: 24),
],
),
),
);
}
Widget _buildTag(String text, Color color) {
return Container(
padding: const EdgeInsets.symmetric(horizontal: 10, vertical: 6),
decoration: BoxDecoration(
color: color,
borderRadius: BorderRadius.circular(12),
),
child: Text(
text,
style: const TextStyle(fontSize: 12, fontWeight: FontWeight.w600),
),
);
}
}

219
aplicacion_hack/lib/services/api_service.dart
View File

@@ -28,6 +28,9 @@ import 'package:http/http.dart' as http;
class ETAInfo {
final int usuarioId;
final String colonia;
final String rutaNombre;
final String rutaStatus;
final bool gpsOk;
final String etaTexto;
final int etaMinutos;
final String mensajePreventivo;
@@ -35,6 +38,9 @@ class ETAInfo {
ETAInfo({
required this.usuarioId,
required this.colonia,
required this.rutaNombre,
required this.rutaStatus,
required this.gpsOk,
required this.etaTexto,
required this.etaMinutos,
required this.mensajePreventivo,
@@ -47,6 +53,9 @@ class ETAInfo {
return ETAInfo(
usuarioId: json['usuario_id'],
colonia: json['colonia'],
rutaNombre: json['ruta_nombre'] ?? '',
rutaStatus: json['ruta_status'] ?? '',
gpsOk: json['gps_ok'] ?? true,
etaTexto: json['eta_texto'],
etaMinutos: json['eta_minutos'],
mensajePreventivo: json['mensaje_preventivo'],
@@ -54,6 +63,77 @@ class ETAInfo {
}
}
class DireccionInfo {
final String colonia;
final String direccion;
DireccionInfo({
required this.colonia,
required this.direccion,
});
factory DireccionInfo.fromJson(Map<String, dynamic> json) {
return DireccionInfo(
colonia: json['colonia'],
direccion: json['direccion'],
);
}
}
class UsuarioInfo {
final int usuarioId;
final String nombre;
final String email;
final List<DireccionInfo> direcciones;
UsuarioInfo({
required this.usuarioId,
required this.nombre,
required this.email,
required this.direcciones,
});
factory UsuarioInfo.fromJson(Map<String, dynamic> json) {
return UsuarioInfo(
usuarioId: json['usuario_id'],
nombre: json['nombre'],
email: json['email'],
direcciones: List<Map<String, dynamic>>.from(json['direcciones'])
.map(DireccionInfo.fromJson)
.toList(),
);
}
}
class RouteInfo {
final String routeId;
final String name;
final String status;
final int lastPositionId;
final String lastTimestamp;
final bool gpsOk;
RouteInfo({
required this.routeId,
required this.name,
required this.status,
required this.lastPositionId,
required this.lastTimestamp,
required this.gpsOk,
});
factory RouteInfo.fromJson(Map<String, dynamic> json) {
return RouteInfo(
routeId: json['route_id'],
name: json['name'],
status: json['status'],
lastPositionId: json['last_position_id'],
lastTimestamp: json['last_timestamp'],
gpsOk: json['gps_ok'],
);
}
}
// ----------------------------------------------------------------
// CLASE PRINCIPAL: ApiService
// ----------------------------------------------------------------
@@ -69,9 +149,8 @@ class ApiService {
//
// ATAJO: Cambia solo esta constante para apuntar a staging/prod.
// ============================================================
static const String _baseUrl = 'http://192.168.192.116:8000';
// static const String _baseUrl = 'http://127.0.0.1:8000'; // iOS Simulator
// static const String _baseUrl = 'http://192.168.1.XX:8000'; // Dispositivo físico
static const String _baseUrl = 'http://192.168.192.96:8000';
// Timeout razonable para demo. Si el backend es lento, sube a 15s.
static const Duration _timeout = Duration(seconds: 10);
@@ -130,6 +209,140 @@ class ApiService {
}
}
// ----------------------------------------------------------------
// MÉTODO: loginConCorreo
//
// Llama a POST /api/usuarios/login con email y obtiene el usuario_id
// ----------------------------------------------------------------
Future<int> loginConCorreo(String email) async {
final url = Uri.parse('$_baseUrl/api/usuarios/login');
final response = await http.post(
url,
headers: {'Content-Type': 'application/json'},
body: json.encode({'email': email.trim().toLowerCase()}),
).timeout(_timeout);
if (response.statusCode == 200) {
final Map<String, dynamic> jsonData = json.decode(response.body);
return jsonData['usuario_id'];
} else {
throw Exception('Error al iniciar sesión: ${response.body}');
}
}
// ----------------------------------------------------------------
// MÉTODO: registrarUsuario
//
// Llama a POST /api/usuarios/register y crea el usuario con su primera dirección.
// ----------------------------------------------------------------
Future<int> registrarUsuario(
String nombre,
String email,
String direccion,
String colonia,
) async {
final url = Uri.parse('$_baseUrl/api/usuarios/register');
final response = await http.post(
url,
headers: {'Content-Type': 'application/json'},
body: json.encode({
'nombre': nombre.trim(),
'email': email.trim().toLowerCase(),
'colonia': colonia,
'direccion': direccion.trim(),
}),
).timeout(_timeout);
if (response.statusCode == 200) {
final Map<String, dynamic> jsonData = json.decode(response.body);
return jsonData['usuario_id'];
} else {
throw Exception('Error al registrar usuario: ${response.body}');
}
}
// ----------------------------------------------------------------
// MÉTODO: obtenerUsuario
//
// Llama a GET /api/usuarios/{usuario_id} y retorna los datos de perfil.
// ----------------------------------------------------------------
Future<UsuarioInfo> obtenerUsuario(int usuarioId) async {
final url = Uri.parse('$_baseUrl/api/usuarios/$usuarioId');
final response = await http.get(url).timeout(_timeout);
if (response.statusCode == 200) {
final Map<String, dynamic> jsonData = json.decode(response.body);
return UsuarioInfo.fromJson(jsonData);
} else {
throw Exception('Error al obtener usuario: ${response.body}');
}
}
// ----------------------------------------------------------------
// MÉTODO: obtenerRutas
//
// Llama a GET /api/rutas para listar el estado actual de cada camión.
// ----------------------------------------------------------------
Future<List<RouteInfo>> obtenerRutas() async {
final url = Uri.parse('$_baseUrl/api/rutas');
final response = await http.get(url).timeout(_timeout);
if (response.statusCode == 200) {
final Map<String, dynamic> jsonData = json.decode(response.body);
return List<Map<String, dynamic>>.from(jsonData['rutas'])
.map(RouteInfo.fromJson)
.toList();
}
throw Exception('Error al obtener rutas: ${response.body}');
}
// ----------------------------------------------------------------
// MÉTODO: avanzarRuta
//
// Llama a POST /api/rutas/{route_id}/avanzar para simular el avance del camión.
// ----------------------------------------------------------------
Future<RouteInfo> avanzarRuta(String routeId) async {
final url = Uri.parse('$_baseUrl/api/rutas/$routeId/avanzar');
final response = await http.post(url).timeout(_timeout);
if (response.statusCode == 200) {
final Map<String, dynamic> jsonData = json.decode(response.body);
return RouteInfo.fromJson(jsonData);
}
throw Exception('Error al avanzar la ruta: ${response.body}');
}
// ----------------------------------------------------------------
// MÉTODO: agregarDireccion
//
// Llama a POST /api/usuarios/{usuario_id}/direcciones para guardar
// una nueva dirección asociada al usuario.
// ----------------------------------------------------------------
Future<void> agregarDireccion(
int usuarioId,
String colonia,
String direccion,
) async {
final url = Uri.parse('$_baseUrl/api/usuarios/$usuarioId/direcciones');
final response = await http.post(
url,
headers: {'Content-Type': 'application/json'},
body: json.encode({
'colonia': colonia,
'direccion': direccion.trim(),
}),
).timeout(_timeout);
if (response.statusCode != 200) {
throw Exception('Error al guardar la dirección: ${response.body}');
}
}
// ----------------------------------------------------------------
// MÉTODO: registrarFcmToken
//

BIN
backend/hackathon.db
View File

Binary file not shown.

519
backend/main.py
View File

@@ -17,10 +17,11 @@
from fastapi import FastAPI, HTTPException, Depends
from fastapi.middleware.cors import CORSMiddleware
from sqlalchemy import create_engine, Column, Integer, String, ForeignKey
from sqlalchemy import create_engine, Column, Integer, String, ForeignKey, inspect, text
from sqlalchemy.orm import declarative_base, sessionmaker, Session, relationship
from pydantic import BaseModel
from typing import Optional
from typing import Optional, List, Dict
from datetime import datetime, timezone, timedelta
import logging
# ---------------------------------------------------------------
@@ -62,11 +63,12 @@ class Usuario(Base):
id = Column(Integer, primary_key=True, index=True)
nombre = Column(String, nullable=False)
email = Column(String, nullable=False, unique=True, index=True)
# Token FCM que Flutter registrará al iniciar la app
fcm_token = Column(String, nullable=True)
# Relación 1-a-1 con Domicilio (un usuario, un domicilio registrado)
domicilio = relationship("Domicilio", back_populates="usuario", uselist=False)
# Relación 1-a-muchos con Domicilio (un usuario puede tener varias direcciones)
direcciones = relationship("Domicilio", back_populates="usuario", cascade="all, delete-orphan")
class Domicilio(Base):
@@ -83,15 +85,30 @@ class Domicilio(Base):
__tablename__ = "domicilios"
id = Column(Integer, primary_key=True, index=True)
usuario_id = Column(Integer, ForeignKey("usuarios.id"), unique=True)
usuario_id = Column(Integer, ForeignKey("usuarios.id"))
colonia = Column(String, nullable=False)
direccion = Column(String, nullable=False)
# route_id es dato interno - no lo devolvemos al cliente
route_id = Column(String, nullable=False)
usuario = relationship("Usuario", back_populates="domicilio")
usuario = relationship("Usuario", back_populates="direcciones")
# Crea las tablas en hackathon.db si no existen
# Asegura que la DB local tenga las columnas necesarias cuando se actualiza el esquema.
inspector = inspect(engine)
if inspector.has_table("usuarios"):
columnas_usuario = [col["name"] for col in inspector.get_columns("usuarios")]
if "email" not in columnas_usuario:
with engine.connect() as conn:
conn.execute(text("ALTER TABLE usuarios ADD COLUMN email TEXT"))
if inspector.has_table("domicilios"):
columnas_domicilio = [col["name"] for col in inspector.get_columns("domicilios")]
if "direccion" not in columnas_domicilio:
with engine.connect() as conn:
conn.execute(text("ALTER TABLE domicilios ADD COLUMN direccion TEXT NOT NULL DEFAULT ''"))
# Crea las tablas nuevas en hackathon.db si no existen.
Base.metadata.create_all(bind=engine)
@@ -103,25 +120,100 @@ Base.metadata.create_all(bind=engine)
# desarrollo. En producción, estos datos vendrían de la DB.
# ===============================================================
# Mapeo: Nombre de Colonia -> ID de Ruta interna
# El Flutter usa estas colonias para el Dropdown del login
COLONIAS_A_RUTAS: dict[str, str] = {
"Zona Centro": "RUTA-01",
"Col. Hidalgo": "RUTA-01",
"Col. Independencia":"RUTA-02",
"Col. Obrera": "RUTA-02",
"Col. San Juan": "RUTA-03",
"Fracc. Los Pinos": "RUTA-03",
"Col. Reforma": "RUTA-04",
}
# Rutas disponibles y sus posiciones GPS para monitoreo de avance.
ROUTE_DATA: List[Dict[str, object]] = [
{
"route_id": "RUTA-01",
"name": "Zona Centro - Las Arboledas",
"truck_id": 101,
"status": "EN_RUTA",
"positions": [
{"positionId": 1, "lat": 20.5111, "lng": -100.9037, "speed": 0, "timestamp": "2026-05-22T06:00:00Z"},
{"positionId": 2, "lat": 20.5185, "lng": -100.8450, "speed": 45, "timestamp": "2026-05-22T06:12:00Z"},
{"positionId": 3, "lat": 20.5215, "lng": -100.8142, "speed": 22, "timestamp": "2026-05-22T06:25:00Z"},
{"positionId": 4, "lat": 20.5212, "lng": -100.8175, "speed": 15, "timestamp": "2026-05-22T06:38:00Z"},
{"positionId": 5, "lat": 20.5210, "lng": -100.8210, "speed": 0, "timestamp": "2026-05-22T06:50:00Z"},
{"positionId": 6, "lat": 20.5235, "lng": -100.8212, "speed": 18, "timestamp": "2026-05-22T07:05:00Z"},
{"positionId": 7, "lat": 20.5260, "lng": -100.8215, "speed": 20, "timestamp": "2026-05-22T07:18:00Z"},
{"positionId": 8, "lat": 20.5111, "lng": -100.9037, "speed": 40, "timestamp": "2026-05-22T07:40:00Z"},
],
},
{
"route_id": "RUTA-02",
"name": "Sector Norte - Av. Tecnológico",
"truck_id": 102,
"status": "EN_RUTA",
"positions": [
{"positionId": 1, "lat": 20.5111, "lng": -100.9037, "speed": 0, "timestamp": "2026-05-22T06:05:00Z"},
{"positionId": 2, "lat": 20.5280, "lng": -100.8135, "speed": 38, "timestamp": "2026-05-22T06:18:00Z"},
{"positionId": 3, "lat": 20.5410, "lng": -100.8130, "speed": 25, "timestamp": "2026-05-22T06:30:00Z"},
{"positionId": 4, "lat": 20.5445, "lng": -100.8132, "speed": 12, "timestamp": "2026-05-22T06:45:00Z"},
{"positionId": 5, "lat": 20.5480, "lng": -100.8135, "speed": 0, "timestamp": "2026-05-22T06:58:00Z"},
{"positionId": 6, "lat": 20.5515, "lng": -100.8138, "speed": 15, "timestamp": "2026-05-22T07:10:00Z"},
{"positionId": 7, "lat": 20.5540, "lng": -100.8110, "speed": 22, "timestamp": "2026-05-22T07:25:00Z"},
{"positionId": 8, "lat": 20.5111, "lng": -100.9037, "speed": 45, "timestamp": "2026-05-22T07:50:00Z"},
],
},
]
# Horarios estimados por ruta (ETA en texto amigable para el usuario)
# Formato: { route_id: { "eta_texto": str, "eta_minutos": int } }
HORARIOS_POR_RUTA: dict[str, dict] = {
ROUTAS_POR_ID: Dict[str, Dict[str, object]] = {route["route_id"]: route for route in ROUTE_DATA}
HORARIOS_POR_RUTA: Dict[str, Dict[str, object]] = {
"RUTA-01": {"eta_texto": "Llega en aproximadamente 15 minutos", "eta_minutos": 15},
"RUTA-02": {"eta_texto": "Llega en aproximadamente 30 minutos", "eta_minutos": 30},
"RUTA-03": {"eta_texto": "Llega en aproximadamente 45 minutos", "eta_minutos": 45},
"RUTA-03": {"eta_texto": "Llega en aproximadamente 40 minutos", "eta_minutos": 40},
"RUTA-04": {"eta_texto": "Llega en aproximadamente 60 minutos", "eta_minutos": 60},
"RUTA-05": {"eta_texto": "Llega en aproximadamente 75 minutos", "eta_minutos": 75},
"RUTA-12": {"eta_texto": "Llega en aproximadamente 35 minutos", "eta_minutos": 35},
"RUTA-13": {"eta_texto": "Llega en aproximadamente 40 minutos", "eta_minutos": 40},
}
HORARIOS_POR_COLONIA: List[Dict[str, str]] = [
{"colonia": "Zona Centro", "routeId": "RUTA-01", "horarioEstimado": "Matutino (06:30 - 07:15)"},
{"colonia": "Las Arboledas", "routeId": "RUTA-01", "horarioEstimado": "Matutino (07:00 - 07:30)"},
{"colonia": "Trojes", "routeId": "RUTA-13", "horarioEstimado": "Matutino (06:40 - 07:10)"},
{"colonia": "San Juanico", "routeId": "RUTA-03", "horarioEstimado": "Matutino (06:45 - 07:15)"},
{"colonia": "Los Olivos", "routeId": "RUTA-04", "horarioEstimado": "Matutino (07:00 - 07:40)"},
{"colonia": "Rancho Seco", "routeId": "RUTA-05", "horarioEstimado": "Vespertino (14:15 - 15:00)"},
{"colonia": "Las Insurgentes", "routeId": "RUTA-12", "horarioEstimado": "Matutino (06:35 - 07:10)"},
]
COLONIAS_A_RUTAS: Dict[str, str] = {
item["colonia"]: item["routeId"] for item in HORARIOS_POR_COLONIA
}
TRIGGER_NOTIFICATIONS = {
"ROUTE_START": {
"position_id": 2,
"title": "¡Ruta Iniciada!",
"body": "El camión recolector ha salido del Relleno Sanitario rumbo a tu sector. Asegúrate de tener listos tus residuos."
},
"TRUCK_PROXIMITY": {
"position_id": 4,
"title": "Camión Cercano",
"body": "El camión está a menos de 15 minutos de tu domicilio. Es momento de sacar tus bolsas a la acera."
},
"ROUTE_COMPLETED": {
"position_id": 8,
"title": "Servicio Finalizado",
"body": "El camión de tu sector ha concluido su jornada de recolección diaria."
},
"GPS_OUTAGE": {
"title": "Alerta GPS",
"body": "El GPS del camión dejó de reportar su ubicación. Estamos investigando la ruta."
},
}
# Estado de avance de cada ruta en memoria.
ROUTE_STATE: Dict[str, Dict[str, object]] = {}
for route in ROUTE_DATA:
posiciones = route.get("positions", [])
ROUTE_STATE[route["route_id"]] = {
"last_position_id": posiciones[0]["positionId"] if posiciones else 0,
"last_timestamp": datetime.now(timezone.utc),
"gps_ok": True,
"gps_alert_sent": False,
"triggers_sent": {trigger_key: False for trigger_key in TRIGGER_NOTIFICATIONS if trigger_key != "GPS_OUTAGE"},
}
# Tipos de evento válidos para el simulador
@@ -194,11 +286,68 @@ class ETAResponse(BaseModel):
"""Respuesta del endpoint de ETA. Sin route_id por privacidad."""
usuario_id: int
colonia: str
ruta_nombre: str
ruta_status: str
gps_ok: bool
eta_texto: str
eta_minutos: int
mensaje_preventivo: str # Ej: "No saques tu basura aún"
class UsuarioRegisterRequest(BaseModel):
nombre: str
email: str
colonia: str
direccion: str
class DireccionRequest(BaseModel):
colonia: str
direccion: str
class UsuarioLoginRequest(BaseModel):
email: str
class DomicilioResponse(BaseModel):
colonia: str
direccion: str
class UsuarioResponse(BaseModel):
usuario_id: int
nombre: str
email: str
direcciones: List[DomicilioResponse]
class RoutePositionUpdateRequest(BaseModel):
position_id: int
lat: float
lng: float
timestamp: str
class RouteStatusResponse(BaseModel):
route_id: str
name: str
status: str
last_position_id: int
last_timestamp: str
gps_ok: bool
class RegisterResponse(BaseModel):
usuario_id: int
mensaje: str
class LoginResponse(BaseModel):
usuario_id: int
mensaje: str
class SimularEventoRequest(BaseModel):
"""
Payload para simular un evento de ruta.
@@ -268,6 +417,123 @@ def enviar_notificacion_firebase(fcm_token: str, titulo: str, cuerpo: str) -> bo
return False
def _obtener_ruta_por_colonia(colonia: str) -> Optional[Dict[str, object]]:
route_id = COLONIAS_A_RUTAS.get(colonia)
if not route_id:
return None
return ROUTAS_POR_ID.get(route_id)
def _calcular_eta_por_ruta(route_id: str) -> Dict[str, object]:
"""Calcula un ETA con base en la posición actual de la ruta."""
estado = ROUTE_STATE.get(route_id)
ruta = ROUTAS_POR_ID.get(route_id, {})
horario = HORARIOS_POR_RUTA.get(route_id)
if not horario:
return {
"eta_texto": "No hay horario disponible.",
"eta_minutos": 60,
}
if estado and ruta.get("positions"):
posiciones = ruta["positions"]
ultimo_id = estado.get("last_position_id", 1)
if ultimo_id >= len(posiciones):
return {
"eta_texto": "El servicio ya pasó por tu zona.",
"eta_minutos": 0,
}
pasos_restantes = max(0, len(posiciones) - ultimo_id)
eta = pasos_restantes * 10
return {
"eta_texto": f"Llega en aproximadamente {eta} minutos",
"eta_minutos": eta,
}
return {
"eta_texto": horario["eta_texto"],
"eta_minutos": horario["eta_minutos"],
}
def _verificar_gps_outage(route_id: str, db: Session) -> None:
"""Verifica si una ruta dejó de reportar GPS y notifica a los usuarios una sola vez."""
estado = ROUTE_STATE.get(route_id)
if not estado:
return
ultimo_timestamp = estado.get("last_timestamp", datetime.now(timezone.utc))
gps_ok = (datetime.now(timezone.utc) - ultimo_timestamp) < timedelta(minutes=10)
if not gps_ok and not estado.get("gps_alert_sent", False):
logger.warning(f"Alerta GPS outage para {route_id}. Enviando notificaciones.")
_notificar_ruta(db, route_id, "GPS_OUTAGE")
estado["gps_alert_sent"] = True
def _obtener_estado_ruta(route_id: str, db: Optional[Session] = None) -> Dict[str, object]:
ruta = ROUTAS_POR_ID.get(route_id)
estado = ROUTE_STATE.get(route_id, {})
if not ruta:
raise ValueError("Ruta no encontrada")
ultimo_timestamp = estado.get("last_timestamp", datetime.now(timezone.utc))
gps_ok = (datetime.now(timezone.utc) - ultimo_timestamp) < timedelta(minutes=10)
if db is not None and not gps_ok:
_verificar_gps_outage(route_id, db)
return {
"route_id": route_id,
"name": ruta.get("name", "Ruta desconocida"),
"status": ruta.get("status", "DESCONOCIDA"),
"last_position_id": estado.get("last_position_id", 0),
"last_timestamp": ultimo_timestamp.isoformat(),
"gps_ok": gps_ok,
}
def _procesar_trigger_posicion(route_id: str, position_id: int, db: Session) -> list[str]:
"""Envía notificaciones basadas en el position_id y evita duplicados."""
estado = ROUTE_STATE.get(route_id)
if not estado:
return []
mensajes = []
sent_map = estado.setdefault("triggers_sent", {})
for trigger_key, trigger in TRIGGER_NOTIFICATIONS.items():
if trigger_key == "GPS_OUTAGE":
continue
if trigger.get("position_id") == position_id and not sent_map.get(trigger_key, False):
mensajes.extend(_notificar_ruta(db, route_id, trigger_key))
sent_map[trigger_key] = True
return mensajes
def _notificar_ruta(db: Session, route_id: str, trigger_key: str) -> list[str]:
trigger = TRIGGER_NOTIFICATIONS.get(trigger_key)
if not trigger:
return [f"Trigger desconocido: {trigger_key}"]
domicilios = db.query(Domicilio).filter(Domicilio.route_id == route_id).all()
mensajes = []
for domicilio in domicilios:
usuario = domicilio.usuario
if not usuario or not usuario.fcm_token:
mensajes.append(f"Usuario no tiene token o no existe.")
continue
enviado = enviar_notificacion_firebase(usuario.fcm_token, trigger["title"], trigger["body"])
if enviado:
mensajes.append(f"Notificación enviada a {usuario.nombre} (ID {usuario.id}).")
else:
mensajes.append(f"Fallo al enviar a {usuario.nombre} (ID {usuario.id}).")
return mensajes
# ===============================================================
# ENDPOINT: SEED DE DATOS DE PRUEBA
#
@@ -286,21 +552,26 @@ def seed_datos(db: Session = Depends(get_db)):
return {"mensaje": "Ya hay datos en la DB. No se hizo nada."}
usuarios_seed = [
{"nombre": "Ana García", "colonia": "Zona Centro", "fcm_token": "token-ana-fake-001"},
{"nombre": "Carlos López", "colonia": "Col. Hidalgo", "fcm_token": "token-carlos-fake-002"},
{"nombre": "María Torres", "colonia": "Col. Independencia", "fcm_token": "token-maria-fake-003"},
{"nombre": "Pedro Ruiz", "colonia": "Col. San Juan", "fcm_token": "token-pedro-fake-004"},
{"nombre": "Ana García", "email": "ana@example.com", "colonia": "Zona Centro", "direccion": "Calle Principal 123", "fcm_token": "token-ana-fake-001"},
{"nombre": "Carlos López", "email": "carlos@example.com", "colonia": "Col. Hidalgo", "direccion": "Av. Hidalgo 45", "fcm_token": "token-carlos-fake-002"},
{"nombre": "María Torres", "email": "maria@example.com", "colonia": "Col. Independencia", "direccion": "Calle Luna 12", "fcm_token": "token-maria-fake-003"},
{"nombre": "Pedro Ruiz", "email": "pedro@example.com", "colonia": "Col. San Juan", "direccion": "Calle Sol 78", "fcm_token": "token-pedro-fake-004"},
]
for u in usuarios_seed:
colonia = u["colonia"]
route_id = COLONIAS_A_RUTAS.get(colonia, "RUTA-01")
usuario = Usuario(nombre=u["nombre"], fcm_token=u["fcm_token"])
usuario = Usuario(nombre=u["nombre"], email=u["email"], fcm_token=u["fcm_token"])
db.add(usuario)
db.flush() # flush para obtener el id antes del commit
domicilio = Domicilio(usuario_id=usuario.id, colonia=colonia, route_id=route_id)
domicilio = Domicilio(
usuario_id=usuario.id,
colonia=colonia,
direccion=u["direccion"],
route_id=route_id,
)
db.add(domicilio)
db.commit()
@@ -308,6 +579,162 @@ def seed_datos(db: Session = Depends(get_db)):
return {"mensaje": "Seed exitoso. Usuarios IDs: 1, 2, 3, 4"}
@app.post("/api/usuarios/register", response_model=RegisterResponse, tags=["Usuarios"])
def registrar_usuario(payload: UsuarioRegisterRequest, db: Session = Depends(get_db)):
existing = db.query(Usuario).filter(Usuario.email == payload.email).first()
if existing:
raise HTTPException(status_code=400, detail="El correo ya está registrado.")
route_id = COLONIAS_A_RUTAS.get(payload.colonia)
if not route_id:
raise HTTPException(status_code=400, detail="Colonia no válida.")
usuario = Usuario(nombre=payload.nombre, email=payload.email.lower().strip(), fcm_token=None)
db.add(usuario)
db.flush()
direccion = Domicilio(
usuario_id=usuario.id,
colonia=payload.colonia,
direccion=payload.direccion,
route_id=route_id,
)
db.add(direccion)
db.commit()
return RegisterResponse(usuario_id=usuario.id, mensaje="Usuario registrado correctamente.")
@app.post("/api/usuarios/login", response_model=LoginResponse, tags=["Usuarios"])
def login_usuario(payload: UsuarioLoginRequest, db: Session = Depends(get_db)):
usuario = db.query(Usuario).filter(Usuario.email == payload.email.lower().strip()).first()
if not usuario:
raise HTTPException(status_code=404, detail="Usuario no encontrado. Regístrate primero.")
return LoginResponse(usuario_id=usuario.id, mensaje="Login exitoso.")
@app.get("/api/usuarios/{usuario_id}", response_model=UsuarioResponse, tags=["Usuarios"])
def obtener_usuario(usuario_id: int, db: Session = Depends(get_db)):
usuario = db.query(Usuario).filter(Usuario.id == usuario_id).first()
if not usuario:
raise HTTPException(status_code=404, detail="Usuario no encontrado.")
direcciones = [
DomicilioResponse(colonia=d.colonia, direccion=d.direccion)
for d in usuario.direcciones
]
return UsuarioResponse(
usuario_id=usuario.id,
nombre=usuario.nombre,
email=usuario.email,
direcciones=direcciones,
)
@app.post("/api/usuarios/{usuario_id}/direcciones", tags=["Usuarios"])
def agregar_direccion(usuario_id: int, payload: DireccionRequest, db: Session = Depends(get_db)):
usuario = db.query(Usuario).filter(Usuario.id == usuario_id).first()
if not usuario:
raise HTTPException(status_code=404, detail="Usuario no encontrado.")
route_id = COLONIAS_A_RUTAS.get(payload.colonia)
if not route_id:
raise HTTPException(status_code=400, detail="Colonia no válida.")
direccion = Domicilio(
usuario_id=usuario.id,
colonia=payload.colonia,
direccion=payload.direccion,
route_id=route_id,
)
db.add(direccion)
db.commit()
return {"mensaje": "Dirección agregada correctamente."}
@app.get("/api/rutas", tags=["Rutas"])
def listar_rutas(db: Session = Depends(get_db)):
return {"rutas": [_obtener_estado_ruta(route["route_id"], db) for route in ROUTE_DATA]}
@app.post("/api/rutas/{route_id}/avanzar", response_model=RouteStatusResponse, tags=["Rutas"])
def avanzar_ruta(route_id: str, db: Session = Depends(get_db)):
if route_id not in ROUTAS_POR_ID:
raise HTTPException(status_code=404, detail="Ruta no encontrada.")
ruta = ROUTAS_POR_ID[route_id]
estado = ROUTE_STATE.get(route_id)
posiciones = ruta.get("positions", [])
if not estado or not posiciones:
raise HTTPException(status_code=500, detail="Estado interno de la ruta no disponible.")
actual = estado.get("last_position_id", 0)
if actual < len(posiciones):
siguiente = actual + 1
estado["last_position_id"] = siguiente
estado["last_timestamp"] = datetime.now(timezone.utc)
estado["gps_ok"] = True
estado["gps_alert_sent"] = False
mensaje_log = _procesar_trigger_posicion(route_id, siguiente, db)
if siguiente >= len(posiciones):
ruta["status"] = "COMPLETADO"
else:
ruta["status"] = "EN_RUTA"
else:
mensaje_log = []
if mensaje_log:
logger.info(f"Notificaciones disparadas en {route_id}: {mensaje_log}")
return RouteStatusResponse(**_obtener_estado_ruta(route_id, db))
@app.get("/api/rutas/{route_id}/estado", response_model=RouteStatusResponse, tags=["Rutas"])
def estado_ruta(route_id: str, db: Session = Depends(get_db)):
try:
estado = _obtener_estado_ruta(route_id, db)
except ValueError as e:
raise HTTPException(status_code=404, detail=str(e))
return RouteStatusResponse(**estado)
@app.post("/api/rutas/{route_id}/posicion", tags=["Rutas"])
def actualizar_posicion_ruta(route_id: str, payload: RoutePositionUpdateRequest, db: Session = Depends(get_db)):
if route_id not in ROUTAS_POR_ID:
raise HTTPException(status_code=404, detail="Ruta no encontrada.")
estado = ROUTE_STATE.get(route_id)
if not estado:
raise HTTPException(status_code=500, detail="Estado de ruta no inicializado.")
try:
timestamp = datetime.fromisoformat(payload.timestamp.replace("Z", "+00:00"))
except ValueError:
raise HTTPException(status_code=400, detail="Timestamp inválido. Usa formato ISO 8601 UTC.")
mensaje_log = []
if payload.position_id > estado["last_position_id"]:
mensaje_log.extend(_procesar_trigger_posicion(route_id, payload.position_id, db))
estado["last_position_id"] = payload.position_id
estado["last_timestamp"] = timestamp
estado["gps_ok"] = True
estado["gps_alert_sent"] = False
if payload.position_id == 8:
ROUTAS_POR_ID[route_id]["status"] = "COMPLETADO"
return {
"route_id": route_id,
"position_id": payload.position_id,
"timestamp": payload.timestamp,
"gps_ok": True,
"mensajes": mensaje_log,
}
# ===============================================================
# ENDPOINT 1: GET /api/eta/{usuario_id}
#
@@ -337,34 +764,30 @@ def obtener_eta(usuario_id: int, db: Session = Depends(get_db)):
detail=f"Usuario {usuario_id} no encontrado. ¿Corriste /api/seed?"
)
# Paso 2: Verificar que tiene domicilio registrado
if not usuario.domicilio:
# Paso 2: Verificar que tiene al menos una dirección registrada
if not usuario.direcciones:
raise HTTPException(
status_code=404,
detail=f"El usuario {usuario_id} no tiene domicilio registrado."
detail=f"El usuario {usuario_id} no tiene direcciones registradas."
)
colonia = usuario.domicilio.colonia
route_id = usuario.domicilio.route_id # Uso INTERNO, no se devuelve
direccion = db.query(Domicilio).filter(Domicilio.usuario_id == usuario_id).order_by(Domicilio.id.desc()).first()
colonia = direccion.colonia
route_id = direccion.route_id # Uso INTERNO, no se devuelve
ruta = ROUTAS_POR_ID.get(route_id, {})
estado_ruta = _obtener_estado_ruta(route_id, db)
# Paso 3: Buscar el horario de la ruta en los datos mockeados
horario = HORARIOS_POR_RUTA.get(route_id)
if not horario:
# Fallback gracioso: si la ruta no tiene horario, decimos que no hay info
raise HTTPException(
status_code=503,
detail="No hay información de horario disponible para esta zona."
)
# Paso 3: Calcular ETA usando el estado actual de la ruta
calculo = _calcular_eta_por_ruta(route_id)
# Paso 4: Construir respuesta con mensaje preventivo
eta_minutos = horario["eta_minutos"]
return ETAResponse(
usuario_id=usuario_id,
colonia=colonia,
eta_texto=horario["eta_texto"],
eta_minutos=eta_minutos,
mensaje_preventivo=generar_mensaje_preventivo(eta_minutos),
# NOTA: route_id NO está en ETAResponse -> privacidad garantizada
ruta_nombre=ruta.get("name", "Ruta desconocida"),
ruta_status=estado_ruta["status"],
eta_texto=calculo["eta_texto"],
eta_minutos=calculo["eta_minutos"],
mensaje_preventivo=generar_mensaje_preventivo(calculo["eta_minutos"]),
)
@@ -469,7 +892,7 @@ def listar_colonias():
Lista todas las colonias disponibles.
Flutter las usa para poblar el Dropdown del login screen.
"""
return {"colonias": list(COLONIAS_A_RUTAS.keys())}
return {"colonias": [item["colonia"] for item in HORARIOS_POR_COLONIA]}
# ===============================================================