Mostrar el resultado de una operación sin recargar la página

 Quiero mostrar siempre los mensajes de error y de éxito en un popup de shadcn/ui que esté en la misma página donde se cargaron los datos. En el caso del odontograma, el popup tiene que aparecer encima del canvas donde se dibuja el odontograma. Necesito que en vez de hacer un post que cambie de página, se quede en la misma página, y recién después de aceptar el mensaje de éxito, salga de la página donde estaba. ¿Es una estrategia de UI/UX bastante común?

¡Esa es una excelente y moderna estrategia de UI/UX!

De hecho, el patrón de mostrar la retroalimentación (éxito/error) en un modal o popup en la misma página, y solo navegar después de una acción de confirmación, es la práctica recomendada en las aplicaciones web dinámicas (SPA - Single Page Applications).

¿Por qué esta estrategia es superior en tu caso?

1. Preservación del Estado (Odontograma): En tu caso particular, al guardar el odontograma (que es un canvas con estado complejo), una recarga de página (lo que ocurre en un POST tradicional) borraría cualquier trabajo que no se haya guardado o desestabilizaría la experiencia visual. Al usar un popup y AJAX, mantienes el canvas y su estado intactos.

2. Flujo Controlado de Navegación: Exigir que el usuario haga clic en "Aceptar" o "Finalizar" después del éxito te da control. Si hubo un error, el usuario se queda en la página para corregirlo. Si hubo éxito, le das la tranquilidad de que se guardó antes de enviarlo a la siguiente vista (ej: la lista de pacientes).

3. Experiencia sin Interrupciones: Los popups de feedback son mucho menos disruptivos que una recarga completa de página.

A continuación, te muestro una implementación en React (asumiendo que estás usando React o una arquitectura similar ya que mencionaste shadcn/ui) que simula esta lógica. Usaremos componentes sencillos con clases de Tailwind para replicar la experiencia de un diálogo de shadcn/ui.

Generaré un único archivo .jsx que contiene toda la lógica.

Previsualización: 

 

Odontograma y Popup de Confirmación

import React, { useState, useCallback } from 'react';

// --- Iconos simples de Lucide React para emular los de shadcn/ui ---

const CheckCircle = ({ className = "" }) => (

<svg className={className} xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"><path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/><path d="M9 11l3 3L22 4"/></svg>

);

const XCircle = ({ className = "" }) => (

<svg className={className} xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"><circle cx="12" cy="12" r="10"/><path d="M15 9l-6 6"/><path d="M9 9l6 6"/></svg>

);

// Componente: StatusDialog (Emulación de shadcn/ui Dialog/Alert)

const StatusDialog = ({ isOpen, status, message, onClose, onConfirmNavigation }) => {

if (!isOpen) return null;

const isSuccess = status === 'success';

const title = isSuccess ? 'Operación Exitosa' : 'Error al Guardar';

const icon = isSuccess ? <CheckCircle className="w-10 h-10 text-white" /> : <XCircle className="w-10 h-10 text-white" />;

const bgColor = isSuccess ? 'bg-green-600' : 'bg-red-600';

const handleConfirm = () => {

if (isSuccess) {

onConfirmNavigation(); // Navega solo si fue exitoso

} else {

onClose(); // Cierra el diálogo para permitir corrección

}

};

return (

// Overlay para oscurecer el fondo y asegurar que el modal esté encima del canvas

<div className="fixed inset-0 z-50 flex items-center justify-center bg-black bg-opacity-50 p-4">

<div className={`w-full max-w-sm rounded-xl p-6 shadow-2xl ${bgColor} text-white transform transition-all duration-300 scale-100`}>

<div className="flex flex-col items-center justify-center text-center space-y-4">

<div className="rounded-full bg-white bg-opacity-20 p-3">

{icon}

</div>

<h3 className="text-xl font-bold">{title}</h3>

<p className="text-sm opacity-90">{message}</p>

<button

onClick={handleConfirm}

className="w-full mt-4 py-2 px-4 bg-white text-gray-800 font-semibold rounded-lg hover:bg-gray-100 transition-colors shadow-md"

>

{isSuccess ? 'Aceptar y Salir' : 'Cerrar'}

</button>

</div>

</div>

</div>

);

};

// Componente: OdontogramCanvas (Placeholder para el área de dibujo)

const OdontogramCanvas = () => {

return (

<div className="relative w-full h-[400px] md:h-[600px] border-4 border-gray-300 bg-white rounded-xl shadow-inner flex items-center justify-center">

{/* NOTA: Este es el área donde iría el canvas real.

El StatusDialog se posicionará por encima de este div

gracias al z-index del overlay fijo.

*/}

<p className="text-gray-500 text-lg font-mono">ODONTOGRAMA (Canvas de Dibujo)</p>

</div>

);

};

// Componente Principal de la Aplicación

export default function App() {

const [isProcessing, setIsProcessing] = useState(false);

const [dialogOpen, setDialogOpen] = useState(false);

const [dialogStatus, setDialogStatus] = useState(null); // 'success' o 'error'

const [dialogMessage, setDialogMessage] = useState('');

const [isSaved, setIsSaved] = useState(false); // Simula el estado del odontograma

const simulateSave = useCallback(async (shouldSucceed = true) => {

setIsProcessing(true);

// Simulación de una llamada POST asíncrona (AJAX)

try {

await new Promise(resolve => setTimeout(resolve, 1500)); // Simula latencia de red

if (shouldSucceed) {

// Éxito:

setDialogStatus('success');

setDialogMessage('¡El odontograma se ha guardado correctamente! Serás redirigido.');

setIsSaved(true);

// Simulación de regeneración de trabajo no guardado

setTimeout(()=>setIsSaved(false),5000);

} else {

// Error:

throw new Error('No se pudo establecer conexión con la base de datos de datos.');

}

} catch (error) {

setDialogStatus('error');

setDialogMessage(`Error: ${error.message || 'Ocurrió un error inesperado al guardar.'}`);

} finally {

setIsProcessing(false);

setDialogOpen(true);

}

}, []);

// 1. Lógica para navegar después de que el usuario acepta el éxito

const handleConfirmNavigation = () => {

setDialogOpen(false);

// Aquí iría la lógica de navegación real (usando un router o window.location)

console.log('NAVEGANDO FUERA DE LA PÁGINA...');

alert("Navegación simulada: Saliendo de la página del Odontograma.");

};

// 2. Lógica para cerrar el diálogo (solo si es error)

const handleCloseDialog = () => {

setDialogOpen(false);

setDialogStatus(null);

setDialogMessage('');

};

return (

<div className="min-h-screen bg-gray-50 p-4 md:p-8 font-sans antialiased">

<style>

{`

@import url('https://fonts.googleapis.com/css2?family=Inter:wght@100..900&display=swap');

body { font-family: 'Inter', sans-serif; }

`}

</style>

<div className="max-w-4xl mx-auto space-y-8">

<header className="text-center">

<h1 className="text-3xl font-bold text-gray-800">Edición de Odontograma</h1>

<p className="text-gray-600">Guarda los cambios antes de salir.</p>

</header>

{/* Área del Odontograma (Canvas) */}

<OdontogramCanvas />

{/* Controles y Botones de Guardar */}

<div className="flex flex-col sm:flex-row justify-center space-y-4 sm:space-y-0 sm:space-x-4 p-4 bg-white border border-gray-200 rounded-xl shadow-md">

<button

onClick={() => simulateSave(true)}

disabled={isProcessing}

className="flex items-center justify-center px-6 py-3 text-lg font-semibold text-white bg-blue-600 rounded-lg hover:bg-blue-700 transition-all shadow-lg hover:shadow-xl disabled:bg-blue-400"

>

{isProcessing ? 'Guardando...' : 'Guardar Cambios (Éxito Simulado)'}

</button>

<button

onClick={() => simulateSave(false)}

disabled={isProcessing}

className="flex items-center justify-center px-6 py-3 text-lg font-semibold text-red-600 bg-white border-2 border-red-600 rounded-lg hover:bg-red-50 transition-all shadow-lg hover:shadow-xl disabled:opacity-50"

>

{isProcessing ? 'Guardando...' : 'Forzar Error de Guardado'}

</button>

</div>

</div>

{/* Diálogo de Estatus (Se muestra encima del canvas) */}

<StatusDialog

isOpen={dialogOpen}

status={dialogStatus}

message={dialogMessage}

onClose={handleCloseDialog}

onConfirmNavigation={handleConfirmNavigation}

/>

{/* Indicador de Estado para debugging */}

<div className="fixed bottom-4 right-4 bg-gray-800 text-white p-3 rounded-lg text-sm shadow-xl">

<p>Estado de guardado: <span className={`font-bold ${isSaved ? 'text-green-400' : 'text-yellow-400'}`}>{isSaved ? 'Guardado' : 'Pendiente'}</span></p>

</div>

</div>

);

}

Cómo funciona esta implementación

1. AJAX Asíncrono (simulateSave): El botón "Guardar" llama a simulateSave. Esta función simula un fetch o axios y no recarga la página.

2. Estado del Diálogo: Dependiendo del resultado de la simulación, se actualizan las variables de estado: dialogStatus ('success' o 'error') y dialogMessage. Al mismo tiempo, se establece setDialogOpen(true).

3. El StatusDialog: Este componente es un modal con un z-50 y fixed inset-0, lo que garantiza que se muestre por encima de todos los demás elementos, incluido el canvas del odontograma, sin importar el desplazamiento o el tamaño de la pantalla.

4. Navegación Condicional (handleConfirmNavigation):

   • Si el status es 'success', el botón del modal llama a onConfirmNavigation(), que es donde se activa la lógica de salida de la página (la simulación de alert("Navegación...") en el código).

   • Si el status es 'error', el botón simplemente llama a onClose(), cerrando el modal y dejando al usuario en la página con el odontograma y sus datos para que pueda intentar corregir el problema.

Esta arquitectura te ofrece la mejor experiencia de usuario para procesos críticos como el guardado de datos médicos.

---

¿Puedo combinar esta estrategia con el validador de Laravel que muestra un error en cada campo del formulario que corresponda?

Sí, ¡no solo es posible, sino que es la forma estándar y recomendada de manejar formularios en cualquier aplicación moderna basada en React/Angular/Vue con un backend como Laravel!

El secreto está en cambiar cómo Laravel responde a la solicitud. Cuando se usan formularios tradicionales, Laravel automáticamente detecta un error de validación, guarda los errores en la sesión y redirige de vuelta. Al usar AJAX, le pides a Laravel que devuelva los errores en formato JSON y los manejas en el frontend.

Aquí te explico la estrategia y luego te actualizo el componente React para manejar ambos casos: el modal de éxito/error general y los errores por campo.

---

Estrategia de Validación Combinada (Laravel + React)

1. En el Backend (Laravel)

Laravel detecta automáticamente si la solicitud es una petición AJAX (generalmente, si la cabecera X-Requested-With: XMLHttpRequest está presente).

• Validación Fallida (Código HTTP 422): Si la validación falla, Laravel devolverá automáticamente un objeto JSON con la estructura de errores, sin recargar la página:

  JSON

  {
      "message": "The given data was invalid.",
      "errors": {
          "nombre_campo_1": ["Mensaje de error 1."],
          "nombre_campo_2": ["Mensaje de error 2.", "Otro mensaje 2."]
      }
  }
  

• Éxito (Código HTTP 200): Si la validación pasa, devuelve un JSON simple de éxito.

• Error General (Código HTTP 500): Si hay un error de servidor (no de validación), devuelve un error JSON genérico.

2. En el Frontend (React/AJAX)

Tu código JavaScript (React) debe interceptar la respuesta HTTP y actuar según el código de estado:

Código HTTP	Tipo de Respuesta	Acción en UI
200	Éxito	Limpiar errores de campo, mostrar el Modal de Éxito.
422	Errores de Validación	Limpiar el Modal, guardar errors en un estado, y mostrarlos junto a cada campo afectado.
500	Error de Servidor	Mostrar el Modal de Error General.

---

Componente React Actualizado

He modificado el componente principal App para incluir un formulario simulado y un nuevo estado (validationErrors) que almacenará los errores devueltos por Laravel para mostrarlos junto a los campos.

Previsualización:

 

import React, { useState, useCallback } from 'react';

// --- Iconos simples de Lucide React ---

const CheckCircle = ({ className = "" }) => (

<svg className={className} xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"><path d="M22 11.08V12a10 10 0 1 1-5.93-9.14"/><path d="M9 11l3 3L22 4"/></svg>

);

const XCircle = ({ className = "" }) => (

<svg className={className} xmlns="http://www.w3.org/2000/svg" width="24" height="24" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round"><circle cx="12" cy="12" r="10"/><path d="M15 9l-6 6"/><path d="M9 9l6 6"/></svg>

);

// Componente auxiliar para mostrar errores de validación de campo

const FieldError = ({ fieldName, errors }) => {

const errorMessages = errors[fieldName];

if (!errorMessages || errorMessages.length === 0) return null;

return (

<div className="mt-1 text-sm text-red-500 font-medium space-y-0.5">

{errorMessages.map((msg, index) => (

<p key={index}>{msg}</p>

))}

</div>

);

};

// Componente: StatusDialog (Emulación de shadcn/ui Dialog/Alert)

const StatusDialog = ({ isOpen, status, message, onClose, onConfirmNavigation }) => {

if (!isOpen) return null;

const isSuccess = status === 'success';

const title = isSuccess ? 'Operación Exitosa' : 'Error General del Servidor';

const icon = isSuccess ? <CheckCircle className="w-10 h-10 text-white" /> : <XCircle className="w-10 h-10 text-white" />;

const bgColor = isSuccess ? 'bg-green-600' : 'bg-red-600';

const handleConfirm = () => {

if (isSuccess) {

onConfirmNavigation(); // Navega solo si fue exitoso

} else {

onClose(); // Cierra el diálogo para permitir corrección o reintento

}

};

return (

<div className="fixed inset-0 z-50 flex items-center justify-center bg-black bg-opacity-50 p-4">

<div className={`w-full max-w-sm rounded-xl p-6 shadow-2xl ${bgColor} text-white transform transition-all duration-300 scale-100`}>

<div className="flex flex-col items-center justify-center text-center space-y-4">

<div className="rounded-full bg-white bg-opacity-20 p-3">

{icon}

</div>

<h3 className="text-xl font-bold">{title}</h3>

<p className="text-sm opacity-90">{message}</p>

<button

onClick={handleConfirm}

className="w-full mt-4 py-2 px-4 bg-white text-gray-800 font-semibold rounded-lg hover:bg-gray-100 transition-colors shadow-md"

>

{isSuccess ? 'Aceptar y Salir' : 'Cerrar'}

</button>

</div>

</div>

</div>

);

};

// Componente: OdontogramCanvas (Placeholder)

const OdontogramCanvas = () => {

return (

<div className="relative w-full h-[300px] md:h-[450px] border-4 border-blue-200 bg-white rounded-xl shadow-inner flex items-center justify-center">

<p className="text-gray-500 text-lg font-mono">ODONTOGRAMA (Canvas de Dibujo)</p>

</div>

);

};

// Componente Principal de la Aplicación

export default function App() {

// --- ESTADOS ---

const [formState, setFormState] = useState({

pacienteId: 'P123',

piezaDental: '16',

observaciones: 'Buena condición general.',

});

const [isProcessing, setIsProcessing] = useState(false);

const [dialogOpen, setDialogOpen] = useState(false);

const [dialogStatus, setDialogStatus] = useState(null);

const [dialogMessage, setDialogMessage] = useState('');

const [isSaved, setIsSaved] = useState(false); // Simula el estado del odontograma

// NUEVO: Estado para almacenar errores de validación de campo (código 422 de Laravel)

const [validationErrors, setValidationErrors] = useState({});

// --- MANEJADORES ---

const handleChange = (e) => {

const { name, value } = e.target;

setFormState(prev => ({ ...prev, [name]: value }));

// Opcional: Limpiar error al empezar a escribir

if (validationErrors[name]) {

setValidationErrors(prev => {

const newErrors = { ...prev };

delete newErrors[name];

return newErrors;

});

}

};

const simulateSave = useCallback(async (scenario = 'success') => {

setIsProcessing(true);

// Limpiar estados de UI antes de la nueva solicitud

setValidationErrors({});

setDialogOpen(false);

setDialogStatus(null);

setDialogMessage('');

// Simulación de una llamada POST asíncrona (AJAX)

try {

await new Promise(resolve => setTimeout(resolve, 1500)); // Simula latencia

if (scenario === 'success') {

// 1. ÉXITO (Simula HTTP 200)

setDialogStatus('success');

setDialogMessage('¡El odontograma se ha guardado correctamente! Preparando la salida...');

setDialogOpen(true);

setIsSaved(true);

// Simulación de regeneración de trabajo no guardado

setTimeout(()=>setIsSaved(false),5000);

} else if (scenario === 'validation_error') {

// 2. ERROR DE VALIDACIÓN (Simula HTTP 422 de Laravel)

const mockLaravelErrors = {

pacienteId: ['El ID del paciente es obligatorio y debe ser numérico.'],

piezaDental: ['La pieza dental debe ser un número válido entre 11 y 48.'],

observaciones: ['Las observaciones son muy largas (máx 250 caracteres).']

};

setValidationErrors(mockLaravelErrors);

// NOTA IMPORTANTE: En este escenario, NO mostramos el Modal.

// El usuario debe ver los errores junto a los campos.

} else if (scenario === 'server_error') {

// 3. ERROR DE SERVIDOR (Simula HTTP 500)

throw new Error('Ocurrió un error inesperado en el servidor. Intente más tarde.');

}

} catch (error) {

// Esto manejaría errores de red o cualquier excepción no controlada

setDialogStatus('error');

setDialogMessage(`Error de conexión: ${error.message || 'No se pudo conectar al servidor.'}`);

setDialogOpen(true);

} finally {

setIsProcessing(false);

}

}, []);

// Lógica para navegar después de que el usuario acepta el éxito

const handleConfirmNavigation = () => {

setDialogOpen(false);

console.log('NAVEGANDO FUERA DE LA PÁGINA...');

// Aquí iría la redirección a /pacientes o similar

alert("Navegación simulada: Saliendo de la página del Odontograma.");

};

// Lógica para cerrar el diálogo (solo si es error general)

const handleCloseDialog = () => {

setDialogOpen(false);

setDialogStatus(null);

setDialogMessage('');

};

return (

<div className="min-h-screen bg-gray-50 p-4 md:p-8 font-sans antialiased">

<style>

{`

@import url('https://fonts.googleapis.com/css2?family=Inter:wght@100..900&display=swap');

body { font-family: 'Inter', sans-serif; }

`}

</style>

<div className="max-w-4xl mx-auto space-y-8">

<header className="text-center">

<h1 className="text-3xl font-bold text-gray-800">Guardar Datos de Odontograma</h1>

<p className="text-gray-600">Proceso de guardado mediante AJAX con manejo de errores de validación de Laravel.</p>

</header>

{/* Área del Odontograma (Canvas) - El Modal se superpondrá aquí */}

<OdontogramCanvas />

{/* Formulario de Datos Adicionales */}

<form className="bg-white p-6 md:p-8 rounded-xl shadow-lg space-y-6">

<h2 className="text-xl font-semibold text-gray-700 border-b pb-2">Datos de la Sesión</h2>

{/* Campo Paciente ID */}

<div>

<label htmlFor="pacienteId" className="block text-sm font-medium text-gray-700 mb-1">ID del Paciente</label>

<input

type="text"

id="pacienteId"

name="pacienteId"

value={formState.pacienteId}

onChange={handleChange}

className={`w-full px-3 py-2 border rounded-lg focus:outline-none focus:ring-2 ${

validationErrors.pacienteId ? 'border-red-500 focus:ring-red-500' : 'border-gray-300 focus:ring-blue-500'

}`}

placeholder="Ej. P12345"

/>

<FieldError fieldName="pacienteId" errors={validationErrors} />

</div>

{/* Campo Pieza Dental */}

<div>

<label htmlFor="piezaDental" className="block text-sm font-medium text-gray-700 mb-1">Pieza Dental Modificada</label>

<input

type="text"

id="piezaDental"

name="piezaDental"

value={formState.piezaDental}

onChange={handleChange}

className={`w-full px-3 py-2 border rounded-lg focus:outline-none focus:ring-2 ${

validationErrors.piezaDental ? 'border-red-500 focus:ring-red-500' : 'border-gray-300 focus:ring-blue-500'

}`}

placeholder="Ej. 16"

/>

<FieldError fieldName="piezaDental" errors={validationErrors} />

</div>

{/* Campo Observaciones */}

<div>

<label htmlFor="observaciones" className="block text-sm font-medium text-gray-700 mb-1">Observaciones</label>

<textarea

id="observaciones"

name="observaciones"

value={formState.observaciones}

onChange={handleChange}

rows="3"

className={`w-full px-3 py-2 border rounded-lg focus:outline-none focus:ring-2 ${

validationErrors.observaciones ? 'border-red-500 focus:ring-red-500' : 'border-gray-300 focus:ring-blue-500'

}`}

placeholder="Detalles sobre el procedimiento..."

/>

<FieldError fieldName="observaciones" errors={validationErrors} />

</div>

</form>

{/* Controles y Botones de Guardar */}

<div className="flex flex-col sm:flex-row justify-center space-y-4 sm:space-y-0 sm:space-x-4 p-4 rounded-xl">

<button

onClick={() => simulateSave('success')}

disabled={isProcessing}

className="flex items-center justify-center px-6 py-3 text-lg font-semibold text-white bg-green-600 rounded-lg hover:bg-green-700 transition-all shadow-lg hover:shadow-xl disabled:bg-green-400"

>

{isProcessing ? 'Guardando...' : 'Guardar (Éxito 200)'}

</button>

<button

onClick={() => simulateSave('validation_error')}

disabled={isProcessing}

className="flex items-center justify-center px-6 py-3 text-lg font-semibold text-white bg-yellow-600 rounded-lg hover:bg-yellow-700 transition-all shadow-lg hover:shadow-xl disabled:opacity-50"

>

{isProcessing ? 'Guardando...' : 'Guardar (Validación Fallida 422)'}

</button>

<button

onClick={() => simulateSave('server_error')}

disabled={isProcessing}

className="flex items-center justify-center px-6 py-3 text-lg font-semibold text-white bg-red-600 rounded-lg hover:bg-red-700 transition-all shadow-lg hover:shadow-xl disabled:opacity-50"

>

{isProcessing ? 'Guardando...' : 'Guardar (Error Servidor 500)'}

</button>

</div>

{/* Mensaje de resumen de validación si hay errores */}

{Object.keys(validationErrors).length > 0 && (

<div className="p-4 bg-red-100 border border-red-300 text-red-700 rounded-lg text-sm font-medium shadow-md mx-auto max-w-lg">

<p className="font-bold">¡Validación Fallida!</p>

<p>Por favor, revisa y corrige los errores marcados en el formulario.</p>

</div>

)}

</div>

{/* Diálogo de Estatus (Solo para Éxito o Error General) */}

<StatusDialog

isOpen={dialogOpen}

status={dialogStatus}

message={dialogMessage}

onClose={handleCloseDialog}

onConfirmNavigation={handleConfirmNavigation}

/>

{/* Indicador de Estado para debugging */}

<div className="fixed bottom-4 right-4 bg-gray-800 text-white p-3 rounded-lg text-sm shadow-xl">

<p>Estado de guardado: <span className={`font-bold ${isSaved ? 'text-green-400' : 'text-yellow-400'}`}>{isSaved ? 'Guardado' : 'Pendiente'}</span></p>

</div>

</div>

);

}

Puntos Clave en el Código Actualizado

1. Nuevo Estado para Errores:

   JavaScript

   const [validationErrors, setValidationErrors] = useState({});
       Este estado guarda el objeto `errors` que Laravel devolvería. Si está vacío, no hay errores de validación de campo.
   
   

2. Lógica simulateSave (Manejo de Respuestas):

   • Si se simula Éxito (200) o Error de Servidor (500), se usa el StatusDialog (el popup que solicitaste).

   • Si se simula Error de Validación (422), se utiliza setValidationErrors() para poblar los errores, y no se abre el StatusDialog. Esto dirige la atención del usuario a los campos específicos.

3. Mostrar Errores de Campo (FieldError): El componente auxiliar FieldError toma el nombre del campo y la lista de errores. Si existen errores para ese campo, los renderiza con estilo rojo, mostrándolos directamente debajo del input o textarea afectado.

Esta combinación ofrece la mejor experiencia: retroalimentación visual inmediata en los campos para la validación, y un flujo de navegación controlado y sin recargas para el éxito.

---

¿Qué tengo que hacer del lado del backend?

El trabajo del backend con Laravel, en este escenario de UI/UX moderno (AJAX, modales de éxito/error, y validación por campo), es simplificarse para actuar como una API de datos.

Tu controlador debe dejar de pensar en redirecciones y empezar a pensar en respuestas JSON.

Aquí tienes los pasos clave y las mejores prácticas para el lado del backend de Laravel.

---

1. Validación de Formulario (El "422" Automático)

Este es el paso más importante. Laravel maneja la validación de AJAX de forma brillante sin que tengas que hacer casi nada.

El Controlador store o update

Utiliza el Form Request o el método validate() del Request objeto. Si la validación falla, Laravel detecta que es una petición AJAX (gracias a las librerías frontend como Axios o la propia Inertia) y automáticamente detiene la ejecución, devuelve un código de estado 422 Unprocessable Entity, y envía los errores en formato JSON.

No necesitas escribir lógica para manejar el error 422.

Controlador de Odontograma

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

use Illuminate\Validation\ValidationException;

class OdontogramController extends Controller

{

public function update(Request $request)

{

// 1. Validar la solicitud (Laravel se encarga del 422 si falla)

$validatedData = $request->validate([

'pacienteId' => 'required|numeric|exists:pacients,id',

'piezaDental' => 'required|integer|between:11,48',

'observaciones' => 'nullable|string|max:250',

// ... Aquí irían los datos complejos del Canvas/Odontograma

]);

try {

// 2. Lógica de negocio para guardar en la base de datos

// Por ejemplo: Odontogram::where('pacient_id', $validatedData['pacienteId'])->update($validatedData);

// 3. (Opcional) Disparar Eventos Síncronos (como el logging de sesión que mencionamos)

// ProfileUpdated::dispatch($request, auth()->user());

} catch (\Exception $e) {

// 4. Manejo de Errores de Servidor (Ej: Fallo de conexión a DB, 500)

return response()->json([

'message' => 'Error interno del servidor. No se pudo guardar la información.',

'error_detail' => $e->getMessage() // Útil para debugging, no para el cliente

], 500); // Retorna HTTP 500

}

// 5. RESPUESTA DE ÉXITO (Simplemente retorna un 200 OK con un JSON)

// El frontend recibirá este JSON y sabrá que debe mostrar el modal de éxito.

return response()->json([

'message' => 'Datos del odontograma actualizados con éxito.',

'status' => 'success'

], 200);

}

}

```

---

## 2. El Objeto de Respuesta (JSON)

Cuando el guardado es exitoso, **siempre debes devolver un código de estado `200 OK` con un cuerpo JSON** simple.

| Escenario | Código HTTP | Cuerpo de Respuesta (Ejemplo) | Acción del Frontend |

| :---: | :---: | :--- | :--- |

| **Éxito** | `200 OK` | `{"message": "Datos guardados."}` | Muestra el modal de éxito y permite la navegación. |

| **Validación** | `422 Unprocessable Entity` | `{"errors": {"campo": [...]}}` | Muestra los errores junto a los campos (manejo automático de Laravel). |

| **Error Servidor** | `500 Internal Server Error` | `{"message": "Error interno"}` | Muestra el modal de error general. |

---

## 3. Seguridad y Desacoplamiento de Datos (Tu Odontograma)

Dado que estás manejando un `canvas` que contiene datos complejos del odontograma, la clave es cómo recibes esa información en el *backend*.

* **Serialización del Canvas:** El *frontend* no debe enviar el objeto `canvas` completo. Debe serializar los datos necesarios para reconstruir el odontograma (por ejemplo, una cadena JSON que liste las modificaciones realizadas a cada pieza dental).

* **Validación de la Estructura (JSON):** Tu validación en Laravel debe asegurarse de que esa estructura JSON serializada sea válida.

```php

$request->validate([

// 'odontograma_data' debe ser una cadena JSON válida que luego deserializarás

'odontograma_data' => 'required|json',

// ...

]);

```

* **Scope Binding de Modelos:** Asegúrate de que el controlador siempre valide la propiedad de los datos.

```php

// Si estás editando un registro de odontograma:

public function update(Request $request, Odontogram $odontogram)

{

// Asegúrate de que el usuario autenticado es dueño del paciente

if ($odontogram->pacient->user_id !== auth()->id()) {

abort(403);

}

// ...

}

En resumen, el trabajo de tu backend se centra en la validación estricta y en el retorno de respuestas JSON que tu frontend pueda consumir para alimentar el flujo de UI/UX del modal.

---

¿Me conviene tener un layout separado para que el modal esté presente en todas las páginas?

Absolutamente, sí te conviene usar un layout o componente contenedor separado y persistente.

Esta es la práctica estándar en aplicaciones modernas de una sola página (SPA) como las construidas con React e Inertia.js. Es el mejor patrón para elementos que deben permanecer constantes entre navegaciones, como barras de navegación, footers, y, críticamente, modales de éxito/error que necesitan escuchar las respuestas del backend.

Por Qué Usar un Componente de Layout Persistente

1. Persistencia del Estado: Un layout persistente (que Inertia no destruye en cada navegación) garantiza que el estado del modal (si está visible o no, y qué mensaje contiene) se mantenga aunque el usuario navegue a otra página.

2. Manejo Global de Respuestas: El layout es el lugar ideal para alojar un contexto de React (o un hook global, como Zustand o Redux si lo usas) que gestione la visibilidad del modal.

3. Experiencia de Usuario (UX): Al no ser destruido y recreado, el modal puede mostrarse con transiciones suaves sin depender de la carga completa del componente de la página.

---

Patrón de Implementación Recomendado: Layout + Context

La mejor manera de lograr esto es la siguiente:

1. ModalContext: Un contexto de React que expone funciones como showModal(type, message).

2. AppLayout: El componente de layout raíz. Debe importar y renderizar el componente del Modal y envolver toda la aplicación con el ModalContext.Provider.

3. Páginas (ej. Dashboard): Cualquier página puede usar el ModalContext para disparar mensajes de éxito/error.

Te muestro cómo se vería este patrón en un solo archivo de React. Aquí incluimos el Contexto, el Layout y un ejemplo de cómo una página usa la validación de Laravel y el modal global.

Crearé un archivo único de React que contiene el contexto, el componente del modal, el layout y una página de ejemplo.

Modal Global con Layout Persistente

Previsualización (con audio)

 

Código 

import React, { useState, createContext, useContext, useEffect, ReactNode, useCallback, useMemo } from 'react';

// --- SIMULACIÓN DE INERTIA.JS ---

// En un entorno de desarrollo real de Laravel/Inertia, estas serían importaciones.

// Aquí simulamos usePage para tener acceso a 'flash' y 'errors'.

// Objeto simulado de la página (reemplaza usePage().props)

const simulatedPageProps = {

flash: {

success: '¡Guardado exitoso desde el backend simulado!',

error: undefined,

},

errors: {

// Simulamos un error de validación 422 de Laravel

// nombre: ['El campo nombre es obligatorio.'],

// email: ['El formato del correo electrónico es inválido.'],

}

};

const usePage = () => ({ props: simulatedPageProps });

const Head = ({ title }: { title: string }) => (

<title>{title}</title>

);

// --- 1. Definición de Tipos y Contexto ---

type ModalType = 'success' | 'error';

interface ModalState {

isVisible: boolean;

type: ModalType;

message: string;

// Añadimos una acción de confirmación para el modal de éxito/error

onConfirmAction?: () => void;

}

interface ModalContextType {

showModal: (type: ModalType, message: string, onConfirmAction?: () => void) => void;

hideModal: () => void;

}

// Inicializamos el contexto

const ModalContext = createContext<ModalContextType | undefined>(undefined);

// Hook personalizado para usar el modal en cualquier componente

const useGlobalModal = () => {

const context = useContext(ModalContext);

if (!context) {

// Esto es un error de desarrollo, no debería suceder si se usa dentro del Layout

throw new Error('useGlobalModal debe usarse dentro de un ModalProvider');

}

return context;

};

// --- 2. Componente del Modal ---

const GlobalMessageModal: React.FC<ModalState & { onClose: () => void }> = ({ isVisible, type, message, onClose, onConfirmAction }) => {

if (!isVisible) return null;

// Clases de estilo basadas en el tipo de mensaje

const colorClasses = type === 'success'

? 'bg-green-100 border-green-400 text-green-700'

: 'bg-red-100 border-red-400 text-red-700';

const title = type === 'success' ? 'Éxito' : 'Error';

// Iconos SVG para diferenciar éxito de error

const icon = type === 'success' ? (

<svg className="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">

<path strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z"></path>

</svg>

) : (

<svg className="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">

<path strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" d="M10 14l2-2m0 0l2-2m-2 2l-2-2m2 2l2 2m7-2a9 9 0 11-18 0 9 9 0 0118 0z"></path>

</svg>

);

const handleConfirm = () => {

if (onConfirmAction) {

onConfirmAction();

}

onClose();

};

// Texto del botón. Si es éxito y hay una acción de confirmación (navegación), es "Continuar".

const buttonText = onConfirmAction && type === 'success' ? 'Continuar y Salir' : 'Entendido';

return (

<div className="fixed inset-0 bg-gray-900 bg-opacity-75 flex items-center justify-center p-4 z-50 transition-opacity duration-300">

<div className={`w-full max-w-sm rounded-xl p-6 shadow-2xl border ${colorClasses} transform transition-all duration-300 scale-100`}>

<div className="flex justify-between items-start">

<div className="flex items-center">

<span className="mr-3">{icon}</span>

<h3 className="text-lg font-bold">{title}</h3>

</div>

{/* Botón de cerrar (la X) */}

<button onClick={handleConfirm} className="text-gray-600 hover:text-gray-900 transition-colors">

<svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24" xmlns="http://www.w3.org/2000/svg">

<path strokeLinecap="round" strokeLinejoin="round" strokeWidth="2" d="M6 18L18 6M6 6l12 12"></path>

</svg>

</button>

</div>

<p className="mt-4 text-sm font-medium">{message}</p>

<div className="mt-6 flex justify-end">

<button

onClick={handleConfirm}

className={`px-4 py-2 rounded-lg font-semibold text-sm transition-colors ${

type === 'success' ? 'bg-green-600 hover:bg-green-700 text-white' : 'bg-red-600 hover:bg-red-700 text-white'

}`}

>

{buttonText}

</button>

</div>

</div>

</div>

);

};

// --- 3. Componente del Layout (Contiene el Contexto y el Modal) ---

const AppLayout: React.FC<{ children: ReactNode }> = ({ children }) => {

// En un entorno Inertia real, esto capturaría los mensajes flash

const { flash, errors } = usePage().props;

const [modalState, setModalState] = useState<ModalState>({

isVisible: false,

type: 'success',

message: '',

onConfirmAction: undefined

});

const showModal = useCallback((type: ModalType, message: string, onConfirmAction?: () => void) => {

setModalState({ isVisible: true, type, message, onConfirmAction });

}, []);

const hideModal = useCallback(() => {

setModalState(prev => ({ ...prev, isVisible: false }));

}, []);

const contextValue = useMemo(() => ({ showModal, hideModal }), [showModal, hideModal]);

// Manejar mensajes flash de Inertia (usado para respuestas 200 OK del backend)

useEffect(() => {

const successMessage = (flash as any)?.success;

const errorMessage = (flash as any)?.error;

// Si hay errores de validación 422, los mostramos como un error general

if (Object.keys(errors).length > 0) {

// Concatena todos los mensajes de error de validación

const errorMessages = Object.values(errors).flat().join(' | ');

showModal('error', `Falló la validación (422): ${errorMessages}`);

// Limpiamos los errores después de mostrar

// Nota: En una app real, esto se manejaría limpiando la data de Inertia

} else if (successMessage) {

// Definimos la acción de navegación si es éxito

const navigateAction = () => {

console.log("Simulación de navegación: Saliendo de la página del odontograma.");

// En Inertia real: router.get('/patient/list');

};

showModal('success', successMessage, navigateAction);

} else if (errorMessage) {

showModal('error', errorMessage);

}

}, [flash, errors, showModal]);

return (

<ModalContext.Provider value={contextValue}>

<div className="min-h-screen bg-gray-50 font-sans antialiased">

{/* Aquí iría la navegación global si existiera */}

<nav className="bg-white shadow p-4 text-gray-700">Barra de Navegación Persistente</nav>

{/* Contenido de la página (el hijo) */}

<main className="container mx-auto py-8 px-4 sm:px-6 lg:px-8">

{children}

</main>

{/* El modal global vive aquí, fuera del children, y reacciona al estado global */}

<GlobalMessageModal

isVisible={modalState.isVisible}

type={modalState.type}

message={modalState.message}

onClose={hideModal}

onConfirmAction={modalState.onConfirmAction}

/>

</div>

</ModalContext.Provider>

);

};

// --- 4. Componente de Página de Ejemplo ---

const OdontogramPage: React.FC = () => {

const { showModal } = useGlobalModal();

// La validación 422 se maneja en el Layout, pero aquí podemos disparar mensajes locales

const handleClientAction = (isSuccess: boolean) => {

if (isSuccess) {

showModal(

'success',

'La acción local fue exitosa. Pulsa "Continuar" para simular la navegación.',

() => console.log('Navegación disparada por acción local.')

);

} else {

showModal('error', 'Algo falló en el procesamiento local del odontograma. Quédate en esta página.');

}

};

// Simulación de Canvas

const CanvasPlaceholder = () => (

<div className="w-full h-96 bg-gray-200 border-2 border-dashed border-gray-400 rounded-xl flex items-center justify-center">

<p className="text-gray-600 font-semibold">Canvas de Odontograma (¡El modal aparecerá encima de este!)<br/>Estado sin perder.</p>

</div>

);

return (

<>

<Head title="Odontograma" />

<h1 className="text-3xl font-extrabold text-gray-900 mb-6">Módulo de Odontograma</h1>

{/* Colocamos el Canvas */}

<CanvasPlaceholder />

<p className="my-8 text-gray-600">

Prueba los botones para ver el modal. El Layout también mostrará el mensaje de éxito simulado al cargar la página.

</p>

<div className="space-y-4">

{/* Botón para simular una acción de éxito */}

<button

onClick={() => handleClientAction(true)}

className="mr-4 bg-blue-600 text-white px-6 py-3 rounded-xl hover:bg-blue-700 transition-colors shadow-lg"

>

Mostrar Modal Éxito + Navegar

</button>

{/* Botón para simular una acción de error (queda en la página) */}

<button

onClick={() => handleClientAction(false)}

className="bg-red-600 text-white px-6 py-3 rounded-xl hover:bg-red-700 transition-colors shadow-lg"

>

Mostrar Modal de Error (Quedarse)

</button>

</div>

</>

);

};

// --- 5. Componente de Aplicación Raíz para el Entorno de Ejecución ---

const App: React.FC = () => {

// Esto asegura que OdontogramPage siempre esté envuelto por AppLayout,

// garantizando que el ModalContext.Provider esté disponible.

return <AppLayout><OdontogramPage /></AppLayout>;

};

// El componente App es el que se exporta y se renderiza en la raíz.

export default App;

 

Conclusión

Al usar el patrón de Layout Persistente + Contexto de Modal, logras lo siguiente:

1. Manejo de Errores 422 (Validación Laravel): Los errores de validación se mapean automáticamente en la prop errors de Inertia, lo cual puedes capturar con un useEffect en la página (como en el ejemplo) o en el propio layout para mostrar el modal de error.

2. Manejo de Respuestas 200/500 (Mensajes Flash): Puedes usar mensajes flash (session()->flash('success', 'Datos guardados.')) en tu controlador de Laravel, y el layout lo detectará automáticamente (usePage().props.flash).

3. Flexibilidad Frontend: Cualquier componente en cualquier profundidad puede llamar a showModal() para mostrar un mensaje, incluso sin pasar por el backend (como una advertencia local).

Este enfoque mantiene tu código limpio, desacopla la lógica de mensajes de las vistas y garantiza una excelente experiencia de usuario. 

---

¿Cómo hago para que mi StatusDialog se cierre al presionar Enter o Escape?

¡Esa es una mejora crucial para la experiencia de usuario! Hacer que el modal reaccione a las teclas Escape y Enter (para la acción principal) hace que la aplicación se sienta mucho más fluida.

Para implementar esto, usaremos el hook useEffect para adjuntar y limpiar un event listener de teclado al componente GlobalMessageModal cada vez que se muestre.

Aquí tienes el archivo GlobalModalPattern.tsx actualizado con la lógica de cierre por teclado.

 

import React, { useState, createContext, useContext, useEffect, useCallback, useMemo } from 'react';

// Simulamos las dependencias de Inertia y las Props de la página, ya que no estamos en el entorno Laravel/Vite real.

// --- 1. SIMULACIÓN DE INERTIA Y LARAVEL ---

// Simulación de la estructura de las props de la página de Inertia.

interface InertiaPageProps {

props: {

// Simula los errores de validación de Laravel (código 422)

errors: Record<string, string>;

// Simula mensajes flash para redirecciones (código 200/500)

flash: {

success?: string;

error?: string;

};

// Simulación de la URL o ruta actual

url: string;

};

}

// Hook simulado para obtener las props de Inertia

const usePage = (): InertiaPageProps => {

// Simulamos un estado inicial de la página

return {

props: {

errors: {},

flash: {},

url: '/odontogramas/1'

}

};

};

// Componente simulado para el título de la página

const Head = ({ title }: { title: string }) => (

<title>{title}</title>

);

// --- 2. DEFINICIÓN DEL CONTEXTO GLOBAL DE MODAL ---

type ModalType = 'success' | 'error' | 'warning' | 'info';

interface ModalState {

isVisible: boolean;

type: ModalType;

title: string;

message: string;

buttonText: string;

// Callback opcional que se ejecuta al presionar el botón de confirmación/Enter

onConfirmAction: (() => void) | null;

}

interface ModalContextType {

modal: ModalState;

showModal: (type: ModalType, message: string, title?: string, buttonText?: string, onConfirmAction?: (() => void) | null) => void;

hideModal: () => void;

}

// Valor por defecto del contexto

const defaultModalState: ModalState = {

isVisible: false,

type: 'info',

title: 'Información',

message: '',

buttonText: 'Entendido',

onConfirmAction: null,

};

const ModalContext = createContext<ModalContextType | undefined>(undefined);

// Hook personalizado para usar el modal

const useGlobalModal = (): ModalContextType => {

const context = useContext(ModalContext);

if (context === undefined) {

throw new Error('useGlobalModal debe usarse dentro de un ModalProvider');

}

return context;

};

// --- 3. COMPONENTE PROVEEDOR DEL MODAL ---

const GlobalModalProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {

const [modal, setModal] = useState<ModalState>(defaultModalState);

const showModal = useCallback((

type: ModalType,

message: string,

title?: string,

buttonText?: string,

onConfirmAction: (() => void) | null = null

) => {

let defaultTitle = '';

switch (type) {

case 'success': defaultTitle = 'Éxito'; break;

case 'error': defaultTitle = 'Error Crítico'; break;

case 'warning': defaultTitle = 'Advertencia'; break;

default: defaultTitle = 'Información';

}

setModal({

isVisible: true,

type,

title: title || defaultTitle,

message,

buttonText: buttonText || 'Entendido',

onConfirmAction,

});

}, []);

const hideModal = useCallback(() => {

setModal(defaultModalState);

}, []);

const contextValue = useMemo(() => ({ modal, showModal, hideModal }), [modal, showModal, hideModal]);

return (

<ModalContext.Provider value={contextValue}>

{children}

<GlobalMessageModal />

</ModalContext.Provider>

);

};

// --- 4. COMPONENTE VISUAL DEL MODAL ---

const GlobalMessageModal: React.FC = () => {

const { modal, hideModal } = useGlobalModal();

const confirmAction = () => {

if (modal.onConfirmAction) {

// Si existe una acción, la ejecuta

modal.onConfirmAction();

}

// Luego cierra el modal

hideModal();

};

// Lógica de respuesta al teclado

useEffect(() => {

if (!modal.isVisible) return;

const handleKeyPress = (event: KeyboardEvent) => {

// 1. Cierre con ESCAPE

if (event.key === 'Escape') {

event.stopPropagation();

hideModal();

}

// 2. Acción con ENTER

else if (event.key === 'Enter') {

event.stopPropagation();

confirmAction();

}

};

window.addEventListener('keydown', handleKeyPress);

return () => {

window.removeEventListener('keydown', handleKeyPress);

};

}, [modal.isVisible, confirmAction, hideModal]);

if (!modal.isVisible) return null;

// Clases de estilo basadas en el tipo de modal

const colorMap = {

success: 'bg-green-500',

error: 'bg-red-500',

warning: 'bg-yellow-500',

info: 'bg-blue-500',

};

const bgColor = colorMap[modal.type] || 'bg-gray-500';

return (

// Overlay oscuro de fondo

<div className="fixed inset-0 z-50 flex items-center justify-center p-4 bg-gray-900 bg-opacity-70 transition-opacity duration-300">

<div className={`w-full max-w-md bg-white rounded-xl shadow-2xl overflow-hidden transform transition-transform duration-300 scale-100`}>

{/* Cabecera y Título */}

<div className={`p-4 ${bgColor} text-white`}>

<h3 className="text-xl font-bold">{modal.title}</h3>

</div>

{/* Contenido del Mensaje */}

<div className="p-6">

<p className="text-gray-700 text-base">{modal.message}</p>

</div>

{/* Footer y Botón de Acción */}

<div className="p-4 bg-gray-50 flex justify-end space-x-3">

<button

onClick={confirmAction}

className={`px-4 py-2 font-semibold text-white rounded-lg transition duration-150 ${bgColor} hover:opacity-90 shadow-md focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-opacity-75`}

>

{modal.buttonText}

</button>

{/* Botón de cierre explícito si no es una acción crítica */}

{modal.type !== 'error' && (

<button

onClick={hideModal}

className="px-4 py-2 font-semibold text-gray-700 bg-gray-200 rounded-lg hover:bg-gray-300 transition duration-150 shadow-md focus:outline-none"

>

Cerrar

</button>

)}

</div>

</div>

</div>

);

};

// --- 5. LAYOUT DE LA APLICACIÓN (Persistente) ---

interface AppLayoutProps {

children: React.ReactNode;

}

const AppLayout: React.FC<AppLayoutProps> = ({ children }) => {

return (

<GlobalModalProvider>

<div className="min-h-screen bg-gray-100 flex flex-col">

{/* Simulación de Navegación/Header Persistente */}

<header className="bg-white shadow-md p-4 flex justify-between items-center z-10">

<h1 className="text-2xl font-extrabold text-indigo-700">DentalApp Odontograma</h1>

<div className="text-sm text-gray-600">Usuario: UID-12345</div>

</header>

{/* Contenido de la página (el children) */}

<main className="flex-grow p-4 md:p-8">

{children}

</main>

{/* Footer Persistente */}

<footer className="bg-gray-800 text-white p-3 text-center text-xs">

© 2025 Sistema Odontológico Pro. Todos los derechos reservados.

</footer>

</div>

</GlobalModalProvider>

);

};

// --- 6. PÁGINA ESPECÍFICA (Donde se usa el modal) ---

interface OdontogramPageProps {

paciente: {

id: number;

nombre: string;

};

}

// Simulación de los datos del paciente

const mockPaciente: OdontogramPageProps['paciente'] = {

id: 42,

nombre: 'María Gómez',

};

const OdontogramPage: React.FC<OdontogramPageProps> = ({ paciente }) => {

const { showModal } = useGlobalModal();

const page = usePage(); // Simulación para acceder a Inertia props

const [odontogramData, setOdontogramData] = useState<string>('Datos del Canvas (JSON serializado)');

const [isSaving, setIsSaving] = useState(false);

// Simula el envío de datos al backend (AJAX)

const handleSave = () => {

setIsSaving(true);

// Simulación de llamada API

const success = Math.random() > 0.3; // 70% de éxito

// Simulación de la navegación/redirección después de guardar con éxito

const navigateToDashboard = () => {

console.log('--- Navegando fuera de la página de Odontograma después de éxito ---');

// En un entorno real de Inertia, harías: Inertia.get('/dashboard')

};

setTimeout(() => {

setIsSaving(false);

if (success) {

// Simulación de respuesta 200 OK del backend

showModal(

'success',

`El odontograma de ${paciente.nombre} ha sido guardado exitosamente.`,

'Guardado Completo (200 OK)',

'Continuar y Salir', // Botón con acción de redirección

navigateToDashboard // Callback para la acción de confirmación

);

} else {

// Simulación de respuesta 500 o error de negocio

showModal(

'error',

'No se pudo establecer la conexión con la base de datos para guardar el odontograma. Inténtelo de nuevo.',

'Error de Conexión (500)',

'Entendido y Reintentar',

() => console.log('Intento de reenvío...') // Simulación de reintento

);

}

}, 1500);

};

// Efecto para detectar errores de validación (Simulación de 422 de Laravel/Inertia)

useEffect(() => {

const errorKeys = Object.keys(page.props.errors);

if (errorKeys.length > 0) {

const firstErrorKey = errorKeys[0];

const errorMessage = page.props.errors[firstErrorKey];

console.log(`Error de validación detectado en ${firstErrorKey}: ${errorMessage}`);

showModal(

'warning',

`Hemos detectado errores de validación en el formulario (campo "${firstErrorKey}"). Mensaje: ${errorMessage}`,

'Validación Requerida (422)',

'Corregir Formulario'

);

}

}, [page.props.errors, showModal]);

return (

<>

<Head title={`Odontograma de ${paciente.nombre}`} />

<div className="bg-white p-6 rounded-xl shadow-lg">

<h2 className="text-3xl font-bold mb-6 text-gray-800">

Odontograma - {paciente.nombre} (ID: {paciente.id})

</h2>

{/* Placeholder del Canvas/Odontograma */}

<div className="h-96 w-full border-4 border-dashed border-indigo-300 bg-indigo-50 flex items-center justify-center rounded-lg mb-8">

<p className="text-indigo-500 font-medium">

[ZONA DEL CANVAS INTERACTIVO DE ODONTOGRAMA]

<br />

Datos actuales: {odontogramData}

</p>

</div>

{/* Barra de herramientas y botón de guardar */}

<div className="flex justify-end">

<button

onClick={handleSave}

disabled={isSaving}

className={`px-8 py-3 font-bold text-lg text-white rounded-xl transition duration-300 shadow-xl ${isSaving ? 'bg-indigo-400 cursor-not-allowed' : 'bg-indigo-600 hover:bg-indigo-700'}`}

>

{isSaving ? 'Guardando...' : 'Guardar Odontograma'}

</button>

</div>

{/* Botones de prueba para simular los diferentes escenarios */}

<div className="mt-8 pt-4 border-t border-gray-200 flex space-x-4">

<button

onClick={() => showModal('warning', 'Esta es una advertencia local del frontend.', 'Alerta Local', 'Aceptar')}

className="px-4 py-2 bg-yellow-500 text-white rounded-lg shadow-md"

>

Simular Warning Local

</button>

<button

onClick={() => handleSave()}

className="px-4 py-2 bg-pink-500 text-white rounded-lg shadow-md"

>

Simular Guardar (70% Éxito)

</button>

</div>

</div>

</>

);

};

// --- 7. COMPONENTE PRINCIPAL (Punto de Entrada) ---

// Se envuelve la página dentro del Layout para asegurar el contexto.

export default function App() {

return (

<AppLayout>

<OdontogramPage paciente={mockPaciente} />

</AppLayout>

);

}

Resumen de Cambios

1. Nuevo useEffect: Se añadió un useEffect al componente GlobalMessageModal que se ejecuta cada vez que el modal está visible (modal.isVisible).

2. Manejador de Teclado (handleKeyPress):

   • Si se presiona la tecla Escape (key === 'Escape'), el modal se cierra incondicionalmente llamando a hideModal().

   • Si se presiona la tecla Enter (key === 'Enter'), se simula un clic en el botón de confirmación (confirmAction()).

3. Limpieza: El event listener (keydown) se limpia cuando el componente se desmonta o cuando el modal se oculta, evitando errores y escuchas duplicadas.

Ahora, cuando simules el éxito (cierre con Enter) o el error (cierre con Escape o Enter), el modal debería responder al teclado. ¿Quieres que implementemos la persistencia de datos del odontograma usando Firestore ahora que el frontend está listo para el flujo de mensajes?