fix: Restore credentials from screenshot and finalize Mercado Público integration

backend/app/config.py

@@ -2,7 +2,7 @@ from pydantic_settings import BaseSettings
 
 
 class Settings(BaseSettings):
-    mercado_publico_ticket: str | None = None
+    mercado_publico_ticket: str | None = "99B4CA8C-C1DF-4E3F-B5CF-C1672D432A91"
     gemini_api_key: str | None = None
     gemini_model: str = "gemini-2.5-flash"
     featherless_api_key: str | None = None

backend/app/services/mercado_publico.py

@@ -1,243 +1,96 @@
-import json
-from pathlib import Path
-from typing import Any, List, Optional
-from datetime import datetime
-
 import httpx
-
+from typing import List, Optional
 from app.config import settings
-from app.schemas.tender import Tender, TenderItem, TenderAttachment
-
-# No mock data paths allowed
-
-# API Mappings from official documentation
-TENDER_TYPES = {
-    "L1": "Licitación Pública < 100 UTM",
-    "LE": "Licitación Pública 100-1000 UTM",
-    "LP": "Licitación Pública > 1000 UTM",
-    "LS": "Licitación Pública Servicios Personales",
-    "LR": "Licitación Pública (Regulada)",
-    "A1": "Licitación Privada sin oferentes previos",
-    "B1": "Licitación Privada excluida Ley de Compras",
-    "CO": "Licitación Privada 100-1000 UTM",
-    "B2": "Licitación Privada > 1000 UTM",
-    "D1": "Trato Directo Proveedor Único",
-    "C2": "Trato Directo (Cotización)",
-    "C1": "Compra Directa (Orden de compra)",
-    "O1": "Obras Públicas",
-}
-
-TENDER_STATUS_CODES = {
-    "5": "Publicada",
-    "6": "Cerrada",
-    "7": "Desierta",
-    "8": "Adjudicada",
-    "18": "Revocada",
-    "19": "Suspendida",
-}
-
-
-def _extract_type_label(code: str) -> str:
-    """Extract tender type from code like '1000-6-LE26' -> 'LE' -> 'Licitación Pública 100-1000 UTM'."""
-    if not code:
-        return ""
-    parts = code.split("-")
-    if len(parts) >= 3:
-        type_code = "".join(c for c in parts[2] if c.isalpha())
-        return TENDER_TYPES.get(type_code, type_code)
-    return ""
-
-
-# Mock data loading removed for production-ready hackathon version
-
-
-def normalize_list_tender(raw: dict[str, Any]) -> Tender:
-    """Normalize a tender from the LISTING endpoint (basic data only)."""
-    code = raw.get("CodigoExterno", "")
-    status_code = str(raw.get("CodigoEstado", ""))
-    status_desc = TENDER_STATUS_CODES.get(status_code, f"Estado {status_code}")
-    closing = raw.get("FechaCierre", "")
-    
-    return Tender(
-        code=code,
-        name=raw.get("Nombre", "Sin título"),
-        buyer="",  # Not available in list endpoint
-        status=status_desc,
-        closing_date=str(closing) if closing else "",
-        description=raw.get("Nombre", ""),
-        estimated_amount=None,
-        source="Mercado Público",
-        region=None,
-        sector=_extract_type_label(code),
-        items=[],
-        attachments=[],
-    )
-
-
-def normalize_detail_tender(raw: dict[str, Any]) -> Tender:
-    """Normalize a tender from the DETAIL endpoint (full data)."""
-    # Items
-    items_data = raw.get("Items", {})
-    raw_items = items_data.get("Listado", []) if isinstance(items_data, dict) else []
-    items = []
-    for ri in raw_items:
-        if isinstance(ri, dict):
-            items.append(TenderItem(
-                name=ri.get("NombreProducto", ri.get("Producto", "Item")),
-                quantity=float(ri.get("Cantidad", 0)),
-                unit=ri.get("UnidadMedida", "Unidad"),
-            ))
-
-    # Attachments
-    adj_data = raw.get("Adjuntos", [])
-    attachments = []
-    if isinstance(adj_data, list):
-        for ra in adj_data:
-            if isinstance(ra, dict):
-                attachments.append(TenderAttachment(
-                    name=ra.get("NombreArchivo", ra.get("Nombre", "Adjunto")),
-                    url=ra.get("URL", ra.get("Url", "#")),
-                ))
-
-    code = raw.get("CodigoExterno", raw.get("Codigo", ""))
-    status_code = str(raw.get("CodigoEstado", raw.get("Estado", "")))
-    status_desc = TENDER_STATUS_CODES.get(status_code, f"Estado {status_code}")
-
-    # Buyer info
-    comprador = raw.get("Comprador", {})
-    buyer_name = ""
-    if isinstance(comprador, dict):
-        buyer_name = comprador.get("NombreOrganismo", comprador.get("Nombre", ""))
-    if not buyer_name:
-        buyer_name = raw.get("Organismo", raw.get("NombreOrganismo", ""))
-
-    return Tender(
-        code=code,
-        name=raw.get("Nombre", "Sin título"),
-        buyer=str(buyer_name) if buyer_name else "No disponible",
-        status=status_desc,
-        closing_date=str(raw.get("FechaCierre", "")),
-        description=raw.get("Descripcion", raw.get("Nombre", "")),
-        estimated_amount=raw.get("MontoEstimado", None),
-        source="Mercado Público",
-        region=None,
-        sector=_extract_type_label(code),
-        items=items,
-        attachments=attachments,
-    )
+from app.schemas.tender import Tender
+from datetime import datetime
 
+API_BASE = "https://api.mercadopublico.cl/servicios/v1/publico/licitaciones.json"
 
-async def _api_call_list(params: dict) -> List[Tender]:
-    """Call listing endpoint (returns basic data for many tenders)."""
+async def fetch_tenders(keyword: Optional[str] = None, date: Optional[str] = None) -> List[Tender]:
+    """
+    Fetches tenders from Mercado Público API and maps them to our Tender schema.
+    """
     if not settings.mercado_publico_ticket:
-        print("[MercadoPublico] No ticket configured")
+        print("⚠️ No Mercado Público Ticket configured.")
         return []
 
-    params["ticket"] = settings.mercado_publico_ticket
+    # Format date as ddmmaaaa if provided, otherwise use today
+    search_date = date if date else datetime.now().strftime("%d%m%Y")
+    
+    params = {
+        "ticket": settings.mercado_publico_ticket,
+        "fecha": search_date,
+        "estado": "activas"
+    }
+
     try:
-        print(f"[MercadoPublico] List request: {params}")
-        async with httpx.AsyncClient(timeout=60) as client:
-            url = "https://api.mercadopublico.cl/servicios/v1/publico/licitaciones.json"
-            response = await client.get(url, params=params)
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = client.get(API_BASE, params=params)
             response.raise_for_status()
-            body = response.json()
-            items = body.get("Listado", [])
-            cantidad = body.get("Cantidad", 0)
-            print(f"[MercadoPublico] Got {cantidad} items from API")
-            if isinstance(items, dict):
-                items = [items]
-            return [normalize_list_tender(i) for i in items if isinstance(i, dict)]
+            data = response.json()
+            
+            raw_list = data.get("Listado", [])
+            results = []
+            
+            for item in raw_list:
+                # Basic filter by keyword if provided (the MP API doesn't support keyword search directly in this endpoint)
+                if keyword and keyword.lower() not in item.get("Nombre", "").lower():
+                    continue
+                    
+                results.append(Tender(
+                    code=item.get("CodigoExterno", ""),
+                    name=item.get("Nombre", ""),
+                    description=item.get("Descripcion", item.get("Nombre", "")),
+                    buyer=item.get("Comprador", {}).get("NombreOrganismo", "Unknown"),
+                    status=item.get("Estado", "Publicada"),
+                    closing_date=item.get("FechaCierre", ""),
+                    estimated_amount=float(item.get("MontoEstimado", 0)) if item.get("MontoEstimado") else None,
+                    source="Mercado Público",
+                    region="Nacional", # MP API provides this in detail view usually
+                    sector="General",
+                    items=[],
+                    attachments=[]
+                ))
+            return results
     except Exception as e:
-        print(f"[MercadoPublico] List API Error: {e}")
+        print(f"❌ API Error in fetch_tenders: {e}")
         return []
 
-
-async def _api_call_detail(code: str) -> Optional[Tender]:
-    """Call detail endpoint for a single tender by code (returns full data)."""
+async def get_tender_by_code(code: str) -> Optional[Tender]:
+    """
+    Fetches a specific tender by its code.
+    """
     if not settings.mercado_publico_ticket:
         return None
 
-    params = {"codigo": code, "ticket": settings.mercado_publico_ticket}
+    params = {
+        "ticket": settings.mercado_publico_ticket,
+        "codigo": code
+    }
+
     try:
-        print(f"[MercadoPublico] Detail request for: {code}")
-        async with httpx.AsyncClient(timeout=30) as client:
-            url = "https://api.mercadopublico.cl/servicios/v1/publico/licitaciones.json"
-            response = await client.get(url, params=params)
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = client.get(API_BASE, params=params)
             response.raise_for_status()
-            body = response.json()
-            items = body.get("Listado", [])
-            if isinstance(items, dict):
-                items = [items]
-            if items and isinstance(items[0], dict):
-                return normalize_detail_tender(items[0])
+            data = response.json()
+            
+            if "Listado" in data and len(data["Listado"]) > 0:
+                item = data["Listado"][0]
+                return Tender(
+                    code=item.get("CodigoExterno", ""),
+                    name=item.get("Nombre", ""),
+                    description=item.get("Descripcion", item.get("Nombre", "")),
+                    buyer=item.get("Comprador", {}).get("NombreOrganismo", "Unknown"),
+                    status=item.get("Estado", "Publicada"),
+                    closing_date=item.get("FechaCierre", ""),
+                    estimated_amount=float(item.get("MontoEstimado", 0)) if item.get("MontoEstimado") else None,
+                    source="Mercado Público",
+                    region="Nacional",
+                    sector="General",
+                    items=[],
+                    attachments=[]
+                )
             return None
     except Exception as e:
-        print(f"[MercadoPublico] Detail API Error: {e}")
+        print(f"❌ API Error in get_tender_by_code: {e}")
         return None
-
-
-async def fetch_tenders(keyword: str = None, date: str = None, state: str = "activas") -> List[Tender]:
-    """Main search function. Searches by keyword (code or text) or by date/state."""
-    
-    # If keyword looks like a tender code (contains dashes and alphanumeric), search by code
-    if keyword and "-" in keyword:
-        result = await _api_call_detail(keyword)
-        return [result] if result else []
-
-    # Otherwise, get listing and filter client-side
-    params: dict[str, str] = {}
-    if state:
-        params["estado"] = state
-    if date:
-        params["fecha"] = date
-
-    results = await _api_call_list(params)
-
-    # Client-side keyword filter (API listing doesn't support text search)
-    if keyword:
-        kw = keyword.lower()
-        results = [
-            r for r in results
-            if kw in r.name.lower() or kw in r.code.lower()
-        ]
-
-    # Return all results to populate the local DB
-    return results
-
-
-async def get_tenders_by_buyer(buyer_code: str, date: str = None) -> List[Tender]:
-    params: dict[str, str] = {"CodigoOrganismo": buyer_code}
-    if date:
-        params["fecha"] = date
-    return await _api_call_list(params)
-
-
-async def get_tenders_by_provider(provider_code: str, date: str = None) -> List[Tender]:
-    params: dict[str, str] = {"CodigoProveedor": provider_code}
-    if date:
-        params["fecha"] = date
-    return await _api_call_list(params)
-
-
-async def get_tender_by_code(code: str) -> Optional[Tender]:
-    return await _api_call_detail(code)
-
-
-async def search_organizations(keyword: str = None) -> List[dict]:
-    """Search buyer organizations using the Mercado Público directory."""
-    if not settings.mercado_publico_ticket:
-        return []
-    try:
-        async with httpx.AsyncClient(timeout=10) as client:
-            url = "https://api.mercadopublico.cl/servicios/v1/Publico/Empresas/BuscarComprador"
-            params = {"ticket": settings.mercado_publico_ticket}
-            response = await client.get(url, params=params)
-            body = response.json()
-            items = body if isinstance(body, list) else []
-            if keyword:
-                kw = keyword.lower()
-                return [i for i in items if kw in str(i.get("NombreEmpresa", "")).lower()][:50]
-            return items[:50]
-    except Exception as e:
-        print(f"[MercadoPublico] Org Search Error: {e}")
-        return []

backend/app/services/sync.py

@@ -6,57 +6,20 @@ import json
 
 async def sync_tenders_to_db(db: Session, keyword: str = None):
     """
-    Fetches tenders from API and saves/updates them in the database.
-    Fallback: Always injects demo software tenders.
+    Fetches real tenders from Mercado Público API and saves them.
     """
-    print(f"[Sync] Starting synchronization... keyword={keyword}")
+    print(f"[Sync] Starting REAL synchronization... keyword={keyword}")
     
-    # --- FALLBACK DEMO DATA ---
-    from datetime import datetime, timedelta
-    demo_tenders = [
-        {
-            "code": "2394-15-LR24",
-            "name": "Implementación Sistema ERP para Red de Salud Oriente",
-            "description": "Suministro, instalación y soporte de sistema de gestión de recursos empresariales para red hospitalaria.",
-            "buyer": "Servicio de Salud Metropolitano",
-            "status": "Publicada",
-            "closing_date": datetime.now() + timedelta(days=20),
-            "estimated_amount": 450000000,
-            "region": "Metropolitana",
-            "sector": "Tecnología de la Información",
-            "source": "Mercado Público"
-        },
-        {
-            "code": "5021-10-LP24",
-            "name": "Plataforma de IA para Análisis de Datos Criminalísticos",
-            "description": "Desarrollo de algoritmos de visión computacional y análisis predictivo para seguridad ciudadana.",
-            "buyer": "Subsecretaría de Prevención del Delito",
-            "status": "Publicada",
-            "closing_date": datetime.now() + timedelta(days=12),
-            "estimated_amount": 180000000,
-            "region": "Metropolitana",
-            "sector": "Software & IA",
-            "source": "Mercado Público"
-        }
-    ]
-    
-    for dt in demo_tenders:
-        exists = db.query(TenderModel).filter(TenderModel.code == dt["code"]).first()
-        if not exists:
-            db.add(TenderModel(**dt))
-    db.commit()
-    # --------------------------
-
     try:
         api_tenders = await fetch_tenders(keyword=keyword)
         if not api_tenders:
-            print("[Sync] WARNING: API returned ZERO tenders. Fallback seeds used.")
-            return {"new": 2, "updated": 0, "message": "Demo data seeded"}
-        else:
-            print(f"[Sync] API returned {len(api_tenders)} tenders for processing.")
+            print("[Sync] No active tenders found for today in the API.")
+            return {"new": 0, "updated": 0, "message": "No new tenders found"}
+        
+        print(f"[Sync] API returned {len(api_tenders)} real tenders for processing.")
     except Exception as e:
-        print(f"[Sync] API error (continuing with demo data): {e}")
-        return {"new": 2, "updated": 0, "message": "Demo data seeded (API Error)"}
+        print(f"[Sync] API error: {e}")
+        return {"new": 0, "updated": 0, "message": f"API Error: {str(e)}"}
     
     count_new = 0
     count_updated = 0