Upload 3 files

api/routers/database.py

@@ -0,0 +1,143 @@
+"""
+Router de testes de database
+Endpoints para verificar conexão e estatísticas do banco
+"""
+from fastapi import APIRouter, HTTPException
+from api.models.responses import DatabaseStatsResponse, MessageResponse
+from api.utils.logger import setup_logger
+
+router = APIRouter()
+logger = setup_logger(__name__)
+
+
+@router.get("/health")
+async def database_health():
+    """
+    **Verifica saúde da conexão com banco de dados.**
+
+    Retorna status da conexão e informações básicas.
+    """
+    try:
+        from database.db_manager import get_db_manager
+
+        db = get_db_manager()
+        is_healthy = db.health_check()
+
+        if is_healthy:
+            return {
+                "status": "healthy",
+                "message": "Database connection OK",
+                "database_url": db.get_connection_info()
+            }
+        else:
+            return {
+                "status": "unhealthy",
+                "message": "Database connection failed"
+            }
+
+    except Exception as e:
+        logger.error(f"Database health check error: {e}")
+        return {
+            "status": "error",
+            "message": str(e)
+        }
+
+
+@router.get("/stats", response_model=DatabaseStatsResponse)
+async def database_stats():
+    """
+    **Estatísticas do banco de dados.**
+
+    Retorna contagem de registros nas principais tabelas.
+    """
+    try:
+        from database.db_manager import get_db_manager
+
+        db = get_db_manager()
+
+        stats = {
+            "total_acordaos": db.count_records("acordaos"),
+            "total_tribunais": db.count_records("tribunais"),
+            "total_usuarios": db.count_records("usuarios"),
+            "total_decisoes": db.count_records("decisoes"),
+        }
+
+        # Tentar pegar tamanho do banco
+        try:
+            size_mb = db.get_database_size_mb()
+            stats["database_size_mb"] = size_mb
+        except:
+            stats["database_size_mb"] = None
+
+        return DatabaseStatsResponse(**stats)
+
+    except Exception as e:
+        logger.error(f"Error getting database stats: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/tables")
+async def list_tables():
+    """
+    **Lista todas as tabelas do banco.**
+
+    Útil para verificar se DDL foi executado corretamente.
+    """
+    try:
+        from database.db_manager import get_db_manager
+
+        db = get_db_manager()
+        tables = db.list_tables()
+
+        return {
+            "tables": tables,
+            "total": len(tables)
+        }
+
+    except Exception as e:
+        logger.error(f"Error listing tables: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.post("/test-insert")
+async def test_insert():
+    """
+    **Testa inserção no banco de dados.**
+
+    Insere um registro de teste e depois remove.
+    Útil para verificar permissões de escrita.
+    """
+    try:
+        from database.db_manager import get_db_manager
+        import uuid
+
+        db = get_db_manager()
+
+        # Tentar inserir um tribunal de teste
+        test_id = str(uuid.uuid4())
+
+        success = db.execute_query(
+            """
+            INSERT INTO tribunais (id, nome, sigla, uf, tipo, created_at, updated_at)
+            VALUES (%s, %s, %s, %s, %s, NOW(), NOW())
+            """,
+            (test_id, "Tribunal Teste", "TEST", "DF", "Teste")
+        )
+
+        if success:
+            # Remover registro de teste
+            db.execute_query(
+                "DELETE FROM tribunais WHERE id = %s",
+                (test_id,)
+            )
+
+            return MessageResponse(
+                message="Test insert/delete successful",
+                details={"test_id": test_id}
+            )
+        else:
+            raise Exception("Insert failed")
+
+    except Exception as e:
+        logger.error(f"Test insert error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

api/routers/files.py

@@ -0,0 +1,170 @@
+"""
+Router de testes de gestão de arquivos
+Endpoints para testar criação, listagem e download de arquivos
+"""
+from fastapi import APIRouter, HTTPException
+from typing import List
+from pathlib import Path
+
+from api.models.requests import FileCreateRequest
+from api.models.responses import FileInfoResponse, MessageResponse
+from api.utils.logger import setup_logger
+
+router = APIRouter()
+logger = setup_logger(__name__)
+
+
+@router.post("/create", response_model=MessageResponse)
+async def create_test_file(request: FileCreateRequest):
+    """
+    **Cria arquivo de teste.**
+
+    Útil para testar sistema de arquivos e permissões.
+    """
+    try:
+        from files.files_manager import FilesManager
+
+        fm = FilesManager()
+
+        # Criar arquivo
+        filepath = fm.save_text_file(
+            content=request.content,
+            filename=request.filename,
+            acordao_id=request.acordao_id
+        )
+
+        logger.info(f"✅ Test file created: {filepath}")
+
+        return MessageResponse(
+            message="File created successfully",
+            details={
+                "filepath": str(filepath),
+                "filename": request.filename,
+                "size": len(request.content)
+            }
+        )
+
+    except Exception as e:
+        logger.error(f"Error creating file: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/list", response_model=List[FileInfoResponse])
+async def list_files(acordao_id: str = None, limit: int = 100):
+    """
+    **Lista arquivos.**
+
+    Args:
+        acordao_id: Filtrar por ID de acórdão (opcional)
+        limit: Limite de resultados
+    """
+    try:
+        from files.files_manager import FilesManager
+
+        fm = FilesManager()
+
+        files = fm.list_files(
+            acordao_id=acordao_id,
+            limit=limit
+        )
+
+        return [
+            FileInfoResponse(
+                filename=f["filename"],
+                size_bytes=f["size_bytes"],
+                hash_sha256=f.get("hash", "unknown"),
+                created_at=f.get("created_at")
+            )
+            for f in files
+        ]
+
+    except Exception as e:
+        logger.error(f"Error listing files: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/info/{filename}")
+async def get_file_info(filename: str):
+    """
+    **Informações sobre um arquivo específico.**
+    """
+    try:
+        from files.files_manager import FilesManager
+
+        fm = FilesManager()
+
+        info = fm.get_file_info(filename)
+
+        if not info:
+            raise HTTPException(status_code=404, detail="File not found")
+
+        return info
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error getting file info: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.delete("/{filename}")
+async def delete_file(filename: str):
+    """
+    **Deleta arquivo.**
+
+    Args:
+        filename: Nome do arquivo a deletar
+    """
+    try:
+        from files.files_manager import FilesManager
+
+        fm = FilesManager()
+
+        success = fm.delete_file(filename)
+
+        if success:
+            logger.info(f"🗑️  File deleted: {filename}")
+            return MessageResponse(
+                message="File deleted successfully",
+                details={"filename": filename}
+            )
+        else:
+            raise HTTPException(status_code=404, detail="File not found")
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error deleting file: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@router.get("/storage/info")
+async def storage_info():
+    """
+    **Informações sobre armazenamento.**
+
+    Retorna uso de disco e estatísticas.
+    """
+    try:
+        from files.files_manager import FilesManager
+        import shutil
+
+        fm = FilesManager()
+
+        # Pegar info de disco
+        total, used, free = shutil.disk_usage(fm.base_path)
+
+        return {
+            "base_path": str(fm.base_path),
+            "storage": {
+                "total_gb": total / (1024**3),
+                "used_gb": used / (1024**3),
+                "free_gb": free / (1024**3),
+                "percent_used": (used / total) * 100
+            },
+            "total_files": len(list(Path(fm.base_path).rglob("*.*")))
+        }
+
+    except Exception as e:
+        logger.error(f"Error getting storage info: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

api/routers/llm.py

@@ -0,0 +1,141 @@
+"""
+Router de testes de LLM
+Endpoints para testar providers e modelos LLM
+"""
+from fastapi import APIRouter, HTTPException
+from datetime import datetime
+import time
+
+from api.models.requests import LLMGenerateRequest
+from api.models.responses import LLMTestResponse, MessageResponse
+from api.utils.logger import setup_logger
+
+router = APIRouter()
+logger = setup_logger(__name__)
+
+
+@router.post("/generate", response_model=LLMTestResponse)
+async def test_llm_generate(request: LLMGenerateRequest):
+    """
+    **Testa geração de texto com LLM.**
+
+    Útil para:
+    - Verificar se API keys estão funcionando
+    - Testar diferentes modelos
+    - Medir latência e tokens
+    """
+    start_time = time.time()
+
+    try:
+        # Importar LLM manager
+        from llm.llm_manager import LLMManager
+
+        llm = LLMManager()
+
+        # Verificar se provider está disponível
+        if not llm.is_provider_available(request.provider):
+            raise HTTPException(
+                status_code=503,
+                detail=f"Provider '{request.provider}' não disponível ou não configurado"
+            )
+
+        # Gerar texto
+        result = await llm.generate(
+            prompt=request.prompt,
+            provider=request.provider,
+            model=request.model,
+            temperature=request.temperature,
+            max_tokens=request.max_tokens
+        )
+
+        duration_ms = (time.time() - start_time) * 1000
+
+        logger.info(
+            f"✅ LLM test [{request.provider}] - "
+            f"Tokens: {result.get('tokens', 0)} - "
+            f"Duration: {duration_ms:.2f}ms"
+        )
+
+        return LLMTestResponse(
+            provider=request.provider,
+            model=result.get("model", request.model or "default"),
+            success=True,
+            response=result.get("text", ""),
+            tokens_used=result.get("tokens"),
+            duration_ms=duration_ms
+        )
+
+    except Exception as e:
+        duration_ms = (time.time() - start_time) * 1000
+
+        logger.error(f"❌ LLM test error: {str(e)}")
+
+        return LLMTestResponse(
+            provider=request.provider,
+            model=request.model or "unknown",
+            success=False,
+            duration_ms=duration_ms,
+            error=str(e)
+        )
+
+
+@router.get("/providers")
+async def list_providers():
+    """
+    **Lista providers LLM disponíveis.**
+
+    Mostra quais providers estão configurados e prontos para uso.
+    """
+    try:
+        from llm.llm_manager import LLMManager
+
+        llm = LLMManager()
+        providers = llm.list_providers()
+
+        return {
+            "providers": providers,
+            "total": len(providers),
+            "default": llm.default_provider
+        }
+
+    except Exception as e:
+        logger.error(f"Error listing providers: {e}")
+        return {
+            "providers": [],
+            "total": 0,
+            "error": str(e)
+        }
+
+
+@router.get("/models/{provider}")
+async def list_models(provider: str):
+    """
+    **Lista modelos disponíveis de um provider.**
+
+    Args:
+        provider: Nome do provider (groq/openai/anthropic)
+    """
+    try:
+        from llm.llm_manager import LLMManager
+
+        llm = LLMManager()
+
+        if not llm.is_provider_available(provider):
+            raise HTTPException(
+                status_code=404,
+                detail=f"Provider '{provider}' não disponível"
+            )
+
+        models = llm.get_available_models(provider)
+
+        return {
+            "provider": provider,
+            "models": models,
+            "total": len(models)
+        }
+
+    except HTTPException:
+        raise
+    except Exception as e:
+        logger.error(f"Error listing models: {e}")
+        raise HTTPException(status_code=500, detail=str(e))