Refactor services to use repository pattern for database operations

- Updated EmpresaReportService to utilize ICatalogoRepository for stored procedure calls.
- Refactored InformeService to include new method for executing Crystal Reports stored procedures.
- Simplified LeadService by removing direct database connections and using ILeadRepository and ILeadQueryRepository.
- Modified ReportService to leverage ICatalogoRepository for querying stored procedures.
- Streamlined UsuarioService to use IUsuarioRepository for user authentication and profile retrieval.
- Added new CatalogoService to handle various catalog-related queries and operations.
- Introduced ArqueoRepository and CatalogoRepository for managing database interactions.
- Created DTOs for various entities including Alumno, Contrato, Cotizacion, Descuento, Documento, Empresa, and Propuesta.
- Implemented BaseController and ErrorController for standardized API responses and error handling.
- Added QuestPDF package for PDF generation capabilities.

backend/src/Ventas.API/Controllers/AlumnoController.cs

@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Core.DTOs;
 using Ventas.Services;
 
 namespace Ventas.API.Controllers;
@@ -28,7 +29,8 @@ public class AlumnoController : ControllerBase
     {
         var result = await _alumnoService.IngresarV2Async(
             request.Rut, request.Nombre, request.Paterno, request.Materno,
-            request.Fecha, request.Fono, request.Mail, request.Ocupacion, request.ProfesionOficio);
+            request.Direccion, request.Comuna, request.Fecha, request.Fono,
+            request.Mail, request.Ocupacion, request.ProfesionOficio);
         return Ok(new { mensaje = result });
     }
 
@@ -77,8 +79,8 @@ public class AlumnoController : ControllerBase
         return Ok(result);
     }
 
-    [HttpGet("{id}/formas-pago")]
+    [HttpGet("formas-pago")]
-    public async Task<IActionResult> FormasPago(string id, [FromQuery] int boleta)
+    public async Task<IActionResult> FormasPago([FromQuery] int boleta)
     {
         var result = await _alumnoService.BuscarFormasPagoAsync(boleta);
         return Ok(result);
@@ -112,30 +114,3 @@ public class AlumnoController : ControllerBase
         return Ok(result);
     }
 }
-
-public class AlumnoIngresoRequest
-{
-    public string Rut { get; set; } = string.Empty;
-    public string Nombre { get; set; } = string.Empty;
-    public string Paterno { get; set; } = string.Empty;
-    public string Materno { get; set; } = string.Empty;
-    public string Fecha { get; set; } = string.Empty;
-    public string Fono { get; set; } = string.Empty;
-    public string Mail { get; set; } = string.Empty;
-    public int Ocupacion { get; set; }
-    public string ProfesionOficio { get; set; } = string.Empty;
-}
-
-public class ApoderadoIngresoRequest
-{
-    public string RutApoderado { get; set; } = string.Empty;
-    public string RutAlumno { get; set; } = string.Empty;
-    public string Nombre { get; set; } = string.Empty;
-    public string Paterno { get; set; } = string.Empty;
-    public string Materno { get; set; } = string.Empty;
-    public string Direccion { get; set; } = string.Empty;
-    public string Comuna { get; set; } = string.Empty;
-    public int Nacionalidad { get; set; }
-    public string Fono { get; set; } = string.Empty;
-    public string Mail { get; set; } = string.Empty;
-}

backend/src/Ventas.API/Controllers/AuthController.cs

@@ -18,6 +18,7 @@ public class AuthController : ControllerBase
         _jwtService = jwtService;
     }
 
+    [AllowAnonymous]
     [HttpPost("login")]
     public async Task<IActionResult> Login([FromBody] LoginRequest request)
     {
@@ -25,12 +26,12 @@ public class AuthController : ControllerBase
         if (usuario == null)
             return Unauthorized(new { mensaje = "Credenciales inválidas" });
 
-        var token = _jwtService.GenerateToken(request.Rut, usuario.Nombre, usuario.Sede ?? "");
+        var token = _jwtService.GenerateToken(request.Rut, usuario.Nombre ?? "", usuario.Sede ?? "");
 
         Response.Cookies.Append("SAM_TOKEN", token, new CookieOptions
         {
             HttpOnly = true,
-            Secure = true,
+            Secure = HttpContext.Request.IsHttps,
             SameSite = SameSiteMode.Strict,
             Expires = DateTime.UtcNow.AddMinutes(30)
         });

backend/src/Ventas.API/Controllers/BaseController.cs

@@ -0,0 +1,12 @@
+using Microsoft.AspNetCore.Mvc;
+
+namespace Ventas.API.Controllers;
+
+[ApiController]
+public abstract class BaseController : ControllerBase
+{
+    protected static async Task<IActionResult> OkResult(Task<IEnumerable<Dictionary<string, object>>> task)
+        => new OkObjectResult(await task);
+
+    protected static IActionResult OkResultSync<T>(T value) => new OkObjectResult(value);
+}

backend/src/Ventas.API/Controllers/ContratoController.cs

@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Core.DTOs;
 using Ventas.Services;
 
 namespace Ventas.API.Controllers;
@@ -17,16 +18,19 @@ public class ContratoController : ControllerBase
     }
 
     [HttpPost]
-    public async Task<IActionResult> Ingresar([FromQuery] int cotizacionId, [FromQuery] string fechaContrato, [FromQuery] int boletaId, [FromQuery] int vendedorId)
+    public async Task<IActionResult> Ingresar([FromBody] ContratoIngresoRequest request)
     {
-        var result = await _contratoService.IngresarAsync(cotizacionId, fechaContrato, boletaId, vendedorId);
+        if (string.IsNullOrEmpty(request.FechaContrato))
+            return BadRequest(new { mensaje = "FechaContrato es requerido" });
+
+        var result = await _contratoService.IngresarAsync(request.CotizacionId, request.BoletaCKT, request.FechaContrato, request.BoletaId, request.VendedorId);
         return Ok(new { id = result });
     }
 
     [HttpPost("detalle")]
-    public async Task<IActionResult> IngresarDetalle([FromQuery] int contratoId, [FromQuery] string empresaId, [FromQuery] string alumnoId, [FromQuery] string cursoId, [FromQuery] string fecha, [FromQuery] int vendedor, [FromQuery] int registroAcademico, [FromQuery] int alumnoTipo)
+    public async Task<IActionResult> IngresarDetalle([FromBody] ContratoDetalleRequest request)
     {
-        var result = await _contratoService.IngresarDetalleAsync(contratoId, empresaId, alumnoId, cursoId, fecha, vendedor, registroAcademico, alumnoTipo);
+        var result = await _contratoService.IngresarDetalleAsync(request.ContratoId, request.EmpresaId, request.AlumnoId, request.CursoId, request.Fecha, request.Vendedor, request.RegistroAcademico, request.AlumnoTipo);
         return Ok(new { id = result });
     }
 
@@ -49,16 +53,19 @@ public class ContratoController : ControllerBase
     }
 
     [HttpPost("empresa")]
-    public async Task<IActionResult> IngresarContratoEmpresa([FromQuery] int cotizacionId, [FromQuery] string empresaId, [FromQuery] int tipoVenta, [FromQuery] int facturaId, [FromQuery] int cantCursos, [FromQuery] int vendedorId)
+    public async Task<IActionResult> IngresarContratoEmpresa([FromBody] ContratoEmpresaRequest request)
     {
-        var result = await _contratoService.IngresarContratoEmpresaAsync(cotizacionId, empresaId, tipoVenta, facturaId, cantCursos, vendedorId);
+        var result = await _contratoService.IngresarContratoEmpresaAsync(request.CotizacionId, request.EmpresaId, request.TipoVenta, request.FacturaId, request.CantCursos, request.VendedorId);
         return Ok(new { id = result });
     }
 
     [HttpPost("cerrado")]
-    public async Task<IActionResult> IngresarContratoCerrado([FromQuery] int prop, [FromQuery] string rut, [FromQuery] int tipoVenta, [FromQuery] string vendedorId)
+    public async Task<IActionResult> IngresarContratoCerrado([FromBody] ContratoCerradoRequest request)
     {
-        var result = await _contratoService.IngresarContratoCerradoAsync(prop, rut, tipoVenta, vendedorId);
+        if (string.IsNullOrEmpty(request.Rut))
+            return BadRequest(new { mensaje = "Rut es requerido" });
+
+        var result = await _contratoService.IngresarContratoCerradoAsync(request.PropuestaId, request.Rut, request.TipoVenta, request.VendedorId);
         return Ok(new { id = result });
     }
 
@@ -70,16 +77,16 @@ public class ContratoController : ControllerBase
     }
 
     [HttpPut("{id}/estado")]
-    public async Task<IActionResult> ActualizarEstado(int id, [FromQuery] string tipo, [FromQuery] string varA, [FromQuery] int varB)
+    public async Task<IActionResult> ActualizarEstado(int id, [FromBody] ContratoEstadoUpdateRequest request)
     {
-        var result = await _contratoService.ActualizarEstadoContratoAsync(tipo, id, varA, varB);
+        var result = await _contratoService.ActualizarEstadoContratoAsync(request.Tipo, id, request.ValorA ?? "", request.ValorB);
         return Ok(new { mensaje = result });
     }
 
     [HttpPut("{id}/firma")]
-    public async Task<IActionResult> ActualizarFirma(int id, [FromQuery] string tipo, [FromQuery] int firmado)
+    public async Task<IActionResult> ActualizarFirma(int id, [FromBody] ContratoFirmaRequest request)
     {
-        var result = await _contratoService.ActualizarFirmaContratoAsync(tipo, id, firmado);
+        var result = await _contratoService.ActualizarFirmaContratoAsync(request.Tipo, id, request.Firmado);
         return Ok(new { mensaje = result });
     }
 }

backend/src/Ventas.API/Controllers/CotizacionController.cs

@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Core.DTOs;
 using Ventas.Services;
 
 namespace Ventas.API.Controllers;
@@ -17,23 +18,23 @@ public class CotizacionController : ControllerBase
     }
 
     [HttpPost]
-    public async Task<IActionResult> Ingresar([FromQuery] string apoderadoId, [FromQuery] string vendedorId, [FromQuery] int descuento, [FromQuery] int tipoDescuento, [FromQuery] string fecha, [FromQuery] int monto, [FromQuery] string validez, [FromQuery] int leadId)
+    public async Task<IActionResult> Ingresar([FromBody] CotizacionIngresoRequest request)
     {
-        var result = await _cotizacionService.IngresarAsync(apoderadoId, vendedorId, descuento, tipoDescuento, fecha, monto, validez, leadId);
+        var result = await _cotizacionService.IngresarAsync(request.ApoderadoId, request.VendedorId, request.SolicitudDescuento, request.Descuento, request.TipoDescuento, request.Fecha, request.Alumnos, request.Curso, request.Monto, request.Validez, request.LeadId);
         return Ok(new { id = result });
     }
 
     [HttpPost("detalle")]
-    public async Task<IActionResult> IngresarDetalle([FromQuery] int cotizacion, [FromQuery] string alumnoId, [FromQuery] int cursoId, [FromQuery] int cantidad, [FromQuery] int tarifa)
+    public async Task<IActionResult> IngresarDetalle([FromBody] CotizacionDetalleRequest request)
     {
-        var result = await _cotizacionService.IngresarDetalleAsync(cotizacion, alumnoId, cursoId, cantidad, tarifa);
+        var result = await _cotizacionService.IngresarDetalleAsync(request.CotizacionId, request.AlumnoId, request.CursoId, request.Cantidad, request.Tarifa);
         return Ok(new { mensaje = result });
     }
 
     [HttpPost("detalle-sin-curso")]
-    public async Task<IActionResult> DetalleSinCurso([FromQuery] int cotizacion, [FromQuery] string alumnoId, [FromQuery] string apoderadoId, [FromQuery] int programaId, [FromQuery] int cantidad, [FromQuery] int tarifa, [FromQuery] int sedeId)
+    public async Task<IActionResult> DetalleSinCurso([FromBody] CotizacionDetalleSinCursoRequest request)
     {
-        var result = await _cotizacionService.DetalleSinCursoAsync(cotizacion, alumnoId, apoderadoId, programaId, cantidad, tarifa, sedeId);
+        var result = await _cotizacionService.DetalleSinCursoAsync(request.CotizacionId, request.AlumnoId, request.ApoderadoId, request.ProgramaId, request.Cantidad, request.Tarifa, request.SedeId);
         return Ok(new { mensaje = result });
     }
 
@@ -89,21 +90,11 @@ public class CotizacionController : ControllerBase
             request.EstadoId, request.OticId, request.Motivo);
         return Ok(new { id = result });
     }
-}
 
-public class CotizacionEmpRequest
+    [HttpPut("{id}/estado")]
-{
+    public async Task<IActionResult> ActualizarEstado(int id, [FromBody] CotizacionEstadoUpdateRequest request)
-    public string EmpresaId { get; set; } = string.Empty;
+    {
-    public string Vendedor { get; set; } = string.Empty;
+        var result = await _cotizacionService.ActualizaEstadoCotizacionAsync(request.Tipo, id, request.ValorA ?? "", request.ValorB);
-    public int Alumnos { get; set; }
+        return Ok(new { mensaje = result });
-    public int Curso { get; set; }
+    }
-    public int EmpresaMonto { get; set; }
-    public int OticMonto { get; set; }
-    public int AlumnoMonto { get; set; }
-    public int CotizacionTipo { get; set; }
-    public DateTime Validez { get; set; }
-    public int DescuentoId { get; set; }
-    public int EstadoId { get; set; }
-    public string OticId { get; set; } = string.Empty;
-    public string Motivo { get; set; } = string.Empty;
 }

backend/src/Ventas.API/Controllers/CursoController.cs

@@ -1,47 +1,32 @@
-using Dapper;
-using Npgsql;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Services;
 
 namespace Ventas.API.Controllers;
 
-[ApiController]
 [Route("api/[controller]")]
 [Authorize]
-public class CursoController : ControllerBase
+public class CursoController : BaseController
 {
-    private readonly string _connectionString;
+    private readonly CatalogoService _catalogo;
 
-    public CursoController(IConfiguration configuration)
+    public CursoController(CatalogoService catalogo) => _catalogo = catalogo;
-    {
-        _connectionString = configuration.GetConnectionString("Default")!;
-    }
-
-    private async Task<IEnumerable<Dictionary<string, object>>> QuerySpAsync(string sp, object parameters)
-    {
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync(sp, parameters, commandType: System.Data.CommandType.StoredProcedure);
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
-    }
 
     [HttpGet]
-    public async Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] string nombre)
+    public Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] string nombre)
-        => Ok(await QuerySpAsync("sige_sam_v3.BuscarCurso", new { tipobusqueda = tipoBusqueda, cursonombre = nombre }));
+        => OkResult(_catalogo.CursoBuscarAsync(tipoBusqueda, nombre));
 
     [HttpGet("horario")]
-    public async Task<IActionResult> BuscarHorario([FromQuery] int sede, [FromQuery] int curso)
+    public Task<IActionResult> BuscarHorario([FromQuery] int sede, [FromQuery] int curso)
-        => Ok(await QuerySpAsync("sam.WEB_Horarios_ecommerce", new { cursoid = curso, sedeid = sede }));
+        => OkResult(_catalogo.CursoHorarioAsync(sede, curso));
 
     [HttpGet("fechas-disponibles")]
-    public async Task<IActionResult> FechaDisponibles([FromQuery] int curso, [FromQuery] int sede)
+    public Task<IActionResult> FechaDisponibles([FromQuery] int curso, [FromQuery] int sede)
-        => Ok(await QuerySpAsync("sige_sam_v3.EcommerceFechas", new { cursoid = curso, sedeid = sede }));
+        => OkResult(_catalogo.CursoFechasAsync(curso, sede));
 
     [HttpGet("apertura")]
-    public async Task<IActionResult> BuscarApertura(
+    public Task<IActionResult> BuscarApertura([FromQuery] string tipoBusqueda, [FromQuery] int codigoCurso,
-        [FromQuery] string tipoBusqueda, [FromQuery] int codigoCurso, [FromQuery] int periodo,
+        [FromQuery] int periodo, [FromQuery] int year, [FromQuery] int producto, [FromQuery] int sede,
-        [FromQuery] int year, [FromQuery] int producto, [FromQuery] int sede,
         [FromQuery] int jornada, [FromQuery] int asignacionProfe, [FromQuery] DateTime fecha)
-        => Ok(await QuerySpAsync("sige_sam_v3.BuscarCursosAperturados",
+        => OkResult(_catalogo.CursoAperturaAsync(tipoBusqueda, codigoCurso, periodo, year, producto, sede, jornada, asignacionProfe, fecha));
-            new { tipobusqueda = tipoBusqueda, codigocurso = codigoCurso, periodo, yearperiodo = year,
-                producto, sede, jornada, asignacion = asignacionProfe, fechatermino = fecha }));
 }

backend/src/Ventas.API/Controllers/DescuentoController.cs

@@ -1,49 +1,29 @@
-using Dapper;
-using Npgsql;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Core.DTOs;
+using Ventas.Services;
 
 namespace Ventas.API.Controllers;
 
-[ApiController]
 [Route("api/[controller]")]
 [Authorize]
-public class DescuentoController : ControllerBase
+public class DescuentoController : BaseController
 {
-    private readonly string _connectionString;
+    private readonly CatalogoService _catalogo;
-
+    public DescuentoController(CatalogoService catalogo) => _catalogo = catalogo;
-    public DescuentoController(IConfiguration configuration)
-    {
-        _connectionString = configuration.GetConnectionString("Default")!;
-    }
 
     [HttpGet]
-    public async Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] int sede, [FromQuery] int programa, [FromQuery] int horario)
+    public Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] int sede, [FromQuery] int programa, [FromQuery] int horario)
-    {
+        => OkResult(_catalogo.DescuentoBuscarAsync(tipoBusqueda, sede, programa, horario));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("sige_sam_v3.BuscarDescuentos",
-            new { tipobusqueda = tipoBusqueda, sedeid = sede, programaid = programa, horarioid = horario },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 
     [HttpGet("summer")]
-    public async Task<IActionResult> Summer([FromQuery] int cantidadCursos)
+    public Task<IActionResult> Summer([FromQuery] int cantidadCursos)
-    {
+        => OkResult(_catalogo.DescuentoSummerAsync(cantidadCursos));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("sige_sam_v3.BuscarDesctoSummer",
-            new { cantidad = cantidadCursos },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 
     [HttpPost]
-    public async Task<IActionResult> Ingresar([FromQuery] int cotizacionId, [FromQuery] int descuentoId, [FromQuery] int tipoDescuento, [FromQuery] int nuevoMonto)
+    public async Task<IActionResult> Ingresar([FromBody] DescuentoIngresoRequest request)
     {
-        using var connection = new NpgsqlConnection(_connectionString);
+        var result = await _catalogo.DescuentoIngresarAsync(request.CotizacionId, request.DescuentoId, request.TipoDescuento, request.NuevoMonto);
-        await connection.ExecuteAsync("sige_sam_v3.DescuentoCotizacion",
+        return Ok(new { mensaje = result });
-            new { cotiid = cotizacionId, desctoid = descuentoId, tipoid = tipoDescuento, nuevototal = nuevoMonto },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(new { mensaje = "ok" });
     }
 }

backend/src/Ventas.API/Controllers/DocumentoController.cs

@@ -1,60 +1,28 @@
-using Dapper;
-using Npgsql;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Core.DTOs;
+using Ventas.Services;
 
 namespace Ventas.API.Controllers;
 
-[ApiController]
 [Route("api/[controller]")]
 [Authorize]
-public class DocumentoController : ControllerBase
+public class DocumentoController : BaseController
 {
-    private readonly string _connectionString;
+    private readonly CatalogoService _catalogo;
-
+    public DocumentoController(CatalogoService catalogo) => _catalogo = catalogo;
-    public DocumentoController(IConfiguration configuration)
-    {
-        _connectionString = configuration.GetConnectionString("Default")!;
-    }
 
     [HttpPost("orden-compra")]
-    public async Task<IActionResult> IngresaOC([FromBody] OCRequest request)
+    public async Task<IActionResult> IngresarOC([FromBody] OCRequest request)
     {
-        using var connection = new NpgsqlConnection(_connectionString);
+        var result = await _catalogo.DocumentoIngresarOCAsync(request.NumeroInterno, request.ContratoId, request.TipoId, request.Glosa, request.Ubicacion, request.Usuario);
-        await connection.ExecuteAsync("Empresa_IngresoOrdenCompra",
+        return Ok(new { mensaje = result });
-            new { numeroin = request.NumeroInterno, contid = request.ContratoId, tipodoc = request.TipoId,
-                glosa = request.Glosa, orig = request.Ubicacion, vendedor = request.Usuario },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(new { mensaje = "ok" });
     }
 
     [HttpPost("sence")]
-    public async Task<IActionResult> IngresaSNC([FromBody] SNCRequest request)
+    public async Task<IActionResult> IngresarSNC([FromBody] SNCRequest request)
     {
-        using var connection = new NpgsqlConnection(_connectionString);
+        var result = await _catalogo.DocumentoIngresarSNCAsync(request.NumeroInterno, request.Alumno, request.ContratoId, request.Glosa, request.Usuario);
-        await connection.ExecuteAsync("Empresa_IngresoInscripcionSence",
+        return Ok(new { mensaje = result });
-            new { numsence = request.NumeroInterno, cont = request.ContratoId, alumnoid = request.Alumno,
-                obsv = request.Glosa, vendedorid = request.Usuario },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(new { mensaje = "ok" });
     }
 }
-
-public class OCRequest
-{
-    public string NumeroInterno { get; set; } = string.Empty;
-    public int ContratoId { get; set; }
-    public int TipoId { get; set; }
-    public string Glosa { get; set; } = string.Empty;
-    public string Ubicacion { get; set; } = string.Empty;
-    public string Usuario { get; set; } = string.Empty;
-}
-
-public class SNCRequest
-{
-    public string NumeroInterno { get; set; } = string.Empty;
-    public string Alumno { get; set; } = string.Empty;
-    public int ContratoId { get; set; }
-    public string Glosa { get; set; } = string.Empty;
-    public string Usuario { get; set; } = string.Empty;
-}

backend/src/Ventas.API/Controllers/EmpresaController.cs

@@ -1,66 +1,30 @@
-using Dapper;
-using Npgsql;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Core.DTOs;
+using Ventas.Services;
 
 namespace Ventas.API.Controllers;
 
-[ApiController]
 [Route("api/[controller]")]
 [Authorize]
-public class EmpresaController : ControllerBase
+public class EmpresaController : BaseController
 {
-    private readonly string _connectionString;
+    private readonly CatalogoService _catalogo;
-
+    public EmpresaController(CatalogoService catalogo) => _catalogo = catalogo;
-    public EmpresaController(IConfiguration configuration)
-    {
-        _connectionString = configuration.GetConnectionString("Default")!;
-    }
 
     [HttpGet]
-    public async Task<IActionResult> Buscar([FromQuery] string busqueda, [FromQuery] string rut, [FromQuery] string varB, [FromQuery] int varC)
+    public Task<IActionResult> Buscar([FromQuery] string busqueda, [FromQuery] string rut, [FromQuery] string nombre, [FromQuery] int tipo)
-    {
+        => OkResult(_catalogo.EmpresaBuscarAsync(busqueda, rut, nombre, tipo));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("ModuloEmpresa_BusquedaEmpresa",
-            new { tipo = busqueda, varz = rut, vary = varB, varx = varC },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 
     [HttpGet("tipos")]
-    public async Task<IActionResult> BuscarTipos([FromQuery] string busqueda)
+    public Task<IActionResult> BuscarTipos([FromQuery] string busqueda)
-    {
+        => OkResult(_catalogo.EmpresaTiposAsync(busqueda));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("Empresa_BuscarTiposEmpresas",
-            new { tipo = busqueda },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 
     [HttpPost]
     public async Task<IActionResult> Ingresar([FromBody] EmpresaIngresoRequest request)
     {
-        using var connection = new NpgsqlConnection(_connectionString);
+        var result = await _catalogo.EmpresaIngresarAsync(request.Rut, request.Nombre, request.Direccion, request.Comuna,
-        await connection.ExecuteAsync("IngresarEmpresaV2",
+            request.Tipo, request.GiroNombre, request.Contacto, request.Fono, request.Mail, request.Origen);
-            new { rutempresa = request.Rut, razonsocial = request.Nombre, drccnempresa = request.Direccion,
+        return Ok(new { mensaje = result });
-                comunaid = request.Comuna, tipoid = request.Tipo,                 gironombre = request.GiroNombre,
-                contactoempresa = request.Contacto, fonocontacto = request.Fono, mailcontacto = request.Mail,
-                originemp = request.Origen },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(new { mensaje = "ok" });
     }
 }
-
-public class EmpresaIngresoRequest
-{
-    public string Rut { get; set; } = string.Empty;
-    public string Nombre { get; set; } = string.Empty;
-    public string Direccion { get; set; } = string.Empty;
-    public string Comuna { get; set; } = string.Empty;
-    public int Tipo { get; set; }
-    public string GiroNombre { get; set; } = string.Empty;
-    public string Contacto { get; set; } = string.Empty;
-    public int Fono { get; set; }
-    public string Mail { get; set; } = string.Empty;
-    public string Origen { get; set; } = string.Empty;
-}

backend/src/Ventas.API/Controllers/ErrorController.cs

@@ -0,0 +1,16 @@
+using Microsoft.AspNetCore.Diagnostics;
+using Microsoft.AspNetCore.Mvc;
+
+namespace Ventas.API.Controllers;
+
+[ApiController]
+[Route("/")]
+public class ErrorController : ControllerBase
+{
+    [HttpGet("error")]
+    public IActionResult Error()
+    {
+        var exception = HttpContext.Features.Get<IExceptionHandlerFeature>()?.Error;
+        return Problem(detail: exception?.Message, statusCode: 500);
+    }
+}

backend/src/Ventas.API/Controllers/HorarioController.cs

@@ -1,26 +1,17 @@
-using Dapper;
-using Npgsql;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Services;
 
 namespace Ventas.API.Controllers;
 
-[ApiController]
 [Route("api/[controller]")]
 [Authorize]
-public class HorarioController : ControllerBase
+public class HorarioController : BaseController
 {
-    private readonly string _connectionString;
+    private readonly CatalogoService _catalogo;
-
+    public HorarioController(CatalogoService catalogo) => _catalogo = catalogo;
-    public HorarioController(IConfiguration configuration) => _connectionString = configuration.GetConnectionString("Default")!;
 
     [HttpGet("bloques")]
-    public async Task<IActionResult> BuscarBloques([FromQuery] string busqueda, [FromQuery] string varA, [FromQuery] string varB)
+    public Task<IActionResult> BuscarBloques([FromQuery] string busqueda, [FromQuery] string tipoBusqueda, [FromQuery] string sede)
-    {
+        => OkResult(_catalogo.HorarioBuscarAsync(busqueda, tipoBusqueda, sede));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("Empresa_HorarioBuscar",
-            new { tipo = busqueda, varz = varA, vary = varB },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 }

backend/src/Ventas.API/Controllers/InformeController.cs

@@ -19,6 +19,9 @@ public class InformeController : ControllerBase
     [HttpGet("ventas-mensuales")]
     public async Task<IActionResult> InformeMensual([FromQuery] int mes, [FromQuery] int agno, [FromQuery] string tipo)
     {
+        if (string.IsNullOrEmpty(tipo))
+            return BadRequest(new { mensaje = "tipo es requerido" });
+
         var result = await _informeService.InformeMensualAsync(mes, agno, tipo);
         return Ok(result);
     }
@@ -33,28 +36,31 @@ public class InformeController : ControllerBase
     [HttpGet("lead-diarios")]
     public async Task<IActionResult> InformeLeadDias([FromQuery] DateTime inicio, [FromQuery] DateTime termino, [FromQuery] string vendedorId)
     {
+        if (string.IsNullOrEmpty(vendedorId))
+            return BadRequest(new { mensaje = "vendedorId es requerido" });
+
         var result = await _informeService.InformeLeadDiasAsync(inicio, termino, vendedorId);
         return Ok(result);
     }
 
     [HttpGet("ventas-empresa")]
-    public async Task<IActionResult> VentasCursosEmpresa([FromQuery] string tipo, [FromQuery] string varA, [FromQuery] string varB, [FromQuery] int varC)
+    public async Task<IActionResult> VentasCursosEmpresa([FromQuery] string tipo, [FromQuery] string valorA, [FromQuery] string valorB, [FromQuery] int valorC)
     {
-        var result = await _informeService.InformeVentasCursosEmpresaAsync(tipo, varA, varB, varC);
+        var result = await _informeService.InformeVentasCursosEmpresaAsync(tipo, valorA, valorB, valorC);
         return Ok(result);
     }
 
     [HttpGet("documentos")]
-    public async Task<IActionResult> InformeDocumentos([FromQuery] string tipo, [FromQuery] string varA, [FromQuery] string varB, [FromQuery] int varC)
+    public async Task<IActionResult> InformeDocumentos([FromQuery] string tipo, [FromQuery] string valorA, [FromQuery] string valorB, [FromQuery] int valorC)
     {
-        var result = await _informeService.InformeDocumentosAsync(tipo, varA, varB, varC);
+        var result = await _informeService.InformeDocumentosAsync(tipo, valorA, valorB, valorC);
         return Ok(result);
     }
 
     [HttpGet("general")]
-    public async Task<IActionResult> InformeGeneral([FromQuery] string busqueda, [FromQuery] string varA, [FromQuery] string varB)
+    public async Task<IActionResult> InformeGeneral([FromQuery] string busqueda, [FromQuery] string valorA, [FromQuery] string valorB)
     {
-        var result = await _informeService.InformeGeneralAsync(busqueda, varA, varB);
+        var result = await _informeService.InformeGeneralAsync(busqueda, valorA, valorB);
         return Ok(result);
     }
 }

backend/src/Ventas.API/Controllers/JornadaController.cs

@@ -1,26 +1,17 @@
-using Dapper;
-using Npgsql;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Services;
 
 namespace Ventas.API.Controllers;
 
-[ApiController]
 [Route("api/[controller]")]
 [Authorize]
-public class JornadaController : ControllerBase
+public class JornadaController : BaseController
 {
-    private readonly string _connectionString;
+    private readonly CatalogoService _catalogo;
-
+    public JornadaController(CatalogoService catalogo) => _catalogo = catalogo;
-    public JornadaController(IConfiguration configuration) => _connectionString = configuration.GetConnectionString("Default")!;
 
     [HttpGet]
-    public async Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] string nombre)
+    public Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] string nombre)
-    {
+        => OkResult(_catalogo.JornadaBuscarAsync(tipoBusqueda, nombre));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("sige_sam_v3.BuscarJornada",
-            new { tipobusqueda = tipoBusqueda, jornadanombre = nombre },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 }

backend/src/Ventas.API/Controllers/LeadController.cs

@@ -67,23 +67,23 @@ public class LeadController : ControllerBase
     }
 
     [HttpPost("{id}/actividad")]
-    public async Task<IActionResult> IngresarActividad(int id, [FromBody] ActividadCreateDto dto, [FromQuery] string usuarioId)
+    public async Task<IActionResult> IngresarActividad(int id, [FromBody] ActividadCreateDto dto)
     {
-        var result = await _leadService.IngresarActividadAsync(id, dto.Tipo, dto.Descripcion, usuarioId);
+        var result = await _leadService.IngresarActividadAsync(id, dto.Tipo, dto.Descripcion, dto.UsuarioId ?? "");
         return Ok(new { mensaje = result });
     }
 
     [HttpPut("{id}/estado")]
-    public async Task<IActionResult> ActualizarEstado(int id, [FromQuery] int estadoId)
+    public async Task<IActionResult> ActualizarEstado(int id, [FromBody] LeadEstadoUpdateRequest request)
     {
-        var result = await _leadService.EstadoUpdateAsync(id, estadoId);
+        var result = await _leadService.EstadoUpdateAsync(id, request.EstadoId);
         return Ok(new { mensaje = result });
     }
 
     [HttpPut("{id}/producto")]
-    public async Task<IActionResult> ActualizarProducto(int id, [FromQuery] string producto)
+    public async Task<IActionResult> ActualizarProducto(int id, [FromBody] LeadProductoUpdateRequest request)
     {
-        var result = await _leadService.ActualizarProductoAsync(id, producto);
+        var result = await _leadService.ActualizarProductoAsync(id, request.Producto);
         return Ok(new { mensaje = result });
     }
 
@@ -95,16 +95,16 @@ public class LeadController : ControllerBase
     }
 
     [HttpPost("{id}/perder")]
-    public async Task<IActionResult> IngresarLeadPerdido(int id, [FromQuery] int motivo, [FromQuery] int estado)
+    public async Task<IActionResult> IngresarLeadPerdido(int id, [FromBody] LeadPerderRequest request)
     {
-        var result = await _leadService.IngresarLeadPerdidoAsync(id, motivo, estado);
+        var result = await _leadService.IngresarLeadPerdidoAsync(id, request.Motivo, request.Estado);
         return Ok(new { mensaje = result });
     }
 
     [HttpPost("{id}/pago")]
     public async Task<IActionResult> IngresarPago(int id, [FromBody] PagoLeadDto dto)
     {
-        var result = await _leadService.IngresarPagoAsync(dto.LeadId, dto.CotizacionId, dto.FormaPago, dto.Monto, dto.CodigoAutorizacion ?? "", dto.DigitoTarjeta ?? "", dto.Cuotas);
+        var result = await _leadService.IngresarPagoAsync(id, dto.CotizacionId, dto.FormaPago, dto.Monto, dto.CodigoAutorizacion ?? "", dto.DigitoTarjeta ?? "", dto.Cuotas);
         return Ok(new { mensaje = result });
     }
 }

backend/src/Ventas.API/Controllers/ProgramaController.cs

@@ -1,26 +1,17 @@
-using Dapper;
-using Npgsql;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Services;
 
 namespace Ventas.API.Controllers;
 
-[ApiController]
 [Route("api/[controller]")]
 [Authorize]
-public class ProgramaController : ControllerBase
+public class ProgramaController : BaseController
 {
-    private readonly string _connectionString;
+    private readonly CatalogoService _catalogo;
-
+    public ProgramaController(CatalogoService catalogo) => _catalogo = catalogo;
-    public ProgramaController(IConfiguration configuration) => _connectionString = configuration.GetConnectionString("Default")!;
 
     [HttpGet]
-    public async Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] string nombre)
+    public Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] string nombre)
-    {
+        => OkResult(_catalogo.ProgramaBuscarAsync(tipoBusqueda, nombre));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("sige_sam_v3.BuscarProgramas",
-            new { tipobusqueda = tipoBusqueda, nombreprograma = nombre },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 }

backend/src/Ventas.API/Controllers/PropuestaController.cs

@@ -1,51 +1,26 @@
-using Dapper;
-using Npgsql;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Core.DTOs;
+using Ventas.Services;
 
 namespace Ventas.API.Controllers;
 
-[ApiController]
 [Route("api/[controller]")]
 [Authorize]
-public class PropuestaController : ControllerBase
+public class PropuestaController : BaseController
 {
-    private readonly string _connectionString;
+    private readonly CatalogoService _catalogo;
-
+    public PropuestaController(CatalogoService catalogo) => _catalogo = catalogo;
-    public PropuestaController(IConfiguration configuration) => _connectionString = configuration.GetConnectionString("Default")!;
 
     [HttpPost]
     public async Task<IActionResult> Ingresar([FromBody] PropuestaIngresoRequest request)
     {
-        using var connection = new NpgsqlConnection(_connectionString);
+        var result = await _catalogo.PropuestaIngresarAsync(request.TipoPropuesta, request.Estado, request.TipoVenta,
-        var result = await connection.QuerySingleOrDefaultAsync<string>(
+            request.Vendedor, request.Fecha, request.Monto, request.OticId, request.EnvioLibre);
-            "Empresa_IngresoPropuestaV2",
-            new { tipo = request.TipoPropuesta, estado = request.Estado, venta = request.TipoVenta,
-                vendedor = request.Vendedor, fecha = request.Fecha, monto = request.Monto,
-                otic = request.OticId, libro = request.EnvioLibre },
-            commandType: System.Data.CommandType.StoredProcedure);
         return Ok(new { id = result });
     }
 
     [HttpGet("datos")]
-    public async Task<IActionResult> Datos([FromQuery] string busqueda, [FromQuery] int prop, [FromQuery] int cotz, [FromQuery] int cont)
+    public Task<IActionResult> Datos([FromQuery] string busqueda, [FromQuery] int propuestaId, [FromQuery] int cotizacionId, [FromQuery] int contratoId)
-    {
+        => OkResult(_catalogo.PropuestaDatosAsync(busqueda, propuestaId, cotizacionId, contratoId));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("ModuloEmpresa_PropuestaCrystalReport",
-            new { tipo = busqueda, prop, cotz, cont },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
-}
-
-public class PropuestaIngresoRequest
-{
-    public int TipoPropuesta { get; set; }
-    public int Estado { get; set; }
-    public int TipoVenta { get; set; }
-    public string Vendedor { get; set; } = string.Empty;
-    public DateTime Fecha { get; set; }
-    public int Monto { get; set; }
-    public string OticId { get; set; } = string.Empty;
-    public string EnvioLibre { get; set; } = string.Empty;
 }

backend/src/Ventas.API/Controllers/RegionController.cs

@@ -1,26 +1,17 @@
-using Dapper;
-using Npgsql;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Services;
 
 namespace Ventas.API.Controllers;
 
-[ApiController]
 [Route("api/[controller]")]
 [Authorize]
-public class RegionController : ControllerBase
+public class RegionController : BaseController
 {
-    private readonly string _connectionString;
+    private readonly CatalogoService _catalogo;
-
+    public RegionController(CatalogoService catalogo) => _catalogo = catalogo;
-    public RegionController(IConfiguration configuration) => _connectionString = configuration.GetConnectionString("Default")!;
 
     [HttpGet]
-    public async Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] string nombre)
+    public Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] string nombre)
-    {
+        => OkResult(_catalogo.RegionBuscarAsync(tipoBusqueda, nombre));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("sige_sam_v3.BuscarRegion",
-            new { tipobusqueda = tipoBusqueda, nombre },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 }

backend/src/Ventas.API/Controllers/ReportController.cs

@@ -1,5 +1,6 @@
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Core.DTOs;
 using Ventas.Services;
 
 namespace Ventas.API.Controllers;
@@ -37,11 +38,8 @@ public class ReportController : ControllerBase
         => File(await _reportService.GenerarPresupuestoPdfAsync(id), "application/pdf", $"presupuesto_{id}.pdf");
 
     [HttpPost("arqueo")]
-    public async Task<IActionResult> ArqueoPdf(
+    public async Task<IActionResult> ArqueoPdf([FromBody] ArqueoPdfRequest request)
-        [FromQuery] string usuario, [FromQuery] DateTime fecha,
+        => File(await _reportService.GenerarArqueoPdfAsync(request.Usuario, request.Fecha, request.Ingresos,
-        [FromBody] List<Dictionary<string, object>> ingresos,
+            request.TotalCredito, request.TotalDebito, request.TotalIntl, request.TotalEstado, request.TotalGeneral),
-        [FromQuery] int totalCredito, [FromQuery] int totalDebito,
+            "application/pdf", $"arqueo_{request.Fecha:yyyyMMdd}.pdf");
-        [FromQuery] int totalIntl, [FromQuery] int totalEstado, [FromQuery] int totalGeneral)
-        => File(await _reportService.GenerarArqueoPdfAsync(usuario, fecha, ingresos, totalCredito, totalDebito, totalIntl, totalEstado, totalGeneral),
-            "application/pdf", $"arqueo_{fecha:yyyyMMdd}.pdf");
 }

backend/src/Ventas.API/Controllers/SalaController.cs

@@ -1,38 +1,25 @@
-using Dapper;
-using Npgsql;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Services;
 
 namespace Ventas.API.Controllers;
 
-[ApiController]
 [Route("api/[controller]")]
 [Authorize]
-public class SalaController : ControllerBase
+public class SalaController : BaseController
 {
-    private readonly string _connectionString;
+    private readonly CatalogoService _catalogo;
-
+    public SalaController(CatalogoService catalogo) => _catalogo = catalogo;
-    public SalaController(IConfiguration configuration) => _connectionString = configuration.GetConnectionString("Default")!;
 
     [HttpGet]
-    public async Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] string nombre, [FromQuery] string sede)
+    public Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] string nombre, [FromQuery] string sede)
-    {
+        => OkResult(_catalogo.SalaBuscarAsync(tipoBusqueda, nombre, sede));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("sige_sam_v3.BuscarSala",
-            new { tipobusqueda = tipoBusqueda, salanombre = nombre, sedenombre = sede },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 
     [HttpGet("ocupacion")]
     public async Task<IActionResult> Ocupacion([FromQuery] int sedeId, [FromQuery] int jornadaId, [FromQuery] int salaId,
         [FromQuery] string fechaInicio, [FromQuery] int horario, [FromQuery] string dia, [FromQuery] string hora)
     {
-        using var connection = new NpgsqlConnection(_connectionString);
+        var result = await _catalogo.SalaOcupacionAsync(sedeId, jornadaId, salaId, fechaInicio, horario, dia, hora);
-        var result = await connection.QuerySingleOrDefaultAsync<string>(
-            "sige_sam_v3.BuscarSalaOcupada",
-            new { sede = sedeId, jornada = jornadaId, fecha = fechaInicio, sala = salaId, horario, diacorto = dia, varhora = hora },
-            commandType: System.Data.CommandType.StoredProcedure);
         return Ok(new { ocupado = !string.IsNullOrEmpty(result), curso = result });
     }
 }

backend/src/Ventas.API/Controllers/SedeController.cs

@@ -1,26 +1,17 @@
-using Dapper;
-using Npgsql;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Services;
 
 namespace Ventas.API.Controllers;
 
-[ApiController]
 [Route("api/[controller]")]
 [Authorize]
-public class SedeController : ControllerBase
+public class SedeController : BaseController
 {
-    private readonly string _connectionString;
+    private readonly CatalogoService _catalogo;
-
+    public SedeController(CatalogoService catalogo) => _catalogo = catalogo;
-    public SedeController(IConfiguration configuration) => _connectionString = configuration.GetConnectionString("Default")!;
 
     [HttpGet]
-    public async Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] string nombre)
+    public Task<IActionResult> Buscar([FromQuery] string tipoBusqueda, [FromQuery] string nombre)
-    {
+        => OkResult(_catalogo.SedeBuscarAsync(tipoBusqueda, nombre));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("sige_sam_v3.BuscarSedes",
-            new { tipobusqueda = tipoBusqueda, sedenombre = nombre },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 }

backend/src/Ventas.API/Controllers/TarifaController.cs

@@ -1,36 +1,21 @@
-using Dapper;
-using Npgsql;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Services;
 
 namespace Ventas.API.Controllers;
 
-[ApiController]
 [Route("api/[controller]")]
 [Authorize]
-public class TarifaController : ControllerBase
+public class TarifaController : BaseController
 {
-    private readonly string _connectionString;
+    private readonly CatalogoService _catalogo;
-
+    public TarifaController(CatalogoService catalogo) => _catalogo = catalogo;
-    public TarifaController(IConfiguration configuration) => _connectionString = configuration.GetConnectionString("Default")!;
 
     [HttpGet]
-    public async Task<IActionResult> Buscar([FromQuery] int producto, [FromQuery] int programa, [FromQuery] int jornada, [FromQuery] int sede, [FromQuery] string fecha)
+    public Task<IActionResult> Buscar([FromQuery] int producto, [FromQuery] int programa, [FromQuery] int jornada, [FromQuery] int sede, [FromQuery] string fecha)
-    {
+        => OkResult(_catalogo.TarifaBuscarAsync(producto, programa, jornada, sede, fecha));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("sige_sam_v3.BuscarTarifa",
-            new { producto, programa, jornada, sede, fecha },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 
     [HttpGet("promocion")]
-    public async Task<IActionResult> Promocion([FromQuery] int tarifaId, [FromQuery] int cantidadCursos)
+    public Task<IActionResult> Promocion([FromQuery] int tarifaId, [FromQuery] int cantidadCursos)
-    {
+        => OkResult(_catalogo.TarifaPromocionAsync(tarifaId, cantidadCursos));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("sige_sam_v3.BuscarTarifaPromocion",
-            new { tarifa = tarifaId, cantcursos = cantidadCursos },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 }

backend/src/Ventas.API/Controllers/UsuarioController.cs

@@ -1,45 +1,25 @@
-using Dapper;
-using Npgsql;
 using Microsoft.AspNetCore.Authorization;
 using Microsoft.AspNetCore.Mvc;
+using Ventas.Services;
 
 namespace Ventas.API.Controllers;
 
-[ApiController]
 [Route("api/[controller]")]
 [Authorize]
-public class UsuarioController : ControllerBase
+public class UsuarioController : BaseController
 {
-    private readonly string _connectionString;
+    private readonly CatalogoService _catalogo;
+    public UsuarioController(CatalogoService catalogo) => _catalogo = catalogo;
 
-    public UsuarioController(IConfiguration configuration) => _connectionString = configuration.GetConnectionString("Default")!;
+    [HttpGet("{usuarioId}")]
+    public Task<IActionResult> Info(string usuarioId)
+        => OkResult(_catalogo.UsuarioInfoAsync(usuarioId));
 
-    [HttpGet("{id}")]
+    [HttpGet("{usuarioId}/perfil")]
-    public async Task<IActionResult> Info(string id)
+    public Task<IActionResult> Perfil(string usuarioId)
-    {
+        => OkResult(_catalogo.UsuarioPerfilAsync(usuarioId));
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("sige_sam_v3.BuscarUsuario",
-            new { usuarioid = id },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
-
-    [HttpGet("{id}/perfil")]
-    public async Task<IActionResult> Perfil(string id)
-    {
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("sige_sam_v3.BuscarPerfilUsuario",
-            new { usuario = id },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 
     [HttpGet("vendedores")]
-    public async Task<IActionResult> VendedoresActivos()
+    public Task<IActionResult> VendedoresActivos()
-    {
+        => OkResult(_catalogo.VendedoresActivosAsync());
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync("sige_sam_v3.BuscarVendedoresActivos",
-            commandType: System.Data.CommandType.StoredProcedure);
-        return Ok(rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!));
-    }
 }

backend/src/Ventas.API/Middleware/JwtMiddleware.cs

@@ -1,45 +0,0 @@
-using System.IdentityModel.Tokens.Jwt;
-using System.Text;
-using Microsoft.IdentityModel.Tokens;
-
-namespace Ventas.API.Middleware;
-
-public class JwtMiddleware
-{
-    private readonly RequestDelegate _next;
-    private readonly string _secret;
-
-    public JwtMiddleware(RequestDelegate next, IConfiguration configuration)
-    {
-        _next = next;
-        _secret = configuration["Jwt:Secret"] ?? "default-dev-secret-change-in-production";
-    }
-
-    public async Task InvokeAsync(HttpContext context)
-    {
-        var token = context.Request.Cookies["SAM_TOKEN"]
-                    ?? context.Request.Headers["Authorization"].FirstOrDefault()?.Split(" ").Last();
-
-        if (token != null)
-        {
-            try
-            {
-                var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_secret));
-                var handler = new JwtSecurityTokenHandler();
-                var principal = handler.ValidateToken(token, new TokenValidationParameters
-                {
-                    ValidateIssuer = false,
-                    ValidateAudience = false,
-                    ValidateLifetime = true,
-                    ValidateIssuerSigningKey = true,
-                    IssuerSigningKey = key
-                }, out _);
-
-                context.User = principal;
-            }
-            catch { }
-        }
-
-        await _next(context);
-    }
-}

backend/src/Ventas.API/Program.cs

@@ -1,9 +1,8 @@
 using System.Text;
 using Microsoft.AspNetCore.Authentication.JwtBearer;
-using Microsoft.EntityFrameworkCore;
 using Microsoft.IdentityModel.Tokens;
 using QuestPDF.Infrastructure;
-using Ventas.Infrastructure.Data;
+using Ventas.Infrastructure.Dapper;
 using Ventas.Infrastructure.Repositories;
 using Ventas.Core.Interfaces;
 using Ventas.Services;
@@ -17,9 +16,6 @@ var connectionString = builder.Configuration.GetConnectionString("Default")!;
 builder.Services.AddControllers();
 builder.Services.AddOpenApi();
 
-builder.Services.AddDbContext<VentasDbContext>(options =>
-    options.UseNpgsql(connectionString));
-
 builder.Services.AddScoped<ILeadRepository>(sp =>
     new LeadRepository(connectionString));
 builder.Services.AddScoped<ILeadQueryRepository>(sp =>
@@ -34,27 +30,34 @@ builder.Services.AddScoped<IUsuarioRepository>(sp =>
     new UsuarioRepository(connectionString));
 builder.Services.AddScoped<IInformeRepository>(sp =>
     new InformeRepository(connectionString));
+builder.Services.AddScoped<IArqueoRepository>(sp =>
+    new ArqueoRepository(connectionString));
+builder.Services.AddScoped<SpComplexQueries>(sp =>
+    new SpComplexQueries(connectionString));
+builder.Services.AddScoped<ICatalogoRepository>(sp =>
+    new CatalogoRepository(connectionString));
 
+builder.Services.AddScoped<CatalogoService>(sp =>
+    new CatalogoService(sp.GetRequiredService<ICatalogoRepository>()));
 builder.Services.AddScoped<LeadService>(sp =>
-    new LeadService(connectionString));
+    new LeadService(sp.GetRequiredService<ILeadRepository>(), sp.GetRequiredService<ILeadQueryRepository>()));
 builder.Services.AddScoped<UsuarioService>(sp =>
-    new UsuarioService(sp.GetRequiredService<IUsuarioRepository>(), connectionString));
+    new UsuarioService(sp.GetRequiredService<IUsuarioRepository>()));
 builder.Services.AddScoped<ContratoService>(sp =>
-    new ContratoService(sp.GetRequiredService<IContratoRepository>(), connectionString));
+    new ContratoService(sp.GetRequiredService<IContratoRepository>(), sp.GetRequiredService<ICatalogoRepository>()));
 builder.Services.AddScoped<CotizacionService>(sp =>
-    new CotizacionService(sp.GetRequiredService<ICotizacionRepository>(), connectionString));
+    new CotizacionService(sp.GetRequiredService<ICotizacionRepository>(), sp.GetRequiredService<ICatalogoRepository>()));
 builder.Services.AddScoped<AlumnoService>(sp =>
-    new AlumnoService(sp.GetRequiredService<IAlumnoRepository>(), connectionString));
+    new AlumnoService(sp.GetRequiredService<IAlumnoRepository>(), sp.GetRequiredService<ICatalogoRepository>()));
 builder.Services.AddScoped<ArqueoService>(sp =>
-    new ArqueoService(connectionString));
+    new ArqueoService(sp.GetRequiredService<IArqueoRepository>()));
 builder.Services.AddScoped<InformeService>();
 builder.Services.AddScoped<ReportService>(sp =>
-    new ReportService(sp.GetRequiredService<ContratoService>(), sp.GetRequiredService<CotizacionService>(), connectionString));
+    new ReportService(sp.GetRequiredService<ContratoService>(), sp.GetRequiredService<CotizacionService>(), sp.GetRequiredService<ICatalogoRepository>()));
 builder.Services.AddScoped<EmpresaReportService>(sp =>
-    new EmpresaReportService(sp.GetRequiredService<IInformeRepository>(), connectionString));
+    new EmpresaReportService(sp.GetRequiredService<IInformeRepository>(), sp.GetRequiredService<ICatalogoRepository>()));
 
-var jwtSecret = builder.Configuration["Jwt:Secret"];
+var jwtSecret = builder.Configuration["Jwt:Secret"] ?? "default-dev-secret-change-in-production";
-if (string.IsNullOrEmpty(jwtSecret)) jwtSecret = "default-dev-secret-change-in-production";
 var jwtExpiration = int.Parse(builder.Configuration["Jwt:ExpirationMinutes"] ?? "30");
 builder.Services.AddScoped<JwtService>(sp =>
     new JwtService(jwtSecret, jwtExpiration));
@@ -67,9 +70,23 @@ builder.Services.AddAuthentication(JwtBearerDefaults.AuthenticationScheme)
             ValidateIssuer = false,
             ValidateAudience = false,
             ValidateLifetime = true,
+            ClockSkew = TimeSpan.Zero,
             ValidateIssuerSigningKey = true,
             IssuerSigningKey = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(jwtSecret))
         };
+
+        options.Events = new JwtBearerEvents
+        {
+            OnMessageReceived = context =>
+            {
+                var cookieToken = context.Request.Cookies["SAM_TOKEN"];
+                if (!string.IsNullOrEmpty(cookieToken))
+                {
+                    context.Token = cookieToken;
+                }
+                return Task.CompletedTask;
+            }
+        };
     });
 
 builder.Services.AddCors(options =>
@@ -88,9 +105,12 @@ if (app.Environment.IsDevelopment())
 {
     app.MapOpenApi();
 }
+else
+{
+    app.UseExceptionHandler("/error");
+}
 
 app.UseCors();
-app.UseMiddleware<Ventas.API.Middleware.JwtMiddleware>();
 app.UseAuthentication();
 app.UseAuthorization();
 app.MapControllers();

backend/src/Ventas.API/Ventas.API.csproj

@@ -8,6 +8,7 @@
 
   <ItemGroup>
     <PackageReference Include="Microsoft.AspNetCore.OpenApi" Version="10.0.2" />
+    <PackageReference Include="Microsoft.AspNetCore.Authentication.JwtBearer" Version="10.0.9" />
   </ItemGroup>
 
   <ItemGroup>

backend/src/Ventas.Core/DTOs/AlumnoDto.cs

@@ -0,0 +1,30 @@
+namespace Ventas.Core.DTOs;
+
+public class AlumnoIngresoRequest
+{
+    public string Rut { get; set; } = string.Empty;
+    public string Nombre { get; set; } = string.Empty;
+    public string Paterno { get; set; } = string.Empty;
+    public string Materno { get; set; } = string.Empty;
+    public string Direccion { get; set; } = "SIN DIRECCION";
+    public string Comuna { get; set; } = "1";
+    public string Fecha { get; set; } = string.Empty;
+    public string Fono { get; set; } = string.Empty;
+    public string Mail { get; set; } = string.Empty;
+    public int Ocupacion { get; set; }
+    public string ProfesionOficio { get; set; } = string.Empty;
+}
+
+public class ApoderadoIngresoRequest
+{
+    public string RutApoderado { get; set; } = string.Empty;
+    public string RutAlumno { get; set; } = string.Empty;
+    public string Nombre { get; set; } = string.Empty;
+    public string Paterno { get; set; } = string.Empty;
+    public string Materno { get; set; } = string.Empty;
+    public string Direccion { get; set; } = string.Empty;
+    public string Comuna { get; set; } = string.Empty;
+    public int Nacionalidad { get; set; }
+    public string Fono { get; set; } = string.Empty;
+    public string Mail { get; set; } = string.Empty;
+}

backend/src/Ventas.Core/DTOs/ContratoDto.cs

@@ -0,0 +1,53 @@
+namespace Ventas.Core.DTOs;
+
+public class ContratoIngresoRequest
+{
+    public int CotizacionId { get; set; }
+    public int BoletaCKT { get; set; } = 1;
+    public string FechaContrato { get; set; } = string.Empty;
+    public int BoletaId { get; set; }
+    public int VendedorId { get; set; }
+}
+
+public class ContratoDetalleRequest
+{
+    public int ContratoId { get; set; }
+    public string EmpresaId { get; set; } = string.Empty;
+    public string AlumnoId { get; set; } = string.Empty;
+    public string CursoId { get; set; } = string.Empty;
+    public string Fecha { get; set; } = string.Empty;
+    public int Vendedor { get; set; }
+    public int RegistroAcademico { get; set; }
+    public int AlumnoTipo { get; set; }
+}
+
+public class ContratoEmpresaRequest
+{
+    public int CotizacionId { get; set; }
+    public string EmpresaId { get; set; } = string.Empty;
+    public int TipoVenta { get; set; }
+    public int FacturaId { get; set; }
+    public int CantCursos { get; set; }
+    public int VendedorId { get; set; }
+}
+
+public class ContratoCerradoRequest
+{
+    public int PropuestaId { get; set; }
+    public string Rut { get; set; } = string.Empty;
+    public int TipoVenta { get; set; }
+    public string VendedorId { get; set; } = string.Empty;
+}
+
+public class ContratoEstadoUpdateRequest
+{
+    public string Tipo { get; set; } = string.Empty;
+    public string? ValorA { get; set; }
+    public int ValorB { get; set; }
+}
+
+public class ContratoFirmaRequest
+{
+    public string Tipo { get; set; } = string.Empty;
+    public int Firmado { get; set; }
+}

backend/src/Ventas.Core/DTOs/CotizacionDto.cs

@@ -0,0 +1,60 @@
+namespace Ventas.Core.DTOs;
+
+public class CotizacionIngresoRequest
+{
+    public string ApoderadoId { get; set; } = string.Empty;
+    public string VendedorId { get; set; } = string.Empty;
+    public int SolicitudDescuento { get; set; } = 1;
+    public int Descuento { get; set; }
+    public int TipoDescuento { get; set; }
+    public string Fecha { get; set; } = string.Empty;
+    public int Alumnos { get; set; } = 1;
+    public int Curso { get; set; } = 1;
+    public int Monto { get; set; }
+    public string Validez { get; set; } = string.Empty;
+    public int LeadId { get; set; }
+}
+
+public class CotizacionDetalleRequest
+{
+    public int CotizacionId { get; set; }
+    public string AlumnoId { get; set; } = string.Empty;
+    public int CursoId { get; set; }
+    public int Cantidad { get; set; }
+    public int Tarifa { get; set; }
+}
+
+public class CotizacionDetalleSinCursoRequest
+{
+    public int CotizacionId { get; set; }
+    public string AlumnoId { get; set; } = string.Empty;
+    public string ApoderadoId { get; set; } = string.Empty;
+    public int ProgramaId { get; set; }
+    public int Cantidad { get; set; }
+    public int Tarifa { get; set; }
+    public int SedeId { get; set; }
+}
+
+public class CotizacionEmpRequest
+{
+    public string EmpresaId { get; set; } = string.Empty;
+    public string Vendedor { get; set; } = string.Empty;
+    public int Alumnos { get; set; }
+    public int Curso { get; set; }
+    public int EmpresaMonto { get; set; }
+    public int OticMonto { get; set; }
+    public int AlumnoMonto { get; set; }
+    public int CotizacionTipo { get; set; }
+    public DateTime Validez { get; set; }
+    public int DescuentoId { get; set; }
+    public int EstadoId { get; set; }
+    public string OticId { get; set; } = string.Empty;
+    public string Motivo { get; set; } = string.Empty;
+}
+
+public class CotizacionEstadoUpdateRequest
+{
+    public string Tipo { get; set; } = string.Empty;
+    public string? ValorA { get; set; }
+    public int ValorB { get; set; }
+}

backend/src/Ventas.Core/DTOs/DescuentoDto.cs

@@ -0,0 +1,9 @@
+namespace Ventas.Core.DTOs;
+
+public class DescuentoIngresoRequest
+{
+    public int CotizacionId { get; set; }
+    public int DescuentoId { get; set; }
+    public int TipoDescuento { get; set; }
+    public int NuevoMonto { get; set; }
+}

backend/src/Ventas.Core/DTOs/DocumentoDto.cs

@@ -0,0 +1,20 @@
+namespace Ventas.Core.DTOs;
+
+public class OCRequest
+{
+    public string NumeroInterno { get; set; } = string.Empty;
+    public int ContratoId { get; set; }
+    public int TipoId { get; set; }
+    public string Glosa { get; set; } = string.Empty;
+    public string Ubicacion { get; set; } = string.Empty;
+    public string Usuario { get; set; } = string.Empty;
+}
+
+public class SNCRequest
+{
+    public string NumeroInterno { get; set; } = string.Empty;
+    public string Alumno { get; set; } = string.Empty;
+    public int ContratoId { get; set; }
+    public string Glosa { get; set; } = string.Empty;
+    public string Usuario { get; set; } = string.Empty;
+}

backend/src/Ventas.Core/DTOs/EmpresaDto.cs

@@ -0,0 +1,15 @@
+namespace Ventas.Core.DTOs;
+
+public class EmpresaIngresoRequest
+{
+    public string Rut { get; set; } = string.Empty;
+    public string Nombre { get; set; } = string.Empty;
+    public string Direccion { get; set; } = string.Empty;
+    public string Comuna { get; set; } = string.Empty;
+    public int Tipo { get; set; }
+    public string GiroNombre { get; set; } = string.Empty;
+    public string Contacto { get; set; } = string.Empty;
+    public string Fono { get; set; } = string.Empty;
+    public string Mail { get; set; } = string.Empty;
+    public string Origen { get; set; } = string.Empty;
+}

backend/src/Ventas.Core/DTOs/LeadDto.cs

@@ -44,9 +44,26 @@ public class ActividadCreateDto
 {
     public string Tipo { get; set; } = string.Empty;
     public string Descripcion { get; set; } = string.Empty;
+    public string? UsuarioId { get; set; }
     public DateTime? FechaPlanificada { get; set; }
 }
 
+public class LeadEstadoUpdateRequest
+{
+    public int EstadoId { get; set; }
+}
+
+public class LeadProductoUpdateRequest
+{
+    public string Producto { get; set; } = string.Empty;
+}
+
+public class LeadPerderRequest
+{
+    public int Motivo { get; set; }
+    public int Estado { get; set; }
+}
+
 public class PagoLeadDto
 {
     public int LeadId { get; set; }

backend/src/Ventas.Core/DTOs/PropuestaDto.cs

@@ -0,0 +1,25 @@
+namespace Ventas.Core.DTOs;
+
+public class PropuestaIngresoRequest
+{
+    public int TipoPropuesta { get; set; }
+    public int Estado { get; set; }
+    public int TipoVenta { get; set; }
+    public string Vendedor { get; set; } = string.Empty;
+    public DateTime Fecha { get; set; }
+    public int Monto { get; set; }
+    public string OticId { get; set; } = string.Empty;
+    public string EnvioLibre { get; set; } = string.Empty;
+}
+
+public class ArqueoPdfRequest
+{
+    public string Usuario { get; set; } = string.Empty;
+    public DateTime Fecha { get; set; }
+    public List<Dictionary<string, object>> Ingresos { get; set; } = [];
+    public int TotalCredito { get; set; }
+    public int TotalDebito { get; set; }
+    public int TotalIntl { get; set; }
+    public int TotalEstado { get; set; }
+    public int TotalGeneral { get; set; }
+}

backend/src/Ventas.Core/Interfaces/IArqueoRepository.cs

@@ -0,0 +1,7 @@
+namespace Ventas.Core.Interfaces;
+
+public interface IArqueoRepository
+{
+    Task<IEnumerable<Dictionary<string, object>>> TodosHoyAsync(DateTime fecha);
+    Task<IEnumerable<Dictionary<string, object>>> HoyAsync(string usuarioId, DateTime fecha);
+}

backend/src/Ventas.Core/Interfaces/ICatalogoRepository.cs

@@ -0,0 +1,8 @@
+namespace Ventas.Core.Interfaces;
+
+public interface ICatalogoRepository
+{
+    Task<IEnumerable<Dictionary<string, object>>> QuerySpAsync(string sp, object parameters);
+    Task<string> ExecuteSpAsync(string sp, object parameters);
+    Task<string?> QuerySingleSpAsync(string sp, object parameters);
+}

backend/src/Ventas.Core/Interfaces/IUsuarioRepository.cs

@@ -1,8 +1,10 @@
+using Ventas.Core.DTOs;
+
 namespace Ventas.Core.Interfaces;
 
 public interface IUsuarioRepository
 {
-    Task<string> BuscarAsync(string usuario, string clave);
+    Task<LoginResponse?> BuscarAsync(string usuario, string clave);
-    Task<string> InfoAsync(string usuario);
+    Task<LoginResponse?> InfoAsync(string usuario);
-    Task<string> PerfilAsync(string usuario);
+    Task<LoginResponse?> PerfilAsync(string usuario);
 }

backend/src/Ventas.Infrastructure/Repositories/ArqueoRepository.cs

@@ -0,0 +1,33 @@
+using Dapper;
+using Npgsql;
+using Ventas.Core.Interfaces;
+
+namespace Ventas.Infrastructure.Repositories;
+
+public class ArqueoRepository : IArqueoRepository
+{
+    private readonly string _connectionString;
+
+    public ArqueoRepository(string connectionString)
+    {
+        _connectionString = connectionString;
+    }
+
+    public async Task<IEnumerable<Dictionary<string, object>>> TodosHoyAsync(DateTime fecha)
+    {
+        using var connection = new NpgsqlConnection(_connectionString);
+        var rows = await connection.QueryAsync("sige_sam_v3.ArqueoHoy",
+            new { fechaarqueo = fecha },
+            commandType: System.Data.CommandType.StoredProcedure);
+        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
+    }
+
+    public async Task<IEnumerable<Dictionary<string, object>>> HoyAsync(string usuarioId, DateTime fecha)
+    {
+        using var connection = new NpgsqlConnection(_connectionString);
+        var rows = await connection.QueryAsync("sige_sam_v3.ArqueoEjecutivo",
+            new { usuarioid = usuarioId, fechaarqueo = fecha },
+            commandType: System.Data.CommandType.StoredProcedure);
+        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
+    }
+}

backend/src/Ventas.Infrastructure/Repositories/CatalogoRepository.cs

@@ -0,0 +1,36 @@
+using Dapper;
+using Npgsql;
+using Ventas.Core.Interfaces;
+
+namespace Ventas.Infrastructure.Repositories;
+
+public class CatalogoRepository : ICatalogoRepository
+{
+    private readonly string _connectionString;
+
+    public CatalogoRepository(string connectionString)
+    {
+        _connectionString = connectionString;
+    }
+
+    public async Task<IEnumerable<Dictionary<string, object>>> QuerySpAsync(string sp, object parameters)
+    {
+        using var connection = new NpgsqlConnection(_connectionString);
+        var rows = await connection.QueryAsync(sp, parameters, commandType: System.Data.CommandType.StoredProcedure);
+        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
+    }
+
+    public async Task<string> ExecuteSpAsync(string sp, object parameters)
+    {
+        using var connection = new NpgsqlConnection(_connectionString);
+        await connection.ExecuteAsync(sp, parameters, commandType: System.Data.CommandType.StoredProcedure);
+        return "ok";
+    }
+
+    public async Task<string?> QuerySingleSpAsync(string sp, object parameters)
+    {
+        using var connection = new NpgsqlConnection(_connectionString);
+        return await connection.QuerySingleOrDefaultAsync<string>(sp, parameters,
+            commandType: System.Data.CommandType.StoredProcedure);
+    }
+}

backend/src/Ventas.Infrastructure/Repositories/LeadRepository.cs

@@ -104,7 +104,7 @@ public class LeadRepository : ILeadRepository
         using var connection = new NpgsqlConnection(_connectionString);
         await connection.ExecuteAsync(
             "sige_sam_v3.GrabaActividadesLead",
-            new { leadid = leadId, tipo = dto.Tipo, descripcion = dto.Descripcion, usuarioid = "" },
+            new { leadid = leadId, tipo = dto.Tipo, descripcion = dto.Descripcion, usuarioid = dto.UsuarioId },
             commandType: System.Data.CommandType.StoredProcedure);
         return "ok";
     }

backend/src/Ventas.Infrastructure/Repositories/UsuarioRepository.cs

@@ -1,5 +1,6 @@
 using Dapper;
 using Npgsql;
+using Ventas.Core.DTOs;
 using Ventas.Core.Interfaces;
 
 namespace Ventas.Infrastructure.Repositories;
@@ -13,33 +14,68 @@ public class UsuarioRepository : IUsuarioRepository
         _connectionString = connectionString;
     }
 
-    public async Task<string> BuscarAsync(string usuario, string clave)
+    public async Task<LoginResponse?> BuscarAsync(string usuario, string clave)
     {
         using var connection = new NpgsqlConnection(_connectionString);
-        var result = await connection.QueryAsync(
+        var data = await connection.QueryAsync(
             "sam.BuscarUsuario",
             new { userid = usuario, passid = clave },
             commandType: System.Data.CommandType.StoredProcedure);
-        return result.Any() ? "ok" : "";
+
+        var user = data.FirstOrDefault();
+        if (user == null) return null;
+
+        var dict = (IDictionary<string, object>)user;
+        dict.TryGetValue("Nombres", out var nombres);
+        dict.TryGetValue("idSede", out var sede);
+        return new LoginResponse
+        {
+            Nombre = nombres?.ToString() ?? "",
+            Sede = sede?.ToString()
+        };
     }
 
-    public async Task<string> InfoAsync(string usuario)
+    public async Task<LoginResponse?> InfoAsync(string usuario)
     {
         using var connection = new NpgsqlConnection(_connectionString);
-        var result = await connection.QueryAsync(
+        var data = await connection.QueryAsync(
             "sige_sam_v3.BuscarUsuario",
             new { usuarioid = usuario },
             commandType: System.Data.CommandType.StoredProcedure);
-        return result.Any() ? "ok" : "";
+
+        var user = data.FirstOrDefault();
+        if (user == null) return null;
+
+        var dict = (IDictionary<string, object>)user;
+        dict.TryGetValue("Nombres", out var nombres);
+        dict.TryGetValue("idSede", out var sede);
+        return new LoginResponse
+        {
+            Nombre = nombres?.ToString() ?? "",
+            Sede = sede?.ToString()
+        };
     }
 
-    public async Task<string> PerfilAsync(string usuario)
+    public async Task<LoginResponse?> PerfilAsync(string usuario)
     {
         using var connection = new NpgsqlConnection(_connectionString);
-        var result = await connection.QueryAsync(
+        var data = await connection.QueryAsync(
             "sige_sam_v3.BuscarPerfilUsuario",
             new { usuario },
             commandType: System.Data.CommandType.StoredProcedure);
-        return result.Any() ? "ok" : "";
+
+        var user = data.FirstOrDefault();
+        if (user == null) return null;
+
+        var dict = (IDictionary<string, object>)user;
+        dict.TryGetValue("Nombres", out var nombres);
+        dict.TryGetValue("idSede", out var sede);
+        dict.TryGetValue("Perfil", out var perfil);
+        return new LoginResponse
+        {
+            Nombre = nombres?.ToString() ?? "",
+            Sede = sede?.ToString(),
+            Perfil = perfil?.ToString()
+        };
     }
 }

backend/src/Ventas.Services/AlumnoService.cs

@@ -1,5 +1,3 @@
-using Dapper;
-using Npgsql;
 using Ventas.Core.Interfaces;
 
 namespace Ventas.Services;
@@ -7,57 +5,50 @@ namespace Ventas.Services;
 public class AlumnoService
 {
     private readonly IAlumnoRepository _alumnoRepository;
-    private readonly string _connectionString;
+    private readonly ICatalogoRepository _catalogo;
 
-    public AlumnoService(IAlumnoRepository alumnoRepository, string connectionString)
+    public AlumnoService(IAlumnoRepository alumnoRepository, ICatalogoRepository catalogo)
     {
         _alumnoRepository = alumnoRepository;
-        _connectionString = connectionString;
+        _catalogo = catalogo;
     }
 
-    private async Task<IEnumerable<Dictionary<string, object>>> QuerySpAsync(string sp, object parameters)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarAsync(string tipoBusqueda, string nombre)
-    {
+        => _catalogo.QuerySpAsync("sige_sam_v3.BuscarAlumnos", new { tipobusqueda = tipoBusqueda, nombrealumno = nombre });
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync(sp, parameters, commandType: System.Data.CommandType.StoredProcedure);
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
-    }
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarAsync(string tipoBusqueda, string nombre)
+    public async Task<string> IngresarV2Async(string rut, string nombre, string paterno, string materno, string direccion, string comuna, string fecha, string fono, string mail, int ocupacion, string profeOficio)
-        => await QuerySpAsync("sige_sam_v3.BuscarAlumnos", new { tipobusqueda = tipoBusqueda, nombrealumno = nombre });
+        => await _alumnoRepository.IngresarV2Async(rut, nombre, paterno, materno, direccion, comuna, fecha, fono, mail, ocupacion, profeOficio);
-
-    public async Task<string> IngresarV2Async(string rut, string nombre, string paterno, string materno, string fecha, string fono, string mail, int ocupacion, string profeOficio)
-        => await _alumnoRepository.IngresarV2Async(rut, nombre, paterno, materno, "SIN DIRECCION", "1", fecha, fono, mail, ocupacion, profeOficio);
 
     public async Task<string> IngresarApoderadoAsync(string rutApoderado, string rutAlumno, string nombre, string paterno, string materno, string direccion, string comuna, int nacionalidad, string fono, string mail)
         => await _alumnoRepository.IngresarApoderadoAsync(rutApoderado, rutAlumno, nombre, paterno, materno, direccion, comuna, nacionalidad, fono, mail);
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarApoderadoAsync(string tipoBusqueda, string nombre)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarApoderadoAsync(string tipoBusqueda, string nombre)
-        => await QuerySpAsync("sige_sam_v3.BuscarApoderado", new { tipobusqueda = tipoBusqueda, nombreapoderado = nombre });
+        => _catalogo.QuerySpAsync("sige_sam_v3.BuscarApoderado", new { tipobusqueda = tipoBusqueda, nombreapoderado = nombre });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> OcupacionAsync()
+    public Task<IEnumerable<Dictionary<string, object>>> OcupacionAsync()
-        => await QuerySpAsync("sige_sam_v3.BuscarOcupaciones", new { });
+        => _catalogo.QuerySpAsync("sige_sam_v3.BuscarOcupaciones", new { });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarContratosAsync(string id)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarContratosAsync(string id)
-        => await QuerySpAsync("sam.BuscarAlumnoContratoPersona", new { alumnoid = id });
+        => _catalogo.QuerySpAsync("sam.BuscarAlumnoContratoPersona", new { alumnoid = id });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarBloqueoAsync(string idAlumno)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarBloqueoAsync(string idAlumno)
-        => await QuerySpAsync("sige_sam_v3.BuscarBloqueoFinazas", new { idcliente = idAlumno });
+        => _catalogo.QuerySpAsync("sige_sam_v3.BuscarBloqueoFinazas", new { idcliente = idAlumno });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarAntiguedadAsync(string idAlumno)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarAntiguedadAsync(string idAlumno)
-        => await QuerySpAsync("sige_sam_v3.AlumnoAntiguedad", new { alumnoid = idAlumno });
+        => _catalogo.QuerySpAsync("sige_sam_v3.AlumnoAntiguedad", new { alumnoid = idAlumno });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarFormasPagoAsync(int boleta)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarFormasPagoAsync(int boleta)
-        => await QuerySpAsync("sige_sam_v3.AlumnoFormaPagoContrato", new { boleta });
+        => _catalogo.QuerySpAsync("sige_sam_v3.AlumnoFormaPagoContrato", new { boleta });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarAnexosContratoAsync(string alumnoId, string contratoId)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarAnexosContratoAsync(string alumnoId, string contratoId)
-        => await QuerySpAsync("sige_sam_v3.AlumnoBuscarAnexos", new { alumnoid = alumnoId, contrato = contratoId });
+        => _catalogo.QuerySpAsync("sige_sam_v3.AlumnoBuscarAnexos", new { alumnoid = alumnoId, contrato = contratoId });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarColegiosAsync(string nombre)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarColegiosAsync(string nombre)
-        => await QuerySpAsync("sam.BuscarColegios", new { nombrelike = nombre });
+        => _catalogo.QuerySpAsync("sam.BuscarColegios", new { nombrelike = nombre });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarProfesionesAsync(string nombre)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarProfesionesAsync(string nombre)
-        => await QuerySpAsync("sam.BuscarProfesiones", new { nombrelike = nombre });
+        => _catalogo.QuerySpAsync("sam.BuscarProfesiones", new { nombrelike = nombre });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarComunasXnombreAsync(string nombre)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarComunasXnombreAsync(string nombre)
-        => await QuerySpAsync("sam.BuscarComunasXnombre", new { nombrelike = nombre });
+        => _catalogo.QuerySpAsync("sam.BuscarComunasXnombre", new { nombrelike = nombre });
 }

backend/src/Ventas.Services/ArqueoService.cs

@@ -1,34 +1,19 @@
-using Dapper;
+using Ventas.Core.Interfaces;
-using Npgsql;
 
 namespace Ventas.Services;
 
 public class ArqueoService
 {
-    private readonly string _connectionString;
+    private readonly IArqueoRepository _arqueoRepository;
 
-    public ArqueoService(string connectionString)
+    public ArqueoService(IArqueoRepository arqueoRepository)
     {
-        _connectionString = connectionString;
+        _arqueoRepository = arqueoRepository;
     }
 
-    public async Task<IEnumerable<Dictionary<string, object>>> TodosHoyAsync(DateTime fecha)
+    public Task<IEnumerable<Dictionary<string, object>>> TodosHoyAsync(DateTime fecha)
-    {
+        => _arqueoRepository.TodosHoyAsync(fecha);
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync(
-            "sige_sam_v3.ArqueoHoy",
-            new { fechaarqueo = fecha },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
-    }
 
-    public async Task<IEnumerable<Dictionary<string, object>>> HoyAsync(string usuarioId, DateTime fecha)
+    public Task<IEnumerable<Dictionary<string, object>>> HoyAsync(string usuarioId, DateTime fecha)
-    {
+        => _arqueoRepository.HoyAsync(usuarioId, fecha);
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync(
-            "sige_sam_v3.ArqueoEjecutivo",
-            new { usuarioid = usuarioId, fechaarqueo = fecha },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
-    }
 }

backend/src/Ventas.Services/CatalogoService.cs

@@ -0,0 +1,92 @@
+using Ventas.Core.Interfaces;
+
+namespace Ventas.Services;
+
+public class CatalogoService
+{
+    private readonly ICatalogoRepository _repo;
+
+    public CatalogoService(ICatalogoRepository repo)
+    {
+        _repo = repo;
+    }
+
+    // Curso
+    public Task<IEnumerable<Dictionary<string, object>>> CursoBuscarAsync(string tipo, string nombre)
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarCurso", new { tipobusqueda = tipo, cursonombre = nombre });
+    public Task<IEnumerable<Dictionary<string, object>>> CursoHorarioAsync(int sede, int curso)
+        => _repo.QuerySpAsync("sam.WEB_Horarios_ecommerce", new { cursoid = curso, sedeid = sede });
+    public Task<IEnumerable<Dictionary<string, object>>> CursoFechasAsync(int curso, int sede)
+        => _repo.QuerySpAsync("sige_sam_v3.EcommerceFechas", new { cursoid = curso, sedeid = sede });
+    public Task<IEnumerable<Dictionary<string, object>>> CursoAperturaAsync(string tipo, int curso, int periodo, int year, int prod, int sede, int jornada, int asignacion, DateTime fecha)
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarCursosAperturados",
+            new { tipobusqueda = tipo, codigocurso = curso, periodo, yearperiodo = year, producto = prod, sede, jornada, asignacion = asignacion, fechatermino = fecha });
+
+    // Sede
+    public Task<IEnumerable<Dictionary<string, object>>> SedeBuscarAsync(string tipo, string nombre)
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarSedes", new { tipobusqueda = tipo, sedenombre = nombre });
+
+    // Region
+    public Task<IEnumerable<Dictionary<string, object>>> RegionBuscarAsync(string tipo, string nombre)
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarRegion", new { tipobusqueda = tipo, nombre });
+
+    // Jornada
+    public Task<IEnumerable<Dictionary<string, object>>> JornadaBuscarAsync(string tipo, string nombre)
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarJornada", new { tipobusqueda = tipo, jornadanombre = nombre });
+
+    // Programa
+    public Task<IEnumerable<Dictionary<string, object>>> ProgramaBuscarAsync(string tipo, string nombre)
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarProgramas", new { tipobusqueda = tipo, nombreprograma = nombre });
+
+    // Sala
+    public Task<IEnumerable<Dictionary<string, object>>> SalaBuscarAsync(string tipo, string nombre, string sede)
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarSala", new { tipobusqueda = tipo, salanombre = nombre, sedenombre = sede });
+    public Task<string?> SalaOcupacionAsync(int sedeId, int jornadaId, int salaId, string fecha, int horario, string dia, string hora)
+        => _repo.QuerySingleSpAsync("sige_sam_v3.BuscarSalaOcupada", new { sede = sedeId, jornada = jornadaId, fecha, sala = salaId, horario, diacorto = dia, varhora = hora });
+
+    // Tarifa
+    public Task<IEnumerable<Dictionary<string, object>>> TarifaBuscarAsync(int producto, int programa, int jornada, int sede, string fecha)
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarTarifa", new { producto, programa, jornada, sede, fecha });
+    public Task<IEnumerable<Dictionary<string, object>>> TarifaPromocionAsync(int tarifaId, int cantCursos)
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarTarifaPromocion", new { tarifa = tarifaId, cantcursos = cantCursos });
+
+    // Horario
+    public Task<IEnumerable<Dictionary<string, object>>> HorarioBuscarAsync(string tipo, string varA, string varB)
+        => _repo.QuerySpAsync("Empresa_HorarioBuscar", new { tipo, varz = varA, vary = varB });
+
+    // Descuento
+    public Task<IEnumerable<Dictionary<string, object>>> DescuentoBuscarAsync(string tipo, int sede, int programa, int horario)
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarDescuentos", new { tipobusqueda = tipo, sedeid = sede, programaid = programa, horarioid = horario });
+    public Task<IEnumerable<Dictionary<string, object>>> DescuentoSummerAsync(int cantidad)
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarDesctoSummer", new { cantidad });
+    public Task<string> DescuentoIngresarAsync(int cotizacionId, int descuentoId, int tipoDescuento, int nuevoMonto)
+        => _repo.ExecuteSpAsync("sige_sam_v3.DescuentoCotizacion", new { cotiid = cotizacionId, desctoid = descuentoId, tipoid = tipoDescuento, nuevototal = nuevoMonto });
+
+    // Documento
+    public Task<string> DocumentoIngresarOCAsync(string interno, int contratoId, int tipoId, string glosa, string ubicacion, string usuario)
+        => _repo.ExecuteSpAsync("Empresa_IngresoOrdenCompra", new { numeroin = interno, contid = contratoId, tipodoc = tipoId, glosa, orig = ubicacion, vendedor = usuario });
+    public Task<string> DocumentoIngresarSNCAsync(string interno, string alumno, int contratoId, string glosa, string usuario)
+        => _repo.ExecuteSpAsync("Empresa_IngresoInscripcionSence", new { numsence = interno, cont = contratoId, alumnoid = alumno, obsv = glosa, vendedorid = usuario });
+
+    // Propuesta
+    public Task<string?> PropuestaIngresarAsync(int tipo, int estado, int venta, string vendedor, DateTime fecha, int monto, string otic, string libro)
+        => _repo.QuerySingleSpAsync("Empresa_IngresoPropuestaV2", new { tipo, estado, venta, vendedor, fecha, monto, otic, libro });
+    public Task<IEnumerable<Dictionary<string, object>>> PropuestaDatosAsync(string busqueda, int prop, int cotz, int cont)
+        => _repo.QuerySpAsync("ModuloEmpresa_PropuestaCrystalReport", new { tipo = busqueda, prop, cotz, cont });
+
+    // Empresa
+    public Task<IEnumerable<Dictionary<string, object>>> EmpresaBuscarAsync(string busqueda, string rut, string varB, int varC)
+        => _repo.QuerySpAsync("ModuloEmpresa_BusquedaEmpresa", new { tipo = busqueda, varz = rut, vary = varB, varx = varC });
+    public Task<IEnumerable<Dictionary<string, object>>> EmpresaTiposAsync(string busqueda)
+        => _repo.QuerySpAsync("Empresa_BuscarTiposEmpresas", new { tipo = busqueda });
+    public Task<string> EmpresaIngresarAsync(string rut, string nombre, string direccion, string comuna, int tipo, string giro, string contacto, string fono, string mail, string origen)
+        => _repo.ExecuteSpAsync("IngresarEmpresaV2", new { rutempresa = rut, razonsocial = nombre, drccnempresa = direccion, comunaid = comuna, tipoid = tipo, gironombre = giro, contactoempresa = contacto, fonocontacto = fono, mailcontacto = mail, originemp = origen });
+
+    // Usuario
+    public Task<IEnumerable<Dictionary<string, object>>> UsuarioInfoAsync(string id)
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarUsuario", new { usuarioid = id });
+    public Task<IEnumerable<Dictionary<string, object>>> UsuarioPerfilAsync(string id)
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarPerfilUsuario", new { usuario = id });
+    public Task<IEnumerable<Dictionary<string, object>>> VendedoresActivosAsync()
+        => _repo.QuerySpAsync("sige_sam_v3.BuscarVendedoresActivos", new { });
+}

backend/src/Ventas.Services/ContratoService.cs

@@ -1,5 +1,3 @@
-using Dapper;
-using Npgsql;
 using Ventas.Core.Interfaces;
 
 namespace Ventas.Services;
@@ -7,80 +5,49 @@ namespace Ventas.Services;
 public class ContratoService
 {
     private readonly IContratoRepository _contratoRepository;
-    private readonly string _connectionString;
+    private readonly ICatalogoRepository _catalogo;
 
-    public ContratoService(IContratoRepository contratoRepository, string connectionString)
+    public ContratoService(IContratoRepository contratoRepository, ICatalogoRepository catalogo)
     {
         _contratoRepository = contratoRepository;
-        _connectionString = connectionString;
+        _catalogo = catalogo;
     }
 
-    private async Task<IEnumerable<Dictionary<string, object>>> QuerySpAsync(string sp, object parameters)
+    public async Task<string> IngresarAsync(int cotizacionId, int boletaCKT, string fechaContrato, int boletaId, int vendedorId)
-    {
+        => await _contratoRepository.IngresarAsync(cotizacionId, boletaCKT, fechaContrato, boletaId, vendedorId);
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync(sp, parameters, commandType: System.Data.CommandType.StoredProcedure);
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
-    }
-
-    public async Task<string> IngresarAsync(int cotizacionId, string fechaContrato, int boletaId, int vendedorId)
-        => await _contratoRepository.IngresarAsync(cotizacionId, 1, fechaContrato, boletaId, vendedorId);
 
     public async Task<string> IngresarDetalleAsync(int contratoId, string empresaId, string alumnoId, string cursoId, string fecha, int vendedor, int registroAcademico, int alumnoTipo)
         => await _contratoRepository.IngresarDetalleAsync(contratoId, empresaId, alumnoId, cursoId, fecha, vendedor, registroAcademico, alumnoTipo);
 
-    public async Task<IEnumerable<Dictionary<string, object>>> PdfContratoAsync(int contrato)
+    public Task<IEnumerable<Dictionary<string, object>>> PdfContratoAsync(int contrato)
-        => await QuerySpAsync("sige_sam_v3.PDFContrato", new { contrato });
+        => _catalogo.QuerySpAsync("sige_sam_v3.PDFContrato", new { contrato });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> PdfContratoJornadasAsync(int contrato)
+    public Task<IEnumerable<Dictionary<string, object>>> PdfContratoJornadasAsync(int contrato)
-        => await QuerySpAsync("sige_sam_v3.PDFContratoJornadas", new { contrato });
+        => _catalogo.QuerySpAsync("sige_sam_v3.PDFContratoJornadas", new { contrato });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> PdfContratoProgramasCursosAsync(int contrato)
+    public Task<IEnumerable<Dictionary<string, object>>> PdfContratoProgramasCursosAsync(int contrato)
-        => await QuerySpAsync("sige_sam_v3.PDFContratoProgramasCursos", new { contrato });
+        => _catalogo.QuerySpAsync("sige_sam_v3.PDFContratoProgramasCursos", new { contrato });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> PdfContratoSedesAsync(int contrato)
+    public Task<IEnumerable<Dictionary<string, object>>> PdfContratoSedesAsync(int contrato)
-        => await QuerySpAsync("sige_sam_v3.PDFContratoSedes", new { contrato });
+        => _catalogo.QuerySpAsync("sige_sam_v3.PDFContratoSedes", new { contrato });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarInformacionAsync(int contrato)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarInformacionAsync(int contrato)
-        => await QuerySpAsync("sige_sam_v3.BuscarInfoContrato", new { contratoid = contrato });
+        => _catalogo.QuerySpAsync("sige_sam_v3.BuscarInfoContrato", new { contratoid = contrato });
 
     public async Task<string> IngresarContratoEmpresaAsync(int cotizacionId, string empresaId, int tipoVenta, int facturaId, int cantCursos, int vendedorId)
-    {
+        => await _catalogo.QuerySingleSpAsync("IngresarContratoEmpresa",
-        using var connection = new NpgsqlConnection(_connectionString);
+            new { cotizacionid = cotizacionId, empresaid = empresaId, tipoventaid = tipoVenta, facturaid = facturaId, cantidadcursos = cantCursos, vendedorid = vendedorId }) ?? "ok";
-        var result = await connection.QuerySingleOrDefaultAsync<string>(
-            "IngresarContratoEmpresa",
-            new { cotizacionid = cotizacionId, empresaid = empresaId, tipoventaid = tipoVenta, facturaid = facturaId, cantidadcursos = cantCursos, vendedorid = vendedorId },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return result ?? "ok";
-    }
 
     public async Task<string> IngresarContratoCerradoAsync(int prop, string rut, int tipoVenta, string vendedorId)
-    {
+        => await _catalogo.QuerySingleSpAsync("Empresa_IngresarContratoV2",
-        using var connection = new NpgsqlConnection(_connectionString);
+            new { prop, rut, tipo = tipoVenta, vendedor = vendedorId }) ?? "ok";
-        var result = await connection.QuerySingleOrDefaultAsync<string>(
-            "Empresa_IngresarContratoV2",
-            new { prop, rut, tipo = tipoVenta, vendedor = vendedorId },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return result ?? "ok";
-    }
 
     public async Task<string> IngresarFirmaPendienteAsync(int contratoId)
-    {
+        => await _catalogo.ExecuteSpAsync("Empresa_IngresarContratoFirma", new { cont = contratoId });
-        using var connection = new NpgsqlConnection(_connectionString);
-        await connection.ExecuteAsync("Empresa_IngresarContratoFirma", new { cont = contratoId }, commandType: System.Data.CommandType.StoredProcedure);
-        return "ok";
-    }
 
     public async Task<string> ActualizarEstadoContratoAsync(string tipo, int contId, string varA, int varB)
-    {
+        => await _catalogo.ExecuteSpAsync("Empresa_ActualizaContrato", new { tipo, contrato = contId, varz = varA, vary = varB });
-        using var connection = new NpgsqlConnection(_connectionString);
-        await connection.ExecuteAsync("Empresa_ActualizaContrato", new { tipo, contrato = contId, varz = varA, vary = varB }, commandType: System.Data.CommandType.StoredProcedure);
-        return "ok";
-    }
 
     public async Task<string> ActualizarFirmaContratoAsync(string tipo, int contrato, int firmado)
-    {
+        => await _catalogo.ExecuteSpAsync("Empresa_ActualizaFirmaContrato", new { tipoeleccion = tipo, cont = contrato, fir = firmado });
-        using var connection = new NpgsqlConnection(_connectionString);
-        await connection.ExecuteAsync("Empresa_ActualizaFirmaContrato", new { tipoeleccion = tipo, cont = contrato, fir = firmado }, commandType: System.Data.CommandType.StoredProcedure);
-        return "ok";
-    }
 }

backend/src/Ventas.Services/CotizacionService.cs

@@ -1,5 +1,3 @@
-using Dapper;
-using Npgsql;
 using Ventas.Core.Interfaces;
 
 namespace Ventas.Services;
@@ -7,53 +5,36 @@ namespace Ventas.Services;
 public class CotizacionService
 {
     private readonly ICotizacionRepository _cotizacionRepository;
-    private readonly string _connectionString;
+    private readonly ICatalogoRepository _catalogo;
 
-    public CotizacionService(ICotizacionRepository cotizacionRepository, string connectionString)
+    public CotizacionService(ICotizacionRepository cotizacionRepository, ICatalogoRepository catalogo)
     {
         _cotizacionRepository = cotizacionRepository;
-        _connectionString = connectionString;
+        _catalogo = catalogo;
     }
 
-    private async Task<IEnumerable<Dictionary<string, object>>> QuerySpAsync(string sp, object parameters)
+    public async Task<string> IngresarAsync(string apoderadoId, string vendedorId, int solicitudDescuento, int descuento, int tipoDescuento, string fecha, int alumnos, int curso, int monto, string validez, int leadId)
-    {
+        => await _cotizacionRepository.PersonaIngresarAsync(apoderadoId, vendedorId, solicitudDescuento, descuento, tipoDescuento, fecha, alumnos, curso, monto, validez, leadId);
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync(sp, parameters, commandType: System.Data.CommandType.StoredProcedure);
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
-    }
-
-    public async Task<string> IngresarAsync(string apoderadoId, string vendedorId, int descuento, int tipoDescuento, string fecha, int monto, string validez, int leadId)
-        => await _cotizacionRepository.PersonaIngresarAsync(apoderadoId, vendedorId, 1, descuento, tipoDescuento, fecha, 1, 1, monto, validez, leadId);
 
     public async Task<string> IngresarDetalleAsync(int cotizacion, string alumnoId, int cursoId, int cantidad, int tarifa)
-    {
+        => await _catalogo.ExecuteSpAsync("sige_sam_v3.IngresarCotizacionDetalle",
-        using var connection = new NpgsqlConnection(_connectionString);
+            new { cotizaion = cotizacion, alumno = alumnoId, codigocurso = cursoId, cantidad, tarifa });
-        await connection.ExecuteAsync("sige_sam_v3.IngresarCotizacionDetalle",
-            new { cotizaion = cotizacion, alumno = alumnoId, codigocurso = cursoId, cantidad, tarifa },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return "ok";
-    }
 
     public async Task<string> DetalleSinCursoAsync(int cotizacion, string alumnoId, string apoderadoId, int programaId, int cantidad, int tarifa, int sedeId)
-    {
+        => await _catalogo.ExecuteSpAsync("sige_sam_v3.IngresarAnexoCotiSinCurso",
-        using var connection = new NpgsqlConnection(_connectionString);
+            new { cotiid = cotizacion, alumnid = alumnoId, apoid = apoderadoId, programid = programaId, cursos = cantidad, tarifaid = tarifa, idsede = sedeId });
-        await connection.ExecuteAsync("sige_sam_v3.IngresarAnexoCotiSinCurso",
-            new { cotiid = cotizacion, alumnid = alumnoId, apoid = apoderadoId, programid = programaId, cursos = cantidad, tarifaid = tarifa, idsede = sedeId },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return "ok";
-    }
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarAsync(int lead)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarAsync(int lead)
-        => await QuerySpAsync("sige_sam_v3.BuscarCotizacionLead", new { leadid = lead });
+        => _catalogo.QuerySpAsync("sige_sam_v3.BuscarCotizacionLead", new { leadid = lead });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarSinCursoAsync(int lead)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarSinCursoAsync(int lead)
-        => await QuerySpAsync("sige_sam_v3.BuscarCotizacionesSinCurso", new { leadid = lead });
+        => _catalogo.QuerySpAsync("sige_sam_v3.BuscarCotizacionesSinCurso", new { leadid = lead });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarInfoAsync(string tipoBusqueda, string nombre)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarInfoAsync(string tipoBusqueda, string nombre)
-        => await QuerySpAsync("sige_sam_v3.BuscarCotizacion", new { tipobusqueda = tipoBusqueda, nombre, fecha = DateTime.Now.ToString("yyyy-MM-dd") });
+        => _catalogo.QuerySpAsync("sige_sam_v3.BuscarCotizacion", new { tipobusqueda = tipoBusqueda, nombre, fecha = DateTime.Now.ToString("yyyy-MM-dd") });
 
-    public async Task<IEnumerable<Dictionary<string, object>>> DetalleAsync(int cotizacion)
+    public Task<IEnumerable<Dictionary<string, object>>> DetalleAsync(int cotizacion)
-        => await QuerySpAsync("sige_sam_v3.BuscarCotizacionDetalle", new { cotizacion });
+        => _catalogo.QuerySpAsync("sige_sam_v3.BuscarCotizacionDetalle", new { cotizacion });
 
     public async Task<string> PersonaPagarAsync(int cotizacion)
         => await _cotizacionRepository.PersonaPagarAsync(cotizacion);
@@ -62,19 +43,9 @@ public class CotizacionService
         => await _cotizacionRepository.DesactivarAsync(cotizacion);
 
     public async Task<string> CotizacionEmpIngresoAsync(string empresaId, string vendedor, int alumnos, int curso, int empresaMonto, int oticMonto, int alumnoMonto, int cotizacionTipo, DateTime validez, int descuentoId, int estadoId, string oticId, string motivo)
-    {
+        => await _catalogo.QuerySingleSpAsync("Empresa_IngresarCotizacionEmpresaV2",
-        using var connection = new NpgsqlConnection(_connectionString);
+            new { rutempresa = empresaId, vendedor, cantidadcursos = curso, cantidadalumnos = alumnos, montpempresa = empresaMonto, montootic = oticMonto, montoalm = alumnoMonto, tipocotz = cotizacionTipo, validez, iddescuento = descuentoId, idestado = estadoId, oticid = oticId, motivo }) ?? "ok";
-        var result = await connection.QuerySingleOrDefaultAsync<string>(
-            "Empresa_IngresarCotizacionEmpresaV2",
-            new { rutempresa = empresaId, vendedor, cantidadcursos = curso, cantidadalumnos = alumnos, montpempresa = empresaMonto, montootic = oticMonto, montoalm = alumnoMonto, tipocotz = cotizacionTipo, validez, iddescuento = descuentoId, idestado = estadoId, oticid = oticId, motivo },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return result ?? "ok";
-    }
 
     public async Task<string> ActualizaEstadoCotizacionAsync(string tipo, int cotzId, string varA, int varB)
-    {
+        => await _catalogo.ExecuteSpAsync("Empresa_ActualizaCotizacion", new { tipo, cotizacion = cotzId, varz = varA, vary = varB });
-        using var connection = new NpgsqlConnection(_connectionString);
-        await connection.ExecuteAsync("Empresa_ActualizaCotizacion", new { tipo, cotizacion = cotzId, varz = varA, vary = varB }, commandType: System.Data.CommandType.StoredProcedure);
-        return "ok";
-    }
 }

backend/src/Ventas.Services/EmpresaReportService.cs

@@ -1,5 +1,3 @@
-using Dapper;
-using Npgsql;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
@@ -10,22 +8,12 @@ namespace Ventas.Services;
 public class EmpresaReportService
 {
     private readonly IInformeRepository _informeRepository;
-    private readonly string _connectionString;
+    private readonly ICatalogoRepository _catalogo;
 
-    public EmpresaReportService(IInformeRepository informeRepository, string connectionString)
+    public EmpresaReportService(IInformeRepository informeRepository, ICatalogoRepository catalogo)
     {
         _informeRepository = informeRepository;
-        _connectionString = connectionString;
+        _catalogo = catalogo;
-    }
-
-    private async Task<IEnumerable<Dictionary<string, object>>> ContratoCrysAsync(string tipo, int cont)
-    {
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync(
-            "Empresa_ContratoCrys",
-            new { tipo, cont },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
     }
 
     private static string GetString(Dictionary<string, object> row, string key) =>
@@ -33,10 +21,10 @@ public class EmpresaReportService
 
     public async Task<byte[]> ContratoAbiertoPdfAsync(int contratoId)
     {
-        var dt01 = await ContratoCrysAsync("CONTRATOREIMPRESION", contratoId);
+        var dt01 = await _catalogo.QuerySpAsync("Empresa_ContratoCrys", new { tipo = "CONTRATOREIMPRESION", cont = contratoId });
-        var dt02 = await ContratoCrysAsync("DETALLECURSO", contratoId);
+        var dt02 = await _catalogo.QuerySpAsync("Empresa_ContratoCrys", new { tipo = "DETALLECURSO", cont = contratoId });
-        var dt03 = await ContratoCrysAsync("HORARIO", contratoId);
+        var dt03 = await _catalogo.QuerySpAsync("Empresa_ContratoCrys", new { tipo = "HORARIO", cont = contratoId });
-        var dt04 = await ContratoCrysAsync("ALUMNO", contratoId);
+        var dt04 = await _catalogo.QuerySpAsync("Empresa_ContratoCrys", new { tipo = "ALUMNO", cont = contratoId });
 
         var header = dt01.FirstOrDefault();
         if (header == null) return [];
@@ -288,11 +276,10 @@ public class EmpresaReportService
         });
     }
 
-    // Variantes CAEMP/CAEMPSNC/CAEMPV2 — mismo SP, layout con/sin SENCE
     public async Task<byte[]> ContratoAbiertoSinSencePdfAsync(int contratoId)
     {
-        var dt01 = await ContratoCrysAsync("CONTRATOREIMPRESION", contratoId);
+        var dt01 = await _catalogo.QuerySpAsync("Empresa_ContratoCrys", new { tipo = "CONTRATOREIMPRESION", cont = contratoId });
-        var dt02 = await ContratoCrysAsync("DETALLECURSO", contratoId);
+        var dt02 = await _catalogo.QuerySpAsync("Empresa_ContratoCrys", new { tipo = "DETALLECURSO", cont = contratoId });
         var header = dt01.FirstOrDefault();
         if (header == null) return [];
 
@@ -324,8 +311,8 @@ public class EmpresaReportService
 
     public async Task<byte[]> ContratoAbiertoConSencePdfAsync(int contratoId)
     {
-        var dt01 = await ContratoCrysAsync("CONTRATOREIMPRESION", contratoId);
+        var dt01 = await _catalogo.QuerySpAsync("Empresa_ContratoCrys", new { tipo = "CONTRATOREIMPRESION", cont = contratoId });
-        var dt02 = await ContratoCrysAsync("DETALLECURSO", contratoId);
+        var dt02 = await _catalogo.QuerySpAsync("Empresa_ContratoCrys", new { tipo = "DETALLECURSO", cont = contratoId });
         var header = dt01.FirstOrDefault();
         if (header == null) return [];
 

backend/src/Ventas.Services/InformeService.cs

@@ -28,4 +28,7 @@ public class InformeService
 
     public async Task<IEnumerable<Dictionary<string, object>>> InformeGeneralAsync(string busqueda, string varA, string varB)
         => await _informeRepository.InformeGeneralAsync(busqueda, varA, varB);
+
+    public async Task<IEnumerable<Dictionary<string, object>>> EjecutarCrystalSpAsync(string tipo, int prop, int cotz, int cont)
+        => await _informeRepository.EjecutarCrystalSpAsync(tipo, prop, cotz, cont);
 }

backend/src/Ventas.Services/LeadService.cs

@@ -1,160 +1,62 @@
-using Dapper;
-using Npgsql;
 using Ventas.Core.DTOs;
+using Ventas.Core.Interfaces;
 
 namespace Ventas.Services;
 
 public class LeadService
 {
-    private readonly string _connectionString;
+    private readonly ILeadRepository _leadRepository;
+    private readonly ILeadQueryRepository _leadQueryRepository;
 
-    public LeadService(string connectionString)
+    public LeadService(ILeadRepository leadRepository, ILeadQueryRepository leadQueryRepository)
     {
-        _connectionString = connectionString;
+        _leadRepository = leadRepository;
+        _leadQueryRepository = leadQueryRepository;
     }
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarAsync(int ejecutivo, int estado, int dias)
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarAsync(int ejecutivo, int estado, int dias)
+        => _leadQueryRepository.BuscarAsync(ejecutivo, estado, dias);
+
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarIDAsync(int id)
+        => _leadQueryRepository.BuscarIDAsync(id);
+
+    public Task<IEnumerable<Dictionary<string, object>>> BuscarNuevosAsync(int ejecutivo)
+        => _leadQueryRepository.BuscarNuevosAsync(ejecutivo);
+
+    public Task<string> IngresarAsync(LeadCreateDto dto)
+        => _leadRepository.IngresarAsync(dto);
+
+    public Task<string> IngresarV2Async(LeadCreateDto dto)
+        => _leadRepository.IngresarV2Async(dto);
+
+    public Task<string> IngresarPagoAsync(int lead, int coti, string pago, int monto, string cod, string dig, int cuota)
+        => _leadRepository.IngresarPagoAsync(new PagoLeadDto
         {
-        using var connection = new NpgsqlConnection(_connectionString);
+            LeadId = lead, CotizacionId = coti, FormaPago = pago,
-        var rows = await connection.QueryAsync(
+            Monto = monto, CodigoAutorizacion = cod, DigitoTarjeta = dig, Cuotas = cuota
-            "sige_sam_v3.BuscarLeadV3",
+        });
-            new { ejecutivo, estadolead = estado, filtro = dias },
-            commandType: System.Data.CommandType.StoredProcedure);
 
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
+    public Task<string> ActualizarProductoAsync(int leadId, string producto)
-    }
+        => _leadRepository.ActualizarProductoAsync(leadId, producto);
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarIDAsync(int id)
+    public Task<IEnumerable<Dictionary<string, object>>> MontosAsync(int ejecutivo)
-    {
+        => _leadQueryRepository.MontosAsync(ejecutivo);
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync(
-            "sige_sam_v3.BuscarLeadID",
-            new { id },
-            commandType: System.Data.CommandType.StoredProcedure);
 
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
+    public Task<IEnumerable<Dictionary<string, object>>> ActividadesAsync(int leadId, string tipo)
-    }
+        => _leadQueryRepository.ActividadesAsync(leadId, tipo);
 
-    public async Task<IEnumerable<Dictionary<string, object>>> BuscarNuevosAsync(int ejecutivo)
+    public Task<string> IngresarActividadAsync(int leadId, string tipo, string descripcion, string usuarioId)
-    {
+        => _leadRepository.IngresarActividadAsync(leadId, new ActividadCreateDto { Tipo = tipo, Descripcion = descripcion, UsuarioId = usuarioId });
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync(
-            "sige_sam_v3.BuscarLeadNuevos",
-            new { ejecutivo },
-            commandType: System.Data.CommandType.StoredProcedure);
 
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
+    public Task<string> EstadoUpdateAsync(int leadId, int estadoId)
-    }
+        => _leadRepository.EstadoUpdateAsync(leadId, estadoId);
 
-    public async Task<string> IngresarAsync(LeadCreateDto dto)
+    public Task<IEnumerable<Dictionary<string, object>>> MotivosPerdidoAsync()
-    {
+        => _leadQueryRepository.MotivosPerdidoAsync();
-        using var connection = new NpgsqlConnection(_connectionString);
-        await connection.ExecuteAsync(
-            "sige_sam_v3.GrabaLead",
-            new { nombrelead = dto.Nombre, maillead = dto.Mail, telefonolead = dto.Telefono, productolead = dto.Producto, contactolead = dto.Contacto, ejecutivoid = dto.EjecutivoId },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return "ok";
-    }
 
-    public async Task<string> IngresarV2Async(LeadCreateDto dto)
+    public Task<string> IngresarLeadPerdidoAsync(int leadId, int motivo, int estado)
-    {
+        => _leadRepository.IngresarLeadPerdidoAsync(leadId, motivo, estado);
-        using var connection = new NpgsqlConnection(_connectionString);
-        var result = await connection.QuerySingleOrDefaultAsync<string>(
-            "sige_sam_v3.GrabaLead",
-            new { nombrelead = dto.Nombre, maillead = dto.Mail, telefonolead = dto.Telefono, productolead = dto.Producto, contactolead = dto.Contacto, ejecutivoid = dto.EjecutivoId },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return result ?? "ok";
-    }
 
-    public async Task<string> IngresarPagoAsync(int lead, int coti, string pago, int monto, string cod, string dig, int cuota)
+    public Task<string> ActualizarContactoAsync(int leadId, string nombre, string mail, string fono, string rut)
-    {
+        => _leadRepository.ActualizarContactoAsync(leadId, new ContactoUpdateDto { Nombre = nombre, Mail = mail, Telefono = fono, Rut = rut });
-        using var connection = new NpgsqlConnection(_connectionString);
-        await connection.ExecuteAsync(
-            "sige_sam_v3.GrabaPagoLead",
-            new { leadid = lead, cotiid = coti, formapago = pago, valor = monto, codauto = cod, digtar = dig, cantcouta = cuota },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return "ok";
-    }
-
-    public async Task<string> ActualizarProductoAsync(int leadId, string producto)
-    {
-        using var connection = new NpgsqlConnection(_connectionString);
-        await connection.ExecuteAsync(
-            "sam.ActualuzarLeadProducto",
-            new { leadid = leadId, productlead = producto },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return "ok";
-    }
-
-    public async Task<IEnumerable<Dictionary<string, object>>> MontosAsync(int ejecutivo)
-    {
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync(
-            "sige_sam_v3.BuscarLeadMontos",
-            new { ejecutivo },
-            commandType: System.Data.CommandType.StoredProcedure);
-
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
-    }
-
-    public async Task<IEnumerable<Dictionary<string, object>>> ActividadesAsync(int leadId, string tipo)
-    {
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync(
-            "sige_sam_v3.BuscarActividadesLead",
-            new { id = leadId, tipoactividad = tipo },
-            commandType: System.Data.CommandType.StoredProcedure);
-
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
-    }
-
-    public async Task<string> IngresarActividadAsync(int leadId, string tipo, string descripcion, string usuarioId)
-    {
-        using var connection = new NpgsqlConnection(_connectionString);
-        await connection.ExecuteAsync(
-            "sige_sam_v3.GrabaActividadesLead",
-            new { leadid = leadId, tipo, descripcion, usuarioid = usuarioId },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return "ok";
-    }
-
-    public async Task<string> EstadoUpdateAsync(int leadId, int estadoId)
-    {
-        using var connection = new NpgsqlConnection(_connectionString);
-        await connection.ExecuteAsync(
-            "sige_sam_v3.ActualizarEstadoLead",
-            new { leadid = leadId, estadolead = estadoId },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return "ok";
-    }
-
-    public async Task<IEnumerable<Dictionary<string, object>>> MotivosPerdidoAsync()
-    {
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync(
-            "sige_sam_v3.BuscarMotivoLeadPerdido",
-            commandType: System.Data.CommandType.StoredProcedure);
-
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
-    }
-
-    public async Task<string> IngresarLeadPerdidoAsync(int leadId, int motivo, int estado)
-    {
-        using var connection = new NpgsqlConnection(_connectionString);
-        await connection.ExecuteAsync(
-            "sige_sam_v3.Lead_Ingresar_Perdido",
-            new { leadid = leadId, motivo, estado },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return "ok";
-    }
-
-    public async Task<string> ActualizarContactoAsync(int leadId, string nombre, string mail, string fono, string rut)
-    {
-        using var connection = new NpgsqlConnection(_connectionString);
-        await connection.ExecuteAsync(
-            "sige_sam_v3.ActualizaLeadContacto",
-            new { leadid = leadId, nombrecontacto = nombre, mailcontacto = mail, fonocontacto = fono, rutcontacto = rut },
-            commandType: System.Data.CommandType.StoredProcedure);
-        return "ok";
-    }
 }

backend/src/Ventas.Services/ReportService.cs

@@ -1,8 +1,7 @@
-using Dapper;
-using Npgsql;
 using QuestPDF.Fluent;
 using QuestPDF.Helpers;
 using QuestPDF.Infrastructure;
+using Ventas.Core.Interfaces;
 
 namespace Ventas.Services;
 
@@ -10,20 +9,13 @@ public class ReportService
 {
     private readonly ContratoService _contratoService;
     private readonly CotizacionService _cotizacionService;
-    private readonly string _connectionString;
+    private readonly ICatalogoRepository _catalogo;
 
-    public ReportService(ContratoService contratoService, CotizacionService cotizacionService, string connectionString)
+    public ReportService(ContratoService contratoService, CotizacionService cotizacionService, ICatalogoRepository catalogo)
     {
         _contratoService = contratoService;
         _cotizacionService = cotizacionService;
-        _connectionString = connectionString;
+        _catalogo = catalogo;
-    }
-
-    private async Task<IEnumerable<Dictionary<string, object>>> QuerySpAsync(string sp, object parameters)
-    {
-        using var connection = new NpgsqlConnection(_connectionString);
-        var rows = await connection.QueryAsync(sp, parameters, commandType: System.Data.CommandType.StoredProcedure);
-        return rows.Select(r => (Dictionary<string, object>)(IDictionary<string, object>)r!);
     }
 
     public async Task<byte[]> GenerarContratoPdfAsync(int contratoId)
@@ -362,7 +354,7 @@ public class ReportService
 
     public async Task<byte[]> GenerarAnexoPdfAsync(int contratoId, int anexoId)
     {
-        var rows = await QuerySpAsync("sige_sam_v3.PDFContratoDetalle", new { contrato = contratoId, detalle = anexoId });
+        var rows = await _catalogo.QuerySpAsync("sige_sam_v3.PDFContratoDetalle", new { contrato = contratoId, detalle = anexoId });
         var row = rows.FirstOrDefault();
         if (row == null) return [];
 
@@ -411,7 +403,7 @@ public class ReportService
 
     public async Task<byte[]> GenerarPresupuestoPdfAsync(int presupuestoId)
     {
-        var rows = await QuerySpAsync("sige_sam_v3.BuscarCotizacionPDF", new { cotizacionid = presupuestoId });
+        var rows = await _catalogo.QuerySpAsync("sige_sam_v3.BuscarCotizacionPDF", new { cotizacionid = presupuestoId });
         var row = rows.FirstOrDefault();
         if (row == null) return [];
 

backend/src/Ventas.Services/UsuarioService.cs

@@ -1,5 +1,3 @@
-using Dapper;
-using Npgsql;
 using Ventas.Core.DTOs;
 using Ventas.Core.Interfaces;
 
@@ -8,50 +6,15 @@ namespace Ventas.Services;
 public class UsuarioService
 {
     private readonly IUsuarioRepository _usuarioRepository;
-    private readonly string _connectionString;
 
-    public UsuarioService(IUsuarioRepository usuarioRepository, string connectionString)
+    public UsuarioService(IUsuarioRepository usuarioRepository)
     {
         _usuarioRepository = usuarioRepository;
-        _connectionString = connectionString;
     }
 
-    public async Task<LoginResponse?> LoginAsync(LoginRequest request)
+    public Task<LoginResponse?> LoginAsync(LoginRequest request)
-    {
+        => _usuarioRepository.BuscarAsync(request.Rut, request.Clave);
-        using var connection = new NpgsqlConnection(_connectionString);
-        var data = await connection.QueryAsync(
-            "sam.BuscarUsuario",
-            new { userid = request.Rut, passid = request.Clave },
-            commandType: System.Data.CommandType.StoredProcedure);
 
-        var user = data.FirstOrDefault();
+    public Task<LoginResponse?> PerfilAsync(string usuarioId)
-        if (user == null) return null;
+        => _usuarioRepository.PerfilAsync(usuarioId);
-
-        var dict = (IDictionary<string, object>)user;
-        return new LoginResponse
-        {
-            Nombre = dict["Nombres"]?.ToString() ?? "",
-            Sede = dict["idSede"]?.ToString()
-        };
-    }
-
-    public async Task<LoginResponse?> PerfilAsync(string usuarioId)
-    {
-        using var connection = new NpgsqlConnection(_connectionString);
-        var data = await connection.QueryAsync(
-            "sige_sam_v3.BuscarPerfilUsuario",
-            new { usuario = usuarioId },
-            commandType: System.Data.CommandType.StoredProcedure);
-
-        var user = data.FirstOrDefault();
-        if (user == null) return null;
-
-        var dict = (IDictionary<string, object>)user;
-        return new LoginResponse
-        {
-            Nombre = dict["Nombres"]?.ToString() ?? "",
-            Sede = dict["idSede"]?.ToString(),
-            Perfil = dict["Perfil"]?.ToString()
-        };
-    }
 }

backend/src/Ventas.Services/Ventas.Services.csproj

@@ -5,6 +5,10 @@
     <ProjectReference Include="..\Ventas.Infrastructure\Ventas.Infrastructure.csproj" />
   </ItemGroup>
 
+  <ItemGroup>
+    <PackageReference Include="QuestPDF" Version="2026.7.0" />
+  </ItemGroup>
+
   <PropertyGroup>
     <TargetFramework>net10.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>