379 lines
14 KiB
Python
379 lines
14 KiB
Python
from azure.storage.blob import BlobServiceClient, BlobClient, ContainerClient, generate_blob_sas, BlobSasPermissions
|
|
from azure.core.exceptions import ResourceNotFoundError, ResourceExistsError
|
|
from typing import List, Optional, BinaryIO
|
|
import logging
|
|
from datetime import datetime, timezone, timedelta
|
|
import os
|
|
from ..core.config import settings
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
|
|
class AzureBlobService:
|
|
"""
|
|
Servicio para interactuar con Azure Blob Storage
|
|
"""
|
|
|
|
def __init__(self):
|
|
"""Inicializar el cliente de Azure Blob Storage"""
|
|
try:
|
|
self.blob_service_client = BlobServiceClient.from_connection_string(
|
|
settings.AZURE_STORAGE_CONNECTION_STRING
|
|
)
|
|
self.container_name = settings.AZURE_CONTAINER_NAME
|
|
logger.info(f"Cliente de Azure Blob Storage inicializado para container: {self.container_name}")
|
|
|
|
# Configurar CORS automáticamente al inicializar
|
|
self._configure_cors()
|
|
except Exception as e:
|
|
logger.error(f"Error inicializando Azure Blob Service: {e}")
|
|
raise e
|
|
|
|
def _configure_cors(self):
|
|
"""
|
|
Configurar CORS en Azure Blob Storage para permitir acceso desde el frontend
|
|
|
|
Esto es necesario para que el navegador pueda cargar PDFs directamente
|
|
desde Azure usando las URLs SAS generadas.
|
|
"""
|
|
try:
|
|
from azure.storage.blob import CorsRule
|
|
|
|
# Definir regla CORS permisiva para desarrollo y producción
|
|
cors_rule = CorsRule(
|
|
allowed_origins=["*"], # En producción, especificar dominios exactos
|
|
allowed_methods=["GET", "HEAD", "OPTIONS"],
|
|
allowed_headers=["*"],
|
|
exposed_headers=["*"],
|
|
max_age_in_seconds=3600
|
|
)
|
|
|
|
# Aplicar la configuración CORS
|
|
self.blob_service_client.set_service_properties(cors=[cors_rule])
|
|
logger.info("CORS configurado exitosamente en Azure Blob Storage")
|
|
|
|
except Exception as e:
|
|
# No fallar si CORS no se puede configurar (puede que ya esté configurado)
|
|
logger.warning(f"No se pudo configurar CORS automáticamente: {e}")
|
|
logger.warning("Asegúrate de configurar CORS manualmente en Azure Portal si es necesario")
|
|
|
|
async def create_container_if_not_exists(self) -> bool:
|
|
"""
|
|
Crear el container si no existe
|
|
Returns: True si se creó, False si ya existía
|
|
"""
|
|
try:
|
|
container_client = self.blob_service_client.get_container_client(self.container_name)
|
|
container_client.create_container()
|
|
logger.info(f"Container '{self.container_name}' creado exitosamente")
|
|
return True
|
|
except ResourceExistsError:
|
|
logger.info(f"Container '{self.container_name}' ya existe")
|
|
return False
|
|
except Exception as e:
|
|
logger.error(f"Error creando container: {e}")
|
|
raise e
|
|
|
|
async def upload_file(self, file_data: BinaryIO, blob_name: str, tema: str = "") -> dict:
|
|
"""
|
|
Subir un archivo a Azure Blob Storage
|
|
|
|
Args:
|
|
file_data: Datos del archivo
|
|
blob_name: Nombre del archivo en el blob
|
|
tema: Tema/carpeta donde guardar el archivo
|
|
|
|
Returns:
|
|
dict: Información del archivo subido
|
|
"""
|
|
try:
|
|
# Construir la ruta completa con tema si se proporciona
|
|
full_blob_name = f"{tema}/{blob_name}" if tema else blob_name
|
|
|
|
# Obtener cliente del blob
|
|
blob_client = self.blob_service_client.get_blob_client(
|
|
container=self.container_name,
|
|
blob=full_blob_name
|
|
)
|
|
|
|
# Subir el archivo
|
|
blob_client.upload_blob(file_data, overwrite=True)
|
|
|
|
# Obtener propiedades del blob
|
|
blob_properties = blob_client.get_blob_properties()
|
|
|
|
logger.info(f"Archivo '{full_blob_name}' subido exitosamente")
|
|
|
|
return {
|
|
"name": blob_name,
|
|
"full_path": full_blob_name,
|
|
"tema": tema,
|
|
"size": blob_properties.size,
|
|
"last_modified": blob_properties.last_modified,
|
|
"url": blob_client.url
|
|
}
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error subiendo archivo '{blob_name}': {e}")
|
|
raise e
|
|
|
|
async def download_file(self, blob_name: str, tema: str = "") -> bytes:
|
|
"""
|
|
Descargar un archivo de Azure Blob Storage
|
|
|
|
Args:
|
|
blob_name: Nombre del archivo
|
|
tema: Tema/carpeta donde está el archivo
|
|
|
|
Returns:
|
|
bytes: Contenido del archivo
|
|
"""
|
|
try:
|
|
# Construir la ruta completa
|
|
full_blob_name = f"{tema}/{blob_name}" if tema else blob_name
|
|
|
|
# Obtener cliente del blob
|
|
blob_client = self.blob_service_client.get_blob_client(
|
|
container=self.container_name,
|
|
blob=full_blob_name
|
|
)
|
|
|
|
# Descargar el archivo
|
|
blob_data = blob_client.download_blob()
|
|
content = blob_data.readall()
|
|
|
|
logger.info(f"Archivo '{full_blob_name}' descargado exitosamente")
|
|
return content
|
|
|
|
except ResourceNotFoundError:
|
|
logger.error(f"Archivo '{full_blob_name}' no encontrado")
|
|
raise FileNotFoundError(f"El archivo '{blob_name}' no existe")
|
|
except Exception as e:
|
|
logger.error(f"Error descargando archivo '{blob_name}': {e}")
|
|
raise e
|
|
|
|
async def delete_file(self, blob_name: str, tema: str = "") -> bool:
|
|
"""
|
|
Eliminar un archivo de Azure Blob Storage
|
|
|
|
Args:
|
|
blob_name: Nombre del archivo
|
|
tema: Tema/carpeta donde está el archivo
|
|
|
|
Returns:
|
|
bool: True si se eliminó exitosamente
|
|
"""
|
|
try:
|
|
# Construir la ruta completa
|
|
full_blob_name = f"{tema}/{blob_name}" if tema else blob_name
|
|
|
|
# Obtener cliente del blob
|
|
blob_client = self.blob_service_client.get_blob_client(
|
|
container=self.container_name,
|
|
blob=full_blob_name
|
|
)
|
|
|
|
# Eliminar el archivo
|
|
blob_client.delete_blob()
|
|
|
|
logger.info(f"Archivo '{full_blob_name}' eliminado exitosamente")
|
|
return True
|
|
|
|
except ResourceNotFoundError:
|
|
logger.error(f"Archivo '{full_blob_name}' no encontrado para eliminar")
|
|
raise FileNotFoundError(f"El archivo '{blob_name}' no existe")
|
|
except Exception as e:
|
|
logger.error(f"Error eliminando archivo '{blob_name}': {e}")
|
|
raise e
|
|
|
|
async def list_files(self, tema: str = "") -> List[dict]:
|
|
"""
|
|
Listar archivos en el container o en un tema específico
|
|
|
|
Args:
|
|
tema: Tema/carpeta específica (opcional)
|
|
|
|
Returns:
|
|
List[dict]: Lista de archivos con sus propiedades
|
|
"""
|
|
try:
|
|
container_client = self.blob_service_client.get_container_client(self.container_name)
|
|
|
|
# Filtrar por tema si se proporciona
|
|
name_starts_with = f"{tema}/" if tema else None
|
|
|
|
blobs = container_client.list_blobs(name_starts_with=name_starts_with)
|
|
|
|
files = []
|
|
for blob in blobs:
|
|
# Extraer información del blob
|
|
blob_info = {
|
|
"name": os.path.basename(blob.name),
|
|
"full_path": blob.name,
|
|
"tema": os.path.dirname(blob.name) if "/" in blob.name else "",
|
|
"size": blob.size,
|
|
"last_modified": blob.last_modified,
|
|
"content_type": blob.content_settings.content_type if blob.content_settings else None
|
|
}
|
|
files.append(blob_info)
|
|
|
|
logger.info(f"Listados {len(files)} archivos" + (f" en tema '{tema}'" if tema else ""))
|
|
return files
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error listando archivos: {e}")
|
|
raise e
|
|
|
|
async def get_file_info(self, blob_name: str, tema: str = "") -> dict:
|
|
"""
|
|
Obtener información de un archivo específico
|
|
|
|
Args:
|
|
blob_name: Nombre del archivo
|
|
tema: Tema/carpeta donde está el archivo
|
|
|
|
Returns:
|
|
dict: Información del archivo
|
|
"""
|
|
try:
|
|
# Construir la ruta completa
|
|
full_blob_name = f"{tema}/{blob_name}" if tema else blob_name
|
|
|
|
# Obtener cliente del blob
|
|
blob_client = self.blob_service_client.get_blob_client(
|
|
container=self.container_name,
|
|
blob=full_blob_name
|
|
)
|
|
|
|
# Obtener propiedades
|
|
properties = blob_client.get_blob_properties()
|
|
|
|
return {
|
|
"name": blob_name,
|
|
"full_path": full_blob_name,
|
|
"tema": tema,
|
|
"size": properties.size,
|
|
"last_modified": properties.last_modified,
|
|
"content_type": properties.content_settings.content_type,
|
|
"url": blob_client.url
|
|
}
|
|
|
|
except ResourceNotFoundError:
|
|
logger.error(f"Archivo '{full_blob_name}' no encontrado")
|
|
raise FileNotFoundError(f"El archivo '{blob_name}' no existe")
|
|
except Exception as e:
|
|
logger.error(f"Error obteniendo info del archivo '{blob_name}': {e}")
|
|
raise e
|
|
|
|
async def get_download_url(self, blob_name: str, tema: str = "") -> str:
|
|
"""
|
|
Obtener URL de descarga directa para un archivo
|
|
|
|
Args:
|
|
blob_name: Nombre del archivo
|
|
tema: Tema/carpeta donde está el archivo
|
|
|
|
Returns:
|
|
str: URL de descarga
|
|
"""
|
|
try:
|
|
# Construir la ruta completa
|
|
full_blob_name = f"{tema}/{blob_name}" if tema else blob_name
|
|
|
|
# Obtener cliente del blob
|
|
blob_client = self.blob_service_client.get_blob_client(
|
|
container=self.container_name,
|
|
blob=full_blob_name
|
|
)
|
|
|
|
return blob_client.url
|
|
|
|
except Exception as e:
|
|
logger.error(f"Error obteniendo URL de descarga para '{blob_name}': {e}")
|
|
raise e
|
|
|
|
async def generate_sas_url(self, blob_name: str, tema: str = "", expiry_hours: int = 1) -> str:
|
|
"""
|
|
Generar una URL SAS (Shared Access Signature) temporal para acceder a un archivo
|
|
|
|
Esta URL permite acceso temporal y seguro al archivo sin requerir autenticación.
|
|
Es ideal para vistas previas de archivos en el navegador.
|
|
|
|
Args:
|
|
blob_name: Nombre del archivo
|
|
tema: Tema/carpeta donde está el archivo
|
|
expiry_hours: Horas de validez de la URL (por defecto 1 hora)
|
|
|
|
Returns:
|
|
str: URL completa con SAS token para acceso temporal
|
|
"""
|
|
try:
|
|
from azure.storage.blob import ContentSettings
|
|
|
|
# Construir la ruta completa del blob
|
|
full_blob_name = f"{tema}/{blob_name}" if tema else blob_name
|
|
|
|
# Obtener cliente del blob
|
|
blob_client = self.blob_service_client.get_blob_client(
|
|
container=self.container_name,
|
|
blob=full_blob_name
|
|
)
|
|
|
|
# Verificar que el archivo existe antes de generar el SAS
|
|
if not blob_client.exists():
|
|
raise FileNotFoundError(f"El archivo '{blob_name}' no existe")
|
|
|
|
# IMPORTANTE: Configurar el blob para que se muestre inline (no descarga)
|
|
# Esto hace que el navegador muestre el PDF en lugar de descargarlo
|
|
try:
|
|
content_settings = ContentSettings(
|
|
content_type='application/pdf',
|
|
content_disposition='inline' # Clave para mostrar en navegador
|
|
)
|
|
blob_client.set_http_headers(content_settings=content_settings)
|
|
logger.info(f"Headers configurados para visualización inline de '{full_blob_name}'")
|
|
except Exception as e:
|
|
logger.warning(f"No se pudieron configurar headers inline: {e}")
|
|
|
|
# Definir el tiempo de expiración del SAS token
|
|
start_time = datetime.now(timezone.utc)
|
|
expiry_time = start_time + timedelta(hours=expiry_hours)
|
|
|
|
# Extraer la account key del connection string para generar el SAS
|
|
# El SAS necesita la account key para firmar el token
|
|
account_key = None
|
|
for part in settings.AZURE_STORAGE_CONNECTION_STRING.split(';'):
|
|
if part.startswith('AccountKey='):
|
|
account_key = part.split('=', 1)[1]
|
|
break
|
|
|
|
if not account_key:
|
|
raise ValueError("No se pudo extraer AccountKey del connection string")
|
|
|
|
# Generar el SAS token con permisos de solo lectura
|
|
sas_token = generate_blob_sas(
|
|
account_name=blob_client.account_name,
|
|
container_name=self.container_name,
|
|
blob_name=full_blob_name,
|
|
account_key=account_key,
|
|
permission=BlobSasPermissions(read=True), # Solo permisos de lectura
|
|
expiry=expiry_time,
|
|
start=start_time
|
|
)
|
|
|
|
# Construir la URL completa con el SAS token
|
|
sas_url = f"{blob_client.url}?{sas_token}"
|
|
|
|
logger.info(f"SAS URL generada para '{full_blob_name}' (válida por {expiry_hours} horas)")
|
|
return sas_url
|
|
|
|
except FileNotFoundError:
|
|
logger.error(f"Archivo '{full_blob_name}' no encontrado para generar SAS")
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Error generando SAS URL para '{blob_name}': {e}")
|
|
raise e
|
|
|
|
|
|
# Instancia global del servicio
|
|
azure_service = AzureBlobService() |