Resumen para las lecciones del Maratón de Java | Bot de Telegram con ChatGPT

Un bot de Telegram es un usuario virtual de Telegram con el que se puede "comunicar" como con una persona real. Tenemos una tarea muy interesante por delante. Debemos crear un bot "inteligente" que sea capaz de:

• mantener un diálogo,
• practicar en citas,
• generar descripciones adecuadas y divertidas para sitios de citas,
• dar consejos durante la correspondencia en sitios de citas.

Para que el bot aprenda todo esto y parezca inteligente, lo conectaremos a ChatGPT.

• Preparación preliminar para el trabajo
• Complemento y resumen breve de la lección №1
• Complemento y resumen breve de la lección №2
• Complemento y resumen breve de la lección №3
• Complemento y resumen breve de la lección №4

Preparación preliminar para el trabajo

Antes de comenzar a programar, necesitamos preparar el entorno de trabajo. Para ello necesitaremos:

• Java (Java Development Kit)
• Una aplicación para escribir y ejecutar programas, IntelliJ IDEA Community Edition
• La plantilla de nuestro proyecto
• Telegram, preferiblemente descargar la versión de escritorio

Instalación de IntelliJ IDEA y descarga del proyecto

Puedes descargar la versión gratuita de IntelliJ IDEA Community Edition desde el sitio web del desarrollador para Windows, MacOS o Linux. Es recomendable descomprimir la plantilla del proyecto y recordar dónde se encuentra la carpeta. Si ya la has descargado, encuentra la ubicación donde está almacenada. Abre IntelliJ IDEA. Si es la primera vez que lo ejecutas, probablemente verás una ventana con la opción de crear un proyecto, abrirlo o descargarlo desde un sistema de control de versiones. Si ya has trabajado en IntelliJ IDEA y tienes otro proyecto abierto, en Windows/Linux haz clic en File – Open, en MacOS en Intellij IDEA – Open. A continuación, en ambos casos, busca la carpeta TinderBolt en el lugar donde la guardaste. Luego haz clic en Open. Ante ti aparecerá una plantilla de proyecto. A la izquierda verás el árbol del proyecto, mientras que a la derecha se mostrará el archivo activo. El árbol del proyecto está compuesto por diferentes directorios y archivos. Los archivos Java que necesitamos están ubicados en la ruta TinderBolt—> src → main → Java → com → javarush → telegram. Si nunca has programado antes, es probable que la estructura del proyecto y el código en los archivos te parezcan algo confusos y demasiado complicados. De hecho, comprender todo esto simplemente requiere práctica. Por ahora, estamos a punto de aprender Java Junior, y los 'juniors' generalmente no crean la estructura del proyecto, sino que solo escriben partes individuales del mismo. Así que durante las próximas clases simularemos el trabajo de un programador principiante en un proyecto cuya plantilla ha sido creada por algún senior o arquitecto.

Un poco de teoría antes de la primera lección

Programa Java o proyecto Java

En el sentido más básico, un programa es una secuencia de comandos que un computador comprende y ejecuta. Estos comandos son escritos por los programadores, en nuestro caso, utilizando el lenguaje Java. Para facilitar el trabajo de los programadores, un proyecto Java tiene una estructura específica. Físicamente, esto se traduce en archivos y carpetas organizados en una jerarquía específica, como pudiste ver en el proyecto abierto TinderBolt. La mayoría de los archivos en un proyecto Java típico son archivos con código Java, pero también pueden incluir archivos de recursos (como archivos de texto o imágenes), archivos de configuración, entre otros. En el caso más simple, un programa puede consistir en un solo archivo con código Java. Java, instalado en el computador, puede traducir este código a un lenguaje comprensible para la máquina (compilarlo), y luego ejecutar el programa. Ejemplo de un programa tan simple:

public class Main {
   public static void main(String[] args) {
       System.out.println("Este es mi programa");
   }
}

Salida en consola Podría haber muchas palabras que son confusas para un principiante. Por ahora, ignoraremos algunas y nos enfocaremos en lo más importante. Este programa sencillo muestra en la pantalla (en la consola) el mensaje 'Esta es mi programa'. Lo hace utilizando la instrucción:

System.out.println("Esta es mi programa");

Cada comando en Java termina con un punto y coma (;). Y un bloque lógico de código está delimitado por llaves { }.

int edad = 35; 
if (edad < 40) { // inicio del bloque lógico 	System.out.println("Todavía eres joven"); // comando 
} // fin del bloque lógico 
/* 
En este ejemplo de código se verifica si la persona, cuya edad está almacenada en la variable edad, es menor de 40 años.
 Si es así, el código imprime el mensaje "Todavía eres joven" en la consola. 
*/

En el código anterior, después del símbolo // comienza un comentario de una sola línea. Y un comentario de varias líneas se puede escribir /* entre barras inclinadas con asterisco, así como lo estamos haciendo ahora */. Los comentarios pueden dejarse para colegas que leerán tu código o para ti mismo, para recordar cosas. La esencia es que los comentarios no se ejecutan en el programa; solo están aquí para explicar algo, y puedes escribir lo que quieras en ellos. Sin embargo, es preferible que transmitan algún significado. ¿Qué más? El operador = no significa igualdad, sino asignación.

String namePhone = "Mi 11";

significa que a la variable namePhone se le ha asignado el valor Mi 11. Para verificar la igualdad en Java se utiliza el operador ==.

No es obligatorio instalarlo

Cuando hay muchos paréntesis y otros signos similares, es fácil confundirse. Y alguien ya ha creado el complemento Rainbow Brackets. Este resalta los paréntesis y otros signos con diferentes colores, mejorando la legibilidad del código.

1. Accede a la sección "Configuración" en Windows/Linux File – Settings, en MacOS IntelliJ IDEA – Preferences.
2. En la ventana que aparece, en el menú lateral, selecciona la sección Plugins y abre la pestaña Marketplace. Luego, en la barra de búsqueda, escribe Rainbow Brackets.
3. Después de la instalación, haz clic en Restart IDE (Reiniciar IDE).

Complemento y resumen breve de la lección №1

Cualquier proyecto en Java está compuesto por varios archivos y carpetas. Estos pueden ser archivos con código Java, archivos de configuración, recursos necesarios para que nuestro programa funcione, como imágenes que se cargarán o archivos de texto cuya información se leerá de diversas formas. Hablemos ahora de la estructura de nuestro proyecto, más específicamente de sus archivos más importantes. Los archivos Java, que son clases Java, se encuentran en la carpeta del proyecto en la ruta src—>main—> java —> com —>javarush—>telegram. En la carpeta de recursos (resources) se encuentran imágenes, mensajes de texto y mensajes de chatGPT. Además, hay un archivo de configuración llamado pom.xml, un archivo .gitignore y muchas otras cosas que pueden resultar confusas para un principiante. Vamos a abstraernos de ellos y volver a nuestros archivos Java. El más importante de todos ellos, donde se realizará la mayor parte del trabajo, es TinderBoltApp. Prácticamente todo el código lo escribiremos en esta clase, en el método principal del bot onUpdateEventReceived(Update update). Los otros clases son:

• UserInfo: Se utiliza para almacenar perfiles de personas en el programa de citas.
• ChatGPTService: Clase diseñada para facilitar la interacción con inteligencia artificial.
• DialogMode: Contiene modos de interacción con el bot (por ejemplo, "entrenamiento en la conversación" o "creación de perfil").
• MultiSessionTelegramBot: Para facilitar la comunicación de nuestro programa con los servidores API de Telegram.

API es una abreviatura de "Application Programming Interface", que se traduce como "Interfaz de Programación de Aplicaciones". Es un conjunto de reglas y protocolos para crear e integrar software. Es decir, el API permite que los programas se comuniquen entre sí, y a los programadores les permite utilizar las capacidades de otros programas en los suyos.

Registro del bot y obtención de nombre de usuario, token y enlace del bot

En nuestra clase TinderBoltApp tenemos las variables:

• TELEGRAM_BOT_NAME
• TELEGRAM_BOT_TOKEN
• OPEN_AI_TOCKEN

Los primeros dos tokens son el nombre de usuario y la contraseña, mientras que hablaremos sobre el tercero en la próxima lección. Para obtener los valores del nombre de usuario y el token (contraseña), necesitamos registrar nuestro bot en el servidor de Telegram:

1. Accede a Telegram.
2. En el campo de búsqueda, busca el bot llamado BotFather (el "padre" de todos los bots).
3. Escribe el comando /start.
4. Presiona /newbot.
5. Elegimos un nombre para nuestro bot
6. Ahora elige un nombre de usuario (username) para tu bot. El nombre debe ser único y terminar en "bot".
7. Si todo está bien, el bot te enviará un mensaje de bienvenida que incluirá tu nombre de usuario, y como token puedes usar el token proporcionado por el bot para HTTP API, así como el enlace a tu bot.
8. Ahora regresa a IntelliJ IDEA, abre la clase TinderBoltApp y nombra las variables:
   TELEGRAM_BOT_NAME = "tu nombre" TELEGRAM_BOT_TOKEN = "tu token de HTTP API"

Nuestro bot aún no sabe hacer nada, pero ya está funcionando. Para ejecutar el programa en IntelliJ IDEA, haz clic en la flecha verde en la esquina superior derecha del editor ▶ (asegúrate de tener abierta la clase TinderBoltApp en la ventana principal). También puedes hacer clic con el botón derecho del ratón en el nombre de la clase TinderBoltApp en el árbol del proyecto y encontrar la misma flecha con la etiqueta Run TinderBoltApp.main() allí. Así es como se ejecuta cualquier programa en Java. Básicamente, hemos ejecutado el método main de la clase TinderBolt. Ahora que el programa está en marcha, podemos regresar a Telegram: nuestro bot está funcionando. Haz clic en el enlace recibido en el mensaje de bienvenida y estarás en el bot. Puedes presionar el botón Start o escribir /start (este es el botón para iniciar la conversación con el bot). Sin embargo, dado que el bot aún no sabe responder, no sucederá nada. Por lo tanto, simplemente detén el programa y pasemos a escribir el código. ¿Cómo nos comunicamos con un bot o una persona viva? Recibimos sus mensajes y escribimos los nuestros. La mayoría de las veces son mensajes de texto, pero también pueden ser imágenes, y en el caso de los bots, también pueden ser comandos. Como mencionamos anteriormente, hay paquetes de API especiales para la comunicación entre programas. Por supuesto, los programadores ya han escrito APIs para bots de Telegram en Java, y nuestro mentor los ha utilizado para crear métodos de comunicación específicamente para nuestro bot. En teoría, podríamos haber hecho esto nosotros mismos, pero habría complicado mucho nuestro trabajo, y apenas estamos empezando a aprender, por lo que ya es bastante difícil para nosotros. Hacer que el bot nos responda no es difícil. Vamos a llamar a ese método en el método principal onUpdateEventReceived de nuestra clase principal TinderBoltAPI. Para hacerlo, en ese método, necesitamos escribir el siguiente comando: java

sendTextMessage("¡Hola!");

Ahora, si ejecutamos el bot, responderá con "¡Hola!" a cualquier mensaje que le enviemos.

Mensajes con botones

Para enviar un mensaje con botones, puedes usar el método sendTextButtonMessage de la siguiente manera:

sendTextButtonMessage( 
"Seleccione el modo de funcionamiento", // Texto antes del botón 
"Inicio", "btn_start", // Texto y comando del botón "Inicio" 
"Parar", "btn_stop" // Texto y comando del botón "Parar" 
);

Ahora, si ejecutamos el bot, veremos dos botones disponibles. Finalmente, para enviar imágenes al chat puedes usar el método sendPhotoMessage:

sendPhotoMessage("nombre_imagen");

Las imágenes están ubicadas en la carpeta resources -> pictures y puedes enviarlas usando su nombre clave.

Trabajo con comandos en Telegram

Los comandos en Telegram comienzan con / (barra inclinada). De hecho, ya hemos trabajado con uno de ellos, es el comando /start. Intentemos hacer que nuestro programa reaccione al comando /start. Por ejemplo, si el usuario envía el comando /start, entonces en respuesta se debe enviar una imagen. En otros casos, el bot no debe enviar ninguna imagen. Para este tipo de condiciones, en Java se utiliza el operador if.

if (condición) {
 Algunas instrucciones; 
}

En nuestro caso, el código del condicional se verá así:

// Verifica si el mensaje del usuario comienza con la comando "/start" 
if (message.startsWith("/start")) { 
// Carga el mensaje con el nombre "main" 
String text = loadMessage("main"); 

// Envía un mensaje de foto con el nombre "main" sendPhotoMessage("main"); 

// Envía un mensaje de texto con el contenido de la variable "text" 
sendTextMessage(text); 

// Finaliza el procesamiento del comando "/start" 
return; 
}

Aquí se indica que si el mensaje del usuario comienza con la comando /start, entonces enviamos la imagen con el nombre main y el texto con el nombre main. Tanto el texto como la imagen están ubicados en las carpetas correspondientes del proyecto en resources. El return normalmente devuelve el valor del método y luego termina la ejecución del método. Sin embargo, si aplicamos return sin un valor no al final del método, sino al final de un bloque de código, por ejemplo, en un operador condicional como aquí, simplemente terminará el procesamiento de nuestro mensaje y no se ejecutarán las siguientes comandos.

Antes y durante la primera clase, debes:

1. Instalar todo lo necesario para trabajar.
2. Escuchar la clase y repetir todo con tu mentor.

Al finalizar, deberías tener un bot que:

• Tenga un nombre, título y un enlace a sí mismo.
• Se inicie correctamente.
• Lea los mensajes de los usuarios.
• Envíe una imagen y una descripción de su función si el usuario envía el comando /start.
• Envíe mensajes de texto simples.

No todo puede ser comprendido de inmediato, pero es importante no confundirse y seguir las instrucciones del mentor. Algunos aspectos se clarificarán más adelante.

Consejos para completar la tarea nº 1

Verificación de la corrección del código y actualización de los cambios en el proyecto

Para ver los cambios que realizas directamente en el trabajo del bot de Telegram, no olvides aplicar todos los cambios (reiniciar el proyecto) en IntelliJ IDEA después de escribir tu código. Para ello, debes hacer clic en la flecha verde circular en la barra horizontal inferior:

Principios importantes de formato de código:

• No olvides colocar punto y coma ; al final de cada comando que crees.
• Cada símbolo de apertura de paréntesis o comillas: (, {, ", debe tener su respectivo símbolo de cierre: ), }, ".
• Si tu código se resalta en rojo, significa que hay un error; revísalo detenidamente.
• Utiliza las sugerencias automáticas y el autocompletado, te ayudarán a escribir el código correctamente.

Recuerda que los nombres de tus variables, métodos y clases deben ser legibles: el nombre debe indicar claramente lo que hacen o para qué están destinados.

Formateo de texto:

• Para enfatizar el texto en cursiva, coloca guiones bajos al principio y al final del fragmento necesario: _texto_
• Para resaltar el texto en negrita, coloca asteriscos al principio y al final del fragmento necesario: *texto*

Complemento y resumen breve de la lección №2

En esta lección, nuestro bot se volverá más inteligente porque integraremos inteligencia artificial, específicamente chatGPT. Y para interactuar con nuestra aplicación, nuestro querido chat se utilizará a través de... exacto, un API especial. Esto significa que nuestro bot cambiará al modo de trabajo con el chat y todos los mensajes posteriores del usuario serán procesados por él directamente.

Qué se necesita para esto

Para empezar, necesitaremos el token de chatGPT, que es la clave con la que nuestro bot podrá comunicarse con el servidor de chatGPT. Puede comprarse o conseguirse de alguna otra manera, pero tuviste suerte, ya que te lo enviaron antes de esta clase. Nuestra primera acción con el código en esta lección es copiar el valor del token enviado y pegarlo en el campo correspondiente.

public static final String OPEN_AI_TOKEN = "pegar aquí tu clave";
public static final String OPEN_AI_TOKEN = «pegar aquí tu clave";

En la lista de comandos del chat está el siguiente: /gpt. Según la descripción en el bot, este comando debería hacer una pregunta a nuestro chatbot. Ahora necesitamos crear un fragmento de código que maneje este comando. Ten en cuenta que si has presionado algún comando o lo has introducido, ya es un mensaje para el bot. Y la pregunta al chat será el siguiente comando. Por lo tanto, debemos manejar dos mensajes. Siguiendo el ejemplo del manejo del comando /start, escribimos el código que significa literalmente lo siguiente: si el mensaje del usuario comienza con la cadena /gpt, nuestro bot cambia al modo de diálogo con el chat. Podemos invitar al usuario a hacer una pregunta al chatbot, y además, para claridad, enviar una imagen y terminar con el mensaje.

if (message.startsWith("/gpt")) {
    currentMode = DialogMode.GPT;
    sendPhotoMessage("gpt");
    sendTextMessage("Escribe cualquier mensaje y veremos qué te responde *ChatGPT*:");
    return;
}

¿Qué es DialogMode?

Son las opciones de funcionamiento del bot, las mismas que están todas descritas en la clase del mismo nombre y luego se muestran en el mensaje de bienvenida. Ingresa allí y encontrarás algo inusual.

public enum DialogMode {
   MAIN,
   PROFILE,
   OPENER,
   MESSAGE,
   DATE,
   GPT,
}

En lugar de class, se usa enum. En realidad, es algo bastante simple y se llama enumeración. Es una clase especial que representa un grupo de constantes (variables no cambiantes). Son útiles para representar un número fijo de valores relacionados, como los días de la semana o los niveles de acceso. Aquí tenemos una enumeración de modos. Entramos en modos al comunicarnos con los bots de Telegram mediante comandos que comienzan con una barra. Ya hemos implementado el manejo del comando /start. Básicamente, nuestra principal tarea es implementar el código que funcione con los seis modos. Modos /profile, /opener, /message, /date, /gpt. En nuestro ENUM, ya están preparados para ellos. Entonces, cuando el usuario entra en un modo específico, nuestro bot debe entender que estamos en ese modo y reaccionar en consecuencia. En esta misma lección, nuestra tarea es preparar un bloque de código donde, después de cambiar al modo de trabajo con el chat GPT (/gpt), pueda responder las preguntas del usuario. Para esto, necesitamos escribir un bloque de código con un operador condicional if. Y para que la comunicación sea más significativa e interesante, utilizamos promts predefinidos. Estos se encuentran en la carpeta resources\prompts. Los prompts son solicitudes bien formuladas al AI. Los nuestros están en la carpeta de recursos. También en esta clase, estudiamos el método para agregar un menú y una lista de comandos. Para ello, existe el método showMainMenu(). En nuestro caso, si incluimos comandos para funciones ya implementadas, el código se verá algo así:

1. /start — menú principal del bot
2. /profile — generar perfil de Tinder 😎
3. /opener — mensaje de introducción 🥰
4. /message — mensajería en tu nombre 😈
5. /date — mensajería con celebridades 🔥
6. /gpt — preguntar al chat GPT una pregunta 🧠

Todos los emojis en el programa se muestran utilizando secuencias especiales de caracteres. Así, al final de esta clase, podemos comunicarnos con el chat de tres maneras:

• Hacer clic en un comando en el mensaje de bienvenida
• Ingresar un comando en el formato /comando
• Hacer clic en el menú y seleccionar el comando correspondiente

En resumen, en esta clase:

• Integramos ChatGPT
• Agregamos el manejo de comandos
• Implementamos el cambio de modo para el diálogo
• Aprendimos cómo trabajar con mensajes promocionales
• Mostramos el menú

Complemento y resumen breve de la sesión №3

Activando el modo de citas /date

Nuestro objetivo es que después de cambiar al modo de citas con el comando /date, el usuario pueda abrir el menú y seleccionar una estrella correspondiente. Luego, debemos enseñarle al bot a responder en nombre de una estrella específica, es decir, alimentarle un prompt que explique con qué estrella va a interactuar. Además, debemos programar los comandos para que responda adecuadamente a todos los mensajes, no solo a uno. Es decir, debemos agregar solicitudes al chat con el historial guardado. En la primera sesión, ya discutimos cómo crear botones para el menú con mensajes de texto. Para crear un menú con estos botones, podemos usar el método sendTextButtonsMessage. Después de esto, en la sesión comenzamos a escribir el manejo para cada botón. Primero aprendimos a enviar la foto de la estrella seleccionada, y luego creamos el propio simulador para invitar a citas. Para crear el simulador, hicimos algunas acciones:

• Transmitimos al programa el prompt que describe la interacción con la estrella correspondiente (todos estos prompts están en la carpeta resources).
• Cambiamos chatGPT del modo pregunta-respuesta al modo diálogo.

Configuración del prompt:

String prompt = loadPrompt(query);
chatGPT.setPrompt(prompt);

Procesamiento del comando /message

En este punto, hemos agregado funcionalidad que permite a chatGPT generar respuestas efectivas para nuestra correspondencia. Para acumular mensajes, utilizamos una variable del tipo ArrayList() o lista. ArrayList en Java es como una lista especial o bloc de notas donde puedes escribir cosas y siempre agregar nuevas entradas al final o borrar las antiguas. Puedes ver fácilmente lo que está en cualquier página de la lista solo conociendo el número de esa página. Si necesitas agregar algo y la lista no tiene espacio, se expandirá automáticamente para que todo quepa. También puedes poner varias cosas iguales seguidas o incluso dejar una página vacía (como null en Java), y eso está bien para esta lista. La única condición es que las entradas en esa lista deben ser del mismo tipo. Es decir, una lista puede contener solo cadenas, solo números, o solo perros del tipo Dog. Imaginemos que tienes una lista de tus películas animadas favoritas y quieres organizarla. Así es como puedes hacerlo con ArrayList:

import java.util.ArrayList; // Importamos la utilidad para usar ArrayList 

public class Main {
    public static void main(String[] args) {
    	// Creamos una nueva lista para películas animadas favoritas
        ArrayList<String> favoriteCartoons = new ArrayList<>();

        // Añadimos películas a la lista 
        favoriteCartoons.add("Tom y Jerry");
        favoriteCartoons.add("Bob Esponja");
        favoriteCartoons.add("Gravity Falls");

        // Ahora supongamos que quieres añadir otra película más 
        favoriteCartoons.add("Avatar: El último maestro aire");

        // Incluso puedes eliminar una película que ya no te guste 
        favoriteCartoons.remove("Bob Esponja"); // Eliminamos "Bob Esponja" de la lista
        }
    }
}

Exactamente de esta manera usamos una lista en nuestro chatbot para almacenar mensajes. Y siguiendo el ejemplo anterior, hemos escrito un controlador para los botones pulsados.

Método join()

El método String.join() en Java permite unir (concatenar) varias cadenas en una sola utilizando un separador. Es muy útil cuando se necesita combinar los elementos de una lista o array en una única cadena con un separador especificado. Sintaxis:

String.join(delimiter, elements);

• delimiter — Es la cadena que se utilizará como separador entre los elementos.
• elements — Son los elementos que se desean unir. Pueden ser pasados como un array o como una secuencia de cadenas.

Ejemplo:

String result = String.join("-", "2024", "01", "01");
System.out.println(result); // Salida: 2024-01-01

Actualización de mensajes

¿Alguna vez has cometido un error en un mensaje y luego lo corregiste? Nuestro bot puede hacerlo usando el método updateTextMessage(message, text). En nuestro caso, reemplazamos el mensaje antes de enviar la solicitud a GPT y luego actualizamos ese mensaje con la respuesta del propio chat. Por ejemplo:

// Enviando un mensaje al chat con el texto "ChatGPT está considerando opciones de respuesta..." 
var sm = sendTextMessage("ChatGPT está considerando opciones de respuesta...");
// Enviando una solicitud a ChatGPT, pasándole un prompt y el historial del chat con el usuario 
String answer = chatGPT.sendMessage(prompt, userChatHistory);

// Actualizando el mensaje previamente enviado (sm) con el texto de respuesta de ChatGPT 
updateTextMessage(sm, answer);

Complemento y resumen breve de la lección №4

En esta sesión implementaremos dos funciones:

• profile – permite generar un perfil para su Tinder personal
• opener – generación de primeros mensajes a extraños

Modo perfil. Creación del perfil del usuario

Al igual que con todos los comandos anteriores, la implementaremos con dos declaraciones condicionales if. Como siempre, lo primero que debemos hacer es verificar si el usuario ha ingresado al modo correspondiente, en nuestro caso, al modo perfil mediante el comando /profile. La respuesta a la entrada de este comando por parte del usuario debe ser cambiar el estado de trabajo del bot a este diálogo usando la siguiente línea:

currentMode = DialogMode.PROFILE;

Después de eso, como de costumbre, se muestra una imagen de apertura y un mensaje de texto típico para el modo. En este caso, se le pide al usuario que escriba información sobre sí mismo. El segundo bloque con el operador if verifica si el usuario está en el modo DialogMode.PROFILE, y si es así, el mensaje enviado por el usuario (donde escribió algo sobre sí mismo) se envía a ChatGPT junto con la solicitud de generar un perfil en Tinder basado en esta información. Podríamos simplemente pedir al usuario que se describa, pero para que la información sea más precisa y el perfil resultante sea más interesante, utilizaremos la clase UserInfo y un contador de preguntas. Durante la redacción de este bloque, creamos un objeto de la clase UserInfo (uno de los clases escritas por el mentor, que se puede ver en el árbol de estructura de clases) y necesitábamos la capacidad de trabajar con objetos como si fueran cadenas. En este bloque nos encontramos con un operador nuevo para nosotros, el switch. Se utiliza para ejecutar diferentes acciones basadas en diferentes condiciones. Es una buena alternativa a una cadena de if-else cuando se verifica una variable contra múltiples valores.

int temperature = 36;

switch(temperature)
{
   case 36:
   		System.out.println("Baja");

   case 37:
   		System.out.println("Normal");

   case 38:
   		System.out.println("Alta");
}

Cuando la temperatura es 36, el programa entrará en el primer bloque de código dentro del switch: la primera línea, y luego de ejecutarla, también se ejecutarán los bloques de código restantes. Pero volviendo a nuestro tema. Como resultado, hemos creado un bloque de código donde el usuario entra en el modo de perfil y se le hacen varias preguntas clave. Las respuestas a estas preguntas se envían todas juntas al ChatGPT, que tiene un prompt para crear un perfil basado en las respuestas del usuario. De hecho, es el ChatGPT quien crea un perfil genial basado en tus datos. Al igual que la última vez, usamos la combinación sendMessage + UpdateMessage: primero enviamos un mensaje preliminar, luego ChatGPT procesa nuestra solicitud, y cuando su respuesta está lista, el mensaje preliminar se cambia por su respuesta.

// Enviando un mensaje al usuario informándole que ChatGPT está trabajando en la respuesta
Message message = sendTextMessage("ChatGPT está pensando... Espere unos segundos");

// Enviando una solicitud a ChatGPT usando el prompt dado y la información del usuario
String answer = chatGPT.sendMessage(prompt, userInfo);

// Actualizando el mensaje previamente enviado con la respuesta de ChatGPT 
updateTextMessage(message, answer);

Haciendo más compleja la condición de verificación del modo actual

Si accidentalmente entramos en el modo incorrecto y el programa ya comenzó a trabajar en él, por ejemplo, en el caso de Opener o Profiler, comenzó a recopilar respuestas a las preguntas, entonces presionar una comando diferente será interpretado como una respuesta a una pregunta. ¿Cómo corregir esto? Necesitamos ajustar la verificación, agregando una condición adicional. Esta condición consiste en que el próximo mensaje no sea un comando. Se puede hacer así:

if (currentMode == DialogMode.GPT && !isMessageCommand()) {
//código
}

Vamos a analizar lo que está escrito aquí. Primero, como antes, verificamos si estamos en algún modo (en este caso, en el modo GPT). Luego, tenemos dos símbolos &&. Este es el operador "y". Une dos condiciones en una: debe cumplirse tanto la condición a la izquierda de && como la condición a la derecha de &&. El operador ! significa negación de lo que le sigue. En este caso, niega lo que devuelve el método isMessageCommand(). Este método en nuestra clase verifica si el mensaje es un comando (/start, /GPT, etc.). En resumen, nuestra condición verifica si estamos en el modo GPT y al mismo tiempo el mensaje del usuario no es un comando. Solo en este caso ejecutamos el código que sigue. Después de esta corrección, si el usuario ingresa un comando, se le cambiará al otro modo. Ahora hemos implementado todo.