Documentación de la Mejora 9: Historial de Conexiones de Usuarios

Descripción de la Mejora

Se implementó una funcionalidad en el proyecto de bot de Telegram para registrar el inicio y fin de las sesiones de los usuarios. Esta funcionalidad permite llevar un historial de conexiones en Redis, lo que facilita el análisis de uso del bot y proporciona trazabilidad de las interacciones de los usuarios.

Detalles de Implementación

1. Creación de la Clase UserSession

Se creó la clase UserSession para representar las sesiones de usuario. Esta clase contiene los atributos necesarios para almacenar los detalles de la sesión, como sessionId, chatId, startTime y endTime.

package umg.TelegramBot.Model;

public class UserSession {
    private String sessionId;
    private long chatId;
    private String startTime;
    private String endTime;

    // Constructor sin argumentos
    public UserSession() {}

    // Constructor con argumentos
    public UserSession(String sessionId, long chatId, String startTime) {
        this.sessionId = sessionId;
        this.chatId = chatId;
        this.startTime = startTime;
    }

    // Getters y setters
    public String getSessionId() { return sessionId; }
    public void setSessionId(String sessionId) { this.sessionId = sessionId; }

    public long getChatId() { return chatId; }
    public void setChatId(long chatId) { this.chatId = chatId; }

    public String getStartTime() { return startTime; }
    public void setStartTime(String startTime) { this.startTime = startTime; }

    public String getEndTime() { return endTime; }
    public void setEndTime(String endTime) { this.endTime = endTime; }
}

2. Modificaciones en TelegramBotService

Se actualizaron los métodos de TelegramBotService para incluir la lógica de inicio y fin de sesión. Se almacenan en Redis los detalles de las sesiones, asociando cada chatId con un sessionId único.

Código de TelegramBotService para el Inicio y Fin de Sesión:

package umg.TelegramBot.Service;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.stereotype.Service;
import org.telegram.telegrambots.bots.TelegramLongPollingBot;
import org.telegram.telegrambots.meta.api.methods.send.SendMessage;
import org.telegram.telegrambots.meta.api.objects.Update;
import org.telegram.telegrambots.meta.exceptions.TelegramApiException;
import umg.TelegramBot.Model.UserSession;

import java.util.Date;
import java.util.UUID;

@Service
public class TelegramBotService extends TelegramLongPollingBot {

    @Value("${telegram.bot.username}")
    private String botUsername;

    @Value("${telegram.bot.token}")
    private String botToken;

    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    private static final String CLIENT_STATE_PREFIX = "client_state:";
    private static final String CLIENT_NAME_PREFIX = "client:";
    private static final String STATE_WAITING_FOR_NAME = "WAITING_FOR_NAME";
    private static final String STATE_WAITING_FOR_QUESTION = "WAITING_FOR_QUESTION";

    // Iniciar la sesión del usuario y guardar en Redis
    private void startUserSession(long chatId) {
        String sessionId = UUID.randomUUID().toString();
        UserSession userSession = new UserSession(sessionId, chatId, new Date().toString());

        redisTemplate.opsForHash().put("session:" + sessionId, "chatId", chatId);
        redisTemplate.opsForHash().put("session:" + sessionId, "startTime", userSession.getStartTime());
        redisTemplate.opsForValue().set("current_session:" + chatId, sessionId);
    }

    // Finalizar la sesión del usuario en Redis
    private void endUserSession(long chatId) {
        String sessionId = (String) redisTemplate.opsForValue().get("current_session:" + chatId);
        if (sessionId != null) {
            redisTemplate.opsForHash().put("session:" + sessionId, "endTime", new Date().toString());
            redisTemplate.delete("current_session:" + chatId);
        } else {
            System.out.println("No se encontró una sesión activa para el chatId: " + chatId);
        }
    }

    @Override
    public void onUpdateReceived(Update update) {
        if (update.hasMessage() && update.getMessage().hasText()) {
            long chatId = update.getMessage().getChatId();
            String messageText = update.getMessage().getText();

            if ("/start".equalsIgnoreCase(messageText)) {
                startUserSession(chatId);
                handleInitialInteraction(chatId);
                return;
            }

            if ("/end".equalsIgnoreCase(messageText)) {
                endUserSession(chatId);
                return;
            }

            handleUserInteraction(chatId, messageText);
        }
    }

    // Otros métodos omitidos por brevedad...
}

3. Verificación del Registro en Redis

Redis se utiliza para almacenar tanto el inicio como el fin de las sesiones de usuario. Puedes verificar las claves en Redis que representan las sesiones activas y finalizadas.

4. Pruebas de la Funcionalidad en el Chat del Bot

Se probaron los comandos /start y /end en el bot para confirmar que las sesiones se registran correctamente en Redis.

ChatBot.Erik.Hernandez.mp4

🤖 Proyecto de Bot de Telegram con OpenAI y Spring Boot

Un bot de Telegram avanzado que integra la API de OpenAI (ChatGPT) con Spring Boot, utilizando Redis para la gestión eficiente de sesiones. 🚀

---

🔧 Tecnologías Utilizadas

• Java ☕: Lenguaje de programación principal.
• Spring Boot 🌱: Framework para crear microservicios.
• Redis 🧰: Sistema de almacenamiento en caché.
• API de Telegram 📬: Para la interacción con los usuarios.
• API de OpenAI 🤖: Para respuestas inteligentes basadas en IA.

---

💡 Características Destacadas

✨ Gestión de sesiones de usuario con Redis.
✨ Captura y almacenamiento del nombre del usuario en Redis para personalizar las interacciones.
✨ Registro de solicitudes y respuestas de los usuarios para un historial de consultas.
✨ Respuestas impulsadas por inteligencia artificial gracias a la API de OpenAI.
✨ Mejora destacada: Implementación del Historial de Conexiones de Usuarios mediante la creación de una entidad UserSession para registrar el inicio y fin de cada sesión.

---

📚 Propósito del Proyecto

Este proyecto fue creado para demostrar cómo integrar servicios de IA en aplicaciones de Telegram, con un enfoque en el uso eficiente de Redis para el manejo de sesiones y datos temporales. También captura el nombre del usuario y almacena tanto las preguntas como las respuestas en Redis para un análisis posterior y mejor trazabilidad.

---

👥 Contribuciones

🙌 ¡Tu participación es bienvenida! Haz un fork del repositorio, trabaja en tus mejoras y envía un pull request. ¡Juntos podemos hacer que este proyecto sea aún mejor!

---

✨ ¡Gracias por visitar este proyecto y por tu interés! ✨