2.-           Pulsar en Start/Empezar para empezar a chatear con el

3.-           Escribiendo “/help” podremos visualizar los diversos comandos, y empezaremos por el comando “/newbot”

4.-           Una vez introducimos el comando “/newbot” nos mostrará lo siguiente:

5.-           Deberemos elegir un nombre para nuestro bot:

6.- A continuación le asignaremos un username a nuestro bot:

7.- Una vez asignado el username nos contestará que hemos conseguido crear nuestro bot, indicándonos Token único el cual deberemos guardar de forma segura y protegida ya que este Token es el que nos permitirá manejar nuestro bot de forma automatizada y sólo debe estar disponible para las personas autorizadas para el manejo del bot.

2.-           Introducir el nombre del Grupo siguiendo la nomenclatura acordada

3.-           En la Gestión del Canal, se deberá configurar el canal como privado para que solo puedan entrar en el canal las personas invitadas.

4.-           El siguiente paso será añadir a las personas que deben estar en cada grupo.

5.-           Una vez añadidos los invitados, ya podrán visualizar en el grupo las notificaciones que el bot envíe de forma automatizada.

Class Operaciones.REST.Notificaciones.Telegram Extends EnsLib.REST.Operation
{

Parameter INVOCATION = "Queue";

Method notificar(pRequest As Mensajes.Request.Notificaciones.TelegramRequest, Output pResponse As Mensajes.Response.Notificaciones.TelegramResponse) As %Status
{
    set pResponse = ##class(Mensajes.Response.Notificaciones.TelegramResponse).%New()
    try {	
        // Preparamos la url para la petición
        set url 	= ##class(Util.TablasMaestras).getValorMaestra("BOT_TELEGRAM","url")
        // A través de una LookUp Table, guardamos el TOKEN del bot de telegram que va a enviar el mensaje
        set bot   	= ##class(Util.TablasMaestras).getValorMaestra("BOT_TELEGRAM","bot")
        // A través de una LookUp Table, guardamos el metodo de la API Telegram para envío de notificaciones
        set method 	= ##class(Util.TablasMaestras).getValorMaestra("BOT_TELEGRAM","method")
        // A través de una LookUp Table, guardamos el ID del chat de telegram donde vamos a enviar el mensaje
        set chatId  = ##class(Util.TablasMaestras).getValorMaestra("BOT_TELEGRAM",pRequest.aplicacion)
        
        set URL = url_bot_method_chatId_"&text="_pRequest.mensaje
        // LA URL resultante de consumo de la API Telegram sería con la siguiente estructura:
        // https://api.telegram.org/bot1234567890:[TOKEN]/sendMessage?chat_id=[CHATID]&text="_pRequest.mensaje
        set tSC=..Adapter.PostURL(URL,.tHttpResponse)

        Set textoError = $System.Status.GetErrorText(tSC)

        If $$$ISERR(tSC)
        {
            While (tHttpResponse.Data.AtEnd = 0) {
                 set linea = tHttpResponse.Data.Read()
                 
            }

        } else {
            While (tHttpResponse.Data.AtEnd = 0) {
                 set linea = tHttpResponse.Data.Read()
                 
            }

        }
    } catch {
        // se captura el error y se imprime
        Set tSC=$$$SystemError
        
        // se carga el resultado en el response
        Set tSC=$$$SystemError
        set textoError = $System.Status.GetErrorText(tSC)
        set pResponse.return      = "010 - "_textoError
    }
 
    Quit $$$OK
}


XData MessageMap
{
<MapItems>

  <MapItem MessageType="Mensajes.Request.Notificaciones.TelegramRequest">
    <Method>notificar</Method>
  </MapItem>

</MapItems>
}

}

Class Operaciones.REST.OAUTH2.Gestion Extends EnsLib.REST.Operation
{

Method consultaUsuario(pRequest As Mensajes.Request.OAUTH2.consultaUsuario, Output pResponse As Mensajes.Response.OAUTH2.consultaUsuario) As %Status
{
	set pResponse = ##class(Mensajes.Response.OAUTH2.consultaUsuario).%New()
	try {	
		//preparamos la url para la petición
		set url     = "IP"
		set port    = "PUERTO"
		set method  = "/oauth2"
		set method2 = "/userinfo"
		//quedando la URL = https://IP:PUERTO/oauth2/userinfo
		set URL = "https://"_url_":"_port_method_method2
		
		
		set tSC = ..Adapter.GetURL(URL,.res)
		
		If $$$ISERR(tSC)
		{
		// Tratamiento del error si falla la llamada
		} else {
			// EXTRAEMOS EL JSON
			set linea = ""
			While (res.Data.AtEnd = 0) {
			    set linea = linea_res.Data.Read()
     		}
				
			// se transforma el objeto JSON a un objeto local
			set claseAux = ##class(%ZEN.Auxiliary.jsonProvider).%New()
			set tSC= claseAux.%ConvertJSONToObject(.linea,"Mensajes.Response.OAUTH2.consultaUsuario",.objeto,1)
			
			// TRATAMIENTO QUE QUERAMOS HACER DE LOS DATOS
		}
   	} catch {
		// Tratamiento del error
   	}
   	
 	Quit $$$OK
}


XData MessageMap
{
<MapItems>
  <MapItem MessageType="Mensajes.Request.OAUTH2.consultaUsuario">
    <Method>consultaUsuario</Method>
  </MapItem>
</MapItems>
}

}

{
    "issuer" : "https://DNS/IP:PUERTO/oauth2",
    "authorization_endpoint" : "https://DNS/IP:PUERTO:57776/oauth2/authorize",
    "token_endpoint" : "https://DNS/IP:PUERTO:57776/oauth2/token",
    "userinfo_endpoint" : "https://DNS/IP:PUERTO/oauth2/userinfo",
    "revocation_endpoint" : "https://DNS/IP:PUERTO/oauth2/revocation",
    "introspection_endpoint" : "https://DNS/IP:PUERTO/oauth2/introspection",
    "jwks_uri" : "https://DNS/IP:PUERTO/oauth2/jwks",
    "registration_endpoint" : "https://DNS/IP:PUERTO/oauth2/register",
    "scopes_supported" : [ "openid", "profile", "email", "address", "phone", "my/scope" ],
    "response_types_supported" : [ "code" ],
    "response_modes_supported" : [ "query", "fragment", "form_post" ],
    "grant_types_supported" : [ "authorization_code", "client_credentials", "refresh_token" ],
    "id_token_signing_alg_values_supported" : [ "HS256", "HS384", "HS512", "RS256", "RS384", "RS512" ],
    "id_token_encryption_alg_values_supported" : [ "none", "RSA1_5", "RSA-OAEP", "A128KW", "A192KW", "A256KW", "dir" ],
    "id_token_encryption_enc_values_supported" : [ "none", "A128CBC-HS256", "A192CBC-HS384", "A256CBC-HS512" ],
    "userinfo_signing_alg_values_supported" : [ "none", "HS256", "HS384", "HS512", "RS256", "RS384", "RS512" ],
    "userinfo_encryption_alg_values_supported" : [ "none", "RSA1_5", "RSA-OAEP", "A128KW", "A192KW", "A256KW", "dir" ],
    "userinfo_encryption_enc_values_supported" : [ "none", "A128CBC-HS256", "A192CBC-HS384", "A256CBC-HS512" ],
    "access_token_signing_alg_values_supported" : [ "none", "HS256", "HS384", "HS512", "RS256", "RS384", "RS512" ],
    "access_token_encryption_alg_values_supported" : [ "none", "RSA1_5", "RSA-OAEP", "A128KW", "A192KW", "A256KW", "dir" ],
    "access_token_encryption_enc_values_supported" : [ "none", "A128CBC-HS256", "A192CBC-HS384", "A256CBC-HS512" ],
    "request_object_signing_alg_values_supported" : [ "none", "HS256", "HS384", "HS512", "RS256", "RS384", "RS512" ],
    "request_object_encryption_alg_values_supported" : [ "none", "RSA1_5", "RSA-OAEP", "A128KW", "A192KW", "A256KW", "dir" ],
    "request_object_encryption_enc_values_supported" : [ "none", "A128CBC-HS256", "A192CBC-HS384", "A256CBC-HS512" ],
    "token_endpoint_auth_methods_supported" : [ "client_secret_post", "client_secret_basic", "client_secret_jwt", "private_key_jwt" ],
    "token_endpoint_auth_signing_alg_values_supported" : [ "HS256", "HS384", "HS512", "RS256", "RS384", "RS512" ],
    "claims_supported" : [ "preferred_username", "email", "email_verified", "name", "phone_number", "phone_number_verified", "iss", "sub", "aud", "exp", "auth_time", "jti" ],
    "ui_locales_supported" : [ "de", "en", "en-us", "es", "fr", "it", "ja", "ko", "nl", "pt-br", "ru", "uk", "zh-cn" ],
    "claims_parameter_supported" : true,
    "request_parameter_supported" : true,
    "request_uri_parameter_supported" : true
}

Grant_type= "client_credentials"

scope = "/my/scope"

Authorization:

   Type: Basic Auth

                user: el generado por el servidor de Autorización

                password: generada por el servidor de Autorización

Body

Seleccionamos "x-www-form-urlencoded" e informamos con el "clientID"

La respuesta de esta llamada será el Token:

Esta llamada se podrá configurar a través de una operación REST como comentábamos anteriormente.

El valor del header "Authorization" se obtiene codificando en Base64 la combinación de "client_id" y "client_secret" separados por ":".

Body

En el body, selecciona la opción x-www-form-urlencoded en Postman y agrega los siguientes parámetros:

• token: El token que deseas validar.
• token_type_hint (opcional): Puedes indicar si el token es un access_token o un refresh_token

El resultado de la llamada será algo así:

{
    "active": true,
    "scope": "my/scope",
    "client_id": "bezkfeZoA3mU2g1dmABlvgv9k1AKHN78JtIgXgcdQeQ",
    "username": "",
    "token_type": "bearer",
    "exp": 1748778056,
    "sub": "bezkfeZoA3mU2g1dmABlvgv9k1AKHN78JtIgXgcdQeQ",
    "aud": "bezkfeZoA3mU2g1dmABlvgv9k1AKHN78JtIgXgcdQeQ",
    "iss": "https://DNS/IP:PUERTO/oauth2"
}

Explicación de los campos:

• "active": true: El token es válido.
• "scope": "my/scope": Permisos asociados al token.
• "client_id": "bezkfeZoA3mU2g1dmABlvgv9k1AKHN78JtIgXgcdQeQ": El cliente que generó el token.
• "username": "": (opcional) Usuario asociado al token.
• "exp": Tiempo de expiración (en formato UNIX timestamp).
• "sub": Identificador único del usuario.
• "aud": Audiencias permitidas.
• "iss": Emisor del token.

Informar el campo "Content-Type" con el valor "application/json".

Body

Os dejo el JSON del body en formato texto. Importante el "client_name" para poder localizar en el portal de gestión nuestro usuario recién creado:

{
  "redirect_uris": [
    "https://client.example.com/callback",
    "https://client.example.com/auth"
  ],
  "grant_types": ["authorization_code", "refresh_token"],
  "response_types": ["code"],
  "client_name": "MiCLIENTE",
  "token_endpoint_auth_method": "client_secret_basic",
  "scope": "my/scope"
}

Tras realizar la llamada veremos la siguiente respuesta con toda la información de creación del usuario:

{
    "client_id": "8IFeFdbCiz7CAJ86Bxz4aZUX8s3W-TP3Litmpx4vqOM",
    "client_secret": "6nWT1lL4BOcM0tYz8zTvzgtSqiGpDOXyj-3-MZCa2ei9QMWxoTMKM49LdWrk8XlQYXaZpsVxuTnzv924L52NSw",
    "registration_access_token": "4v5mCm0w0MP6uA0YnZpSTD0ib-XFYnE4i0vlA9QWC9sas9BsSxH8Mipij5XOUvEv5yDRtXKkHmMMLhZjCd5LHw",
    "registration_client_uri": "https://DNS/IP:PUERTO/oauth2/register?client_id=8IFeFdbCiz7CAJ86Bxz4aZUX8s3W-TP3Litmpx4vqOM",
    "client_id_issued_at": 1748779129,
    "client_secret_expires_at": 0,
    "redirect_uris": [
        "https://client.example.com/callback",
        "https://client.example.com/auth"
    ],
    "response_types": [
        "code"
    ],
    "grant_types": [
        "authorization_code",
        "refresh_token"
    ],
    "application_type": "web",
    "client_name": "MiCLIENTE",
    "id_token_signed_response_alg": "RS256",
    "token_endpoint_auth_method": "client_secret_basic"
}

En el portal de gestión, podemos confirmar la creación del usuario:

Así como confirmar el valor del "clientSecret" y el "clientID" que nos ha devuelto la llamada:

Objetivo conseguido, ¡USUARIO CREADO!

Informamos "Basic Auth" con nuestro "client_id" y nuestro "secret_client"

Header

Informamos el "Content-Type" con ""application/x-www-form-urlencoded".

Body

Informamos el "token" que queremos revocar y el "token_type_hint" con "access_token".

Finalmente tendremos un HTTP 200 como respuesta de la llamada:

De esta forma quedará el Token revocado.