EFC/EFC-DESK-V2
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

first commit

Browse Source
This commit is contained in:
Luis Andrade
2026-02-09 10:55:45 -07:00
commit 7cca957e1a
77 changed files with 44415 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

466
Classes/ApiClient.cs Normal file
View File

@@ -0,0 +1,466 @@
using EFCDesk.Entidades;
using System;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Text.Json;
using System.Threading;
using System.Threading.Tasks;
namespace EFCDesk.Classes
{
public class ApiException : Exception
{
public int StatusCode { get; }
public ApiException(string message, int statusCode) : base(message)
{
StatusCode = statusCode;
}
}
public class ApiClient : IDisposable
{
private readonly HttpClient _httpClient;
private readonly int _maxRetries;
private readonly TimeSpan _retryDelay;
private string? _currentToken;
private string? _currentRefreshToken;
private readonly object _tokenLock = new object();
public ApiClient(TimeSpan? timeout = null, int maxRetries = 3, TimeSpan? retryDelay = null)
{
_httpClient = new HttpClient();
if (timeout.HasValue)
_httpClient.Timeout = timeout.Value;
else
_httpClient.Timeout = TimeSpan.FromSeconds(30);
_maxRetries = maxRetries >= 0 ? maxRetries : 3;
_retryDelay = retryDelay ?? TimeSpan.FromSeconds(2);
}
//private void SetAuthorization(string token)
//{
// if (string.IsNullOrWhiteSpace(token))
// throw new ArgumentException("El token no puede estar vacío.", nameof(token));
// _httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Token", token);
//}
public string EndpointLoginToken()
{
return @"/api/v1/token/";
}
public string EndpointRefreshToken()
{
return @"/api/v1/token/refresh/";
}
private void SetAuthorizationBearer(string token, string refresh_token)
{
if (string.IsNullOrWhiteSpace(token))
throw new ArgumentException("El token no puede estar vacío.", nameof(token));
if (string.IsNullOrWhiteSpace(refresh_token))
throw new ArgumentException("El refresh token no puede estar vacío.", nameof(refresh_token));
lock (_tokenLock)
{
_currentToken = token;
_currentRefreshToken = refresh_token;
_httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", token);
}
}
private async Task<bool> TryRefreshTokenAsync()
{
try
{
Globales.configJson = ConfiguracionJSON.LoadFromJson();
// Obtener el refresh token actual guardado
string? savedToken = Globales.refresToken;
if (string.IsNullOrEmpty(savedToken))
return false;
// Usar el endpoint de refresh token
string dominio = Globales.configJson.DominioExp ?? "";
if (string.IsNullOrEmpty(dominio))
return false;
string refreshUrl = dominio + EndpointRefreshToken();
// Crear solicitud de refresh con el token actual
var refreshData = new { refresh = savedToken };
var jsonContent = JsonSerializer.Serialize(refreshData);
using var content = new StringContent(jsonContent, System.Text.Encoding.UTF8, "application/json");
// Limpiar headers para esta solicitud
_httpClient.DefaultRequestHeaders.Authorization = null;
var response = await _httpClient.PostAsync(refreshUrl, content);
if (response.IsSuccessStatusCode)
{
string responseContent = await response.Content.ReadAsStringAsync();
if (IsJson(responseContent) && HasJsonData(responseContent))
{
using var doc = JsonDocument.Parse(responseContent);
var root = doc.RootElement;
// Buscar nuevo token en la respuesta (ajustar según tu API)
string newToken = "";
if (root.TryGetProperty("access", out var accessProp))
{
newToken = accessProp.GetString() ?? "";
}
else if (root.TryGetProperty("token", out var tokenProp))
{
newToken = tokenProp.GetString() ?? "";
}
// Buscar nuevo refresh token en la respuesta (ajustar según tu API)
string newRefreshToken = "";
if (root.TryGetProperty("refresh", out var refreshProp))
{
newRefreshToken = refreshProp.GetString() ?? "";
}
else if (root.TryGetProperty("refresh_token", out var refreshtokenProp))
{
newRefreshToken = refreshtokenProp.GetString() ?? "";
}
if (!string.IsNullOrEmpty(newToken) && !string.IsNullOrEmpty(newRefreshToken))
{
// Guardar nuevo token
Globales.accesToken = newToken;
// Guardar nuevo refresh token
Globales.refresToken = newRefreshToken;
// Actualizar headers
SetAuthorizationBearer(newToken, newRefreshToken);
return true;
}
}
}
return false;
}
catch (Exception ex)
{
Globales.logger.LogError("Error al intentar refresh token", ex);
return false;
}
finally
{
// Restaurar el token actual si el refresh falló
if (!string.IsNullOrEmpty(_currentToken) && !string.IsNullOrEmpty(_currentRefreshToken))
{
SetAuthorizationBearer(_currentToken, _currentRefreshToken);
}
}
}
private async Task EnsureTokenAsync()
{
// Si ya tenemos token en memoria, usarlo
if (!string.IsNullOrEmpty(_currentToken) && !string.IsNullOrEmpty(_currentRefreshToken))
{
SetAuthorizationBearer(_currentToken, _currentRefreshToken);
return;
}
// Intentar obtener token guardado
string? savedToken = Globales.accesToken;
string? savedRefreshToken = Globales.refresToken;
if (!string.IsNullOrEmpty(savedToken) && !string.IsNullOrEmpty(savedRefreshToken))
{
SetAuthorizationBearer(savedToken, savedRefreshToken);
return;
}
throw new InvalidOperationException("No hay token disponible. Inicie sesión primero.");
}
private async Task<string> SendWithRetriesAsync(Func<Task<HttpResponseMessage>> sendFunc, bool requireAuth = true)
{
int attempts = 0;
while (true)
{
attempts++;
try
{
// Asegurar que tenemos token antes de enviar (solo si requiere auth)
if (requireAuth)
await EnsureTokenAsync();
var response = await sendFunc();
if (!response.IsSuccessStatusCode)
{
// Si es 401 Unauthorized y requiere auth, intentar refresh token
if (response.StatusCode == System.Net.HttpStatusCode.Unauthorized && requireAuth)
{
bool refreshed = await TryRefreshTokenAsync();
if (refreshed)
{
// Reintentar con nuevo token
response = await sendFunc();
if (response.IsSuccessStatusCode)
return await response.Content.ReadAsStringAsync();
}
}
string errorContent = await response.Content.ReadAsStringAsync();
// throw new ApiException($"Error {response.StatusCode}: {errorContent}", (int)response.StatusCode);
return errorContent;
}
return await response.Content.ReadAsStringAsync();
}
catch (TaskCanceledException) when (attempts <= _maxRetries)
{
// Timeout: reintentar
await Task.Delay(_retryDelay);
}
catch (HttpRequestException) when (attempts <= _maxRetries)
{
// Error red: reintentar
await Task.Delay(_retryDelay);
}
catch (TaskCanceledException)
{
return CrearJsonError(408, "Tiempo de espera agotado");
}
catch (HttpRequestException ex)
{
return CrearJsonError(503, $"Error de red: {ex.Message}");
}
catch (Exception ex)
{
return CrearJsonError(500, $"Error inesperado: {ex.Message}");
}
}
}
public async Task<string> GetAsync(string url)
{
return await SendWithRetriesAsync(() => _httpClient.GetAsync(url));
}
public async Task<string> PostJsonAsync(string url, string jsonContent)
{
using var content = new StringContent(jsonContent, System.Text.Encoding.UTF8, "application/json");
return await SendWithRetriesAsync(() => _httpClient.PostAsync(url, content));
}
public async Task<string> PutJsonAsync(string url, string jsonContent)
{
using var content = new StringContent(jsonContent, System.Text.Encoding.UTF8, "application/json");
return await SendWithRetriesAsync(() => _httpClient.PutAsync(url, content));
}
public async Task<string> DeleteAsync(string url)
{
return await SendWithRetriesAsync(() => _httpClient.DeleteAsync(url));
}
// Método para enviar archivo y JSON juntos en multipart/form-data
public async Task<string> PostMultipartAsync(string url, string filePath, object jsonData, string fileFieldName = "archivo", string jsonFieldName = "data")
{
if (string.IsNullOrWhiteSpace(filePath) || !File.Exists(filePath))
throw new ArgumentException("El archivo no existe o la ruta es inválida.", nameof(filePath));
using var form = new MultipartFormDataContent();
// Archivo
var fileStream = File.OpenRead(filePath);
var fileContent = new StreamContent(fileStream);
form.Add(fileContent, fileFieldName, Path.GetFileName(filePath));
// JSON
var jsonString = JsonSerializer.Serialize(jsonData);
var jsonContent = new StringContent(jsonString, System.Text.Encoding.UTF8, "application/json");
form.Add(jsonContent, jsonFieldName);
return await SendWithRetriesAsync(() => _httpClient.PostAsync(url, form));
}
public async Task<string> PostMultipartAsync(string url, string filePath, string organizacion, string pedimento,
string documentType,
string fuente,
string fileFieldName = "archivo"
)
{
if (string.IsNullOrWhiteSpace(filePath) || !File.Exists(filePath))
throw new ArgumentException("El archivo no existe o la ruta es inválida.", nameof(filePath));
using var form = new MultipartFormDataContent();
// Archivo
var fileStream = File.OpenRead(filePath);
var fileContent = new StreamContent(fileStream);
fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
form.Add(fileContent, fileFieldName, Path.GetFileName(filePath));
// Campos de texto
form.Add(new StringContent(organizacion), "organizacion");
form.Add(new StringContent(pedimento), "pedimento");
form.Add(new StringContent(documentType), "document_type");
form.Add(new StringContent(fuente), "fuente");
return await SendWithRetriesAsync(() => _httpClient.PostAsync(url, form));
}
//public async Task<string> PostMultipartZipAsync(string url, string token, byte[] zipBytes, string zipFileName, string fileFieldName = "archivos")
//{
// if (zipBytes == null || zipBytes.Length == 0)
// throw new ArgumentException("El ZIP está vacío o no es válido.", nameof(zipBytes));
// SetAuthorization(token);
// using var form = new MultipartFormDataContent();
// // Convertimos el byte[] a contenido del archivo
// var fileContent = new ByteArrayContent(zipBytes);
// fileContent.Headers.ContentType = MediaTypeHeaderValue.Parse("application/zip");
// // Nombre del archivo en el multipart
// form.Add(fileContent, fileFieldName, zipFileName);
// // Campos de texto
// //form.Add(new StringContent(pedimento), "pedimento");
// return await SendWithRetriesAsync(() => _httpClient.PostAsync(url, form));
//}
public async Task<string> PostMultipartZipAsync(string url, string filePath, string zipFileName, Dictionary<string, string> metadatos, string fileFieldName = "archivos")
{
if (string.IsNullOrWhiteSpace(filePath) || !File.Exists(filePath))
throw new ArgumentException("El archivo no existe o la ruta es inválida.", nameof(filePath));
using var form = new MultipartFormDataContent();
// Archivo
var fileStream = File.OpenRead(filePath);
var fileContent = new StreamContent(fileStream);
fileContent.Headers.ContentType = new MediaTypeHeaderValue("application/octet-stream");
form.Add(fileContent, fileFieldName, Path.GetFileName(filePath));
if (metadatos != null)
{
foreach (var kvp in metadatos)
{
form.Add(new StringContent(kvp.Value), kvp.Key);
}
}
// Campos de texto
//form.Add(new StringContent(organizacion), "organizacion");
//form.Add(new StringContent(pedimento), "pedimento");
//form.Add(new StringContent(documentType), "document_type");
//form.Add(new StringContent(fuente), "fuente");
return await SendWithRetriesAsync(() => _httpClient.PostAsync(url, form));
}
// Método existente que acepta string JSON
public async Task<string> PostJsonWithoutAuthAsync(string url, string jsonContent)
{
using var content = new StringContent(jsonContent, System.Text.Encoding.UTF8, "application/json");
return await SendWithRetriesAsync(() => _httpClient.PostAsync(url, content), requireAuth: false);
}
// Nueva sobrecarga que acepta cualquier objeto
public async Task<string> PostJsonWithoutAuthAsync(string url, object data)
{
var jsonContent = JsonSerializer.Serialize(data);
return await PostJsonWithoutAuthAsync(url, jsonContent);
}
public bool IsJson(string response)
{
if (string.IsNullOrWhiteSpace(response)) return false;
try
{
using var doc = JsonDocument.Parse(response);
return true;
}
catch (JsonException)
{
return false;
}
}
public bool HasJsonData(string response)
{
if (string.IsNullOrWhiteSpace(response)) return false;
try
{
using var doc = JsonDocument.Parse(response);
var root = doc.RootElement;
if (root.ValueKind == JsonValueKind.Object)
{
return root.EnumerateObject().Any();
}
else if (root.ValueKind == JsonValueKind.Array)
{
return root.GetArrayLength() > 0;
}
else
{
return false;
}
}
catch (JsonException)
{
return false;
}
}
// Método para deserializar el JSON a un objeto genérico
public T? TryParseJson<T>(string response) where T : class
{
if (string.IsNullOrWhiteSpace(response)) return null;
try
{
return JsonSerializer.Deserialize<T>(response);
}
catch (JsonException ex)
{
Globales.logger.LogError($"Error al deserializar JSON: {ex.Message}");
return null;
}
}
private static string CrearJsonError(int status, string message)
{
return $$"""
{
"success": false,
"status": {{status}},
"message": "{{message.Replace("\"", "\\\"")}}"
}
""";
}
public void Dispose()
{
_httpClient.Dispose();
}
}
}