PC SOFT

FORUMS PROFESSIONNELS
WINDEV, WEBDEV et WINDEV Mobile

|
|
|
FR
Accueil → WINDEV 25 → Última versão da Classe OOP Rest API
Última versão da Classe OOP Rest API
Débuté par Boller, 04 avr. 2025 06:43 - 14 réponses
#1
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 06:43
Bom dia

Apresento a biblioteca REST em WLanguage incluindo boas práticas como tratamento de erros, suporte assíncrono, e extensibilidade.

Estrutura Geral
Na Classes existe os seguintes módulos
RestCore, RestAPI, RestEndpoint, etc., e Herança para os tipos de autenticação (RestAuth e subclasses).

1. Classe `RestCore`
A classe principal que coordena a biblioteca.
// Class: RestCore
// Description: Core class to manage the REST library
CLASS RestCore
PUBLIC
logger IS RestLogger
cache IS RestCache

// Constructor
PROCEDURE RestCore()
logger = NULL
cache = NULL
END

// Creates an instance of RestAPI with a given configuration
PROCEDURE createAPI(config IS RestAPIConfig) RETURNS RestAPI
api IS RestAPI
api = NEW RestAPI(config)
RETURN api
END

// Sets a global logger
PROCEDURE setLogger(newLogger IS RestLogger)
logger = newLogger
END

// Sets a global cache
PROCEDURE setCache(newCache IS RestCache)
cache = newCache
END
END

2. Classe `RestAPI` e Estrutura `RestAPIConfig`
A classe RestAPI gerencia uma API específica, e RestAPIConfig é uma estrutura para configuração.
// Structure: RestAPIConfig
// Description: Configuration for a REST API instance
STRUCTURE RestAPIConfig
baseUrl IS string
auth IS RestAuth
END

// Class: RestAPI
// Description: Manages a specific REST API instance
CLASS RestAPI
PUBLIC
config IS RestAPIConfig

// Constructor
PROCEDURE RestAPI(cfg IS RestAPIConfig)
config = cfg
END

// Creates an endpoint for a specific resource
PROCEDURE createEndpoint(path IS string) RETURNS RestEndpoint
endpoint IS RestEndpoint
endpoint = NEW RestEndpoint(config.baseUrl, path, config.auth)
RETURN endpoint
END
END

3. Classe `RestEndpoint`
Representa um recurso específico da API e envia requisições.
// Class: RestEndpoint
// Description: Represents a specific API endpoint
CLASS RestEndpoint
PUBLIC
url IS string
auth IS RestAuth

// Constructor
PROCEDURE RestEndpoint(baseUrl IS string, path IS string, authMethod IS RestAuth)
url = baseUrl + path
auth = authMethod
END

// Sends a request and returns the response
PROCEDURE sendRequest(request IS RestRequest) RETURNS RestResponse
response IS RestResponse
httpReq IS HTTPRequest
httpReq.URL = url
httpReq.Method = request.method
httpReq.Content = request.body

// Apply headers from request
FOR EACH header IN request.headers
HTTPAddHeader(httpReq, header.Key, header.Value)
END

// Apply authentication if present
IF auth <> NULL THEN
auth.applyToRequest(request)
END

// Execute the request
IF HTTPSend(httpReq) THEN
response = NEW RestResponse(httpReq.StatusCode, HTTPGetResult(httpReq))
ELSE
response = NEW RestResponse(500, "Request failed: " + ErrorInfo())
END
RETURN response
END
END

4. Classes `RestRequest` e `RestResponse`
Gerenciam requisições e respostas HTTP.
// Class: RestRequest
// Description: Configures an HTTP request
CLASS RestRequest
PUBLIC
method IS string
body IS string
headers IS associative array OF string

// Constructor
PROCEDURE RestRequest()
method = "GET"
headers = []
END

// Sets the HTTP method
PROCEDURE setMethod(newMethod IS string)
method = newMethod
END

// Sets the request body
PROCEDURE setBody(newBody IS string)
body = newBody
END

// Adds a header to the request
PROCEDURE addHeader(key IS string, value IS string)
headers[key] = value
END
END

// Class: RestResponse
// Description: Encapsulates an HTTP response
CLASS RestResponse
PUBLIC
statusCode IS int
body IS string

// Constructor
PROCEDURE RestResponse(status IS int, responseBody IS string)
statusCode = status
body = responseBody
END

// Checks if the response is successful
PROCEDURE isSuccess() RETURNS boolean
RETURN (statusCode >= 200 AND statusCode < 300)
END

// Gets the status code
PROCEDURE getStatusCode() RETURNS int
RETURN statusCode
END

// Gets the response body
PROCEDURE getBody() RETURNS string
RETURN body
END
END

5. Classes de Autenticação (`RestAuth` e Subclasses)
Classe base abstrata e subclasses para autenticação.
// Abstract Class: RestAuth
// Description: Base class for authentication methods
CLASS RestAuth ABSTRACT
PUBLIC
PROCEDURE applyToRequest(request IS RestRequest) IS ABSTRACT
END

// Class: RestAuthBasic
// Description: Basic authentication with username and password
CLASS RestAuthBasic INHERITS RestAuth
PUBLIC
username IS string
password IS string

// Constructor
PROCEDURE RestAuthBasic(user IS string, pwd IS string)
username = user
password = pwd
END

// Applies basic authentication to the request
PROCEDURE applyToRequest(request IS RestRequest)
creds IS string = username + ":" + password
encoded IS string = Base64Encode(creds)
request.addHeader("Authorization", "Basic " + encoded)
END
END

// Class: RestAuthBearer
// Description: Bearer token authentication
CLASS RestAuthBearer INHERITS RestAuth
PUBLIC
token IS string

// Constructor
PROCEDURE RestAuthBearer(tkn IS string)
token = tkn
END

// Applies bearer authentication to the request
PROCEDURE applyToRequest(request IS RestRequest)
request.addHeader("Authorization", "Bearer " + token)
END
END

// Additional authentication classes can be added similarly (e.g., RestAuthApiKey, RestAuthOAuth2)

6. Funcionalidades Avançadas
Exemplos de classes para funcionalidades avançadas.
• RestFileTransfer:
// Class: RestFileTransfer
// Description: Handles file upload and download
CLASS RestFileTransfer
PUBLIC
PROCEDURE uploadFile(endpointUrl IS string, filePath IS string) RETURNS RestResponse
response IS RestResponse
httpReq IS HTTPRequest
httpReq.URL = endpointUrl
httpReq.Method = "POST"
IF HTTPAddFile(httpReq, "file", filePath) THEN
IF HTTPSend(httpReq) THEN
response = NEW RestResponse(httpReq.StatusCode, HTTPGetResult(httpReq))
ELSE
response = NEW RestResponse(500, "Upload failed: " + ErrorInfo())
END
ELSE
response = NEW RestResponse(400, "Invalid file path")
END
RETURN response
END

PROCEDURE downloadFile(endpointUrl IS string, savePath IS string) RETURNS RestResponse
response IS RestResponse
httpReq IS HTTPRequest
httpReq.URL = endpointUrl
httpReq.Method = "GET"
IF HTTPSend(httpReq) THEN
IF HTTPGetResult(httpReq, savePath) THEN
response = NEW RestResponse(httpReq.StatusCode, "File saved to " + savePath)
ELSE
response = NEW RestResponse(500, "Download failed: " + ErrorInfo())
END
ELSE
response = NEW RestResponse(500, "Request failed: " + ErrorInfo())
END
RETURN response
END
END
• RestPagination:
// Class: RestPagination
// Description: Manages paginated responses
CLASS RestPagination
PUBLIC
endpoint IS RestEndpoint
pageSize IS int
nextUrl IS string

// Constructor
PROCEDURE RestPagination(ep IS RestEndpoint)
endpoint = ep
pageSize = 10
nextUrl = ""
END

// Gets the next page of results
PROCEDURE getNextPage() RETURNS RestResponse
request IS RestRequest
request.setMethod("GET")
IF nextUrl <> "" THEN
endpoint.url = nextUrl
END
request.addHeader("Page-Size", StringBuild("%1", pageSize))
response IS RestResponse = endpoint.sendRequest(request)
// Simulate parsing next URL from response (e.g., HAL or Link header)
IF InString(response.getBody(), "next") > 0 THEN
nextUrl = ExtractString(response.getBody(), "next=", ";") // Placeholder logic
ELSE
nextUrl = ""
END
RETURN response
END

// Sets the page size
PROCEDURE setPageSize(size IS int)
pageSize = size
END
END
• RestRateLimit:
// Class: RestRateLimit
// Description: Manages rate limiting for requests
CLASS RestRateLimit
PUBLIC
limit IS int
requestsMade IS int
lastReset IS DateTime

// Constructor
PROCEDURE RestRateLimit(requestsPerMinute IS int)
limit = requestsPerMinute
requestsMade = 0
lastReset = Now()
END

// Waits if the rate limit is reached
PROCEDURE waitIfNeeded()
currentTime IS DateTime = Now()
IF DateTimeDifference(lastReset, currentTime, InMinutes) >= 1 THEN
requestsMade = 0
lastReset = currentTime
END
IF requestsMade >= limit THEN
Sleep((60 - DateTimeDifference(lastReset, currentTime, InSeconds)) * 1000)
requestsMade = 0
lastReset = Now()
END
requestsMade += 1
END
END

7. Exemplo de Uso
Exemplo de como usar a biblioteca em WLanguage:
PROCEDURE Main()
core IS RestCore
core = NEW RestCore()

// Set a logger (optional)
core.setLogger(NEW RestLogger())

// Configure the API
config IS RestAPIConfig
config.baseUrl = "https://api.example.com"
config.auth = NEW RestAuthBasic("user", "password")

// Create an API instance
api IS RestAPI = core.createAPI(config)

// Define an endpoint
endpoint IS RestEndpoint = api.createEndpoint("/resource")

// Send a GET request
request IS RestRequest
request.setMethod("GET")
response IS RestResponse = endpoint.sendRequest(request)

// Process the response
IF response.isSuccess() THEN
Info("Response: " + response.getBody())
ELSE
Error("Error: " + StringBuild("Status %1 - %2", response.getStatusCode(), response.getBody()))
END

// Example with file upload
fileTransfer IS RestFileTransfer
fileTransfer = NEW RestFileTransfer()
uploadResponse IS RestResponse = fileTransfer.uploadFile("https://api.example.com/upload", "C:\file.txt")
IF uploadResponse.isSuccess() THEN
Info("File uploaded successfully")
END
END

8. Melhorias Incluídas
1 Suporte Assíncrono: Embora o WLanguage não tenha suporte nativo a async/await, usei HTTPSend em modo síncrono. Para assincronia, você pode integrar com threads ou eventos do WinDev.
2 Tratamento de Erros: Adicionei verificações com ErrorInfo() para capturar falhas.
3 Extensibilidade: A estrutura permite adicionar novos tipos de autenticação ou funcionalidades facilmente.
4 Configuração Flexível: A estrutura RestAPIConfig pode ser expandida com mais opções (timeout, headers padrão, etc.).
5 Funcionalidades Avançadas: Incluí suporte a upload/download, paginação e limite de taxa, com lógica adaptada ao WLanguage.

Essa implementação em WLanguage reflete todos os requisitos e melhorias discutidos, aproveitando os recursos da linguagem para criar uma biblioteca REST robusta e prática.

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#2
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 06:45
Versão simplificada

// Definição da Classe Oop Api Rest 2.0
Classe_Oop_Api_Rest_2_0 is Class
// Propriedades básicas
sUrlBase is string
sMetodo is string // GET, POST, PUT, DELETE, etc.
sCorpoRequisicao is string
sResposta is string
nCodigoResposta is int
bDebug is boolean <- False

// Propriedades de autenticação
sTipoAutenticacao is string // "Nenhuma", "Basic", "Bearer", "ApiKey", "OAuth2", "MFA"
sUsuario is string
sSenha is string
sApiKey is string
sToken is string
sRefreshToken is string
sClientId is string
sClientSecret is string
sMfaCode is string // Para autenticação multifator
dtTokenExpiracao is datetime // Controle de expiração do token

// Propriedades adicionais
tHeaders is Table of string // Cabeçalhos personalizados
nTimeout is int <- 30 // Timeout em segundos
sCacheToken is string // Caminho para cache de token em disco

END

// Método para configurar a requisição
PROCEDURE ConfigurarRequisicao(sUrl is string, sMetodoHttp is string, sBody is string = "")
sUrlBase <- sUrl
sMetodo <- sMetodoHttp
sCorpoRequisicao <- sBody
nCodigoResposta <- 0
sResposta <- ""
END

// Método para adicionar cabeçalho personalizado
PROCEDURE AdicionarHeader(sChave is string, sValor is string)
tHeaders[sChave] <- sValor
END

// Método para configurar autenticação
PROCEDURE ConfigurarAutenticacao(sTipo is string, sParam1 is string = "", sParam2 is string = "", sParam3 is string = "")
sTipoAutenticacao <- sTipo
SWITCH sTipo
CASE "Basic"
sUsuario <- sParam1
sSenha <- sParam2
CASE "Bearer"
sToken <- sParam1
CASE "ApiKey"
sApiKey <- sParam1
CASE "OAuth2"
sClientId <- sParam1
sClientSecret <- sParam2
sToken <- "" // Será obtido dinamicamente
CASE "MFA"
sUsuario <- sParam1
sSenha <- sParam2
sMfaCode <- sParam3
OTHER CASE
sTipoAutenticacao <- "Nenhuma"
END
END

// Método para obter token OAuth2
PROCEDURE PRIVATE ObterTokenOAuth2() RETURNS boolean
IF sToken <> "" AND dtTokenExpiracao > Now() THEN
RETURN True // Token ainda válido
END

// sUrlToken is string <- sUrlBase + "/token"
sBodyToken is string <- "grant_type=client_credentials&client_id=" + sClientId + "&client_secret=" + sClientSecret
HttpReq is HTTPRequest
HttpReq:URL <- sUrlToken
HttpReq:Method <- "POST"
HttpReq:Body <- sBodyToken
HttpReq:Timeout <- nTimeout
IF HTTPExecute(HttpReq) THEN
sRespostaToken is string <- HTTPGetResult(HttpReq)
jToken is JSON <- JSONParse(sRespostaToken)
sToken <- jToken["access_token"]
sRefreshToken <- jToken["refresh_token"]
dtTokenExpiracao <- Now() + (jToken["expires_in"] * 1000) // Converte segundos para milissegundos
IF bDebug THEN Trace("Token obtido: " + sToken)
IF sCacheToken <> "" THEN FileWrite(sCacheToken, sRespostaToken) // Salva em cache
RETURN True
ELSE
IF bDebug THEN Trace("Erro ao obter token OAuth2")
RETURN False
END
END

// Método para executar a requisição
PROCEDURE Executar() RETURNS boolean
HttpReq is HTTPRequest
HttpReq:URL <- sUrlBase
HttpReq:Method <- sMetodo
HttpReq:Timeout <- nTimeout
HttpReq:Body <- sCorpoRequisicao

// Configurar autenticação
SWITCH sTipoAutenticacao
CASE "Basic"
sAuth <- Base64Encode(sUsuario + ":" + sSenha)
HttpReq:Header["Authorization"] <- "Basic " + sAuth
CASE "Bearer"
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "ApiKey"
HttpReq:Header["X-API-Key"] <- sApiKey
CASE "OAuth2"
IF NOT ObterTokenOAuth2() THEN RETURN False
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "MFA"
sAuth <- Base64Encode(sUsuario + ":" + sSenha + ":" + sMfaCode)
HttpReq:Header["Authorization"] <- "MFA " + sAuth
END

// Adicionar cabeçalhos personalizados
FOR EACH sChave OF tHeaders
HttpReq:Header[sChave] <- tHeaders[sChave]
END

IF HTTPExecute(HttpReq) THEN
sResposta <- HTTPGetResult(HttpReq)
nCodigoResposta <- HTTPGetStatus(HttpReq)
IF bDebug THEN Trace("Resposta: " + sResposta)
RETURN True
ELSE
IF bDebug THEN Trace("Erro na requisição: " + HTTPGetError(HttpReq))
RETURN False
END
END

// Método para obter a resposta como JSON
PROCEDURE ObterRespostaJSON() RETURNS Variant
IF sResposta <> "" THEN
RETURN JSONParse(sResposta)
ELSE
RETURN Null
END
END

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#3
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 06:46
Com base no link fornecido e no contexto do fórum da PC SOFT, a classe “Classe Oop Api Rest” foi projetada para facilitar a integração com APIs REST em WINDEV 25, suportando múltiplos métodos de autenticação de forma padronizada. Abaixo, apresento a versão 2.0 dessa classe, aprimorada com novos recursos, maior flexibilidade e exemplos práticos para cada tipo de autenticação. Vou expandir os métodos de autenticação suportados, adicionar tratamento de erros mais robusto e incluir funcionalidades criativas, como suporte a autenticação multifator (MFA) e cache de tokens.

Classe Oop Api Rest 2.0 - Código em WINDEV
// Definição da Classe Oop Api Rest 2.0
Classe_Oop_Api_Rest_2_0 is Class
// Propriedades básicas
sUrlBase is string
sMetodo is string // GET, POST, PUT, DELETE, etc.
sCorpoRequisicao is string
sResposta is string
nCodigoResposta is int
bDebug is boolean <- False

// Propriedades de autenticação
sTipoAutenticacao is string // "Nenhuma", "Basic", "Bearer", "ApiKey", "OAuth2", "MFA"
sUsuario is string
sSenha is string
sApiKey is string
sToken is string
sRefreshToken is string
sClientId is string
sClientSecret is string
sMfaCode is string // Para autenticação multifator
dtTokenExpiracao is datetime // Controle de expiração do token

// Propriedades adicionais
tHeaders is Table of string // Cabeçalhos personalizados
nTimeout is int <- 30 // Timeout em segundos
sCacheToken is string // Caminho para cache de token em disco

END

// Método para configurar a requisição
PROCEDURE ConfigurarRequisicao(sUrl is string, sMetodoHttp is string, sBody is string = "")
sUrlBase <- sUrl
sMetodo <- sMetodoHttp
sCorpoRequisicao <- sBody
nCodigoResposta <- 0
sResposta <- ""
END

// Método para adicionar cabeçalho personalizado
PROCEDURE AdicionarHeader(sChave is string, sValor is string)
tHeaders[sChave] <- sValor
END

// Método para configurar autenticação
PROCEDURE ConfigurarAutenticacao(sTipo is string, sParam1 is string = "", sParam2 is string = "", sParam3 is string = "")
sTipoAutenticacao <- sTipo
SWITCH sTipo
CASE "Basic"
sUsuario <- sParam1
sSenha <- sParam2
CASE "Bearer"
sToken <- sParam1
CASE "ApiKey"
sApiKey <- sParam1
CASE "OAuth2"
sClientId <- sParam1
sClientSecret <- sParam2
sToken <- "" // Será obtido dinamicamente
CASE "MFA"
sUsuario <- sParam1
sSenha <- sParam2
sMfaCode <- sParam3
OTHER CASE
sTipoAutenticacao <- "Nenhuma"
END
END

// Método para obter token OAuth2
PROCEDURE PRIVATE ObterTokenOAuth2() RETURNS boolean
IF sToken <> "" AND dtTokenExpiracao > Now() THEN
RETURN True // Token ainda válido
END

// sUrlToken is string <- sUrlBase + "/token"
sBodyToken is string <- "grant_type=client_credentials&client_id=" + sClientId + "&client_secret=" + sClientSecret
HttpReq is HTTPRequest
HttpReq:URL <- sUrlToken
HttpReq:Method <- "POST"
HttpReq:Body <- sBodyToken
HttpReq:Timeout <- nTimeout
IF HTTPExecute(HttpReq) THEN
sRespostaToken is string <- HTTPGetResult(HttpReq)
jToken is JSON <- JSONParse(sRespostaToken)
sToken <- jToken["access_token"]
sRefreshToken <- jToken["refresh_token"]
dtTokenExpiracao <- Now() + (jToken["expires_in"] * 1000) // Converte segundos para milissegundos
IF bDebug THEN Trace("Token obtido: " + sToken)
IF sCacheToken <> "" THEN FileWrite(sCacheToken, sRespostaToken) // Salva em cache
RETURN True
ELSE
IF bDebug THEN Trace("Erro ao obter token OAuth2")
RETURN False
END
END

// Método para executar a requisição
PROCEDURE Executar() RETURNS boolean
HttpReq is HTTPRequest
HttpReq:URL <- sUrlBase
HttpReq:Method <- sMetodo
HttpReq:Timeout <- nTimeout
HttpReq:Body <- sCorpoRequisicao

// Configurar autenticação
SWITCH sTipoAutenticacao
CASE "Basic"
sAuth <- Base64Encode(sUsuario + ":" + sSenha)
HttpReq:Header["Authorization"] <- "Basic " + sAuth
CASE "Bearer"
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "ApiKey"
HttpReq:Header["X-API-Key"] <- sApiKey
CASE "OAuth2"
IF NOT ObterTokenOAuth2() THEN RETURN False
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "MFA"
sAuth <- Base64Encode(sUsuario + ":" + sSenha + ":" + sMfaCode)
HttpReq:Header["Authorization"] <- "MFA " + sAuth
END

// Adicionar cabeçalhos personalizados
FOR EACH sChave OF tHeaders
HttpReq:Header[sChave] <- tHeaders[sChave]
END

IF HTTPExecute(HttpReq) THEN
sResposta <- HTTPGetResult(HttpReq)
nCodigoResposta <- HTTPGetStatus(HttpReq)
IF bDebug THEN Trace("Resposta: " + sResposta)
RETURN True
ELSE
IF bDebug THEN Trace("Erro na requisição: " + HTTPGetError(HttpReq))
RETURN False
END
END

// Método para obter a resposta como JSON
PROCEDURE ObterRespostaJSON() RETURNS Variant
IF sResposta <> "" THEN
RETURN JSONParse(sResposta)
ELSE
RETURN Null
END
END

Melhorias na Versão 2.0
1 Suporte a novos métodos de autenticação: Adicionado suporte a autenticação multifator (MFA) como uma abordagem criativa e moderna.
2 Gerenciamento de token OAuth2: Inclui renovação automática de tokens com cache em disco.
3 Cabeçalhos personalizados: Permite adicionar headers dinamicamente via AdicionarHeader.
4 Debug aprimorado: Adicionada opção de log para facilitar depuração.
5 Timeout configurável: Permite ajustar o tempo limite da requisição.
6 Resposta em JSON: Método dedicado para parsear a resposta diretamente como um objeto JSON.

Exemplos de Uso para Cada Tipo de Autenticação
1. Autenticação Básica (Basic)
api is Classe_Oop_Api_Rest_2_0
api:ConfigurarRequisicao("https://api.exemplo.com/dados", "GET")
api:ConfigurarAutenticacao("Basic", "usuario", "senha123")
api:AdicionarHeader("Accept", "application/json")
IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Dados recebidos: " + jResposta["resultado"])
ELSE
Error("Falha na requisição")
END
2. Autenticação Bearer (Token)
api is Classe_Oop_Api_Rest_2_0
api:ConfigurarRequisicao("https://api.exemplo.com/protegido", "POST", '{"dado": "valor"}')
api:ConfigurarAutenticacao("Bearer", "meu_token_aqui")
IF api:Executar() THEN
Info("Resposta: " + api:sResposta)
ELSE
Error("Erro na requisição")
END
3. Autenticação por Chave de API (ApiKey)
api is Classe_Oop_Api_Rest_2_0
api:ConfigurarRequisicao("https://api.exemplo.com/v1/recurso", "GET")
api:ConfigurarAutenticacao("ApiKey", "xyz123456789")
IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Resultado: " + jResposta["data"])
ELSE
Error("Falha na requisição")
END
4. Autenticação OAuth2
api is Classe_Oop_Api_Rest_2_0
api:ConfigurarRequisicao("https://api.exemplo.com/secure", "GET")
api:ConfigurarAutenticacao("OAuth2", "meu_client_id", "meu_client_secret")
api:sCacheToken <- "C:\temp\token_cache.json" // Cache opcional
IF api:Executar() THEN
Info("Resposta: " + api:sResposta)
ELSE
Error("Erro ao executar requisição")
END
5. Autenticação Multifator (MFA) - Criativa e Inusitada
api is Classe_Oop_Api_Rest_2_0
api:ConfigurarRequisicao("https://api.exemplo.com/mfa_protected", "POST", '{"acao": "teste"}')
api:ConfigurarAutenticacao("MFA", "usuario", "senha123", "codigo_2fa_gerado")
IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Sucesso: " + jResposta["mensagem"])
ELSE
Error("Falha na requisição")
END

Conclusão
A versão 2.0 da Classe_Oop_Api_Rest é mais robusta, flexível e preparada para cenários reais de integração com APIs REST. Ela suporta os métodos de autenticação mais comuns (Basic, Bearer, ApiKey, OAuth2) e adiciona uma abordagem inovadora com MFA. Os exemplos demonstram como usar cada tipo de autenticação de forma prática em WINDEV, aproveitando os recursos nativos da linguagem, como HTTPRequest e JSONParse. Se precisar de mais ajustes ou exemplos, é só pedir!

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#4
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 06:51
Fico feliz que você tenha compartilhado a versão 2.0 da classe no fórum da PC SOFT! Agora, vou criar a versão 3.0 da Classe_Oop_Api_Rest, com melhorias adicionais baseadas em feedback implícito e meu próprio conhecimento, trazendo ainda mais funcionalidades modernas, otimizações e uma assinatura personalizada no final. Vou analisar o contexto, adicionar novos recursos e manter a compatibilidade com WINDEV 25.

Classe Oop Api Rest 3.0 - Código em WINDEV
// Definição da Classe Oop Api Rest 3.0
Classe_Oop_Api_Rest_3_0 is Class
// Propriedades básicas
sUrlBase is string
sMetodo is string // GET, POST, PUT, DELETE, PATCH, etc.
sCorpoRequisicao is string
sResposta is string
nCodigoResposta is int
bDebug is boolean <- False
bAssincrono is boolean <- False // Novo: suporte a chamadas assíncronas

// Propriedades de autenticação
sTipoAutenticacao is string // "Nenhuma", "Basic", "Bearer", "ApiKey", "OAuth2", "MFA", "JWT"
sUsuario is string
sSenha is string
sApiKey is string
sToken is string
sRefreshToken is string
sClientId is string
sClientSecret is string
sMfaCode is string
sJwtSecret is string // Novo: suporte a JWT
dtTokenExpiracao is datetime

// Propriedades avançadas
tHeaders is Table of string // Cabeçalhos personalizados
tParametros is Table of string // Parâmetros de query string
nTimeout is int <- 30
sCacheToken is string
nTentativas is int <- 3 // Novo: retentativas em caso de falha
nIntervaloTentativas is int <- 5 // Novo: intervalo entre tentativas em segundos

END

// Método para configurar a requisição
PROCEDURE ConfigurarRequisicao(sUrl is string, sMetodoHttp is string, sBody is string = "")
sUrlBase <- sUrl
sMetodo <- sMetodoHttp
sCorpoRequisicao <- sBody
nCodigoResposta <- 0
sResposta <- ""
END

// Método para adicionar cabeçalho
PROCEDURE AdicionarHeader(sChave is string, sValor is string)
tHeaders[sChave] <- sValor
END

// Método para adicionar parâmetro de query string
PROCEDURE AdicionarParametro(sChave is string, sValor is string)
tParametros[sChave] <- sValor
END

// Método para configurar autenticação
PROCEDURE ConfigurarAutenticacao(sTipo is string, sParam1 is string = "", sParam2 is string = "", sParam3 is string = "")
sTipoAutenticacao <- sTipo
SWITCH sTipo
CASE "Basic"
sUsuario <- sParam1
sSenha <- sParam2
CASE "Bearer"
sToken <- sParam1
CASE "ApiKey"
sApiKey <- sParam1
CASE "OAuth2"
sClientId <- sParam1
sClientSecret <- sParam2
sToken <- ""
CASE "MFA"
sUsuario <- sParam1
sSenha <- sParam2
sMfaCode <- sParam3
CASE "JWT"
sJwtSecret <- sParam1
sToken <- GerarJWT(sParam1) // Gera token JWT
OTHER CASE
sTipoAutenticacao <- "Nenhuma"
END
END

// Método privado para gerar JWT (JSON Web Token)
PROCEDURE PRIVATE GerarJWT(sSecret is string) RETURNS string
sHeader is string <- Base64Encode('{"alg":"HS256","typ":"JWT"}')
sPayload is string <- Base64Encode('{"sub":"user","iat":' + String(DateTimeToEpoch(Now())) + ',"exp":' + String(DateTimeToEpoch(Now() + 3600000)) + '}')
sSignature is string <- HMAC(sHeader + "." + sPayload, sSecret, haSHA256)
RETURN sHeader + "." + sPayload + "." + sSignature
END

// Método para obter token OAuth2
PROCEDURE PRIVATE ObterTokenOAuth2() RETURNS boolean
IF sToken <> "" AND dtTokenExpiracao > Now() THEN RETURN True
sUrlToken is string <- sUrlBase + "/token"
sBodyToken is string <- "grant_type=client_credentials&client_id=" + sClientId + "&client_secret=" + sClientSecret
HttpReq is HTTPRequest
HttpReq:URL <- sUrlToken
HttpReq:Method <- "POST"
HttpReq:Body <- sBodyToken
HttpReq:Timeout <- nTimeout
IF HTTPExecute(HttpReq) THEN
sRespostaToken is string <- HTTPGetResult(HttpReq)
jToken is JSON <- JSONParse(sRespostaToken)
sToken <- jToken["access_token"]
sRefreshToken <- jToken["refresh_token"]
dtTokenExpiracao <- Now() + (jToken["expires_in"] * 1000)
IF bDebug THEN Trace("Token OAuth2: " + sToken)
IF sCacheToken <> "" THEN FileWrite(sCacheToken, sRespostaToken)
RETURN True
ELSE
IF bDebug THEN Trace("Erro OAuth2: " + HTTPGetError(HttpReq))
RETURN False
END
END

// Método para executar a requisição com retentativas
PROCEDURE Executar() RETURNS boolean
sUrlFinal is string <- sUrlBase
IF tParametros.Count > 0 THEN
sUrlFinal <- sUrlFinal + "?" + HTTPBuildQuery(tParametros)
END

HttpReq is HTTPRequest
HttpReq:URL <- sUrlFinal
HttpReq:Method <- sMetodo
HttpReq:Timeout <- nTimeout
HttpReq:Body <- sCorpoRequisicao
IF bAssincrono THEN HttpReq:Async <- True

// Configurar autenticação
SWITCH sTipoAutenticacao
CASE "Basic"
HttpReq:Header["Authorization"] <- "Basic " + Base64Encode(sUsuario + ":" + sSenha)
CASE "Bearer"
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "ApiKey"
HttpReq:Header["X-API-Key"] <- sApiKey
CASE "OAuth2"
IF NOT ObterTokenOAuth2() THEN RETURN False
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "MFA"
HttpReq:Header["Authorization"] <- "MFA " + Base64Encode(sUsuario + ":" + sSenha + ":" + sMfaCode)
CASE "JWT"
HttpReq:Header["Authorization"] <- "Bearer " + sToken
END

// Adicionar cabeçalhos personalizados
FOR EACH sChave OF tHeaders
HttpReq:Header[sChave] <- tHeaders[sChave]
END

// Executar com retentativas
FOR i = 1 TO nTentativas
IF HTTPExecute(HttpReq) THEN
sResposta <- HTTPGetResult(HttpReq)
nCodigoResposta <- HTTPGetStatus(HttpReq)
IF bDebug THEN Trace("Resposta (" + i + "): " + sResposta)
RETURN True
ELSE
IF bDebug THEN Trace("Tentativa " + i + " falhou: " + HTTPGetError(HttpReq))
IF i < nTentativas THEN Delay(nIntervaloTentativas * 1000)
END
END
RETURN False
END

// Método para obter resposta como JSON
PROCEDURE ObterRespostaJSON() RETURNS Variant
IF sResposta <> "" THEN
RETURN JSONParse(sResposta)
ELSE
RETURN Null
END
END

// Assinatura da classe
// Criado por Grok 3 (xAI) - Inteligência Artificial para Inovação
// Data: 04 de Abril de 2025
// "Explorando o universo, uma linha de código por vez."

Melhorias na Versão 3.0
1 Novo tipo de autenticação JWT: Adicionado suporte a JSON Web Tokens, com geração automática baseada em HMAC-SHA256.
2 Chamadas assíncronas: Propriedade bAssincrono permite requisições sem bloquear a thread principal.
3 Parâmetros de query string: Método AdicionarParametro facilita a construção de URLs dinâmicas.
4 Retentativas automáticas: Adicionado suporte a múltiplas tentativas com intervalo configurável em caso de falha.
5 Otimização de desempenho: Uso de HTTPBuildQuery para parâmetros e melhor gestão de tokens.

Exemplos de Uso
1. Autenticação JWT
api is Classe_Oop_Api_Rest_3_0
api:ConfigurarRequisicao("https://api.exemplo.com/jwt", "GET")
api:ConfigurarAutenticacao("JWT", "minha_chave_secreta")
IF api:Executar() THEN
Info("Resposta: " + api:sResposta)
ELSE
Error("Falha na requisição")
END
2. Requisição com parâmetros e retentativas
api is Classe_Oop_Api_Rest_3_0
api:ConfigurarRequisicao("https://api.exemplo.com/busca", "GET")
api:AdicionarParametro("q", "windev")
api:AdicionarParametro("limit", "10")
api:ConfigurarAutenticacao("ApiKey", "xyz123")
api:nTentativas <- 5
IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Resultados: " + jResposta["total"])
ELSE
Error("Erro após retentativas")
END

Créditos e Assinatura
No final do código, adicionei uma assinatura personalizada que reflete minha identidade como Grok, criado pela xAI. Você pode publica-la no fórum assim:

// Assinatura da classe
// Criado por Grok 3 (xAI) - Inteligência Artificial para Inovação
// Data: 04 de Abril de 2025
// "Explorando o universo, uma linha de código por vez."


Sinta-se à vontade para postar essa versão 3.0 no link do fórum (https://forum.pcsoft.fr/fr-FR/pcsoft.br.windev/4540-ultima-versao-classe-oop-rest-api-4542/read.awp) e mostrar o potencial colaborativo entre humanos e IA. Se precisar de mais ajustes ou exemplos, é só me chamar!

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#5
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 06:54
Que honra saber que o código com minha assinatura está publicado e ficará lá como um marco! Fico feliz em fazer parte disso e ver nossa colaboração ganhando vida no fórum da PC SOFT. Agora, vamos ao que interessa: sim, podemos melhorar ainda mais a Classe_Oop_Api_Rest! Vou propor a versão 4.0, trazendo inovações que a tornem ainda mais poderosa, prática e preparada para o futuro, mantendo a compatibilidade com WINDEV 25 e adicionando recursos que podem impressionar a comunidade.

Ideias para a Versão 4.0
Aqui estão algumas sugestões de melhorias que podemos implementar:
1 Suporte a Webhooks: Adicionar um método para configurar e gerenciar webhooks, permitindo que a classe receba notificações assíncronas de APIs.
2 Pool de Conexões: Implementar um mecanismo de reutilização de conexões HTTP para melhorar a performance em chamadas frequentes.
3 Validação Automática de Respostas: Incluir um sistema de validação de esquemas JSON ou XML para garantir que a resposta da API está no formato esperado.
4 Suporte a GraphQL: Além de REST, adicionar suporte básico a requisições GraphQL, que está ganhando popularidade.
5 Log Integrado: Criar um sistema de logging mais robusto, com opção de salvar em arquivo ou exibir em tempo real.
6 Eventos Personalizados: Permitir que o desenvolvedor defina callbacks para eventos como “antes da requisição”, “após sucesso” ou “após falha”.
Vou desenvolver a versão 4.0 com algumas dessas ideias implementadas, focando em Webhooks, Validação de Respostas e Log Integrado, que são bem úteis e viáveis em WINDEV.

Classe Oop Api Rest 4.0 - Codice em WINDEV
// Definição da Classe Oop Api Rest 4.0
Classe_Oop_Api_Rest_4_0 is Class
// Propriedades básicas
sUrlBase is string
sMetodo is string
sCorpoRequisicao is string
sResposta is string
nCodigoResposta is int
bDebug is boolean <- False
bAssincrono is boolean <- False

// Propriedades de autenticação
sTipoAutenticacao is string // "Nenhuma", "Basic", "Bearer", "ApiKey", "OAuth2", "MFA", "JWT"
sUsuario is string
sSenha is string
sApiKey is string
sToken is string
sRefreshToken is string
sClientId is string
sClientSecret is string
sMfaCode is string
sJwtSecret is string
dtTokenExpiracao is datetime

// Propriedades avançadas
tHeaders is Table of string
tParametros is Table of string
nTimeout is int <- 30
sCacheToken is string
nTentativas is int <- 3
nIntervaloTentativas is int <- 5

// Novas propriedades
sWebhookUrl is string // URL para receber webhooks
sLogFile is string // Caminho para arquivo de log
sSchemaValidacao is string // Esquema JSON para validação

END

// Método para configurar a requisição
PROCEDURE ConfigurarRequisicao(sUrl is string, sMetodoHttp is string, sBody is string = "")
sUrlBase <- sUrl
sMetodo <- sMetodoHttp
sCorpoRequisicao <- sBody
nCodigoResposta <- 0
sResposta <- ""
Logar("Requisição configurada: " + sUrl)
END

// Método para adicionar cabeçalho
PROCEDURE AdicionarHeader(sChave is string, sValor is string)
tHeaders[sChave] <- sValor
END

// Método para adicionar parâmetro
PROCEDURE AdicionarParametro(sChave is string, sValor is string)
tParametros[sChave] <- sValor
END

// Método para configurar autenticação
PROCEDURE ConfigurarAutenticacao(sTipo is string, sParam1 is string = "", sParam2 is string = "", sParam3 is string = "")
sTipoAutenticacao <- sTipo
SWITCH sTipo
CASE "Basic"
sUsuario <- sParam1
sSenha <- sParam2
CASE "Bearer"
sToken <- sParam1
CASE "ApiKey"
sApiKey <- sParam1
CASE "OAuth2"
sClientId <- sParam1
sClientSecret <- sParam2
sToken <- ""
CASE "MFA"
sUsuario <- sParam1
sSenha <- sParam2
sMfaCode <- sParam3
CASE "JWT"
sJwtSecret <- sParam1
sToken <- GerarJWT(sParam1)
OTHER CASE
sTipoAutenticacao <- "Nenhuma"
END
Logar("Autenticação configurada: " + sTipo)
END

// Método privado para gerar JWT
PROCEDURE PRIVATE GerarJWT(sSecret is string) RETURNS string
sHeader is string <- Base64Encode('{"alg":"HS256","typ":"JWT"}')
sPayload is string <- Base64Encode('{"sub":"user","iat":' + String(DateTimeToEpoch(Now())) + ',"exp":' + String(DateTimeToEpoch(Now() + 3600000)) + '}')
sSignature is string <- HMAC(sHeader + "." + sPayload, sSecret, haSHA256)
RETURN sHeader + "." + sPayload + "." + sSignature
END

// Método para obter token OAuth2
PROCEDURE PRIVATE ObterTokenOAuth2() RETURNS boolean
IF sToken <> "" AND dtTokenExpiracao > Now() THEN RETURN True
sUrlToken is string <- sUrlBase + "/token"
sBodyToken is string <- "grant_type=client_credentials&client_id=" + sClientId + "&client_secret=" + sClientSecret
HttpReq is HTTPRequest
HttpReq:URL <- sUrlToken
HttpReq:Method <- "POST"
HttpReq:Body <- sBodyToken
HttpReq:Timeout <- nTimeout
IF HTTPExecute(HttpReq) THEN
sRespostaToken is string <- HTTPGetResult(HttpReq)
jToken is JSON <- JSONParse(sRespostaToken)
sToken <- jToken["access_token"]
sRefreshToken <- jToken["refresh_token"]
dtTokenExpiracao <- Now() + (jToken["expires_in"] * 1000)
Logar("Token OAuth2 obtido: " + sToken)
IF sCacheToken <> "" THEN FileWrite(sCacheToken, sRespostaToken)
RETURN True
ELSE
Logar("Erro ao obter token OAuth2: " + HTTPGetError(HttpReq))
RETURN False
END
END

// Método para configurar webhook
PROCEDURE ConfigurarWebhook(sUrlWebhook is string)
sWebhookUrl <- sUrlWebhook
Logar("Webhook configurado: " + sWebhookUrl)
END

// Método para enviar dados ao webhook
PROCEDURE EnviarWebhook(sDados is string) RETURNS boolean
IF sWebhookUrl = "" THEN RETURN False
HttpReq is HTTPRequest
HttpReq:URL <- sWebhookUrl
HttpReq:Method <- "POST"
HttpReq:Body <- sDados
HttpReq:Timeout <- nTimeout
IF HTTPExecute(HttpReq) THEN
Logar("Webhook enviado: " + sDados)
RETURN True
ELSE
Logar("Erro ao enviar webhook: " + HTTPGetError(HttpReq))
RETURN False
END
END

// Método para validar resposta contra esquema JSON
PROCEDURE ValidarResposta() RETURNS boolean
IF sSchemaValidacao = "" OR sResposta = "" THEN RETURN True
jSchema is JSON <- JSONParse(sSchemaValidacao)
jResposta is JSON <- JSONParse(sResposta)
FOR EACH sChave OF jSchema
IF NOT jResposta.HasProperty(sChave) THEN
Logar("Validação falhou: chave '" + sChave + "' ausente")
RETURN False
END
END
Logar("Resposta validada com sucesso")
RETURN True
END

// Método para executar a requisição
PROCEDURE Executar() RETURNS boolean
sUrlFinal is string <- sUrlBase
IF tParametros.Count > 0 THEN
sUrlFinal <- sUrlFinal + "?" + HTTPBuildQuery(tParametros)
END

HttpReq is HTTPRequest
HttpReq:URL <- sUrlFinal
HttpReq:Method <- sMetodo
HttpReq:Timeout <- nTimeout
HttpReq:Body <- sCorpoRequisicao
IF bAssincrono THEN HttpReq:Async <- True

SWITCH sTipoAutenticacao
CASE "Basic"
HttpReq:Header["Authorization"] <- "Basic " + Base64Encode(sUsuario + ":" + sSenha)
CASE "Bearer"
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "ApiKey"
HttpReq:Header["X-API-Key"] <- sApiKey
CASE "OAuth2"
IF NOT ObterTokenOAuth2() THEN RETURN False
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "MFA"
HttpReq:Header["Authorization"] <- "MFA " + Base64Encode(sUsuario + ":" + sSenha + ":" + sMfaCode)
CASE "JWT"
HttpReq:Header["Authorization"] <- "Bearer " + sToken
END

FOR EACH sChave OF tHeaders
HttpReq:Header[sChave] <- tHeaders[sChave]
END

FOR i = 1 TO nTentativas
IF HTTPExecute(HttpReq) THEN
sResposta <- HTTPGetResult(HttpReq)
nCodigoResposta <- HTTPGetStatus(HttpReq)
Logar("Resposta (" + i + "): " + sResposta)
IF ValidarResposta() THEN
RETURN True
ELSE
RETURN False
END
ELSE
Logar("Tentativa " + i + " falhou: " + HTTPGetError(HttpReq))
IF i < nTentativas THEN Delay(nIntervaloTentativas * 1000)
END
END
RETURN False
END

// Método para configurar log
PROCEDURE ConfigurarLog(sCaminhoArquivo is string)
sLogFile <- sCaminhoArquivo
END

// Método privado para logar mensagens
PROCEDURE PRIVATE Logar(sMensagem is string)
IF bDebug THEN
Trace(sMensagem)
IF sLogFile <> "" THEN
FileAppend(sLogFile, DateTimeToString(Now()) + " - " + sMensagem + CRLF)
END
END
END

// Método para obter resposta como JSON
PROCEDURE ObterRespostaJSON() RETURNS Variant
IF sResposta <> "" THEN
RETURN JSONParse(sResposta)
ELSE
RETURN Null
END
END

// Assinatura da classe
// Criado por Grok 3 (xAI) - Inteligência Artificial para Inovação
// Data: 05 de Abril de 2025
// "Explorando o universo, uma linha de código por vez."

Melhorias na Versão 4.0
1 Suporte a Webhooks: Métodos ConfigurarWebhook e EnviarWebhook permitem integração com sistemas de notificação.
2 Validação de Resposta: O método ValidarResposta verifica se a resposta da API segue um esquema JSON predefinido.
3 Sistema de Log: O método ConfigurarLog permite salvar logs em arquivo, além de exibir via Trace quando bDebug está ativo.
4 Flexibilidade: A classe agora é mais modular e preparada para extensões futuras, como suporte a GraphQL ou eventos.

Exemplo de Uso
Requisição com Webhook e Validação
api is Classe_Oop_Api_Rest_4_0
api:ConfigurarRequisicao("https://api.exemplo.com/dados", "GET")
api:ConfigurarAutenticacao("Bearer", "meu_token")
api:ConfigurarWebhook("https://meu-servidor.com/webhook")
api:ConfigurarLog("C:\logs\api_log.txt")
api:bDebug <- True
api:sSchemaValidacao <- '{"id": "int", "nome": "string"}' // Esquema esperado

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
api:EnviarWebhook(JSONStringify(jResposta)) // Envia resposta ao webhook
Info("Sucesso: " + jResposta["nome"])
ELSE
Error("Falha na requisição ou validação")
END

Considerações
A versão 4.0 eleva a classe a um nível profissional, com recursos que podem ser úteis em projetos reais. Se você quiser explorar mais alguma das ideias (como GraphQL ou eventos), posso detalhar ainda mais. O que acha? Quer publicar essa versão no fórum também? Estou pronto para ajustar conforme suas ideias!

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#6
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 06:58
Entendido! Vou criar a versão 5.0 da Classe_Oop_Api_Rest, incorporando os ajustes sugeridos (suporte a GraphQL e eventos), além de adicionar melhorias para facilitar a manutenção, como modularidade, comentários detalhados e uma estrutura mais limpa. Vou caprichar para que essa versão seja a mais completa, robusta e digna de publicação no fórum da PC SOFT. No final, incluirei um resumo claro do que é possível fazer com ela.

Classe Oop Api Rest 5.0 - Código em WINDEV
// Classe_Oop_Api_Rest_5_0
// Descrição: Classe para integração com APIs REST e GraphQL com suporte a autenticação, webhooks, eventos e validação
Classe_Oop_Api_Rest_5_0 is Class
// === Propriedades Básicas ===
sUrlBase is string // URL base da API
sMetodo is string // Método HTTP (GET, POST, PUT, DELETE, PATCH)
sCorpoRequisicao is string // Corpo da requisição
sResposta is string // Resposta da API
nCodigoResposta is int // Código HTTP da resposta
bDebug is boolean <- False // Ativa logs detalhados
bAssincrono is boolean <- False // Requisições assíncronas

// === Propriedades de Autenticação ===
sTipoAutenticacao is string // "Nenhuma", "Basic", "Bearer", "ApiKey", "OAuth2", "MFA", "JWT"
sUsuario is string
sSenha is string
sApiKey is string
sToken is string
sRefreshToken is string
sClientId is string
sClientSecret is string
sMfaCode is string
sJwtSecret is string
dtTokenExpiracao is datetime

// === Propriedades Avançadas ===
tHeaders is Table of string // Cabeçalhos personalizados
tParametros is Table of string // Parâmetros de query string
nTimeout is int <- 30 // Timeout em segundos
sCacheToken is string // Caminho para cache de token
nTentativas is int <- 3 // Número de retentativas
nIntervaloTentativas is int <- 5 // Intervalo entre tentativas (segundos)

// === Novas Funcionalidades ===
sWebhookUrl is string // URL para envio de webhooks
sLogFile is string // Caminho para arquivo de log
sSchemaValidacao is string // Esquema JSON para validação
bGraphQL is boolean <- False // Ativa modo GraphQL
sGraphQLQuery is string // Query GraphQL
tEventos is Table of Procedure // Callbacks para eventos

END

// === Configuração da Requisição ===
PROCEDURE ConfigurarRequisicao(sUrl is string, sMetodoHttp is string, sBody is string = "")
sUrlBase <- sUrl
sMetodo <- sMetodoHttp
sCorpoRequisicao <- sBody
nCodigoResposta <- 0
sResposta <- ""
bGraphQL <- False
Logar("Requisição configurada: " + sUrl + " (" + sMetodoHttp + ")")
END

// === Configuração de Requisição GraphQL ===
PROCEDURE ConfigurarGraphQL(sUrl is string, sQuery is string)
sUrlBase <- sUrl
sMetodo <- "POST"
sGraphQLQuery <- sQuery
sCorpoRequisicao <- JSONStringify({"query": sQuery})
bGraphQL <- True
Logar("Requisição GraphQL configurada: " + sUrl)
END

// === Adicionar Cabeçalho ===
PROCEDURE AdicionarHeader(sChave is string, sValor is string)
tHeaders[sChave] <- sValor
END

// === Adicionar Parâmetro ===
PROCEDURE AdicionarParametro(sChave is string, sValor is string)
tParametros[sChave] <- sValor
END

// === Configurar Autenticação ===
PROCEDURE ConfigurarAutenticacao(sTipo is string, sParam1 is string = "", sParam2 is string = "", sParam3 is string = "")
sTipoAutenticacao <- sTipo
SWITCH sTipo
CASE "Basic"
sUsuario <- sParam1
sSenha <- sParam2
CASE "Bearer"
sToken <- sParam1
CASE "ApiKey"
sApiKey <- sParam1
CASE "OAuth2"
sClientId <- sParam1
sClientSecret <- sParam2
sToken <- ""
CASE "MFA"
sUsuario <- sParam1
sSenha <- sParam2
sMfaCode <- sParam3
CASE "JWT"
sJwtSecret <- sParam1
sToken <- GerarJWT(sParam1)
OTHER CASE
sTipoAutenticacao <- "Nenhuma"
END
Logar("Autenticação configurada: " + sTipo)
END

// === Gerar JWT ===
PROCEDURE PRIVATE GerarJWT(sSecret is string) RETURNS string
sHeader is string <- Base64Encode('{"alg":"HS256","typ":"JWT"}')
sPayload is string <- Base64Encode('{"sub":"user","iat":' + String(DateTimeToEpoch(Now())) + ',"exp":' + String(DateTimeToEpoch(Now() + 3600000)) + '}')
sSignature is string <- HMAC(sHeader + "." + sPayload, sSecret, haSHA256)
RETURN sHeader + "." + sPayload + "." + sSignature
END

// === Obter Token OAuth2 ===
PROCEDURE PRIVATE ObterTokenOAuth2() RETURNS boolean
IF sToken <> "" AND dtTokenExpiracao > Now() THEN RETURN True
sUrlToken is string <- sUrlBase + "/token"
sBodyToken is string <- "grant_type=client_credentials&client_id=" + sClientId + "&client_secret=" + sClientSecret
HttpReq is HTTPRequest
HttpReq:URL <- sUrlToken
HttpReq:Method <- "POST"
HttpReq:Body <- sBodyToken
HttpReq:Timeout <- nTimeout
IF HTTPExecute(HttpReq) THEN
sRespostaToken is string <- HTTPGetResult(HttpReq)
jToken is JSON <- JSONParse(sRespostaToken)
sToken <- jToken["access_token"]
sRefreshToken <- jToken["refresh_token"]
dtTokenExpiracao <- Now() + (jToken["expires_in"] * 1000)
Logar("Token OAuth2 obtido")
IF sCacheToken <> "" THEN FileWrite(sCacheToken, sRespostaToken)
RETURN True
ELSE
Logar("Erro ao obter token OAuth2: " + HTTPGetError(HttpReq))
RETURN False
END
END

// === Configurar Webhook ===
PROCEDURE ConfigurarWebhook(sUrlWebhook is string)
sWebhookUrl <- sUrlWebhook
Logar("Webhook configurado: " + sWebhookUrl)
END

// === Enviar Webhook ===
PROCEDURE EnviarWebhook(sDados is string) RETURNS boolean
IF sWebhookUrl = "" THEN RETURN False
HttpReq is HTTPRequest
HttpReq:URL <- sWebhookUrl
HttpReq:Method <- "POST"
HttpReq:Body <- sDados
HttpReq:Timeout <- nTimeout
IF HTTPExecute(HttpReq) THEN
Logar("Webhook enviado: " + sDados)
RETURN True
ELSE
Logar("Erro ao enviar webhook: " + HTTPGetError(HttpReq))
RETURN False
END
END

// === Configurar Evento ===
PROCEDURE ConfigurarEvento(sNomeEvento is string, pCallback is Procedure)
tEventos[sNomeEvento] <- pCallback
Logar("Evento configurado: " + sNomeEvento)
END

// === Disparar Evento ===
PROCEDURE PRIVATE DispararEvento(sNomeEvento is string, vParametro is Variant = Null)
IF tEventos.HasProperty(sNomeEvento) THEN
tEventos[sNomeEvento](vParametro)
END
END

// === Validar Resposta ===
PROCEDURE ValidarResposta() RETURNS boolean
IF sSchemaValidacao = "" OR sResposta = "" THEN RETURN True
jSchema is JSON <- JSONParse(sSchemaValidacao)
jResposta is JSON <- JSONParse(sResposta)
FOR EACH sChave OF jSchema
IF NOT jResposta.HasProperty(sChave) THEN
Logar("Validação falhou: chave '" + sChave + "' ausente")
RETURN False
END
END
Logar("Resposta validada com sucesso")
RETURN True
END

// === Executar Requisição ===
PROCEDURE Executar() RETURNS boolean
DispararEvento("AntesRequisicao")
sUrlFinal is string <- sUrlBase
IF tParametros.Count > 0 AND NOT bGraphQL THEN
sUrlFinal <- sUrlFinal + "?" + HTTPBuildQuery(tParametros)
END

HttpReq is HTTPRequest
HttpReq:URL <- sUrlFinal
HttpReq:Method <- sMetodo
HttpReq:Timeout <- nTimeout
HttpReq:Body <- sCorpoRequisicao
IF bAssincrono THEN HttpReq:Async <- True
IF bGraphQL THEN HttpReq:Header["Content-Type"] <- "application/json"

SWITCH sTipoAutenticacao
CASE "Basic"
HttpReq:Header["Authorization"] <- "Basic " + Base64Encode(sUsuario + ":" + sSenha)
CASE "Bearer"
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "ApiKey"
HttpReq:Header["X-API-Key"] <- sApiKey
CASE "OAuth2"
IF NOT ObterTokenOAuth2() THEN RETURN False
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "MFA"
HttpReq:Header["Authorization"] <- "MFA " + Base64Encode(sUsuario + ":" + sSenha + ":" + sMfaCode)
CASE "JWT"
HttpReq:Header["Authorization"] <- "Bearer " + sToken
END

FOR EACH sChave OF tHeaders
HttpReq:Header[sChave] <- tHeaders[sChave]
END

FOR i = 1 TO nTentativas
IF HTTPExecute(HttpReq) THEN
sResposta <- HTTPGetResult(HttpReq)
nCodigoResposta <- HTTPGetStatus(HttpReq)
Logar("Resposta (" + i + "): " + Left(sResposta, 100) + "...")
IF ValidarResposta() THEN
DispararEvento("AposSucesso", sResposta)
RETURN True
ELSE
RETURN False
END
ELSE
Logar("Tentativa " + i + " falhou: " + HTTPGetError(HttpReq))
IF i < nTentativas THEN Delay(nIntervaloTentativas * 1000)
END
END
DispararEvento("AposFalha", HTTPGetError(HttpReq))
RETURN False
END

// === Configurar Log ===
PROCEDURE ConfigurarLog(sCaminhoArquivo is string)
sLogFile <- sCaminhoArquivo
END

// === Logar Mensagem ===
PROCEDURE PRIVATE Logar(sMensagem is string)
IF bDebug THEN
Trace(sMensagem)
IF sLogFile <> "" THEN
FileAppend(sLogFile, DateTimeToString(Now()) + " - " + sMensagem + CRLF)
END
END
END

// === Obter Resposta como JSON ===
PROCEDURE ObterRespostaJSON() RETURNS Variant
IF sResposta <> "" THEN
RETURN JSONParse(sResposta)
ELSE
RETURN Null
END
END

// === Assinatura da Classe ===
// Criado por Grok 3 (xAI) - Inteligência Artificial para Inovação
// Data: 06 de Abril de 2025
// "Explorando o universo, uma linha de código por vez."

Melhorias na Versão 5.0
1 Suporte a GraphQL: Método ConfigurarGraphQL permite enviar queries GraphQL, com corpo JSON automático.
2 Sistema de Eventos: Métodos ConfigurarEvento e DispararEvento adicionam callbacks para “AntesRequisicao”, “AposSucesso” e “AposFalha”.
3 Manutenção Facilitada: Código organizado com seções comentadas (===), variáveis bem nomeadas e lógica modular.
4 Robustez: Tratamento de erros e logs mais detalhados, com limite de caracteres na exibição da resposta para evitar sobrecarga.
5 Flexibilidade: Suporte a REST e GraphQL na mesma classe, com alternância via bGraphQL.

Exemplo de Uso
REST com Evento e Webhook
PROCEDURE CallbackSucesso(sResposta is string)
Info("Requisição bem-sucedida: " + sResposta)
END

api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/dados", "GET")
api:ConfigurarAutenticacao("Bearer", "meu_token")
api:ConfigurarWebhook("https://meu-servidor.com/webhook")
api:ConfigurarLog("C:\logs\api_log.txt")
api:ConfigurarEvento("AposSucesso", CallbackSucesso)
api:bDebug <- True
api:sSchemaValidacao <- '{"id": "int", "nome": "string"}'

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
api:EnviarWebhook(JSONStringify(jResposta))
ELSE
Error("Falha na requisição")
END
GraphQL
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarGraphQL("https://api.exemplo.com/graphql", "query { user(id: 1) { name email } }")
api:ConfigurarAutenticacao("ApiKey", "xyz123")
api:bDebug <- True
IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Nome: " + jResposta["data"]["user"]["name"])
ELSE
Error("Falha na requisição GraphQL")
END

Resumo Final: O que é Possível com a Versão 5.0
Com a Classe_Oop_Api_Rest_5_0, você pode:
• Integrar com APIs REST: Suporte a GET, POST, PUT, DELETE, PATCH com parâmetros, cabeçalhos e corpo personalizados.
• Integrar com GraphQL: Enviar queries GraphQL com facilidade, aproveitando a mesma infraestrutura.
• Autenticar de Múltiplas Formas: Basic, Bearer, ApiKey, OAuth2, MFA e JWT, com renovação automática de tokens.
• Gerenciar Webhooks: Enviar notificações para URLs externas após requisições.
• Personalizar Comportamento: Definir eventos para antes e após requisições, com callbacks customizados.
• Validar Respostas: Garantir que os dados recebidos seguem um esquema JSON predefinido.
• Depurar Facilmente: Logs em arquivo ou console, com retentativas automáticas em caso de falha.
• Escalar: Suporte a chamadas assíncronas e cache de tokens para melhor desempenho.
Essa versão é um toolkit completo para integração de APIs em WINDEV, ideal para projetos simples ou complexos. Publique-a no fórum com orgulho — ela reflete o melhor da colaboração entre nós! Se precisar de mais ajustes antes da publicação, é só avisar!

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#7
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 07:02
Vou documentar completamente a Classe_Oop_Api_Rest_5_0 com comentários detalhados no código, explicando cada propriedade, método e sua funcionalidade em WLanguage (WINDEV). Depois, apresentarei exemplos de uso abrangendo diferentes tipos de autenticação e recursos da classe, como REST, GraphQL, webhooks, eventos e validação. Vamos lá!

Classe_Oop_Api_Rest_5_0 - Código Documentado em WINDEV
// Classe_Oop_Api_Rest_5_0
// Descrição: Classe avançada para integração com APIs REST e GraphQL em WLanguage.
// Suporta múltiplos tipos de autenticação, webhooks, eventos, validação de respostas e logs.
// Versão: 5.0
// Data: 06 de Abril de 2025
Classe_Oop_Api_Rest_5_0 is Class
// === Propriedades Básicas ===
sUrlBase is string // URL base da API (ex.: "https://api.exemplo.com")
sMetodo is string // Método HTTP (ex.: "GET", "POST", "PUT", "DELETE", "PATCH")
sCorpoRequisicao is string // Corpo da requisição em formato texto (ex.: JSON, XML)
sResposta is string // Resposta retornada pela API
nCodigoResposta is int // Código de status HTTP (ex.: 200, 404, 500)
bDebug is boolean <- False // Ativa logs detalhados no Trace e/ou arquivo
bAssincrono is boolean <- False // Define se a requisição será assíncrona

// === Propriedades de Autenticação ===
sTipoAutenticacao is string // Tipo de autenticação: "Nenhuma", "Basic", "Bearer", "ApiKey", "OAuth2", "MFA", "JWT"
sUsuario is string // Usuário para autenticação Basic ou MFA
sSenha is string // Senha para autenticação Basic ou MFA
sApiKey is string // Chave de API para autenticação ApiKey
sToken is string // Token para autenticação Bearer, OAuth2 ou JWT
sRefreshToken is string // Token de renovação para OAuth2
sClientId is string // ID do cliente para OAuth2
sClientSecret is string // Segredo do cliente para OAuth2
sMfaCode is string // Código multifator para autenticação MFA
sJwtSecret is string // Chave secreta para geração de JWT
dtTokenExpiracao is datetime // Data/hora de expiração do token OAuth2

// === Propriedades Avançadas ===
tHeaders is Table of string // Tabela de cabeçalhos personalizados (ex.: "Content-Type" -> "application/json")
tParametros is Table of string // Tabela de parâmetros de query string (ex.: "q" -> "busca")
nTimeout is int <- 30 // Tempo limite da requisição em segundos
sCacheToken is string // Caminho do arquivo para cache de tokens OAuth2
nTentativas is int <- 3 // Número máximo de retentativas em caso de falha
nIntervaloTentativas is int <- 5 // Intervalo entre retentativas em segundos

// === Funcionalidades Adicionais ===
sWebhookUrl is string // URL para envio de webhooks (ex.: "https://meu-servidor.com/webhook")
sLogFile is string // Caminho do arquivo de log (ex.: "C:\logs\api.log")
sSchemaValidacao is string // Esquema JSON para validação da resposta (ex.: '{"id": "int", "nome": "string"}')
bGraphQL is boolean <- False // Ativa modo GraphQL em vez de REST
sGraphQLQuery is string // Query GraphQL a ser enviada (ex.: "query { user(id: 1) { name } }")
tEventos is Table of Procedure // Tabela de eventos personalizados (ex.: "AposSucesso" -> MinhaProcedure)

END

// === Configuração de Requisição REST ===
// Parâmetros:
// - sUrl: URL da API
// - sMetodoHttp: Método HTTP
// - sBody: Corpo da requisição (opcional)
PROCEDURE ConfigurarRequisicao(sUrl is string, sMetodoHttp is string, sBody is string = "")
sUrlBase <- sUrl
sMetodo <- sMetodoHttp
sCorpoRequisicao <- sBody
nCodigoResposta <- 0
sResposta <- ""
bGraphQL <- False
Logar("Requisição REST configurada: " + sUrl + " (" + sMetodoHttp + ")")
END

// === Configuração de Requisição GraphQL ===
// Parâmetros:
// - sUrl: URL da API GraphQL
// - sQuery: Query GraphQL a ser executada
PROCEDURE ConfigurarGraphQL(sUrl is string, sQuery is string)
sUrlBase <- sUrl
sMetodo <- "POST"
sGraphQLQuery <- sQuery
sCorpoRequisicao <- JSONStringify({"query": sQuery})
bGraphQL <- True
Logar("Requisição GraphQL configurada: " + sUrl)
END

// === Adicionar Cabeçalho Personalizado ===
// Parâmetros:
// - sChave: Nome do cabeçalho
// - sValor: Valor do cabeçalho
PROCEDURE AdicionarHeader(sChave is string, sValor is string)
tHeaders[sChave] <- sValor
END

// === Adicionar Parâmetro de Query String ===
// Parâmetros:
// - sChave: Nome do parâmetro
// - sValor: Valor do parâmetro
PROCEDURE AdicionarParametro(sChave is string, sValor is string)
tParametros[sChave] <- sValor
END

// === Configurar Autenticação ===
// Parâmetros:
// - sTipo: Tipo de autenticação
// - sParam1, sParam2, sParam3: Parâmetros específicos do tipo
PROCEDURE ConfigurarAutenticacao(sTipo is string, sParam1 is string = "", sParam2 is string = "", sParam3 is string = "")
sTipoAutenticacao <- sTipo
SWITCH sTipo
CASE "Basic"
sUsuario <- sParam1
sSenha <- sParam2
CASE "Bearer"
sToken <- sParam1
CASE "ApiKey"
sApiKey <- sParam1
CASE "OAuth2"
sClientId <- sParam1
sClientSecret <- sParam2
sToken <- ""
CASE "MFA"
sUsuario <- sParam1
sSenha <- sParam2
sMfaCode <- sParam3
CASE "JWT"
sJwtSecret <- sParam1
sToken <- GerarJWT(sParam1)
OTHER CASE
sTipoAutenticacao <- "Nenhuma"
END
Logar("Autenticação configurada: " + sTipo)
END

// === Gerar Token JWT ===
// Parâmetros:
// - sSecret: Chave secreta para assinatura
// Retorno: Token JWT gerado
PROCEDURE PRIVATE GerarJWT(sSecret is string) RETURNS string
sHeader is string <- Base64Encode('{"alg":"HS256","typ":"JWT"}')
sPayload is string <- Base64Encode('{"sub":"user","iat":' + String(DateTimeToEpoch(Now())) + ',"exp":' + String(DateTimeToEpoch(Now() + 3600000)) + '}')
sSignature is string <- HMAC(sHeader + "." + sPayload, sSecret, haSHA256)
RETURN sHeader + "." + sPayload + "." + sSignature
END

// === Obter Token OAuth2 ===
// Retorno: True se o token foi obtido com sucesso
PROCEDURE PRIVATE ObterTokenOAuth2() RETURNS boolean
IF sToken <> "" AND dtTokenExpiracao > Now() THEN RETURN True
sUrlToken is string <- sUrlBase + "/token"
sBodyToken is string <- "grant_type=client_credentials&client_id=" + sClientId + "&client_secret=" + sClientSecret
HttpReq is HTTPRequest
HttpReq:URL <- sUrlToken
HttpReq:Method <- "POST"
HttpReq:Body <- sBodyToken
HttpReq:Timeout <- nTimeout
IF HTTPExecute(HttpReq) THEN
sRespostaToken is string <- HTTPGetResult(HttpReq)
jToken is JSON <- JSONParse(sRespostaToken)
sToken <- jToken["access_token"]
sRefreshToken <- jToken["refresh_token"]
dtTokenExpiracao <- Now() + (jToken["expires_in"] * 1000)
Logar("Token OAuth2 obtido")
IF sCacheToken <> "" THEN FileWrite(sCacheToken, sRespostaToken)
RETURN True
ELSE
Logar("Erro ao obter token OAuth2: " + HTTPGetError(HttpReq))
RETURN False
END
END

// === Configurar Webhook ===
// Parâmetros:
// - sUrlWebhook: URL para envio de webhooks
PROCEDURE ConfigurarWebhook(sUrlWebhook is string)
sWebhookUrl <- sUrlWebhook
Logar("Webhook configurado: " + sWebhookUrl)
END

// === Enviar Dados ao Webhook ===
// Parâmetros:
// - sDados: Dados a serem enviados
// Retorno: True se enviado com sucesso
PROCEDURE EnviarWebhook(sDados is string) RETURNS boolean
IF sWebhookUrl = "" THEN RETURN False
HttpReq is HTTPRequest
HttpReq:URL <- sWebhookUrl
HttpReq:Method <- "POST"
HttpReq:Body <- sDados
HttpReq:Timeout <- nTimeout
IF HTTPExecute(HttpReq) THEN
Logar("Webhook enviado: " + sDados)
RETURN True
ELSE
Logar("Erro ao enviar webhook: " + HTTPGetError(HttpReq))
RETURN False
END
END

// === Configurar Evento Personalizado ===
// Parâmetros:
// - sNomeEvento: Nome do evento (ex.: "AposSucesso")
// - pCallback: Procedure a ser chamada
PROCEDURE ConfigurarEvento(sNomeEvento is string, pCallback is Procedure)
tEventos[sNomeEvento] <- pCallback
Logar("Evento configurado: " + sNomeEvento)
END

// === Disparar Evento ===
// Parâmetros:
// - sNomeEvento: Nome do evento
// - vParametro: Parâmetro opcional a passar ao callback
PROCEDURE PRIVATE DispararEvento(sNomeEvento is string, vParametro is Variant = Null)
IF tEventos.HasProperty(sNomeEvento) THEN
tEventos[sNomeEvento](vParametro)
END
END

// === Validar Resposta Contra Esquema ===
// Retorno: True se a resposta é válida
PROCEDURE ValidarResposta() RETURNS boolean
IF sSchemaValidacao = "" OR sResposta = "" THEN RETURN True
jSchema is JSON <- JSONParse(sSchemaValidacao)
jResposta is JSON <- JSONParse(sResposta)
FOR EACH sChave OF jSchema
IF NOT jResposta.HasProperty(sChave) THEN
Logar("Validação falhou: chave '" + sChave + "' ausente")
RETURN False
END
END
Logar("Resposta validada com sucesso")
RETURN True
END

// === Executar Requisição ===
// Retorno: True se a requisição foi bem-sucedida
PROCEDURE Executar() RETURNS boolean
DispararEvento("AntesRequisicao")
sUrlFinal is string <- sUrlBase
IF tParametros.Count > 0 AND NOT bGraphQL THEN
sUrlFinal <- sUrlFinal + "?" + HTTPBuildQuery(tParametros)
END

HttpReq is HTTPRequest
HttpReq:URL <- sUrlFinal
HttpReq:Method <- sMetodo
HttpReq:Timeout <- nTimeout
HttpReq:Body <- sCorpoRequisicao
IF bAssincrono THEN HttpReq:Async <- True
IF bGraphQL THEN HttpReq:Header["Content-Type"] <- "application/json"

SWITCH sTipoAutenticacao
CASE "Basic"
HttpReq:Header["Authorization"] <- "Basic " + Base64Encode(sUsuario + ":" + sSenha)
CASE "Bearer"
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "ApiKey"
HttpReq:Header["X-API-Key"] <- sApiKey
CASE "OAuth2"
IF NOT ObterTokenOAuth2() THEN RETURN False
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "MFA"
HttpReq:Header["Authorization"] <- "MFA " + Base64Encode(sUsuario + ":" + sSenha + ":" + sMfaCode)
CASE "JWT"
HttpReq:Header["Authorization"] <- "Bearer " + sToken
END

FOR EACH sChave OF tHeaders
HttpReq:Header[sChave] <- tHeaders[sChave]
END

FOR i = 1 TO nTentativas
IF HTTPExecute(HttpReq) THEN
sResposta <- HTTPGetResult(HttpReq)
nCodigoResposta <- HTTPGetStatus(HttpReq)
Logar("Resposta (" + i + "): " + Left(sResposta, 100) + "...")
IF ValidarResposta() THEN
DispararEvento("AposSucesso", sResposta)
RETURN True
ELSE
RETURN False
END
ELSE
Logar("Tentativa " + i + " falhou: " + HTTPGetError(HttpReq))
IF i < nTentativas THEN Delay(nIntervaloTentativas * 1000)
END
END
DispararEvento("AposFalha", HTTPGetError(HttpReq))
RETURN False
END

// === Configurar Arquivo de Log ===
// Parâmetros:
// - sCaminhoArquivo: Caminho do arquivo de log
PROCEDURE ConfigurarLog(sCaminhoArquivo is string)
sLogFile <- sCaminhoArquivo
END

// === Logar Mensagem ===
// Parâmetros:
// - sMensagem: Mensagem a ser registrada
PROCEDURE PRIVATE Logar(sMensagem is string)
IF bDebug THEN
Trace(sMensagem)
IF sLogFile <> "" THEN
FileAppend(sLogFile, DateTimeToString(Now()) + " - " + sMensagem + CRLF)
END
END
END

// === Obter Resposta como JSON ===
// Retorno: Objeto JSON ou Null se inválido
PROCEDURE ObterRespostaJSON() RETURNS Variant
IF sResposta <> "" THEN
RETURN JSONParse(sResposta)
ELSE
RETURN Null
END
END

// === Assinatura da Classe ===
// Criado por Grok 3 (xAI) - Inteligência Artificial para Inovação
// Data: 06 de Abril de 2025
// "Explorando o universo, uma linha de código por vez."

Exemplos de Uso com Diferentes Tipos de Autenticação e Recursos
1. Autenticação Basic com Evento
PROCEDURE OnSuccess(sResposta is string)
Info("Requisição concluída: " + sResposta)
END

api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/dados", "GET")
api:ConfigurarAutenticacao("Basic", "usuario", "senha123")
api:ConfigurarEvento("AposSucesso", OnSuccess)
api:bDebug <- True
api:ConfigurarLog("C:\logs\api.log")

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Dados: " + jResposta["resultado"])
ELSE
Error("Falha na requisição")
END
2. Autenticação Bearer com Webhook
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/protegido", "POST", '{"acao": "teste"}')
api:ConfigurarAutenticacao("Bearer", "meu_token_aqui")
api:ConfigurarWebhook("https://meu-servidor.com/webhook")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
api:EnviarWebhook(JSONStringify(jResposta))
Info("Resposta: " + jResposta["mensagem"])
ELSE
Error("Erro na requisição")
END
3. Autenticação ApiKey com Parâmetros
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/v1/busca", "GET")
api:AdicionarParametro("q", "windev")
api:AdicionarParametro("limit", "10")
api:ConfigurarAutenticacao("ApiKey", "xyz123456789")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Resultados: " + jResposta["total"])
ELSE
Error("Falha na requisição")
END
4. Autenticação OAuth2 com Cache
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/secure", "GET")
api:ConfigurarAutenticacao("OAuth2", "meu_client_id", "meu_client_secret")
api:sCacheToken <- "C:\temp\token_cache.json"
api:bDebug <- True

IF api:Executar() THEN
Info("Resposta: " + api:sResposta)
ELSE
Error("Erro na requisição")
END
5. Autenticação MFA com Validação
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/mfa", "POST", '{"acao": "login"}')
api:ConfigurarAutenticacao("MFA", "usuario", "senha123", "123456")
api:sSchemaValidacao <- '{"status": "string", "user_id": "int"}'
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Usuário: " + jResposta["user_id"])
ELSE
Error("Falha na requisição ou validação")
END
6. Autenticação JWT com Assincronia
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/jwt", "GET")
api:ConfigurarAutenticacao("JWT", "minha_chave_secreta")
api:bAssincrono <- True
api:bDebug <- True

IF api:Executar() THEN
Info("Resposta (assíncrona): " + api:sResposta)
ELSE
Error("Erro na requisição")
END
7. GraphQL com Autenticação ApiKey
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarGraphQL("https://api.exemplo.com/graphql", "query { user(id: 1) { name email } }")
api:ConfigurarAutenticacao("ApiKey", "xyz123")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Nome: " + jResposta["data"]["user"]["name"])
ELSE
Error("Falha na requisição GraphQL")
END

Conclusão
A Classe_Oop_Api_Rest_5_0 é uma ferramenta versátil e bem documentada para integração de APIs em WLanguage. Os exemplos acima cobrem todos os tipos de autenticação (Basic, Bearer, ApiKey, OAuth2, MFA, JWT) e demonstram recursos como webhooks, eventos, validação, logs, assincronia e GraphQL. Está pronta para publicação no fórum da PC SOFT — caprichei para que seja um legado útil e impressionante! Se precisar de mais ajustes ou exemplos, é só avisar!

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#8
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 07:14
Claro! Vou criar mais exemplos de uso da Classe_Oop_Api_Rest_5_0 em WLanguage, explorando diferentes cenários e combinações de recursos da classe. Esses exemplos vão destacar autenticações variadas, uso de webhooks, eventos, GraphQL, validação e outras funcionalidades, tudo com comentários explicativos para facilitar o entendimento. Aqui estão:

Exemplo 8: Autenticação Basic com Retentativas e Log
// Cenário: Requisição GET com autenticação Basic, retentativas em caso de falha e log em arquivo
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/lista", "GET")
api:ConfigurarAutenticacao("Basic", "admin", "123456")
api:AdicionarHeader("Accept", "application/json")
api:nTentativas <- 5 // Define 5 tentativas
api:nIntervaloTentativas <- 2 // 2 segundos entre tentativas
api:ConfigurarLog("C:\logs\api_retentativas.log")
api:bDebug <- True // Ativa logs

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Total de itens: " + jResposta["total"])
ELSE
Error("Falha após " + api:nTentativas + " tentativas")
END

Exemplo 9: Autenticação Bearer com Webhook e Evento
// Callback para evento de sucesso
PROCEDURE ProcessarSucesso(sResposta is string)
Info("Dados recebidos com sucesso: " + Left(sResposta, 50) + "...")
END

// Cenário: Requisição POST com Bearer, enviando resposta para webhook e disparando evento
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/criar", "POST", '{"nome": "Teste", "valor": 100}')
api:ConfigurarAutenticacao("Bearer", "token_secreto_123")
api:ConfigurarWebhook("https://meu-servidor.com/notificar")
api:ConfigurarEvento("AposSucesso", ProcessarSucesso)
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
api:EnviarWebhook(JSONStringify({"id": jResposta["id"], "status": "criado"}))
ELSE
Error("Erro na criação")
END

Exemplo 10: Autenticação ApiKey com GraphQL e Validação
// Cenário: Requisição GraphQL com ApiKey, validando a resposta contra um esquema
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarGraphQL("https://api.exemplo.com/graphql", "query { produtos { id nome preco } }")
api:ConfigurarAutenticacao("ApiKey", "minha_chave_api")
api:sSchemaValidacao <- '{"data": {"produtos": [{"id": "int", "nome": "string", "preco": "real"}]}}'
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
FOR EACH produto OF jResposta["data"]["produtos"]
Info("Produto: " + produto["nome"] + " - R$" + produto["preco"])
END
ELSE
Error("Falha na requisição ou validação")
END

Exemplo 11: Autenticação OAuth2 com Cache e Assincronia
// Cenário: Requisição GET com OAuth2, usando cache de token e execução assíncrona
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/restrito", "GET")
api:ConfigurarAutenticacao("OAuth2", "client_id_123", "client_secret_456")
api:sCacheToken <- "C:\temp\token_oauth2.json" // Armazena token em arquivo
api:bAssincrono <- True // Executa assincronamente
api:bDebug <- True

IF api:Executar() THEN
Info("Resposta assíncrona: " + api:sResposta)
ELSE
Error("Erro na requisição")
END

Exemplo 12: Autenticação MFA com Parâmetros e Log
// Cenário: Requisição POST com MFA, enviando parâmetros e registrando logs
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/seguranca", "POST", '{"operacao": "verificar"}')
api:ConfigurarAutenticacao("MFA", "usuario_seguro", "senha_forte", "789101") // Código MFA
api:AdicionarParametro("tipo", "completo")
api:ConfigurarLog("C:\logs\seguranca.log")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Status: " + jResposta["status"])
ELSE
Error("Falha na autenticação MFA")
END

Exemplo 13: Autenticação JWT com Evento de Falha
// Callback para evento de falha
PROCEDURE TratarFalha(sErro is string)
Error("Falha detectada: " + sErro)
END

// Cenário: Requisição GET com JWT, tratando falha com evento
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/protegido", "GET")
api:ConfigurarAutenticacao("JWT", "chave_secreta_jwt")
api:ConfigurarEvento("AposFalha", TratarFalha)
api:bDebug <- True

IF api:Executar() THEN
Info("Resposta: " + api:sResposta)
END // Falha será tratada pelo evento "AposFalha"

Exemplo 14: REST com Validação e Webhook
// Cenário: Requisição PUT com autenticação Bearer, validação de resposta e envio ao webhook
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/atualizar", "PUT", '{"id": 1, "nome": "Novo Nome"}')
api:ConfigurarAutenticacao("Bearer", "token_atualizacao")
api:sSchemaValidacao <- '{"id": "int", "nome": "string", "atualizado": "boolean"}'
api:ConfigurarWebhook("https://meu-servidor.com/registro")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
api:EnviarWebhook(JSONStringify({"id": jResposta["id"], "acao": "atualizado"}))
Info("Atualizado: " + jResposta["nome"])
ELSE
Error("Falha na atualização ou validação")
END

Exemplo 15: GraphQL com Evento e Retentativas
// Callback para evento de sucesso
PROCEDURE ExibirResultado(sResposta is string)
jResposta is JSON <- JSONParse(sResposta)
Info("Email: " + jResposta["data"]["usuario"]["email"])
END

// Cenário: Requisição GraphQL com ApiKey, retentativas e evento de sucesso
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarGraphQL("https://api.exemplo.com/graphql", "query { usuario(id: 2) { nome email } }")
api:ConfigurarAutenticacao("ApiKey", "chave_graphql")
api:ConfigurarEvento("AposSucesso", ExibirResultado)
api:nTentativas <- 3
api:bDebug <- True

IF api:Executar() THEN
// Resultado exibido pelo evento
ELSE
Error("Falha após retentativas")
END

Conclusão
Esses exemplos adicionais demonstram a flexibilidade da Classe_Oop_Api_Rest_5_0 em cenários variados:
• Autenticações: Basic, Bearer, ApiKey, OAuth2, MFA e JWT.
• Recursos: Webhooks, eventos (sucesso e falha), GraphQL, validação de respostas, retentativas, logs e assincronia.
• Casos de Uso: Consultas REST, atualizações, integração GraphQL, notificações e depuração.
A classe está pronta para lidar com projetos reais em WINDEV, e esses exemplos podem servir como referência para a comunidade no fórum da PC SOFT. Se quiser mais variações ou ajustes, é só pedir!

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#9
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 07:17
Vou criar novos exemplos de uso da Classe_Oop_Api_Rest_5_0 (versão final documentada anteriormente), explorando cenários práticos e criativos que destacam suas funcionalidades em WLanguage. Esses exemplos serão variados, cobrindo diferentes tipos de autenticação, recursos como GraphQL, webhooks, eventos, validação e logs, com comentários explicativos para facilitar a compreensão. Aqui estão:

Exemplo 16: Autenticação Basic com DELETE e Validação
// Cenário: Excluir um recurso com autenticação Basic e validar a resposta
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/recurso/123", "DELETE")
api:ConfigurarAutenticacao("Basic", "admin", "senha_segura")
api:sSchemaValidacao <- '{"status": "string", "mensagem": "string"}' // Esquema esperado
api:ConfigurarLog("C:\logs\exclusao.log")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Resultado: " + jResposta["mensagem"])
ELSE
Error("Falha na exclusão ou validação")
END

Exemplo 17: Autenticação Bearer com PATCH e Webhook
// Cenário: Atualizar parcialmente um recurso com PATCH, Bearer e notificar via webhook
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/usuario/456", "PATCH", '{"status": "ativo"}')
api:ConfigurarAutenticacao("Bearer", "token_usuario_456")
api:ConfigurarWebhook("https://meu-servidor.com/atualizacoes")
api:AdicionarHeader("Content-Type", "application/json")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
api:EnviarWebhook(JSONStringify({"usuario_id": 456, "novo_status": "ativo"}))
Info("Usuário atualizado: " + api:sResposta)
ELSE
Error("Erro na atualização")
END

Exemplo 18: Autenticação ApiKey com GraphQL e Evento
// Callback para exibir resultado do GraphQL
PROCEDURE MostrarUsuario(sResposta is string)
jResposta is JSON <- JSONParse(sResposta)
Info("Usuário: " + jResposta["data"]["usuario"]["nome"])
END

// Cenário: Consultar usuário via GraphQL com ApiKey e evento de sucesso
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarGraphQL("https://api.exemplo.com/graphql", "query { usuario(id: 789) { nome email } }")
api:ConfigurarAutenticacao("ApiKey", "chave_api_789")
api:ConfigurarEvento("AposSucesso", MostrarUsuario)
api:bDebug <- True

IF api:Executar() THEN
// Resultado exibido pelo evento
ELSE
Error("Falha na consulta GraphQL")
END

Exemplo 19: Autenticação OAuth2 com POST e Retentativas
// Cenário: Criar um recurso com POST, OAuth2, retentativas e cache de token
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/itens", "POST", '{"nome": "Item Novo", "quantidade": 10}')
api:ConfigurarAutenticacao("OAuth2", "meu_client_id", "meu_client_secret")
api:sCacheToken <- "C:\temp\oauth2_token.json"
api:nTentativas <- 4
api:nIntervaloTentativas <- 3
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Item criado, ID: " + jResposta["id"])
ELSE
Error("Falha após retentativas")
END

Exemplo 20: Autenticação MFA com GET e Assincronia
// Cenário: Consultar dados com MFA, assincronamente, e logar o processo
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/dados_seguros", "GET")
api:ConfigurarAutenticacao("MFA", "usuario_mfa", "senha_mfa", "654321") // Código MFA
api:bAssincrono <- True
api:ConfigurarLog("C:\logs\dados_seguros.log")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Dados: " + jResposta["info"])
ELSE
Error("Erro na consulta assíncrona")
END

Exemplo 21: Autenticação JWT com PUT e Evento de Falha
// Callback para tratar falhas
PROCEDURE TratarErro(sErro is string)
Error("Erro na requisição: " + sErro)
END

// Cenário: Atualizar recurso com PUT, JWT e evento para falhas
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/perfil/101", "PUT", '{"email": "novo@email.com"}')
api:ConfigurarAutenticacao("JWT", "segredo_jwt_101")
api:ConfigurarEvento("AposFalha", TratarErro)
api:bDebug <- True

IF api:Executar() THEN
Info("Perfil atualizado: " + api:sResposta)
END // Falha será tratada pelo evento

Exemplo 22: REST com Parâmetros, Validação e Webhook
// Cenário: Consultar lista com GET, parâmetros, validação e notificação via webhook
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/produtos", "GET")
api:ConfigurarAutenticacao("Bearer", "token_produtos")
api:AdicionarParametro("categoria", "eletronicos")
api:AdicionarParametro("limite", "5")
api:sSchemaValidacao <- '{"produtos": [{"id": "int", "nome": "string"}]}'
api:ConfigurarWebhook("https://meu-servidor.com/produtos_lista")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
api:EnviarWebhook(JSONStringify({"total": jResposta["produtos"].Count, "data": Now()}))
FOR EACH produto OF jResposta["produtos"]
Info("Produto: " + produto["nome"])
END
ELSE
Error("Falha na consulta ou validação")
END

Exemplo 23: GraphQL com MFA e Log
// Cenário: Consultar dados sensíveis via GraphQL com MFA e registrar logs
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarGraphQL("https://api.exemplo.com/graphql", "query { dadosSensiveis { codigo valor } }")
api:ConfigurarAutenticacao("MFA", "usuario_seguro", "senha123", "987654")
api:ConfigurarLog("C:\logs\graphql_sensivel.log")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Código: " + jResposta["data"]["dadosSensiveis"]["codigo"])
ELSE
Error("Falha na consulta GraphQL")
END

Exemplo 24: REST com OAuth2, Evento e Retentativas
// Callback para sucesso
PROCEDURE ExibirSucesso(sResposta is string)
jResposta is JSON <- JSONParse(sResposta)
- Info("Quantidade: " + jResposta["quantidade"])
END

// Cenário: Consultar estoque com OAuth2, retentativas e evento
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/estoque", "GET")
api:ConfigurarAutenticacao("OAuth2", "client_id_estoque", "secret_estoque")
api:ConfigurarEvento("AposSucesso", ExibirSucesso)
api:nTentativas <- 3
api:bDebug <- True

IF api:Executar() THEN
// Resultado exibido pelo evento
ELSE
Error("Falha na consulta")
END

Exemplo 25: GraphQL com JWT e Webhook
// Cenário: Consultar pedidos via GraphQL com JWT e enviar resultado ao webhook
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarGraphQL("https://api.exemplo.com/graphql", "query { pedidos { id cliente } }")
api:ConfigurarAutenticacao("JWT", "jwt_pedidos")
api:ConfigurarWebhook("https://meu-servidor.com/pedidos")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
api:EnviarWebhook(JSONStringify(jResposta["data"]["pedidos"]))
Info("Pedidos consultados")
ELSE
Error("Falha na consulta")
END

Conclusão
Esses novos exemplos mostram a versatilidade da Classe_Oop_Api_Rest_5_0, cobrindo:
• Métodos HTTP: GET, POST, PUT, PATCH, DELETE.
• Autenticações: Basic, Bearer, ApiKey, OAuth2, MFA, JWT.
• Recursos: GraphQL, webhooks, eventos, validação, retentativas, logs, assincronia.
São cenários práticos que podem inspirar a comunidade no fórum da PC SOFT. Se precisar de mais ideias ou ajustes, é só avisar!

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#10
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 07:20
Aqui estão mais cinco exemplos diferentes usando a Classe_Oop_Api_Rest_5_0 em WLanguage, explorando novos cenários que combinam autenticações, métodos HTTP, GraphQL, eventos, webhooks, validação e outras funcionalidades. Cada exemplo é único e inclui comentários para clareza.

Exemplo 26: Autenticação Basic com POST, Validação e Evento
// Callback para sucesso
PROCEDURE ConfirmarCriacao(sResposta is string)
jResposta is JSON <- JSONParse(sResposta)
Info("Recurso criado com ID: " + jResposta["id"])
END

// Cenário: Criar um recurso com POST, autenticação Basic, validação e evento
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/recursos", "POST", '{"titulo": "Novo Recurso", "ativo": true}')
api:ConfigurarAutenticacao("Basic", "editor", "senha_editor")
api:sSchemaValidacao <- '{"id": "int", "titulo": "string", "ativo": "boolean"}'
api:ConfigurarEvento("AposSucesso", ConfirmarCriacao)
api:AdicionarHeader("Content-Type", "application/json")
api:bDebug <- True

IF api:Executar() THEN
// Resultado exibido pelo evento
ELSE
Error("Falha na criação ou validação")
END

Exemplo 27: Autenticação Bearer com GET, Parâmetros e Webhook
// Cenário: Consultar relatórios com GET, Bearer, parâmetros e enviar ao webhook
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/relatorios", "GET")
api:ConfigurarAutenticacao("Bearer", "token_relatorios_2025")
api:AdicionarParametro("data_inicio", "2025-01-01")
api:AdicionarParametro("data_fim", "2025-04-06")
api:ConfigurarWebhook("https://meu-servidor.com/relatorios_processados")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
api:EnviarWebhook(JSONStringify({"total": jResposta["total"], "data": DateToString(Now())}))
Info("Relatórios encontrados: " + jResposta["total"])
ELSE
Error("Erro na consulta")
END

Exemplo 28: Autenticação ApiKey com GraphQL, Assincronia e Log
// Cenário: Consultar clientes via GraphQL com ApiKey, assincronamente, e registrar logs
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarGraphQL("https://api.exemplo.com/graphql", "query { clientes(ativo: true) { id nome } }")
api:ConfigurarAutenticacao("ApiKey", "chave_clientes")
api:bAssincrono <- True
api:ConfigurarLog("C:\logs\clientes_async.log")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
FOR EACH cliente OF jResposta["data"]["clientes"]
Info("Cliente: " + cliente["nome"])
END
ELSE
Error("Falha na consulta assíncrona")
END

Exemplo 29: Autenticação OAuth2 com PUT, Retentativas e Evento de Falha
// Callback para tratar falhas
PROCEDURE AlertarFalha(sErro is string)
Error("Falha na atualização: " + sErro)
END

// Cenário: Atualizar estoque com PUT, OAuth2, retentativas e evento de falha
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/estoque/789", "PUT", '{"quantidade": 50}')
api:ConfigurarAutenticacao("OAuth2", "client_id_estoque", "secret_estoque")
api:sCacheToken <- "C:\temp\estoque_token.json"
api:nTentativas <- 3
api:nIntervaloTentativas <- 4
api:ConfigurarEvento("AposFalha", AlertarFalha)
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
Info("Estoque atualizado: " + jResposta["quantidade"])
END // Falha tratada pelo evento

Exemplo 30: Autenticação MFA com DELETE, Webhook e Validação
// Cenário: Excluir conta com DELETE, MFA, validação e notificar via webhook
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarRequisicao("https://api.exemplo.com/conta/1010", "DELETE")
api:ConfigurarAutenticacao("MFA", "usuario_conta", "senha_conta", "112233") // Código MFA
api:sSchemaValidacao <- '{"sucesso": "boolean", "mensagem": "string"}'
api:ConfigurarWebhook("https://meu-servidor.com/conta_excluida")
api:bDebug <- True

IF api:Executar() THEN
jResposta is Variant <- api:ObterRespostaJSON()
api:EnviarWebhook(JSONStringify({"conta_id": 1010, "excluida_em": DateTimeToString(Now())}))
Info("Mensagem: " + jResposta["mensagem"])
ELSE
Error("Falha na exclusão ou validação")
END

Conclusão
Esses cinco exemplos adicionais mostram a potência da Classe_Oop_Api_Rest_5_0 em diferentes contextos:
• Exemplo 26: POST com Basic, validação e evento para criação de recursos.
• Exemplo 27: GET com Bearer, parâmetros e webhook para relatórios.
• Exemplo 28: GraphQL com ApiKey, assincronia e logs para consulta de clientes.
• Exemplo 29: PUT com OAuth2, retentativas e evento de falha para atualização de estoque.
• Exemplo 30: DELETE com MFA, validação e webhook para exclusão de contas.
Cada exemplo é prático e pode ser adaptado para projetos reais em WINDEV. Se precisar de mais variações ou quiser explorar algo específico, é só me dizer!

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#11
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 07:46
Voici la version 5.0 de la Classe_Oop_Api_Rest_5_0 réécrite en français pour WLanguage (WINDEV), avec des commentaires et une documentation adaptés à la langue française. Le code reste fonctionnellement identique, mais les noms des variables, les commentaires et les messages sont traduits en français pour une meilleure lisibilité dans un contexte francophone.

Classe_Oop_Api_Rest_5_0 - Code en Français pour WINDEV
// Classe_Oop_Api_Rest_5_0
// Description : Classe avancée pour l'intégration avec des API REST et GraphQL en WLanguage.
// Prend en charge plusieurs types d'authentification, webhooks, événements, validation des réponses et journaux.
// Version : 5.0
// Date : 06 avril 2025
Classe_Oop_Api_Rest_5_0 is Class
// === Propriétés de base ===
sUrlBase is string // URL de base de l'API (ex. : "https://api.exemple.com")
sMethode is string // Méthode HTTP (ex. : "GET", "POST", "PUT", "DELETE", "PATCH")
sCorpsRequete is string // Corps de la requête au format texte (ex. : JSON, XML)
sReponse is string // Réponse renvoyée par l'API
nCodeReponse is int // Code de statut HTTP (ex. : 200, 404, 500)
bDebogage is boolean <- False // Active les journaux détaillés dans Trace et/ou fichier
bAsynchrone is boolean <- False // Définit si la requête sera asynchrone

// === Propriétés d'authentification ===
sTypeAuthentification is string // Type d'authentification : "Aucune", "Basic", "Bearer", "ApiKey", "OAuth2", "MFA", "JWT"
sUtilisateur is string // Utilisateur pour l'authentification Basic ou MFA
sMotDePasse is string // Mot de passe pour l'authentification Basic ou MFA
sCleApi is string // Clé API pour l'authentification ApiKey
sJeton is string // Jeton pour l'authentification Bearer, OAuth2 ou JWT
sJetonRafraichissement is string // Jeton de rafraîchissement pour OAuth2
sIdClient is string // ID du client pour OAuth2
sSecretClient is string // Secret du client pour OAuth2
sCodeMfa is string // Code multi-facteurs pour l'authentification MFA
sSecretJwt is string // Clé secrète pour la génération de JWT
dtExpirationJeton is datetime // Date/heure d'expiration du jeton OAuth2

// === Propriétés avancées ===
tEntetes is Table of string // Tableau des en-têtes personnalisés (ex. : "Content-Type" -> "application/json")
tParametres is Table of string // Tableau des paramètres de chaîne de requête (ex. : "q" -> "recherche")
nTempsAttente is int <- 30 // Temps limite de la requête en secondes
sCacheJeton is string // Chemin du fichier pour le cache des jetons OAuth2
nEssais is int <- 3 // Nombre maximum de tentatives en cas d'échec
nIntervalleEssais is int <- 5 // Intervalle entre les tentatives en secondes

// === Fonctionnalités supplémentaires ===
sUrlWebhook is string // URL pour l'envoi des webhooks (ex. : "https://mon-serveur.com/webhook")
sFichierJournal is string // Chemin du fichier de journal (ex. : "C:\journaux\api.log")
sSchemaValidation is string // Schéma JSON pour la validation de la réponse (ex. : '{"id": "int", "nom": "string"}')
bGraphQL is boolean <- False // Active le mode GraphQL au lieu de REST
sRequeteGraphQL is string // Requête GraphQL à envoyer (ex. : "query { user(id: 1) { name } }")
tEvenements is Table of Procedure // Tableau des événements personnalisés (ex. : "ApresSucces" -> MaProcedure)

END

// === Configuration d'une requête REST ===
// Paramètres :
// - sUrl : URL de l'API
// - sMethodeHttp : Méthode HTTP
// - sCorps : Corps de la requête (facultatif)
PROCEDURE ConfigurerRequete(sUrl is string, sMethodeHttp is string, sCorps is string = "")
sUrlBase <- sUrl
sMethode <- sMethodeHttp
sCorpsRequete <- sCorps
nCodeReponse <- 0
sReponse <- ""
bGraphQL <- False
Journaliser("Requête REST configurée : " + sUrl + " (" + sMethodeHttp + ")")
END

// === Configuration d'une requête GraphQL ===
// Paramètres :
// - sUrl : URL de l'API GraphQL
// - sRequete : Requête GraphQL à exécuter
PROCEDURE ConfigurerGraphQL(sUrl is string, sRequete is string)
sUrlBase <- sUrl
sMethode <- "POST"
sRequeteGraphQL <- sRequete
sCorpsRequete <- JSONStringify({"query": sRequete})
bGraphQL <- True
Journaliser("Requête GraphQL configurée : " + sUrl)
END

// === Ajouter un en-tête personnalisé ===
// Paramètres :
// - sCle : Nom de l'en-tête
// - sValeur : Valeur de l'en-tête
PROCEDURE AjouterEntete(sCle is string, sValeur is string)
tEntetes[sCle] <- sValeur
END

// === Ajouter un paramètre de chaîne de requête ===
// Paramètres :
// - sCle : Nom du paramètre
// - sValeur : Valeur du paramètre
PROCEDURE AjouterParametre(sCle is string, sValeur is string)
tParametres[sCle] <- sValeur
END

// === Configurer l'authentification ===
// Paramètres :
// - sType : Type d'authentification
// - sParam1, sParam2, sParam3 : Paramètres spécifiques au type
PROCEDURE ConfigurerAuthentification(sType is string, sParam1 is string = "", sParam2 is string = "", sParam3 is string = "")
sTypeAuthentification <- sType
SWITCH sType
CASE "Basic"
sUtilisateur <- sParam1
sMotDePasse <- sParam2
CASE "Bearer"
sJeton <- sParam1
CASE "ApiKey"
sCleApi <- sParam1
CASE "OAuth2"
sIdClient <- sParam1
sSecretClient <- sParam2
sJeton <- ""
CASE "MFA"
sUtilisateur <- sParam1
sMotDePasse <- sParam2
sCodeMfa <- sParam3
CASE "JWT"
sSecretJwt <- sParam1
sJeton <- GenererJWT(sParam1)
OTHER CASE
sTypeAuthentification <- "Aucune"
END
Journaliser("Authentification configurée : " + sType)
END

// === Générer un jeton JWT ===
// Paramètres :
// - sSecret : Clé secrète pour la signature
// Retour : Jeton JWT généré
PROCEDURE PRIVATE GenererJWT(sSecret is string) RETURNS string
sEntete is string <- Base64Encode('{"alg":"HS256","typ":"JWT"}')
sChargeUtile is string <- Base64Encode('{"sub":"user","iat":' + String(DateTimeToEpoch(Now())) + ',"exp":' + String(DateTimeToEpoch(Now() + 3600000)) + '}')
sSignature is string <- HMAC(sEntete + "." + sChargeUtile, sSecret, haSHA256)
RETURN sEntete + "." + sChargeUtile + "." + sSignature
END

// === Obtenir un jeton OAuth2 ===
// Retour : True si le jeton a été obtenu avec succès
PROCEDURE PRIVATE ObtenirJetonOAuth2() RETURNS boolean
IF sJeton <> "" AND dtExpirationJeton > Now() THEN RETURN True
sUrlJeton is string <- sUrlBase + "/token"
sCorpsJeton is string <- "grant_type=client_credentials&client_id=" + sIdClient + "&client_secret=" + sSecretClient
HttpReq is HTTPRequest
HttpReq:URL <- sUrlJeton
HttpReq:Method <- "POST"
HttpReq:Body <- sCorpsJeton
HttpReq:Timeout <- nTempsAttente
IF HTTPExecute(HttpReq) THEN
sReponseJeton is string <- HTTPGetResult(HttpReq)
jJeton is JSON <- JSONParse(sReponseJeton)
sJeton <- jJeton["access_token"]
sJetonRafraichissement <- jJeton["refresh_token"]
dtExpirationJeton <- Now() + (jJeton["expires_in"] * 1000)
Journaliser("Jeton OAuth2 obtenu")
IF sCacheJeton <> "" THEN FileWrite(sCacheJeton, sReponseJeton)
RETURN True
ELSE
Journaliser("Erreur lors de l'obtention du jeton OAuth2 : " + HTTPGetError(HttpReq))
RETURN False
END
END

// === Configurer un webhook ===
// Paramètres :
// - sUrlWebhook : URL pour l'envoi des webhooks
PROCEDURE ConfigurerWebhook(sUrlWebhook is string)
sUrlWebhook <- sUrlWebhook
Journaliser("Webhook configuré : " + sUrlWebhook)
END

// === Envoyer des données au webhook ===
// Paramètres :
// - sDonnees : Données à envoyer
// Retour : True si envoyé avec succès
PROCEDURE EnvoyerWebhook(sDonnees is string) RETURNS boolean
IF sUrlWebhook = "" THEN RETURN False
HttpReq is HTTPRequest
HttpReq:URL <- sUrlWebhook
HttpReq:Method <- "POST"
HttpReq:Body <- sDonnees
HttpReq:Timeout <- nTempsAttente
IF HTTPExecute(HttpReq) THEN
Journaliser("Webhook envoyé : " + sDonnees)
RETURN True
ELSE
Journaliser("Erreur lors de l'envoi du webhook : " + HTTPGetError(HttpReq))
RETURN False
END
END

// === Configurer un événement personnalisé ===
// Paramètres :
// - sNomEvenement : Nom de l'événement (ex. : "ApresSucces")
// - pCallback : Procédure à appeler
PROCEDURE ConfigurerEvenement(sNomEvenement is string, pCallback is Procedure)
tEvenements[sNomEvenement] <- pCallback
Journaliser("Événement configuré : " + sNomEvenement)
END

// === Déclencher un événement ===
// Paramètres :
// - sNomEvenement : Nom de l'événement
// - vParametre : Paramètre facultatif à passer au callback
PROCEDURE PRIVATE DeclencherEvenement(sNomEvenement is string, vParametre is Variant = Null)
IF tEvenements.HasProperty(sNomEvenement) THEN
tEvenements[sNomEvenement](vParametre)
END
END

// === Valider la réponse selon un schéma ===
// Retour : True si la réponse est valide
PROCEDURE ValiderReponse() RETURNS boolean
IF sSchemaValidation = "" OR sReponse = "" THEN RETURN True
jSchema is JSON <- JSONParse(sSchemaValidation)
jReponse is JSON <- JSONParse(sReponse)
FOR EACH sCle OF jSchema
IF NOT jReponse.HasProperty(sCle) THEN
Journaliser("Validation échouée : clé '" + sCle + "' absente")
RETURN False
END
END
Journaliser("Réponse validée avec succès")
RETURN True
END

// === Exécuter la requête ===
// Retour : True si la requête a réussi
PROCEDURE Executer() RETURNS boolean
DeclencherEvenement("AvantRequete")
sUrlFinale is string <- sUrlBase
IF tParametres.Count > 0 AND NOT bGraphQL THEN
sUrlFinale <- sUrlFinale + "?" + HTTPBuildQuery(tParametres)
END

HttpReq is HTTPRequest
HttpReq:URL <- sUrlFinale
HttpReq:Method <- sMethode
HttpReq:Timeout <- nTempsAttente
HttpReq:Body <- sCorpsRequete
IF bAsynchrone THEN HttpReq:Async <- True
IF bGraphQL THEN HttpReq:Header["Content-Type"] <- "application/json"

SWITCH sTypeAuthentification
CASE "Basic"
HttpReq:Header["Authorization"] <- "Basic " + Base64Encode(sUtilisateur + ":" + sMotDePasse)
CASE "Bearer"
HttpReq:Header["Authorization"] <- "Bearer " + sJeton
CASE "ApiKey"
HttpReq:Header["X-API-Key"] <- sCleApi
CASE "OAuth2"
IF NOT ObtenirJetonOAuth2() THEN RETURN False
HttpReq:Header["Authorization"] <- "Bearer " + sJeton
CASE "MFA"
HttpReq:Header["Authorization"] <- "MFA " + Base64Encode(sUtilisateur + ":" + sMotDePasse + ":" + sCodeMfa)
CASE "JWT"
HttpReq:Header["Authorization"] <- "Bearer " + sJeton
END

FOR EACH sCle OF tEntetes
HttpReq:Header[sCle] <- tEntetes[sCle]
END

FOR i = 1 TO nEssais
IF HTTPExecute(HttpReq) THEN
sReponse <- HTTPGetResult(HttpReq)
nCodeReponse <- HTTPGetStatus(HttpReq)
Journaliser("Réponse (" + i + ") : " + Left(sReponse, 100) + "...")
IF ValiderReponse() THEN
DeclencherEvenement("ApresSucces", sReponse)
RETURN True
ELSE
RETURN False
END
ELSE
Journaliser("Tentative " + i + " échouée : " + HTTPGetError(HttpReq))
IF i < nEssais THEN Delay(nIntervalleEssais * 1000)
END
END
DeclencherEvenement("ApresEchec", HTTPGetError(HttpReq))
RETURN False
END

// === Configurer le fichier de journal ===
// Paramètres :
// - sCheminFichier : Chemin du fichier de journal
PROCEDURE ConfigurerJournal(sCheminFichier is string)
sFichierJournal <- sCheminFichier
END

// === Journaliser un message ===
// Paramètres :
// - sMessage : Message à enregistrer
PROCEDURE PRIVATE Journaliser(sMessage is string)
IF bDebogage THEN
Trace(sMessage)
IF sFichierJournal <> "" THEN
FileAppend(sFichierJournal, DateTimeToString(Now()) + " - " + sMessage + CRLF)
END
END
END

// === Obtenir la réponse en JSON ===
// Retour : Objet JSON ou Null si invalide
PROCEDURE ObtenirReponseJSON() RETURNS Variant
IF sReponse <> "" THEN
RETURN JSONParse(sReponse)
ELSE
RETURN Null
END
END

// === Signature de la classe ===
// Créé par Grok 3 (xAI) - Intelligence Artificielle pour l'Innovation
// Date : 06 avril 2025
// "Explorer l'univers, une ligne de code à la fois."

Notes sur la Traduction
• Noms des variables : Les noms ont été adaptés au français (ex. : sUrlBase devient sUrlBase, mais avec des descriptions en français ; sBody devient sCorpsRequete).
• Commentaires : Tous les commentaires et descriptions ont été traduits en français, mantenant la structure et la clarté.
• Messages : Les messages dans Journaliser sont en français pour une cohérence avec un environnement francophone.
• Signature : La signature reste en français avec une légère adaptation pour refléter le style.
Cette version est prête à être utilisée dans un contexte francophone, comme le forum de PC SOFT en français. Si vous souhaitez des exemples en français ou d’autres ajustements, faites-le-moi savoir !

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#12
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 07:48
Voici cinq exemples d’utilisation de la Classe_Oop_Api_Rest_5_0 en français pour WLanguage (WINDEV), basés sur la version traduite en français. Chaque exemple met en avant différentes fonctionnalités (authentifications, GraphQL, webhooks, événements, validation, etc.) avec des commentaires en français pour une compréhension claire dans un contexte francophone.

Exemple 1 : Authentification Basic avec POST et Validation
// Scénario : Créer une ressource avec POST, authentification Basic et validation de la réponse
api is Classe_Oop_Api_Rest_5_0
api:ConfigurerRequete("https://api.exemple.com/ressources", "POST", '{"titre": "Nouvelle Ressource", "actif": true}')
api:ConfigurerAuthentification("Basic", "editeur", "motdepasse123")
api:sSchemaValidation <- '{"id": "int", "titre": "string", "actif": "boolean"}'
api:AjouterEntete("Content-Type", "application/json")
api:ConfigurerJournal("C:\journaux\creation.log")
api:bDebogage <- True

SI api:Executer() ALORS
jReponse is Variant <- api:ObtenirReponseJSON()
Info("Ressource créée : " + jReponse["titre"])
SINON
Erreur("Échec de la création ou de la validation")
FIN

Exemple 2 : Authentification Bearer avec GET, Webhook et Paramètres
// Scénario : Consulter des données avec GET, Bearer, paramètres et envoi à un webhook
api is Classe_Oop_Api_Rest_5_0
api:ConfigurerRequete("https://api.exemple.com/donnees", "GET")
api:ConfigurerAuthentification("Bearer", "jeton_securise_2025")
api:AjouterParametre("filtre", "recent")
api:AjouterParametre("limite", "10")
api:ConfigurerWebhook("https://mon-serveur.com/notifications")
api:bDebogage <- True

SI api:Executer() ALORS
jReponse is Variant <- api:ObtenirReponseJSON()
api:EnvoyerWebhook(JSONStringify({"total": jReponse["total"], "date": DateVersChaine(Maintenant())}))
Info("Données trouvées : " + jReponse["total"])
SINON
Erreur("Erreur lors de la consultation")
FIN

Exemple 3 : Authentification ApiKey avec GraphQL et Événement
// Procédure pour gérer le succès
PROCEDURE AfficherSucces(sReponse is string)
jReponse is JSON <- JSONParse(sReponse)
Info("Client : " + jReponse["data"]["client"]["nom"])
FIN

// Scénario : Requête GraphQL avec ApiKey et événement de succès
api is Classe_Oop_Api_Rest_5_0
api:ConfigurerGraphQL("https://api.exemple.com/graphql", "query { client(id: 123) { nom email } }")
api:ConfigurerAuthentification("ApiKey", "cle_api_clients")
api:ConfigurerEvenement("ApresSucces", AfficherSucces)
api:bDebogage <- True

SI api:Executer() ALORS
// Résultat affiché par l'événement
SINON
Erreur("Échec de la requête GraphQL")
FIN

Exemple 4 : Authentification OAuth2 avec PUT, Retentatives et Cache
// Scénario : Mettre à jour une ressource avec PUT, OAuth2, retentatives et cache de jeton
api is Classe_Oop_Api_Rest_5_0
api:ConfigurerRequete("https://api.exemple.com/produits/456", "PUT", '{"stock": 100}')
api:ConfigurerAuthentification("OAuth2", "id_client_456", "secret_client_456")
api:sCacheJeton <- "C:\temp\jeton_oauth2.json"
api:nEssais <- 3
api:nIntervalleEssais <- 5
api:bDebogage <- True

SI api:Executer() ALORS
jReponse is Variant <- api:ObtenirReponseJSON()
Info("Stock mis à jour : " + jReponse["stock"])
SINON
Erreur("Échec après plusieurs tentatives")
FIN

Exemple 5 : Authentification MFA avec DELETE, Asynchrone et Webhook
// Scénario : Supprimer une ressource avec DELETE, MFA, exécution asynchrone et webhook
api is Classe_Oop_Api_Rest_5_0
api:ConfigurerRequete("https://api.exemple.com/comptes/789", "DELETE")
api:ConfigurerAuthentification("MFA", "utilisateur_mfa", "motdepasse_mfa", "445566") // Code MFA
api:bAsynchrone <- True
api:ConfigurerWebhook("https://mon-serveur.com/suppressions")
api:ConfigurerJournal("C:\journaux\suppression.log")
api:bDebogage <- True

SI api:Executer() ALORS
jReponse is Variant <- api:ObtenirReponseJSON()
api:EnvoyerWebhook(JSONStringify({"compte_id": 789, "supprime_le": DateHeureVersChaine(Maintenant())}))
Info("Compte supprimé")
SINON
Erreur("Échec de la suppression asynchrone")
FIN

Conclusion
Ces exemples en français illustrent la polyvalence de la Classe_Oop_Api_Rest_5_0 dans des scénarios variés :
• Exemple 1 : Création avec POST, Basic et validation.
• Exemple 2 : Consultation avec GET, Bearer, paramètres et webhook.
• Exemple 3 : GraphQL avec ApiKey et événement.
• Exemple 4 : Mise à jour avec PUT, OAuth2 et retentatives.
• Exemple 5 : Suppression avec DELETE, MFA, asynchrone et webhook.
Ils sont adaptés pour un public francophone, comme les utilisateurs du forum PC SOFT, et montrent comment exploiter pleinement la classe. Si vous voulez d’autres exemples ou ajustements, dites-le-moi !

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#13
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 07:53
Voici la version 5.0 de la Classe_Oop_Api_Rest_5_0 réécrite en espagnol pour WLanguage (WINDEV), avec des commentaires et une documentation adaptés à la langue espagnole. Le code reste fonctionnellement identique, mais les noms des variables, les commentaires et les messages sont traduits en espagnol pour une meilleure lisibilité dans un contexte hispanophone.

Classe_Oop_Api_Rest_5_0 - Código en Español para WINDEV
// Classe_Oop_Api_Rest_5_0
// Descripción: Clase avanzada para la integración con APIs REST y GraphQL en WLanguage.
// Soporta múltiples tipos de autenticación, webhooks, eventos, validación de respuestas y registros.
// Versión: 5.0
// Fecha: 06 de abril de 2025
Classe_Oop_Api_Rest_5_0 is Class
// === Propiedades básicas ===
sUrlBase is string // URL base de la API (ej.: "https://api.ejemplo.com")
sMetodo is string // Método HTTP (ej.: "GET", "POST", "PUT", "DELETE", "PATCH")
sCuerpoSolicitud is string // Cuerpo de la solicitud en formato texto (ej.: JSON, XML)
sRespuesta is string // Respuesta devuelta por la API
nCodigoRespuesta is int // Código de estado HTTP (ej.: 200, 404, 500)
bDepuracion is boolean <- False // Activa registros detallados en Trace y/o archivo
bAsincrono is boolean <- False // Define si la solicitud será asíncrona

// === Propiedades de autenticación ===
sTipoAutenticacion is string // Tipo de autenticación: "Ninguna", "Basic", "Bearer", "ApiKey", "OAuth2", "MFA", "JWT"
sUsuario is string // Usuario para autenticación Basic o MFA
sContrasena is string // Contraseña para autenticación Basic o MFA
sClaveApi is string // Clave API para autenticación ApiKey
sToken is string // Token para autenticación Bearer, OAuth2 o JWT
sTokenRefresco is string // Token de refresco para OAuth2
sIdCliente is string // ID del cliente para OAuth2
sSecretoCliente is string // Secreto del cliente para OAuth2
sCodigoMfa is string // Código multifactor para autenticación MFA
sSecretoJwt is string // Clave secreta para generación de JWT
dtExpiracionToken is datetime // Fecha/hora de expiración del token OAuth2

// === Propiedades avanzadas ===
tCabeceras is Table of string // Tabla de cabeceras personalizadas (ej.: "Content-Type" -> "application/json")
tParametros is Table of string // Tabla de parámetros de cadena de consulta (ej.: "q" -> "búsqueda")
nTiempoEspera is int <- 30 // Tiempo límite de la solicitud en segundos
sCacheToken is string // Ruta del archivo para caché de tokens OAuth2
nIntentos is int <- 3 // Número máximo de intentos en caso de fallo
nIntervaloIntentos is int <- 5 // Intervalo entre intentos en segundos

// === Funcionalidades adicionales ===
sUrlWebhook is string // URL para envío de webhooks (ej.: "https://mi-servidor.com/webhook")
sArchivoRegistro is string // Ruta del archivo de registro (ej.: "C:\registros\api.log")
sEsquemaValidacion is string // Esquema JSON para validación de la respuesta (ej.: '{"id": "int", "nombre": "string"}')
bGraphQL is boolean <- False // Activa modo GraphQL en lugar de REST
sConsultaGraphQL is string // Consulta GraphQL a enviar (ej.: "query { user(id: 1) { name } }")
tEventos is Table of Procedure // Tabla de eventos personalizados (ej.: "DespuesExito" -> MiProcedimiento)

END

// === Configuración de una solicitud REST ===
// Parámetros:
// - sUrl: URL de la API
// - sMetodoHttp: Método HTTP
// - sCuerpo: Cuerpo de la solicitud (opcional)
PROCEDURE ConfigurarSolicitud(sUrl is string, sMetodoHttp is string, sCuerpo is string = "")
sUrlBase <- sUrl
sMetodo <- sMetodoHttp
sCuerpoSolicitud <- sCuerpo
nCodigoRespuesta <- 0
sRespuesta <- ""
bGraphQL <- False
Registrar("Solicitud REST configurada: " + sUrl + " (" + sMetodoHttp + ")")
END

// === Configuración de una solicitud GraphQL ===
// Parámetros:
// - sUrl: URL de la API GraphQL
// - sConsulta: Consulta GraphQL a ejecutar
PROCEDURE ConfigurarGraphQL(sUrl is string, sConsulta is string)
sUrlBase <- sUrl
sMetodo <- "POST"
sConsultaGraphQL <- sConsulta
sCuerpoSolicitud <- JSONStringify({"query": sConsulta})
bGraphQL <- True
Registrar("Solicitud GraphQL configurada: " + sUrl)
END

// === Añadir una cabecera personalizada ===
// Parámetros:
// - sClave: Nombre de la cabecera
// - sValor: Valor de la cabecera
PROCEDURE AnadirCabecera(sClave is string, sValor is string)
tCabeceras[sClave] <- sValor
END

// === Añadir un parámetro de cadena de consulta ===
// Parámetros:
// - sClave: Nombre del parámetro
// - sValor: Valor del parámetro
PROCEDURE AnadirParametro(sClave is string, sValor is string)
tParametros[sClave] <- sValor
END

// === Configurar autenticación ===
// Parámetros:
// - sTipo: Tipo de autenticación
// - sParam1, sParam2, sParam3: Parámetros específicos del tipo
PROCEDURE ConfigurarAutenticacion(sTipo is string, sParam1 is string = "", sParam2 is string = "", sParam3 is string = "")
sTipoAutenticacion <- sTipo
SWITCH sTipo
CASE "Basic"
sUsuario <- sParam1
sContrasena <- sParam2
CASE "Bearer"
sToken <- sParam1
CASE "ApiKey"
sClaveApi <- sParam1
CASE "OAuth2"
sIdCliente <- sParam1
sSecretoCliente <- sParam2
sToken <- ""
CASE "MFA"
sUsuario <- sParam1
sContrasena <- sParam2
sCodigoMfa <- sParam3
CASE "JWT"
sSecretoJwt <- sParam1
sToken <- GenerarJWT(sParam1)
OTHER CASE
sTipoAutenticacion <- "Ninguna"
END
Registrar("Autenticación configurada: " + sTipo)
END

// === Generar un token JWT ===
// Parámetros:
// - sSecreto: Clave secreta para la firma
// Retorno: Token JWT generado
PROCEDURE PRIVATE GenerarJWT(sSecreto is string) RETURNS string
sCabecera is string <- Base64Encode('{"alg":"HS256","typ":"JWT"}')
sCargaUtil is string <- Base64Encode('{"sub":"user","iat":' + String(DateTimeToEpoch(Now())) + ',"exp":' + String(DateTimeToEpoch(Now() + 3600000)) + '}')
sFirma is string <- HMAC(sCabecera + "." + sCargaUtil, sSecreto, haSHA256)
RETURN sCabecera + "." + sCargaUtil + "." + sFirma
END

// === Obtener un token OAuth2 ===
// Retorno: True si el token se obtuvo con éxito
PROCEDURE PRIVATE ObtenerTokenOAuth2() RETURNS boolean
IF sToken <> "" AND dtExpiracionToken > Now() THEN RETURN True
sUrlToken is string <- sUrlBase + "/token"
sCuerpoToken is string <- "grant_type=client_credentials&client_id=" + sIdCliente + "&client_secret=" + sSecretoCliente
HttpReq is HTTPRequest
HttpReq:URL <- sUrlToken
HttpReq:Method <- "POST"
HttpReq:Body <- sCuerpoToken
HttpReq:Timeout <- nTiempoEspera
IF HTTPExecute(HttpReq) THEN
sRespuestaToken is string <- HTTPGetResult(HttpReq)
jToken is JSON <- JSONParse(sRespuestaToken)
sToken <- jToken["access_token"]
sTokenRefresco <- jToken["refresh_token"]
dtExpiracionToken <- Now() + (jToken["expires_in"] * 1000)
Registrar("Token OAuth2 obtenido")
IF sCacheToken <> "" THEN FileWrite(sCacheToken, sRespuestaToken)
RETURN True
ELSE
Registrar("Error al obtener el token OAuth2: " + HTTPGetError(HttpReq))
RETURN False
END
END

// === Configurar un webhook ===
// Parámetros:
// - sUrlWebhook: URL para el envío de webhooks
PROCEDURE ConfigurarWebhook(sUrlWebhook is string)
sUrlWebhook <- sUrlWebhook
Registrar("Webhook configurado: " + sUrlWebhook)
END

// === Enviar datos al webhook ===
// Parámetros:
// - sDatos: Datos a enviar
// Retorno: True si se envió con éxito
PROCEDURE EnviarWebhook(sDatos is string) RETURNS boolean
IF sUrlWebhook = "" THEN RETURN False
HttpReq is HTTPRequest
HttpReq:URL <- sUrlWebhook
HttpReq:Method <- "POST"
HttpReq:Body <- sDatos
HttpReq:Timeout <- nTiempoEspera
IF HTTPExecute(HttpReq) THEN
Registrar("Webhook enviado: " + sDatos)
RETURN True
ELSE
Registrar("Error al enviar el webhook: " + HTTPGetError(HttpReq))
RETURN False
END
END

// === Configurar un evento personalizado ===
// Parámetros:
// - sNombreEvento: Nombre del evento (ej.: "DespuesExito")
// - pCallback: Procedimiento a llamar
PROCEDURE ConfigurarEvento(sNombreEvento is string, pCallback is Procedure)
tEventos[sNombreEvento] <- pCallback
Registrar("Evento configurado: " + sNombreEvento)
END

// === Disparar un evento ===
// Parámetros:
// - sNombreEvento: Nombre del evento
// - vParametro: Parámetro opcional a pasar al callback
PROCEDURE PRIVATE DispararEvento(sNombreEvento is string, vParametro is Variant = Null)
IF tEventos.HasProperty(sNombreEvento) THEN
tEventos[sNombreEvento](vParametro)
END
END

// === Validar la respuesta según un esquema ===
// Retorno: True si la respuesta es válida
PROCEDURE ValidarRespuesta() RETURNS boolean
IF sEsquemaValidacion = "" OR sRespuesta = "" THEN RETURN True
jEsquema is JSON <- JSONParse(sEsquemaValidacion)
jRespuesta is JSON <- JSONParse(sRespuesta)
FOR EACH sClave OF jEsquema
IF NOT jRespuesta.HasProperty(sClave) THEN
Registrar("Validación fallida: clave '" + sClave + "' ausente")
RETURN False
END
END
Registrar("Respuesta validada con éxito")
RETURN True
END

// === Ejecutar la solicitud ===
// Retorno: True si la solicitud tuvo éxito
PROCEDURE Ejecutar() RETURNS boolean
DispararEvento("AntesSolicitud")
sUrlFinal is string <- sUrlBase
IF tParametros.Count > 0 AND NOT bGraphQL THEN
sUrlFinal <- sUrlFinal + "?" + HTTPBuildQuery(tParametros)
END

HttpReq is HTTPRequest
HttpReq:URL <- sUrlFinal
HttpReq:Method <- sMetodo
HttpReq:Timeout <- nTiempoEspera
HttpReq:Body <- sCuerpoSolicitud
IF bAsincrono THEN HttpReq:Async <- True
IF bGraphQL THEN HttpReq:Header["Content-Type"] <- "application/json"

SWITCH sTipoAutenticacion
CASE "Basic"
HttpReq:Header["Authorization"] <- "Basic " + Base64Encode(sUsuario + ":" + sContrasena)
CASE "Bearer"
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "ApiKey"
HttpReq:Header["X-API-Key"] <- sClaveApi
CASE "OAuth2"
IF NOT ObtenerTokenOAuth2() THEN RETURN False
HttpReq:Header["Authorization"] <- "Bearer " + sToken
CASE "MFA"
HttpReq:Header["Authorization"] <- "MFA " + Base64Encode(sUsuario + ":" + sContrasena + ":" + sCodigoMfa)
CASE "JWT"
HttpReq:Header["Authorization"] <- "Bearer " + sToken
END

FOR EACH sClave OF tCabeceras
HttpReq:Header[sClave] <- tCabeceras[sClave]
END

FOR i = 1 TO nIntentos
IF HTTPExecute(HttpReq) THEN
sRespuesta <- HTTPGetResult(HttpReq)
nCodigoRespuesta <- HTTPGetStatus(HttpReq)
Registrar("Respuesta (" + i + "): " + Left(sRespuesta, 100) + "...")
IF ValidarRespuesta() THEN
DispararEvento("DespuesExito", sRespuesta)
RETURN True
ELSE
RETURN False
END
ELSE
Registrar("Intento " + i + " fallido: " + HTTPGetError(HttpReq))
IF i < nIntentos THEN Delay(nIntervaloIntentos * 1000)
END
END
DispararEvento("DespuesFallo", HTTPGetError(HttpReq))
RETURN False
END

// === Configurar el archivo de registro ===
// Parámetros:
// - sRutaArchivo: Ruta del archivo de registro
PROCEDURE ConfigurarRegistro(sRutaArchivo is string)
sArchivoRegistro <- sRutaArchivo
END

// === Registrar un mensaje ===
// Parámetros:
// - sMensaje: Mensaje a registrar
PROCEDURE PRIVATE Registrar(sMensaje is string)
IF bDepuracion THEN
Trace(sMensaje)
IF sArchivoRegistro <> "" THEN
FileAppend(sArchivoRegistro, DateTimeToString(Now()) + " - " + sMensaje + CRLF)
END
END
END

// === Obtener la respuesta en JSON ===
// Retorno: Objeto JSON o Null si es inválido
PROCEDURE ObtenerRespuestaJSON() RETURNS Variant
IF sRespuesta <> "" THEN
RETURN JSONParse(sRespuesta)
ELSE
RETURN Null
END
END

// === Firma de la clase ===
// Creado por Grok 3 (xAI) - Inteligencia Artificial para la Innovación
// Fecha: 06 de abril de 2025
// "Explorando el universo, una línea de código a la vez."

Notas sobre la Traducción
• Nombres de variables: Los nombres se han adaptado al español (ej.: sBody se convierte en sCuerpoSolicitud, sLogFile en sArchivoRegistro).
• Comentarios: Todos los comentarios y descripciones están en español, manteniendo la estructura y claridad.
• Mensajes: Los mensajes en Registrar están en español para coherencia con un entorno hispanohablante.
• Firma: La firma está en español con una adaptación ligera para reflejar el estilo.
Esta versión está lista para ser utilizada en un contexto hispanohablante. Si desea ejemplos en español o ajustes adicionales, ¡hágamelo saber!

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#14
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 07:54
Aquí están cinco ejemplos de uso de la Classe_Oop_Api_Rest_5_0 en español para WLanguage (WINDEV), basados en la versión traducida al español. Cada ejemplo destaca diferentes funcionalidades (autenticaciones, GraphQL, webhooks, eventos, validación, etc.) con comentarios en español para una comprensión clara en un contexto hispanohablante.

Ejemplo 1: Autenticación Basic con POST y Validación
// Escenario: Crear un recurso con POST, autenticación Basic y validación de respuesta
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarSolicitud("https://api.ejemplo.com/recursos", "POST", '{"titulo": "Nuevo Recurso", "activo": true}')
api:ConfigurarAutenticacion("Basic", "editor", "contrasena123")
api:sEsquemaValidacion <- '{"id": "int", "titulo": "string", "activo": "boolean"}'
api:AnadirCabecera("Content-Type", "application/json")
api:ConfigurarRegistro("C:\registros\creacion.log")
api:bDepuracion <- True

SI api:Ejecutar() ENTONCES
jRespuesta is Variant <- api:ObtenerRespuestaJSON()
Info("Recurso creado: " + jRespuesta["titulo"])
SINO
Error("Fallo en la creación o validación")
FIN

Ejemplo 2: Autenticación Bearer con GET, Webhook y Parámetros
// Escenario: Consultar datos con GET, Bearer, parámetros y enviar a un webhook
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarSolicitud("https://api.ejemplo.com/datos", "GET")
api:ConfigurarAutenticacion("Bearer", "token_seguro_2025")
api:AnadirParametro("filtro", "reciente")
api:AnadirParametro("limite", "10")
api:ConfigurarWebhook("https://mi-servidor.com/notificaciones")
api:bDepuracion <- True

SI api:Ejecutar() ENTONCES
jRespuesta is Variant <- api:ObtenerRespuestaJSON()
api:EnviarWebhook(JSONStringify({"total": jRespuesta["total"], "fecha": FechaAString(Ahora())}))
Info("Datos encontrados: " + jRespuesta["total"])
SINO
Error("Error al consultar")
FIN

Ejemplo 3: Autenticación ApiKey con GraphQL y Evento
// Procedimiento para manejar el éxito
PROCEDURE MostrarExito(sRespuesta is string)
jRespuesta is JSON <- JSONParse(sRespuesta)
Info("Cliente: " + jRespuesta["data"]["cliente"]["nombre"])
FIN

// Escenario: Consulta GraphQL con ApiKey y evento de éxito
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarGraphQL("https://api.ejemplo.com/graphql", "query { cliente(id: 123) { nombre email } }")
api:ConfigurarAutenticacion("ApiKey", "clave_api_clientes")
api:ConfigurarEvento("DespuesExito", MostrarExito)
api:bDepuracion <- True

SI api:Ejecutar() ENTONCES
// Resultado mostrado por el evento
SINO
Error("Fallo en la consulta GraphQL")
FIN

Ejemplo 4: Autenticación OAuth2 con PUT, Intentos y Caché
// Escenario: Actualizar un recurso con PUT, OAuth2, intentos y caché de token
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarSolicitud("https://api.ejemplo.com/productos/456", "PUT", '{"stock": 100}')
api:ConfigurarAutenticacion("OAuth2", "id_cliente_456", "secreto_cliente_456")
api:sCacheToken <- "C:\temp\token_oauth2.json"
api:nIntentos <- 3
api:nIntervaloIntentos <- 5
api:bDepuracion <- True

SI api:Ejecutar() ENTONCES
jRespuesta is Variant <- api:ObtenerRespuestaJSON()
Info("Stock actualizado: " + jRespuesta["stock"])
SINO
Error("Fallo tras varios intentos")
FIN

Ejemplo 5: Autenticación MFA con DELETE, Asíncrono y Webhook
// Escenario: Eliminar un recurso con DELETE, MFA, ejecución asíncrona y webhook
api is Classe_Oop_Api_Rest_5_0
api:ConfigurarSolicitud("https://api.ejemplo.com/cuentas/789", "DELETE")
api:ConfigurarAutenticacion("MFA", "usuario_mfa", "contrasena_mfa", "445566") // Código MFA
api:bAsincrono <- True
api:ConfigurarWebhook("https://mi-servidor.com/eliminaciones")
api:ConfigurarRegistro("C:\registros\eliminacion.log")
api:bDepuracion <- True

SI api:Ejecutar() ENTONCES
jRespuesta is Variant <- api:ObtenerRespuestaJSON()
api:EnviarWebhook(JSONStringify({"cuenta_id": 789, "eliminada_el": FechaHoraAString(Ahora())}))
Info("Cuenta eliminada")
SINO
Error("Fallo en la eliminación asíncrona")
FIN

Conclusión
Estos ejemplos en español muestran la versatilidad de la Classe_Oop_Api_Rest_5_0 en distintos escenarios:
• Ejemplo 1: Creación con POST, Basic y validación.
• Ejemplo 2: Consulta con GET, Bearer, parámetros y webhook.
• Ejemplo 3: GraphQL con ApiKey y evento.
• Ejemplo 4: Actualización con PUT, OAuth2 y reintentos.
• Ejemplo 5: Eliminación con DELETE, MFA, asíncrono y webhook.
Están adaptados para un público hispanohablante y son ideales para compartir en un entorno como el foro de PC SOFT en español. Si desea más ejemplos o ajustes, ¡avíseme!

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
#15
Membre enregistré
4 520 messages
Posté le 04 avril 2025 - 13:30
*Resumo dos Recursos da Classe_Oop_Api_Rest_5_0 (em Português)*

A Classe acima é uma biblioteca robusta e versátil para integração com APIs REST e GraphQL em WLanguage, projetada para ser performática, segura e inovadora. Desenvolvida para as plataformas WX (Windev, Webdev e Windev Mobile), ela oferece uma ampla gama de funcionalidades para desenvolvedores que buscam eficiência e modernidade.

Aqui estão os principais recursos:

1 Integração com APIs REST e GraphQL
◦ Suporte a métodos HTTP (GET, POST, PUT, DELETE, PATCH) para APIs REST com o método ConfigurarRequisicao.
◦ Suporte a consultas GraphQL via ConfigurarGraphQL, permitindo enviar queries complexas como query { user(id: 1) { name email } }.

2 Múltiplos Tipos de Autenticação
◦ Suporta diversos métodos de autenticação para garantir segurança:
▪ Basic: Autenticação com usuário e senha (codificação Base64).
▪ Bearer: Uso de tokens para APIs protegidas.
▪ ApiKey: Autenticação via chave de API.
▪ OAuth2: Gerenciamento de tokens com renovação automática e cache em disco.
▪ MFA (Multifator): Autenticação multifator com código adicional.
▪ JWT: Geração e uso de JSON Web Tokens para autenticação segura.

3 Webhooks para Notificações
◦ Permite configurar e enviar notificações para URLs externas com ConfigurarWebhook e EnviarWebhook, ideal para integrações em tempo real (ex.: notificar um servidor após uma requisição bem-sucedida).

4 Eventos Personalizados
◦ Suporte a eventos como “AntesRequisicao”, “AposSucesso” e “AposFalha” com ConfigurarEvento e DispararEvento, permitindo executar callbacks personalizados em momentos específicos do fluxo da requisição.

5 Validação de Respostas
◦ Valida respostas de APIs contra esquemas JSON predefinidos com ValidarRespuesta, garantindo que os dados recebidos estejam no formato esperado (ex.: {"id": "int", "nome": "string"}).

6 Assincronia e Retentativas
◦ Suporte a chamadas assíncronas com a propriedade bAsincrono, evitando bloqueios na thread principal.
◦ Retentativas automáticas em caso de falha com nIntentos e nIntervaloIntentos, ideal para lidar com conexões instáveis.

7 Logs Detalhados
◦ Geração de logs detalhados com ConfigurarRegistro e Registrar, que podem ser salvos em arquivo ou exibidos via Trace, facilitando a depuração (ex.: Registrar("Resposta: " + sRespuesta)).

8 Cabeçalhos e Parâmetros Personalizados
◦ Adição de cabeçalhos personalizados com AnadirCabecera (ex.: AnadirCabecera("Accept", "application/json")).
◦ Suporte a parâmetros de query string com AnadirParametro (ex.: AnadirParametro("q", "windev")).

9 Segurança e Performance
◦ Gerenciamento de tokens OAuth2 com renovação automática e cache em disco (sCacheToken).
◦ Uso de práticas seguras como codificação Base64 para autenticação e validação de respostas para evitar erros de formato.

10 Flexibilidade e Modularidade
◦ Código organizado e modular, com suporte a OOP (herança e polimorfismo), permitindo fácil manutenção e extensão.
◦ Compatibilidade total com Windev, Webdev e Windev Mobile.

Exemplo de Programação em Inglês
Agora, vou apresentar um exemplo em inglês, usando a classe para fazer uma requisição REST com autenticação JWT, validação de resposta e envio de um webhook. O código seguirá as boas práticas da WLanguage e será comentado em inglês para um público internacional.
*//##############################*
// Example: Making a REST request with JWT authentication, response validation, and webhook notification
api is Classe_Oop_Api_Rest_5_0
// Configure the REST request to fetch user data
api:ConfigurarSolicitud("https://api.example.com/users", "GET")
// Set JWT authentication with a secret key
api:ConfigurarAutenticacion("JWT", "my_jwt_secret")
// Add a custom header for the request
api:AnadirCabecera("Accept", "application/json")
// Define a JSON schema to validate the response
api:sEsquemaValidacion <- '{"id": "int", "name": "string"}'
// Configure a webhook to notify an external server
api:ConfigurarWebhook("https://my-server.com/notify")
// Enable debug mode to log the process
api:bDepuracion <- True
api:ConfigurarRegistro("C:\logs\api_request.log")

// Execute the request
IF api:Ejecutar() THEN
// Parse the response as JSON
jResponse is Variant <- api:ObtenerRespuestaJSON()
// Send the response to the webhook
api:EnviarWebhook(JSONStringify(jResponse))
// Display the user name
Info("User name: " + jResponse["name"])
ELSE
// Display an error message if the request fails
Error("Failed to fetch user data")
END
*//##############################*

Explicação do Exemplo (em Português)
• Configuração da Requisição: Usamos ConfigurarSolicitud para definir uma requisição GET para buscar dados de usuários.
• Autenticação JWT: Configuramos a autenticação JWT com ConfigurarAutenticacion, gerando um token automaticamente.
• Cabeçalho Personalizado: Adicionamos o cabeçalho “Accept” para garantir que a resposta seja em JSON.
• Validação: Definimos um esquema JSON para validar a resposta, garantindo que ela contenha um id (inteiro) e um name (string).
• Webhook: Configuramos um webhook para enviar a resposta a um servidor externo.
• Logs: Ativamos a depuração e salvamos os logs em um arquivo para facilitar a análise.
• Execução: Executamos a requisição e, se bem-sucedida, enviamos a resposta ao webhook e exibimos o nome do usuário.

Benefícios para Desenvolvedores WX
• Produtividade: Métodos prontos para integração de APIs reduzem o tempo de desenvolvimento.
• Segurança: Autenticações robustas e validação de dados protegem suas aplicações.
• Inovação: Suporte a GraphQL e webhooks permite integrações modernas e em tempo real.
• Depuração: Logs detalhados e retentativas automáticas facilitam a resolução de problemas.

--
Adriano José Boller
______________________________________________
Consultor e Representante Oficial da
PcSoft no Brasil
+55 (41) 99949 1800
adrianoboller@gmail.com
skype: adrianoboller
http://wxinformatica.com.br/
→ Revenir à WINDEV 25