Tabla funel_compra

create_funel_compra_table.py

@@ -0,0 +1,70 @@
+"""Script para crear la tabla funel_compra"""
+
+from connection import get_connection
+import logging
+
+logging.basicConfig(level=logging.INFO, format='%(message)s')
+logger = logging.getLogger(__name__)
+
+def create_funel_compra_table():
+    """Crea la tabla funel_compra en la BD"""
+    
+    conn = get_connection()
+    
+    if not conn:
+        logger.error("❌ No se pudo conectar a la base de datos")
+        return False
+    
+    try:
+        cursor = conn.cursor()
+        
+        logger.info("📝 Creando tabla funel_compra...")
+        
+        sql = """
+        CREATE TABLE IF NOT EXISTS `funel_compra` (
+            `id` INT AUTO_INCREMENT PRIMARY KEY,
+            `usuario` VARCHAR(255) NOT NULL,
+            `mail` VARCHAR(255) NOT NULL,
+            `accion` VARCHAR(255) NOT NULL,
+            `created_at` TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP(),
+            INDEX idx_usuario (usuario),
+            INDEX idx_mail (mail),
+            INDEX idx_accion (accion),
+            INDEX idx_created_at (created_at)
+        ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci
+        """
+        
+        cursor.execute(sql)
+        conn.commit()
+        
+        logger.info("✅ Tabla 'funel_compra' creada exitosamente")
+        
+        # Describir tabla
+        cursor.execute("DESCRIBE funel_compra")
+        fields = cursor.fetchall()
+        cursor.close()
+        conn.close()
+        
+        logger.info("\n📋 Estructura de la tabla:")
+        logger.info("=" * 100)
+        logger.info(f"{'Campo':<20} | {'Tipo':<25} | {'Null':<6} | {'Key':<8} | {'Extra':<30}")
+        logger.info("-" * 100)
+        for field in fields:
+            field_name = field[0]
+            field_type = field[1]
+            field_null = field[2]
+            field_key = field[3]
+            field_extra = str(field[5]) if field[5] else '-'
+            logger.info(f"{field_name:<20} | {field_type:<25} | {field_null:<6} | {field_key:<8} | {field_extra:<30}")
+        logger.info("=" * 100)
+        
+        return True
+        
+    except Exception as e:
+        logger.error(f"❌ Error al crear la tabla: {str(e)}")
+        conn.close()
+        return False
+
+
+if __name__ == "__main__":
+    create_funel_compra_table()

funciones.py

@@ -589,3 +589,204 @@ def obtener_todas_acciones(limit: int = 10, offset: int = 0) -> dict:
             "success": False,
             "error": f"Error al obtener acciones: {str(e)}"
         }
+
+
+def crear_evento_funel(datos) -> dict:
+    """
+    Crea un evento en el funel de compra.
+    
+    Args:
+        datos: Object FunelCompraRequest con usuario, mail, accion
+    
+    Returns:
+        dict: Evento creado o error
+    """
+    
+    conn = get_connection()
+    
+    if not conn:
+        logger.error("❌ No se pudo conectar a la base de datos")
+        return {
+            "success": False,
+            "error": "No se pudo conectar a la base de datos"
+        }
+    
+    try:
+        logger.info(f"📊 Registrando evento funel - Usuario: {datos.usuario}, Mail: {datos.mail}, Acción: {datos.accion}")
+        
+        cursor = conn.cursor()
+        
+        sql = """
+        INSERT INTO `funel_compra` 
+        (usuario, mail, accion)
+        VALUES (%s, %s, %s)
+        """
+        
+        valores = (datos.usuario, datos.mail, datos.accion)
+        
+        cursor.execute(sql, valores)
+        conn.commit()
+        
+        logger.info(f"✅ Evento funel registrado en BD - Usuario: {datos.usuario}")
+        
+        # Recuperar el evento creado
+        cursor.execute(
+            "SELECT * FROM `funel_compra` WHERE usuario = %s AND mail = %s AND accion = %s ORDER BY created_at DESC LIMIT 1",
+            (datos.usuario, datos.mail, datos.accion)
+        )
+        
+        evento = cursor.fetchone()
+        cursor.close()
+        conn.close()
+        
+        if evento:
+            logger.info(f"✅ Evento recuperado - ID: {evento[0]}")
+            return {
+                "success": True,
+                "data": {
+                    "id": evento[0],
+                    "usuario": evento[1],
+                    "mail": evento[2],
+                    "accion": evento[3],
+                    "created_at": evento[4]
+                }
+            }
+        else:
+            logger.error("❌ No se pudo recuperar el evento creado")
+            return {
+                "success": False,
+                "error": "No se pudo recuperar el evento"
+            }
+        
+    except Exception as e:
+        logger.error(f"❌ Error al crear evento funel: {str(e)}")
+        return {
+            "success": False,
+            "error": f"Error al crear evento: {str(e)}"
+        }
+
+
+def obtener_eventos_funel(usuario: str) -> dict:
+    """
+    Obtiene todos los eventos de funel para un usuario.
+    
+    Args:
+        usuario: Nombre del usuario
+    
+    Returns:
+        dict: Lista de eventos o error
+    """
+    
+    conn = get_connection()
+    
+    if not conn:
+        logger.error("❌ No se pudo conectar a la base de datos")
+        return {
+            "success": False,
+            "error": "No se pudo conectar a la base de datos"
+        }
+    
+    try:
+        logger.info(f"🔍 Buscando eventos funel - Usuario: {usuario}")
+        cursor = conn.cursor()
+        
+        cursor.execute(
+            "SELECT * FROM `funel_compra` WHERE usuario = %s ORDER BY created_at DESC",
+            (usuario,)
+        )
+        
+        eventos = cursor.fetchall()
+        cursor.close()
+        conn.close()
+        
+        datos = []
+        for evento in eventos:
+            datos.append({
+                "id": evento[0],
+                "usuario": evento[1],
+                "mail": evento[2],
+                "accion": evento[3],
+                "created_at": evento[4]
+            })
+        
+        logger.info(f"✅ Se obtuvieron {len(datos)} eventos para el usuario: {usuario}")
+        
+        return {
+            "success": True,
+            "data": datos,
+            "total": len(datos)
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ Error al obtener eventos funel: {str(e)}")
+        return {
+            "success": False,
+            "error": f"Error al obtener eventos: {str(e)}"
+        }
+
+
+def obtener_todos_eventos_funel(limit: int = 10, offset: int = 0) -> dict:
+    """
+    Obtiene todos los eventos del funel con paginación.
+    
+    Args:
+        limit: Cantidad máxima de registros
+        offset: Desplazamiento para paginación
+    
+    Returns:
+        dict: Lista de eventos paginada o error
+    """
+    
+    conn = get_connection()
+    
+    if not conn:
+        logger.error("❌ No se pudo conectar a la base de datos")
+        return {
+            "success": False,
+            "error": "No se pudo conectar a la base de datos"
+        }
+    
+    try:
+        logger.info(f"📚 Obteniendo todos los eventos funel - Limit: {limit}, Offset: {offset}")
+        cursor = conn.cursor()
+        
+        # Obtener total
+        cursor.execute("SELECT COUNT(*) FROM `funel_compra`")
+        total = cursor.fetchone()[0]
+        logger.info(f"📊 Total de eventos: {total}")
+        
+        # Obtener con paginación
+        cursor.execute(
+            "SELECT * FROM `funel_compra` ORDER BY created_at DESC LIMIT %s OFFSET %s",
+            (limit, offset)
+        )
+        
+        eventos = cursor.fetchall()
+        logger.info(f"✅ Se obtuvieron {len(eventos)} eventos")
+        cursor.close()
+        conn.close()
+        
+        datos = []
+        for evento in eventos:
+            datos.append({
+                "id": evento[0],
+                "usuario": evento[1],
+                "mail": evento[2],
+                "accion": evento[3],
+                "created_at": evento[4]
+            })
+        
+        return {
+            "success": True,
+            "data": datos,
+            "total": total,
+            "limit": limit,
+            "offset": offset
+        }
+        
+    except Exception as e:
+        logger.error(f"❌ Error al obtener eventos funel: {str(e)}")
+        return {
+            "success": False,
+            "error": f"Error al obtener eventos: {str(e)}"
+        }

imagen_log.sql

@@ -41,3 +41,15 @@ CREATE TABLE `actions` (
   `created_at` timestamp DEFAULT CURRENT_TIMESTAMP,
   `updated_at` timestamp DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
 );
+
+CREATE TABLE `funel_compra` (
+  `id` int AUTO_INCREMENT PRIMARY KEY,
+  `usuario` varchar(255) NOT NULL,
+  `mail` varchar(255) NOT NULL,
+  `accion` varchar(255) NOT NULL,
+  `created_at` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP,
+  INDEX idx_usuario (usuario),
+  INDEX idx_mail (mail),
+  INDEX idx_accion (accion),
+  INDEX idx_created_at (created_at)
+);

main.py

@@ -5,8 +5,8 @@ Aplicación FastAPI - Endpoints
 import logging
 from fastapi import FastAPI, HTTPException, Query
 from fastapi.responses import JSONResponse
-from models import RegistroRequest, RegistroResponse, CalificacionRequest, ActionRequest, ActionResponse
-from funciones import crear_registro, obtener_registros, actualizar_calificacion, crear_o_actualizar_action, obtener_action, obtener_todas_acciones
+from models import RegistroRequest, RegistroResponse, CalificacionRequest, ActionRequest, ActionResponse, FunelCompraRequest, FunelCompraResponse
+from funciones import crear_registro, obtener_registros, actualizar_calificacion, crear_o_actualizar_action, obtener_action, obtener_todas_acciones, crear_evento_funel, obtener_eventos_funel, obtener_todos_eventos_funel
 from datetime import datetime
 
 # Configurar logging
@@ -277,10 +277,82 @@ async def obtener_acciones(
         )
 
 
+@app.post("/funel-compra", response_model=dict, tags=["Funel Compra"])
+async def registrar_funel_compra(datos: FunelCompraRequest):
+    """
+    Registra un evento en el funel de compra.
+    
+    Acciones típicas: inicio, visualizacion, intento_compra, compra_exitosa, abandono
+    """
+    logger.info(f"📊 POST /funel-compra - Usuario: {datos.usuario}, Mail: {datos.mail}, Acción: {datos.accion}")
+    
+    resultado = crear_evento_funel(datos)
+    
+    if resultado["success"]:
+        logger.info(f"✅ Evento registrado: {resultado['data']}")
+        return {
+            "success": True,
+            "data": resultado["data"]
+        }
+    else:
+        logger.error(f"❌ Error al registrar evento: {resultado['error']}")
+        raise HTTPException(
+            status_code=400,
+            detail=resultado["error"]
+        )
 
-if __name__ == "__main__":
-    import uvicorn
-    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=True)
+
+@app.get("/funel-compra/{usuario}", response_model=dict, tags=["Funel Compra"])
+async def obtener_funel_usuario(usuario: str):
+    """
+    Obtiene todos los eventos del funel de compra para un usuario específico.
+    """
+    logger.info(f"🔍 GET /funel-compra/{usuario}")
+    
+    resultado = obtener_eventos_funel(usuario)
+    
+    if resultado["success"]:
+        logger.info(f"✅ Se obtuvieron {resultado['total']} eventos para {usuario}")
+        return {
+            "success": True,
+            "data": resultado["data"],
+            "total": resultado["total"]
+        }
+    else:
+        logger.error(f"❌ Error al obtener eventos: {resultado['error']}")
+        raise HTTPException(
+            status_code=500,
+            detail=resultado["error"]
+        )
+
+
+@app.get("/funel-compra", response_model=dict, tags=["Funel Compra"])
+async def listar_funel_compra(limit: int = Query(10, ge=1, le=100), offset: int = Query(0, ge=0)):
+    """
+    Obtiene todos los eventos del funel de compra con paginación.
+    """
+    logger.info(f"📚 GET /funel-compra - Limit: {limit}, Offset: {offset}")
+    
+    resultado = obtener_todos_eventos_funel(limit, offset)
+    
+    if resultado["success"]:
+        logger.info(f"✅ Se obtuvieron {len(resultado['data'])} eventos (Total: {resultado['total']})")
+        return {
+            "success": True,
+            "data": resultado["data"],
+            "pagination": {
+                "total": resultado["total"],
+                "limit": limit,
+                "offset": offset,
+                "pages": (resultado["total"] + limit - 1) // limit
+            }
+        }
+    else:
+        logger.error(f"❌ Error al obtener eventos: {resultado['error']}")
+        raise HTTPException(
+            status_code=500,
+            detail=resultado["error"]
+        )
 
 
 if __name__ == "__main__":

models.py

@@ -160,3 +160,35 @@ class ActionResponse(BaseModel):
             "created_at": "2025-01-13T10:30:00",
             "updated_at": "2025-02-06T15:45:00"
         }
+
+
+class FunelCompraRequest(BaseModel):
+    """Modelo para crear/registrar un evento en el funel de compra"""
+    usuario: str = Field(..., max_length=255, description="Nombre de usuario")
+    mail: str = Field(..., description="Email del usuario")
+    accion: str = Field(..., max_length=255, description="Acción realizada en el funel (ej: inicio, visualizacion, intento_compra, compra_exitosa)")
+
+    class Config:
+        example = {
+            "usuario": "moibe",
+            "mail": "moi.estrello@gmail.com",
+            "accion": "compra_exitosa"
+        }
+
+
+class FunelCompraResponse(BaseModel):
+    """Modelo para respuesta de registros del funel de compra"""
+    id: int = Field(..., description="ID único del registro")
+    usuario: str
+    mail: str
+    accion: str
+    created_at: datetime
+
+    class Config:
+        example = {
+            "id": 1,
+            "usuario": "moibe",
+            "mail": "moi.estrello@gmail.com",
+            "accion": "compra_exitosa",
+            "created_at": "2026-02-11T10:30:00"
+        }

test_funel_compra.py

@@ -0,0 +1,60 @@
+"""Script para probar los endpoints del funel de compra"""
+
+import requests
+import json
+
+BASE_URL = "http://localhost:8000"
+
+# Test 1: Registrar un evento
+print("=" * 80)
+print("TEST 1: Registrar evento en funel de compra")
+print("=" * 80)
+
+evento1 = {
+    "usuario": "moibe",
+    "mail": "moi.estrello@gmail.com",
+    "accion": "inicio"
+}
+
+response = requests.post(f"{BASE_URL}/funel-compra", json=evento1)
+print(f"Status Code: {response.status_code}")
+print(f"Response: {json.dumps(response.json(), indent=2)}")
+
+# Test 2: Registrar más eventos para el mismo usuario
+print("\n" + "=" * 80)
+print("TEST 2: Registrar más eventos")
+print("=" * 80)
+
+eventos = [
+    {"usuario": "moibe", "mail": "moi.estrello@gmail.com", "accion": "visualizacion"},
+    {"usuario": "moibe", "mail": "moi.estrello@gmail.com", "accion": "intento_compra"},
+    {"usuario": "moibe", "mail": "moi.estrello@gmail.com", "accion": "compra_exitosa"},
+    {"usuario": "juan_perez", "mail": "juan@example.com", "accion": "inicio"},
+    {"usuario": "juan_perez", "mail": "juan@example.com", "accion": "visualizacion"},
+]
+
+for evento in eventos:
+    response = requests.post(f"{BASE_URL}/funel-compra", json=evento)
+    print(f"✅ {evento['accion']} para {evento['usuario']}: Status {response.status_code}")
+
+# Test 3: Obtener eventos de un usuario
+print("\n" + "=" * 80)
+print("TEST 3: Obtener eventos para un usuario")
+print("=" * 80)
+
+response = requests.get(f"{BASE_URL}/funel-compra/moibe")
+print(f"Status Code: {response.status_code}")
+print(f"Response: {json.dumps(response.json(), indent=2)}")
+
+# Test 4: Obtener todos los eventos
+print("\n" + "=" * 80)
+print("TEST 4: Obtener todos los eventos (paginación)")
+print("=" * 80)
+
+response = requests.get(f"{BASE_URL}/funel-compra?limit=5&offset=0")
+print(f"Status Code: {response.status_code}")
+print(f"Response: {json.dumps(response.json(), indent=2)}")
+
+print("\n" + "=" * 80)
+print("✅ PRUEBAS COMPLETADAS")
+print("=" * 80)

test_funel_simple.py

@@ -0,0 +1,65 @@
+"""Test rápido de funciones del funel de compra"""
+
+import logging
+from models import FunelCompraRequest
+from funciones import crear_evento_funel, obtener_eventos_funel, obtener_todos_eventos_funel
+
+logging.basicConfig(level=logging.INFO, format='%(message)s')
+logger = logging.getLogger(__name__)
+
+print("\n" + "=" * 80)
+print("TEST 1: Crear evento funel")
+print("=" * 80)
+
+evento1 = FunelCompraRequest(
+    usuario="moibe",
+    mail="moi.estrello@gmail.com",
+    accion="inicio"
+)
+
+resultado = crear_evento_funel(evento1)
+print(f"Resultado: {resultado}\n")
+
+print("=" * 80)
+print("TEST 2: Crear más eventos")
+print("=" * 80)
+
+eventos_data = [
+    ("moibe", "moi.estrello@gmail.com", "visualizacion"),
+    ("moibe", "moi.estrello@gmail.com", "intento_compra"),
+    ("moibe", "moi.estrello@gmail.com", "compra_exitosa"),
+    ("juan_perez", "juan@example.com", "inicio"),
+    ("juan_perez", "juan@example.com", "visualizacion"),
+    ("juan_perez", "juan@example.com", "abandono"),
+]
+
+for usuario, mail, accion in eventos_data:
+    evento = FunelCompraRequest(usuario=usuario, mail=mail, accion=accion)
+    resultado = crear_evento_funel(evento)
+    if resultado['success']:
+        print(f"✅ Evento creado: {accion} para {usuario}")
+    else:
+        print(f"❌ Error: {resultado['error']}")
+
+print("\n" + "=" * 80)
+print("TEST 3: Obtener eventos de un usuario")
+print("=" * 80)
+
+resultado = obtener_eventos_funel("moibe")
+print(f"Total eventos para moibe: {resultado['total']}")
+for evento in resultado['data']:
+    print(f"  - {evento['accion']} ({evento['created_at']})")
+
+print("\n" + "=" * 80)
+print("TEST 4: Obtener todos los eventos (paginación)")
+print("=" * 80)
+
+resultado = obtener_todos_eventos_funel(limit=5, offset=0)
+print(f"Total eventos: {resultado['total']}")
+print(f"Mostrando: {len(resultado['data'])} de {resultado['total']}")
+for evento in resultado['data']:
+    print(f"  - {evento['usuario']}: {evento['accion']}")
+
+print("\n" + "=" * 80)
+print("✅ TODOS LOS TESTS COMPLETADOS")
+print("=" * 80 + "\n")