adision de bases para trabajo completo de back-v1.0.0

app/modules/edos/models.py

@@ -20,7 +20,7 @@ class EDOS(Base):
     razon_social = Column(String(100), nullable=False)
     situacion  = Column(SQLEnum(Situacion, name="situcion", create_type=False), nullable=False)
     numero_definitivo = Column(String(60), nullable=False)
-    fecha_definitivo = Column(Date, nullable=False )
+    fecha_definitivo = Column(Date, nullable=True )
     publicaccion_sat = Column(Date, nullable=True)
     numero_def_dof = Column(String(100), nullable=True)
     fecha_def_dof = Column(Date, nullable=True)

app/modules/edos/route.py

@@ -0,0 +1,77 @@
+
+from fastapi import APIRouter, HTTPException, Query, Body
+from app.modules.edos.service import XMACSVService
+from typing import Optional, Dict, Any
+
+from app.helpers.extractCsv import CSVExtractor
+
+router = APIRouter(prefix='/api/csv', tags=['CSV Import'])
+
+@router.post('/import-from-url')
+async def import_csv(data: Dict[str, Any] = Body(..., example={"url": "http://example.com/data.csv"})):
+    """Endpoint to download CSV and process, write and see on DB"""
+
+
+    csv_url = data.get('url')
+    dry_run = data.get('dry_run', True)
+    max_rows = data.get('max_rows')
+
+    if not csv_url:
+        raise HTTPException(400, "url del CSV requerida")
+    
+    if not isinstance(csv_url, str):
+        raise HTTPException(
+            status_code=400,
+            detail="la URL debe ser un texto valido"
+        )
+    
+    try: 
+        result = XMACSVService.process_csv_from_url(
+            csv_url= csv_url,
+            dry_run=dry_run,
+            max_rows=max_rows,
+        )
+
+        return {
+            'status' : 'success',
+            'message': 'Procesamiento completado',
+            'data': result
+        }
+  
+    except Exception as e: 
+        print(f"Error on endpoint: {str(e)}")
+        import traceback
+        traceback.print_exc()
+
+        raise HTTPException(
+            status_code=500,
+            detail=f"Procesing CSV error: {str(e)}"
+        )
+    
+
+@router.post('/import-from-url/v2')
+async def import_csv(data: dict):
+    """Endpoint simple para probar el extractor"""
+    csv_url = data.get('url')
+    
+    if not csv_url:
+        raise HTTPException(400, "url del CSV requerida")
+    
+    try:
+        # Probar extractor
+        content = CSVExtractor.download_csv(csv_url)
+        rows = CSVExtractor.read_csv(content)
+        
+        return {
+            'status': 'success',
+            'message': 'CSV procesado correctamente',
+            'data': {
+                'url': csv_url,
+                'total_filas': len(rows),
+                'primeras_filas': rows[:3] if rows else [],
+                'columnas': list(rows[0].keys()) if rows else []
+            }
+        }
+        
+    except Exception as e:
+        raise HTTPException(500, detail=str(e))

app/modules/edos/schema.py

@@ -1,6 +1,33 @@
 from pydantic import BaseModel, EmailStr, Field, validator
-from datetime import datetime
+from datetime import datetime, date
 from typing import Optional
 #
 import re
-from enum import Enum
+from enum import Enum
+
+class Situacion(Enum):
+    SENTENCIA_FAVORABLE ="sentencia_favorable"
+    DEFINITIVO="definitivo"
+
+
+class EdosUpload(BaseModel):
+    numero : str
+    razon_social : str
+    situacion : Situacion
+    numero_definitivo : str
+    fecha_definitivo : date
+    publicaccion_sat : date
+    numero_def_dof : str
+    fecha_def_dof : date
+    publicacion_dof : date
+    numero_fav_sat : str
+
+
+class EdosResponse(EdosUpload):
+    pass
+
+
+class messageResponse(BaseModel):
+    message: str
+
+

app/modules/edos/service.py

@@ -0,0 +1,74 @@
+from sqlalchemy.orm import Session
+from datetime import datetime
+from typing import Optional
+from fastapi import HTTPException
+from app.modules.edos.models import EDOS
+from app.modules.edos.schema import EdosResponse, EdosUpload, messageResponse
+
+
+from app.helpers.csv_mapper import CSVMapper
+from app.helpers.db_adapter import DBAdapter
+from app.helpers.extractCsv import CSVExtractor
+
+class XMACSVService:
+    """ Orquester"""
+
+    @staticmethod
+    def process_csv_from_url(
+        csv_url: str,
+        dry_run: bool = False,
+        max_rows: int = None
+        ) -> dict:
+        """ flow download and parsing, filter and adapt"""
+
+
+        try:
+            # X - EXTRACT
+            print(f"📥 Descargando CSV: {csv_url}")
+            
+            # ✅ Ahora download_csv retorna (content, encoding)
+            content, encoding = CSVExtractor.download_csv(csv_url)
+            print(f"   ✅ Descargado {len(content)} bytes, encoding: {encoding}")
+            
+            # Parsear CSV
+            raw_rows = CSVExtractor.read_csv(content)
+            print(f"   ✅ Parseadas {len(raw_rows)} filas")
+            
+            if not raw_rows:
+                return {
+                    'total_extracted': 0,
+                    'total_mapped': 0,
+                    'inserted': 0,
+                    'errors': ['No se encontraron datos en el CSV']
+                }
+            
+            # Mostrar columnas encontradas
+            print(f"   📋 Columnas: {list(raw_rows[0].keys())}")
+            
+            # M - MAP (si tienes mapper)
+            # Por ahora, usar datos crudos
+            mapped_rows = raw_rows
+            
+            if max_rows:
+                mapped_rows = mapped_rows[:max_rows]
+                print(f"   🔒 Limitado a {max_rows} filas")
+            
+            # A - ADAPT
+            if not dry_run:
+                print(f"   💾 Insertando {len(mapped_rows)} filas en BD")
+                # Aquí iría la inserción en BD
+            
+            return {
+                'total_extracted': len(raw_rows),
+                'total_mapped': len(mapped_rows),
+                'inserted': len(mapped_rows) if not dry_run else 0,
+                'dry_run': dry_run,
+                'columns': list(raw_rows[0].keys()) if raw_rows else [],
+                'sample': raw_rows[:2] if raw_rows else []
+            }
+            
+        except Exception as e:
+            print(f"❌ Error: {str(e)}")
+            import traceback
+            traceback.print_exc()
+            raise