Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

//mi duda es que, como recibo una confirmación de que el mensaje realmenete se guardo…

  1. User

    //mi duda es que, como recibo una confirmación de que el mensaje realmenete se guardo function connectWebSocket() { ws = new WebSocket(wsUrl); ws.onopen = () => { ws.send( JSON.stringify({ emisor, type: 'auth', token: token }) ); pingInterval = setInterval(() => { if (ws.readyState === WebSocket.OPEN) { ws.send(JSON.stringify({type: 'ping'})); } }, 30000); }; ws.onclose = () => { clearInterval(pingInterval); setTimeout(connectWebSocket, 5000); }; ws.onerror = error => { console.error('Error en WebSocket:', error); }; ws.onmessage = ({data}) => { const message = JSON.parse(data); if (message.type === 'pong') { } else if (message.type === 'set_emisor') { ws.send(JSON.stringify({emisor})); } else { manejarMensajeWebSocket(JSON.stringify(message)); } }; }

    /*
     *   FUNCIONES PARA ENVIAR MENSAJE
     */
    
    /*
    

    parte de server.php : public function onOpen(ConnectionInterface conn) { this->clients->attach(conn); echo "New connection! ({conn->resourceId})\n";

        // Envía una instrucción para que el cliente envíe su token de autenticación
        $conn->send(json_encode(['type' => 'auth', 'message' => 'Por favor, envía tu token de autenticación.']));
    }
    
    public function onMessage(ConnectionInterface $from, $msg)
    {
        // Log para mostrar el mensaje recibido
        echo "Mensaje recibido de {$from->resourceId}: " . $msg . "\n";
    (... codigos relacionado con la verf. de token y autor omitidos)
            // Guardar el mensaje en WordPress
        echo "Intentando guardar mensaje en WordPress...\n";
    
        // Verificar si hay un token autenticado asociado
        if (isset($this->autenticados[$from->resourceId])) {
            echo "Token autenticado: " . $this->autenticados[$from->resourceId] . "\n";
    
            // Obtener el user_id (emisor) para pasarlo junto con el token
            if (isset($data['emisor'])) {
                $user_id = $data['emisor'];
                $this->guardarMensajeEnWordPress($data, $this->autenticados[$from->resourceId], $user_id);
            } else {
                echo "Error: No se proporcionó un emisor en los datos\n";
            }
        } else {
            echo "Error: No se encontró un token autenticado para la conexión {$from->resourceId}\n";
        }
    }
    
    
    private function guardarMensajeEnWordPress($data, $token, $user_id)
    {
        echo "Datos a enviar a WordPress: " . json_encode($data) . "\n";
        echo "Token usado para autenticar en WordPress: $token\n";
        echo "User ID usado para autenticar en WordPress: $user_id\n";
    
        $url = 'https://2upra.com/wp-json/galle/v2/procesarmensaje';
        $max_intentos = 5; // Número máximo de intentos
        $intento_actual = 0;
    
        while ($intento_actual < $max_intentos) {
            // Iniciar cURL
            $ch = curl_init($url);
    
            // Configurar opciones de cURL
            curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
            curl_setopt($ch, CURLOPT_HTTPHEADER, [
                'Content-Type: application/json',
                "X-WP-Token: $token",   // Cambia a X-WP-Token o cualquier nombre adecuado
                "X-User-ID: $user_id"   // Envía el user_id en los encabezados
            ]);
            curl_setopt($ch, CURLOPT_POST, true);
            curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($data));
    
            // Ejecutar la solicitud cURL
            $result = curl_exec($ch);
            $error = curl_error($ch);
    
            // Si cURL tiene éxito
            if ($result !== FALSE) {
                echo "Respuesta de WordPress: {$result}\n";
                curl_close($ch);
                break; // Salir del bucle si la solicitud es exitosa
            } else {
                echo "Error de cURL: No se pudo guardar el mensaje en WordPress. Detalles: {$error}\n";
                print_r(curl_getinfo($ch)); // Muestra información de depuración sobre la solicitud cURL
            }
    
            curl_close($ch);
            
            // Incrementar el contador de intentos
            $intento_actual++;
    
            // Esperar antes de reintentar (opcional)
            if ($intento_actual < $max_intentos) {
                sleep(2); // Espera 2 segundos antes de reintentar
                echo "Reintentando (intento $intento_actual de $max_intentos)...\n";
            }
        }
    
        if ($intento_actual == $max_intentos) {
            echo "Se alcanzó el número máximo de intentos. El mensaje no se pudo guardar.\n";
        }
    }
    */
    
    function enviarMensajeWs(receptor, mensaje, adjunto = null, metadata = null) {
        console.log('enviarMensajeWs: Preparando datos del mensaje para enviar.');
        
        const messageData = { emisor, receptor, mensaje, adjunto, metadata };
        console.log('enviarMensajeWs: Datos del mensaje preparados: ', messageData);
    
        if (ws?.readyState === WebSocket.OPEN) {
            console.log('enviarMensajeWs: WebSocket está abierto, enviando mensaje...');
            ws.send(JSON.stringify(messageData));
            console.log('enviarMensajeWs: Mensaje enviado correctamente.');
        } else {
            console.error('enviarMensajeWs: WebSocket no está conectado, no se puede enviar el mensaje.');
            alert('No se puede enviar el mensaje, por favor, reinicia la página.');
        }
    }
    
    function setupEnviarMensajeHandler() {
        console.log('setupEnviarMensajeHandler: Inicializando el manejador de eventos para enviar mensajes.');
    
        document.addEventListener('click', event => {
            console.log('setupEnviarMensajeHandler - Evento click: Detectado.');
            if (event.target.matches('.enviarMensaje')) {
    
                enviarMensaje();
            }
        });
    
        const mensajeInput = document.querySelector('.mensajeContenido');
        mensajeInput.addEventListener('keydown', event => {
            if (event.key === 'Enter' && !event.altKey) {
                event.preventDefault();
                enviarMensaje();
            }
        });
    
        function enviarMensaje() {
            console.log('enviarMensaje: Iniciando el proceso de envío del mensaje.');
            
            const listaMensajes = document.querySelector('.listaMensajes');
            if (subidaChatProgreso === true) {
                console.log('enviarMensaje: Subida de chat en progreso, mostrando alerta al usuario.');
                alert('Por favor espera a que se complete la subida del archivo.');
                return;
            }
    
            const mensaje = mensajeInput.value;
            if (mensaje.trim() !== '') {
                console.log('enviarMensaje: Mensaje no vacío, procediendo a enviar.');
    
                ocultarPreviews();
                console.log('enviarMensaje: Previews ocultas.');
    
                let adjunto = null;
                if (archivoChatId || archivoChatUrl) {
                    adjunto = {
                        archivoChatId: archivoChatId,
                        archivoChatUrl: archivoChatUrl
                    };
                    console.log('enviarMensaje: Archivo adjunto detectado. Añadiendo al mensaje.');
                    archivoChatId = null;
                    archivoChatUrl = null;
                }
    
                enviarMensajeWs(receptor, mensaje, adjunto);
                console.log(`enviarMensaje: Mensaje enviado a través de WebSocket al receptor ${receptor}.`);
                
                // aqui hace falta una confirmación visual si el mensaje realmente llega a guardarse
                agregarMensajeAlChat(mensaje, 'mensajeDerecha', new Date(), listaMensajes, null, false, adjunto);
                console.log('enviarMensaje: Mensaje agregado al chat.');
    
                mensajeInput.value = '';
                const mensajeVistaPrevia = `Tu: ${mensaje}`;
                actualizarListaConversaciones(receptor, mensajeVistaPrevia);
                console.log('enviarMensaje: Lista de conversaciones actualizada.');
            } else {
                console.log('enviarMensaje: Mensaje vacío, no se enviará nada.');
            }
        }
    }
    
  2. Assistant

    Hola,

    Para proporcionar una confirmación visual de que el mensaje realmente se ha guardado en el servidor, puedes implementar un mecanismo de confirmación (acknowledgment) a través del WebSocket. Esto implica que, una vez que el servidor guarda el mensaje en WordPress, envíe una respuesta al cliente confirmando que el proceso fue exitoso.

    A continuación, te explico cómo puedes hacerlo paso a paso:


    1. Modificar el servidor para enviar una confirmación

    Después de que el servidor haya guardado el mensaje en WordPress exitosamente, puedes enviar una respuesta al cliente a través del WebSocket indicando que el mensaje se ha guardado.

    En tu código server.php, dentro de la función guardarMensajeEnWordPress(), después de un guardado exitoso, envía una respuesta al cliente:

    private function guardarMensajeEnWordPress($data, $token, $user_id)
    {
        // ... código existente ...
    
        // Ejecutar la solicitud cURL
        $result = curl_exec($ch);
        $error = curl_error($ch);
    
        // Si cURL tiene éxito
        if ($result !== FALSE) {
            echo "Respuesta de WordPress: {$result}\n";
            
            // **Enviar confirmación al cliente**
            $confirmation = [
                'type' => 'message_saved',
                'message_id' => $result['id'] ?? null, // Si WordPress devuelve un ID de mensaje
                'timestamp' => time(),
                'original_message' => $data
            ];
            $from->send(json_encode($confirmation));
    
            curl_close($ch);
            break; // Salir del bucle si la solicitud es exitosa
        } else {
            echo "Error de cURL: No se pudo guardar el mensaje en WordPress. Detalles: {$error}\n";
            // ... resto del código ...
        }
    }
    

    Notas:

    • Asegúrate de que $result contiene la información necesaria. Si WordPress devuelve un ID de mensaje al guardarlo, puedes incluirlo en la confirmación.
    • Si $from no está disponible dentro de guardarMensajeEnWordPress, podrías pasar la conexión como parámetro a la función.

    2. Escuchar la confirmación en el cliente

    En tu código JavaScript, dentro de la función connectWebSocket(), añade una condición para manejar este tipo de mensajes:

    ws.onmessage = ({ data }) => {
        const message = JSON.parse(data);
        if (message.type === 'pong') {
            // Manejo del ping-pong
        } else if (message.type === 'set_emisor') {
            ws.send(JSON.stringify({ emisor }));
        } else if (message.type === 'message_saved') {
            // **Manejar la confirmación de que el mensaje se guardó**
            manejarConfirmacionMensajeGuardado(message);
        } else {
            manejarMensajeWebSocket(JSON.stringify(message));
        }
    };
    

    Y define la función manejarConfirmacionMensajeGuardado:

    function manejarConfirmacionMensajeGuardado(message) {
        console.log('Mensaje guardado en el servidor:', message);
    
        // **Actualizar la interfaz de usuario para indicar que el mensaje se guardó**
        // Busca el mensaje en la lista de mensajes usando el temp_id
        const listaMensajes = document.querySelector('.listaMensajes');
        const mensajeElemento = listaMensajes.querySelector(`[data-temp-id="${message.original_message.temp_id}"]`);
        
        if (mensajeElemento) {
            // Añade una clase o modifica el elemento para indicar que se ha enviado con éxito
            mensajeElemento.classList.add('mensajeEnviado');
            
            // Opcional: Remueve la clase que indica que está pendiente
            mensajeElemento.classList.remove('mensajePendiente');
        }
    }
    

    3. Asignar un ID temporal al mensaje al enviarlo

    Cuando envíes el mensaje desde el cliente, asigna un ID temporal (temp_id) que te permita identificarlo cuando recibas la confirmación:

    function enviarMensajeWs(receptor, mensaje, adjunto = null, metadata = null) {
        console.log('enviarMensajeWs: Preparando datos del mensaje para enviar.');
        
        const temp_id = Date.now(); // O genera un UUID si prefieres
    
        const messageData = { emisor, receptor, mensaje, adjunto, metadata, temp_id };
        console.log('enviarMensajeWs: Datos del mensaje preparados: ', messageData);
    
        if (ws?.readyState === WebSocket.OPEN) {
            console.log('enviarMensajeWs: WebSocket está abierto, enviando mensaje...');
            ws.send(JSON.stringify(messageData));
            console.log('enviarMensajeWs: Mensaje enviado correctamente.');
    
            // Añade el mensaje a la interfaz con el temp_id
            const listaMensajes = document.querySelector('.listaMensajes');
            agregarMensajeAlChat(mensaje, 'mensajeDerecha', new Date(), listaMensajes, null, false, adjunto, temp_id);
            console.log('enviarMensajeWs: Mensaje agregado al chat con temp_id.');
        } else {
            console.error('enviarMensajeWs: WebSocket no está conectado, no se puede enviar el mensaje.');
            alert('No se puede enviar el mensaje, por favor, reinicia la página.');
        }
    }
    

    Modifica la función agregarMensajeAlChat para aceptar el temp_id y asignarlo al elemento del mensaje:

    function agregarMensajeAlChat(mensaje, clase, fecha, listaMensajes, usuario, esNuevo, adjunto, temp_id) {
        // ... código existente ...
    
        const mensajeElemento = document.createElement('div');
        mensajeElemento.classList.add('mensaje', clase);
    
        // **Asignar el temp_id como atributo data**
        if (temp_id) {
            mensajeElemento.setAttribute('data-temp-id', temp_id);
            
            // Añade una clase para indicar que está pendiente de confirmación
            mensajeElemento.classList.add('mensajePendiente');
        }
    
        // ... resto del código para construir el mensaje ...
    
        listaMensajes.appendChild(mensajeElemento);
        // Desplazar hacia el final del chat
        listaMensajes.scrollTop = listaMensajes.scrollHeight;
    }
    

    4. Actualizar la interfaz de usuario

    Puedes mostrar un indicador visual (por ejemplo, un icono de reloj, un color diferente, o un texto) cuando el mensaje está pendiente y cambiarlo cuando recibes la confirmación.

    CSS Ejemplo:

    /* Estilo para mensajes pendientes */
    .mensajePendiente {
        opacity: 0.6;
    }
    
    /* Estilo para mensajes enviados */
    .mensajeEnviado {
        opacity: 1;
    }
    

    5. Agregar manejo de errores

    Si el mensaje no se guarda después de varios intentos, puedes enviar un mensaje de error al cliente y actualizar la interfaz para notificar al usuario.

    En el servidor, después de alcanzar el número máximo de intentos:

    if ($intento_actual == $max_intentos) {
        echo "Se alcanzó el número máximo de intentos. El mensaje no se pudo guardar.\n";
    
        // **Enviar mensaje de error al cliente**
        $errorResponse = [
            'type' => 'message_error',
            'error' => 'No se pudo guardar el mensaje en el servidor.',
            'original_message' => $data
        ];
        $from->send(json_encode($errorResponse));
    }
    

    En el cliente, añade un manejador para este tipo de mensaje:

    ws.onmessage = ({ data }) => {
        const message = JSON.parse(data);
        if (message.type === 'pong') {
            // ...
        } else if (message.type === 'set_emisor') {
            ws.send(JSON.stringify({ emisor }));
        } else if (message.type === 'message_saved') {
            manejarConfirmacionMensajeGuardado(message);
        } else if (message.type === 'message_error') {
            manejarErrorMensaje(message);
        } else {
            manejarMensajeWebSocket(JSON.stringify(message));
        }
    };
    

    Define la función manejarErrorMensaje:

    function manejarErrorMensaje(message) {
        console.error('Error al guardar el mensaje:', message.error);
    
        // **Actualizar la interfaz de usuario para indicar el error**
        const listaMensajes = document.querySelector('.listaMensajes');
        const mensajeElemento = listaMensajes.querySelector(`[data-temp-id="${message.original_message.temp_id}"]`);
        
        if (mensajeElemento) {
            // Añade una clase o modifica el elemento para indicar que hubo un error
            mensajeElemento.classList.add('mensajeError');
            
            // Opcional: Remueve la clase que indica que está pendiente
            mensajeElemento.classList.remove('mensajePendiente');
            
            // Opcional: Mostrar mensaje de error al usuario
            const errorElemento = document.createElement('span');
            errorElemento.textContent = 'Error al enviar';
            errorElemento.classList.add('mensajeErrorTexto');
            mensajeElemento.appendChild(errorElemento);
        }
    }
    

    CSS para el mensaje de error:

    /* Estilo para mensajes con error */
    .mensajeError {
        opacity: 0.6;
        color: red;
    }
    
    .mensajeErrorTexto {
        color: red;
        font-size: 12px;
        margin-left: 5px;
    }
    

    6. Consideraciones adicionales

    • Timeouts y reintentos: Puedes implementar un mecanismo de timeout en el cliente para considerar que el mensaje ha fallado si no recibe confirmación después de cierto tiempo.
    • Reenviar mensajes fallidos: Puedes ofrecer al usuario la opción de reintentar enviar los mensajes que han fallado.
    • Optimizar el flujo de mensajes: Asegúrate de manejar correctamente los casos en que el WebSocket se desconecta, para evitar pérdida de mensajes.

    Con estos cambios, tendrás un flujo completo donde el cliente envía un mensaje, lo muestra en la interfaz como "pendiente" y, una vez que recibe la confirmación del servidor de que el mensaje se ha guardado, actualiza el estado visual a "enviado". Si hay un error, también puedes manejarlo y mostrar una indicación al usuario.

    Espero que esta solución te ayude a implementar la confirmación visual que necesitas. Si tienes más preguntas o necesitas más detalles, no dudes en preguntar.