feat: Implementación CRUD Canillitas, Distribuidores y Precios de Publicación
Backend API:
- Canillitas (`dist_dtCanillas`):
- Implementado CRUD completo (Modelos, DTOs, Repositorio, Servicio, Controlador).
- Lógica para manejo de `Accionista`, `Baja`, `FechaBaja`.
- Auditoría en `dist_dtCanillas_H`.
- Validación de legajo único y lógica de empresa vs accionista.
- Distribuidores (`dist_dtDistribuidores`):
- Implementado CRUD completo (Modelos, DTOs, Repositorio, Servicio, Controlador).
- Auditoría en `dist_dtDistribuidores_H`.
- Creación de saldos iniciales para el nuevo distribuidor en todas las empresas.
- Verificación de NroDoc único y Nombre opcionalmente único.
- Precios de Publicación (`dist_Precios`):
- Implementado CRUD básico (Modelos, DTOs, Repositorio, Servicio, Controlador).
- Endpoints anidados bajo `/publicaciones/{idPublicacion}/precios`.
- Lógica de negocio para cerrar período de precio anterior al crear uno nuevo.
- Lógica de negocio para reabrir período de precio anterior al eliminar el último.
- Auditoría en `dist_Precios_H`.
- Auditoría en Eliminación de Publicaciones:
- Extendido `PublicacionService.EliminarAsync` para eliminar en cascada registros de precios, recargos, porcentajes de pago (distribuidores y canillitas) y secciones de publicación.
- Repositorios correspondientes (`PrecioRepository`, `RecargoZonaRepository`, `PorcPagoRepository`, `PorcMonCanillaRepository`, `PubliSeccionRepository`) actualizados con métodos `DeleteByPublicacionIdAsync` que registran en sus respectivas tablas `_H` (si existen y se implementó la lógica).
- Asegurada la correcta propagación del `idUsuario` para la auditoría en cascada.
- Correcciones de Nulabilidad:
- Ajustados los métodos `MapToDto` y su uso en `CanillaService` y `PublicacionService` para manejar correctamente tipos anulables.
Frontend React:
- Canillitas:
- `canillaService.ts`.
- `CanillaFormModal.tsx` con selectores para Zona y Empresa, y lógica de Accionista.
- `GestionarCanillitasPage.tsx` con filtros, paginación, y acciones (editar, toggle baja).
- Distribuidores:
- `distribuidorService.ts`.
- `DistribuidorFormModal.tsx` con múltiples campos y selector de Zona.
- `GestionarDistribuidoresPage.tsx` con filtros, paginación, y acciones (editar, eliminar).
- Precios de Publicación:
- `precioService.ts`.
- `PrecioFormModal.tsx` para crear/editar períodos de precios (VigenciaD, VigenciaH opcional, precios por día).
- `GestionarPreciosPublicacionPage.tsx` accesible desde la gestión de publicaciones, para listar y gestionar los períodos de precios de una publicación específica.
- Layout:
- Reemplazado el uso de `Grid` por `Box` con Flexbox en `CanillaFormModal`, `GestionarCanillitasPage` (filtros), `DistribuidorFormModal` y `PrecioFormModal` para resolver problemas de tipos y mejorar la consistencia del layout de formularios.
- Navegación:
- Actualizadas las rutas y pestañas para los nuevos módulos y sub-módulos.
This commit is contained in:
@@ -0,0 +1,205 @@
|
||||
using Dapper;
|
||||
using GestionIntegral.Api.Data.Repositories;
|
||||
using GestionIntegral.Api.Models.Distribucion;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using System.Collections.Generic;
|
||||
using System.Data;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public class CanillaRepository : ICanillaRepository
|
||||
{
|
||||
private readonly DbConnectionFactory _connectionFactory;
|
||||
private readonly ILogger<CanillaRepository> _logger;
|
||||
|
||||
public CanillaRepository(DbConnectionFactory connectionFactory, ILogger<CanillaRepository> logger)
|
||||
{
|
||||
_connectionFactory = connectionFactory;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<(Canilla Canilla, string NombreZona, string NombreEmpresa)>> GetAllAsync(string? nomApeFilter, int? legajoFilter, bool? soloActivos)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder(@"
|
||||
SELECT c.*, z.Nombre AS NombreZona, ISNULL(e.Nombre, 'N/A (Accionista)') AS NombreEmpresa
|
||||
FROM dbo.dist_dtCanillas c
|
||||
INNER JOIN dbo.dist_dtZonas z ON c.Id_Zona = z.Id_Zona
|
||||
LEFT JOIN dbo.dist_dtEmpresas e ON c.Empresa = e.Id_Empresa -- Empresa 0 no tendrá join
|
||||
WHERE 1=1");
|
||||
var parameters = new DynamicParameters();
|
||||
|
||||
if (soloActivos.HasValue)
|
||||
{
|
||||
sqlBuilder.Append(soloActivos.Value ? " AND c.Baja = 0" : " AND c.Baja = 1");
|
||||
}
|
||||
if (!string.IsNullOrWhiteSpace(nomApeFilter))
|
||||
{
|
||||
sqlBuilder.Append(" AND c.NomApe LIKE @NomApe");
|
||||
parameters.Add("NomApe", $"%{nomApeFilter}%");
|
||||
}
|
||||
if (legajoFilter.HasValue)
|
||||
{
|
||||
sqlBuilder.Append(" AND c.Legajo = @Legajo");
|
||||
parameters.Add("Legajo", legajoFilter.Value);
|
||||
}
|
||||
sqlBuilder.Append(" ORDER BY c.NomApe;");
|
||||
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QueryAsync<Canilla, string, string, (Canilla, string, string)>(
|
||||
sqlBuilder.ToString(),
|
||||
(canilla, nombreZona, nombreEmpresa) => (canilla, nombreZona, nombreEmpresa),
|
||||
parameters,
|
||||
splitOn: "NombreZona,NombreEmpresa"
|
||||
);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener todos los Canillas.");
|
||||
return Enumerable.Empty<(Canilla, string, string)>();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<(Canilla? Canilla, string? NombreZona, string? NombreEmpresa)> GetByIdAsync(int id)
|
||||
{
|
||||
const string sql = @"
|
||||
SELECT c.*, z.Nombre AS NombreZona, ISNULL(e.Nombre, 'N/A (Accionista)') AS NombreEmpresa
|
||||
FROM dbo.dist_dtCanillas c
|
||||
INNER JOIN dbo.dist_dtZonas z ON c.Id_Zona = z.Id_Zona
|
||||
LEFT JOIN dbo.dist_dtEmpresas e ON c.Empresa = e.Id_Empresa
|
||||
WHERE c.Id_Canilla = @Id";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
var result = await connection.QueryAsync<Canilla, string, string, (Canilla, string, string)>(
|
||||
sql,
|
||||
(canilla, nombreZona, nombreEmpresa) => (canilla, nombreZona, nombreEmpresa),
|
||||
new { Id = id },
|
||||
splitOn: "NombreZona,NombreEmpresa"
|
||||
);
|
||||
return result.SingleOrDefault();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener Canilla por ID: {IdCanilla}", id);
|
||||
return (null, null, null);
|
||||
}
|
||||
}
|
||||
public async Task<Canilla?> GetByIdSimpleAsync(int id) // Para uso interno del servicio
|
||||
{
|
||||
const string sql = "SELECT * FROM dbo.dist_dtCanillas WHERE Id_Canilla = @Id";
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QuerySingleOrDefaultAsync<Canilla>(sql, new { Id = id });
|
||||
}
|
||||
|
||||
|
||||
public async Task<bool> ExistsByLegajoAsync(int legajo, int? excludeIdCanilla = null)
|
||||
{
|
||||
if (legajo == 0) return false; // Legajo 0 es como nulo, no debería validarse como único
|
||||
var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.dist_dtCanillas WHERE Legajo = @Legajo AND Legajo != 0"); // Excluir legajo 0 de la unicidad
|
||||
var parameters = new DynamicParameters();
|
||||
parameters.Add("Legajo", legajo);
|
||||
|
||||
if (excludeIdCanilla.HasValue)
|
||||
{
|
||||
sqlBuilder.Append(" AND Id_Canilla != @ExcludeIdCanilla");
|
||||
parameters.Add("ExcludeIdCanilla", excludeIdCanilla.Value);
|
||||
}
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.ExecuteScalarAsync<bool>(sqlBuilder.ToString(), parameters);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error en ExistsByLegajoAsync para Canilla con Legajo: {Legajo}", legajo);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<Canilla?> CreateAsync(Canilla nuevoCanilla, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
const string sqlInsert = @"
|
||||
INSERT INTO dbo.dist_dtCanillas (Legajo, NomApe, Parada, Id_Zona, Accionista, Obs, Empresa, Baja, FechaBaja)
|
||||
OUTPUT INSERTED.*
|
||||
VALUES (@Legajo, @NomApe, @Parada, @IdZona, @Accionista, @Obs, @Empresa, @Baja, @FechaBaja);";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_dtCanillas_H
|
||||
(Id_Canilla, Legajo, NomApe, Parada, Id_Zona, Accionista, Obs, Empresa, Baja, FechaBaja, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdCanilla, @Legajo, @NomApe, @Parada, @IdZona, @Accionista, @Obs, @Empresa, @Baja, @FechaBaja, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
var connection = transaction.Connection!;
|
||||
var insertedCanilla = await connection.QuerySingleAsync<Canilla>(sqlInsert, nuevoCanilla, transaction);
|
||||
|
||||
if (insertedCanilla == null) throw new DataException("No se pudo crear el canilla.");
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
insertedCanilla.IdCanilla, insertedCanilla.Legajo, insertedCanilla.NomApe, insertedCanilla.Parada, insertedCanilla.IdZona,
|
||||
insertedCanilla.Accionista, insertedCanilla.Obs, insertedCanilla.Empresa, insertedCanilla.Baja, insertedCanilla.FechaBaja,
|
||||
Id_Usuario = idUsuario, FechaMod = DateTime.Now, TipoMod = "Creado"
|
||||
}, transaction);
|
||||
return insertedCanilla;
|
||||
}
|
||||
|
||||
public async Task<bool> UpdateAsync(Canilla canillaAActualizar, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
var canillaActual = await connection.QuerySingleOrDefaultAsync<Canilla>(
|
||||
"SELECT * FROM dbo.dist_dtCanillas WHERE Id_Canilla = @IdCanilla", new { canillaAActualizar.IdCanilla }, transaction);
|
||||
if (canillaActual == null) throw new KeyNotFoundException("Canilla no encontrado para actualizar.");
|
||||
|
||||
const string sqlUpdate = @"
|
||||
UPDATE dbo.dist_dtCanillas SET
|
||||
Legajo = @Legajo, NomApe = @NomApe, Parada = @Parada, Id_Zona = @IdZona,
|
||||
Accionista = @Accionista, Obs = @Obs, Empresa = @Empresa
|
||||
-- Baja y FechaBaja se manejan por ToggleBajaAsync
|
||||
WHERE Id_Canilla = @IdCanilla;";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_dtCanillas_H
|
||||
(Id_Canilla, Legajo, NomApe, Parada, Id_Zona, Accionista, Obs, Empresa, Baja, FechaBaja, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdCanilla, @LegajoActual, @NomApeActual, @ParadaActual, @IdZonaActual, @AccionistaActual, @ObsActual, @EmpresaActual, @BajaActual, @FechaBajaActual, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdCanilla = canillaActual.IdCanilla,
|
||||
LegajoActual = canillaActual.Legajo, NomApeActual = canillaActual.NomApe, ParadaActual = canillaActual.Parada, IdZonaActual = canillaActual.IdZona,
|
||||
AccionistaActual = canillaActual.Accionista, ObsActual = canillaActual.Obs, EmpresaActual = canillaActual.Empresa,
|
||||
BajaActual = canillaActual.Baja, FechaBajaActual = canillaActual.FechaBaja, // Registrar estado actual de baja
|
||||
Id_Usuario = idUsuario, FechaMod = DateTime.Now, TipoMod = "Actualizado"
|
||||
}, transaction);
|
||||
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, canillaAActualizar, transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
|
||||
public async Task<bool> ToggleBajaAsync(int id, bool darDeBaja, DateTime? fechaBaja, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
var canillaActual = await connection.QuerySingleOrDefaultAsync<Canilla>(
|
||||
"SELECT * FROM dbo.dist_dtCanillas WHERE Id_Canilla = @IdCanilla", new { IdCanilla = id }, transaction);
|
||||
if (canillaActual == null) throw new KeyNotFoundException("Canilla no encontrado para dar de baja/alta.");
|
||||
|
||||
const string sqlUpdate = "UPDATE dbo.dist_dtCanillas SET Baja = @Baja, FechaBaja = @FechaBaja WHERE Id_Canilla = @IdCanilla;";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_dtCanillas_H
|
||||
(Id_Canilla, Legajo, NomApe, Parada, Id_Zona, Accionista, Obs, Empresa, Baja, FechaBaja, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdCanilla, @Legajo, @NomApe, @Parada, @IdZona, @Accionista, @Obs, @Empresa, @BajaNueva, @FechaBajaNueva, @Id_Usuario, @FechaMod, @TipoModHist);";
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
canillaActual.IdCanilla, canillaActual.Legajo, canillaActual.NomApe, canillaActual.Parada, canillaActual.IdZona,
|
||||
canillaActual.Accionista, canillaActual.Obs, canillaActual.Empresa,
|
||||
BajaNueva = darDeBaja, FechaBajaNueva = (darDeBaja ? fechaBaja : null), // FechaBaja solo si se da de baja
|
||||
Id_Usuario = idUsuario, FechaMod = DateTime.Now, TipoModHist = (darDeBaja ? "Baja" : "Alta")
|
||||
}, transaction);
|
||||
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, new { Baja = darDeBaja, FechaBaja = (darDeBaja ? fechaBaja : null), IdCanilla = id }, transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,212 @@
|
||||
using Dapper;
|
||||
using GestionIntegral.Api.Models.Distribucion;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using System.Collections.Generic;
|
||||
using System.Data;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public class DistribuidorRepository : IDistribuidorRepository
|
||||
{
|
||||
private readonly DbConnectionFactory _connectionFactory;
|
||||
private readonly ILogger<DistribuidorRepository> _logger;
|
||||
|
||||
public DistribuidorRepository(DbConnectionFactory connectionFactory, ILogger<DistribuidorRepository> logger)
|
||||
{
|
||||
_connectionFactory = connectionFactory;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<(Distribuidor Distribuidor, string? NombreZona)>> GetAllAsync(string? nombreFilter, string? nroDocFilter)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder(@"
|
||||
SELECT d.*, z.Nombre AS NombreZona
|
||||
FROM dbo.dist_dtDistribuidores d
|
||||
LEFT JOIN dbo.dist_dtZonas z ON d.Id_Zona = z.Id_Zona
|
||||
WHERE 1=1");
|
||||
var parameters = new DynamicParameters();
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(nombreFilter))
|
||||
{
|
||||
sqlBuilder.Append(" AND d.Nombre LIKE @Nombre");
|
||||
parameters.Add("Nombre", $"%{nombreFilter}%");
|
||||
}
|
||||
if (!string.IsNullOrWhiteSpace(nroDocFilter))
|
||||
{
|
||||
sqlBuilder.Append(" AND d.NroDoc LIKE @NroDoc");
|
||||
parameters.Add("NroDoc", $"%{nroDocFilter}%");
|
||||
}
|
||||
sqlBuilder.Append(" ORDER BY d.Nombre;");
|
||||
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QueryAsync<Distribuidor, string, (Distribuidor, string?)>(
|
||||
sqlBuilder.ToString(),
|
||||
(dist, zona) => (dist, zona),
|
||||
parameters,
|
||||
splitOn: "NombreZona"
|
||||
);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener todos los Distribuidores.");
|
||||
return Enumerable.Empty<(Distribuidor, string?)>();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<(Distribuidor? Distribuidor, string? NombreZona)> GetByIdAsync(int id)
|
||||
{
|
||||
const string sql = @"
|
||||
SELECT d.*, z.Nombre AS NombreZona
|
||||
FROM dbo.dist_dtDistribuidores d
|
||||
LEFT JOIN dbo.dist_dtZonas z ON d.Id_Zona = z.Id_Zona
|
||||
WHERE d.Id_Distribuidor = @Id";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
var result = await connection.QueryAsync<Distribuidor, string, (Distribuidor, string?)>(
|
||||
sql,
|
||||
(dist, zona) => (dist, zona),
|
||||
new { Id = id },
|
||||
splitOn: "NombreZona"
|
||||
);
|
||||
return result.SingleOrDefault();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener Distribuidor por ID: {IdDistribuidor}", id);
|
||||
return (null, null);
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<Distribuidor?> GetByIdSimpleAsync(int id)
|
||||
{
|
||||
const string sql = "SELECT * FROM dbo.dist_dtDistribuidores WHERE Id_Distribuidor = @Id";
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QuerySingleOrDefaultAsync<Distribuidor>(sql, new { Id = id });
|
||||
}
|
||||
|
||||
public async Task<bool> ExistsByNroDocAsync(string nroDoc, int? excludeIdDistribuidor = null)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.dist_dtDistribuidores WHERE NroDoc = @NroDoc");
|
||||
var parameters = new DynamicParameters();
|
||||
parameters.Add("NroDoc", nroDoc);
|
||||
if (excludeIdDistribuidor.HasValue)
|
||||
{
|
||||
sqlBuilder.Append(" AND Id_Distribuidor != @ExcludeId");
|
||||
parameters.Add("ExcludeId", excludeIdDistribuidor.Value);
|
||||
}
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.ExecuteScalarAsync<bool>(sqlBuilder.ToString(), parameters);
|
||||
}
|
||||
public async Task<bool> ExistsByNameAsync(string nombre, int? excludeIdDistribuidor = null)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.dist_dtDistribuidores WHERE Nombre = @Nombre");
|
||||
var parameters = new DynamicParameters();
|
||||
parameters.Add("Nombre", nombre);
|
||||
if (excludeIdDistribuidor.HasValue)
|
||||
{
|
||||
sqlBuilder.Append(" AND Id_Distribuidor != @ExcludeId");
|
||||
parameters.Add("ExcludeId", excludeIdDistribuidor.Value);
|
||||
}
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.ExecuteScalarAsync<bool>(sqlBuilder.ToString(), parameters);
|
||||
}
|
||||
|
||||
public async Task<bool> IsInUseAsync(int id)
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
string[] checkQueries = {
|
||||
"SELECT TOP 1 1 FROM dbo.dist_EntradasSalidas WHERE Id_Distribuidor = @Id",
|
||||
"SELECT TOP 1 1 FROM dbo.cue_PagosDistribuidor WHERE Id_Distribuidor = @Id",
|
||||
"SELECT TOP 1 1 FROM dbo.dist_PorcPago WHERE Id_Distribuidor = @Id"
|
||||
};
|
||||
foreach (var query in checkQueries)
|
||||
{
|
||||
if (await connection.ExecuteScalarAsync<int?>(query, new { Id = id }) == 1) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
public async Task<Distribuidor?> CreateAsync(Distribuidor nuevoDistribuidor, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
const string sqlInsert = @"
|
||||
INSERT INTO dbo.dist_dtDistribuidores (Nombre, Contacto, NroDoc, Id_Zona, Calle, Numero, Piso, Depto, Telefono, Email, Localidad)
|
||||
OUTPUT INSERTED.*
|
||||
VALUES (@Nombre, @Contacto, @NroDoc, @IdZona, @Calle, @Numero, @Piso, @Depto, @Telefono, @Email, @Localidad);";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_dtDistribuidores_H
|
||||
(Id_Distribuidor, Nombre, Contacto, NroDoc, Id_Zona, Calle, Numero, Piso, Depto, Telefono, Email, Localidad, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdDistribuidor, @Nombre, @Contacto, @NroDoc, @IdZona, @Calle, @Numero, @Piso, @Depto, @Telefono, @Email, @Localidad, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
var connection = transaction.Connection!;
|
||||
var inserted = await connection.QuerySingleAsync<Distribuidor>(sqlInsert, nuevoDistribuidor, transaction);
|
||||
if (inserted == null) throw new DataException("Error al crear distribuidor.");
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
inserted.IdDistribuidor, inserted.Nombre, inserted.Contacto, inserted.NroDoc, inserted.IdZona,
|
||||
inserted.Calle, inserted.Numero, inserted.Piso, inserted.Depto, inserted.Telefono, inserted.Email, inserted.Localidad,
|
||||
Id_Usuario = idUsuario, FechaMod = DateTime.Now, TipoMod = "Creado"
|
||||
}, transaction);
|
||||
return inserted;
|
||||
}
|
||||
|
||||
public async Task<bool> UpdateAsync(Distribuidor distribuidorAActualizar, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
var actual = await connection.QuerySingleOrDefaultAsync<Distribuidor>(
|
||||
"SELECT * FROM dbo.dist_dtDistribuidores WHERE Id_Distribuidor = @IdDistribuidor",
|
||||
new { distribuidorAActualizar.IdDistribuidor }, transaction);
|
||||
if (actual == null) throw new KeyNotFoundException("Distribuidor no encontrado.");
|
||||
|
||||
const string sqlUpdate = @"
|
||||
UPDATE dbo.dist_dtDistribuidores SET
|
||||
Nombre = @Nombre, Contacto = @Contacto, NroDoc = @NroDoc, Id_Zona = @IdZona, Calle = @Calle, Numero = @Numero,
|
||||
Piso = @Piso, Depto = @Depto, Telefono = @Telefono, Email = @Email, Localidad = @Localidad
|
||||
WHERE Id_Distribuidor = @IdDistribuidor;";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_dtDistribuidores_H
|
||||
(Id_Distribuidor, Nombre, Contacto, NroDoc, Id_Zona, Calle, Numero, Piso, Depto, Telefono, Email, Localidad, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdDistribuidor, @Nombre, @Contacto, @NroDoc, @IdZona, @Calle, @Numero, @Piso, @Depto, @Telefono, @Email, @Localidad, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdDistribuidor = actual.IdDistribuidor, Nombre = actual.Nombre, Contacto = actual.Contacto, NroDoc = actual.NroDoc, IdZona = actual.IdZona,
|
||||
Calle = actual.Calle, Numero = actual.Numero, Piso = actual.Piso, Depto = actual.Depto, Telefono = actual.Telefono, Email = actual.Email, Localidad = actual.Localidad,
|
||||
Id_Usuario = idUsuario, FechaMod = DateTime.Now, TipoMod = "Actualizado"
|
||||
}, transaction);
|
||||
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, distribuidorAActualizar, transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
|
||||
public async Task<bool> DeleteAsync(int id, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
var actual = await connection.QuerySingleOrDefaultAsync<Distribuidor>(
|
||||
"SELECT * FROM dbo.dist_dtDistribuidores WHERE Id_Distribuidor = @Id", new { Id = id }, transaction);
|
||||
if (actual == null) throw new KeyNotFoundException("Distribuidor no encontrado.");
|
||||
|
||||
const string sqlDelete = "DELETE FROM dbo.dist_dtDistribuidores WHERE Id_Distribuidor = @Id";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_dtDistribuidores_H
|
||||
(Id_Distribuidor, Nombre, Contacto, NroDoc, Id_Zona, Calle, Numero, Piso, Depto, Telefono, Email, Localidad, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdDistribuidor, @Nombre, @Contacto, @NroDoc, @IdZona, @Calle, @Numero, @Piso, @Depto, @Telefono, @Email, @Localidad, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdDistribuidor = actual.IdDistribuidor, actual.Nombre, actual.Contacto, actual.NroDoc, actual.IdZona,
|
||||
actual.Calle, actual.Numero, actual.Piso, actual.Depto, actual.Telefono, actual.Email, actual.Localidad,
|
||||
Id_Usuario = idUsuario, FechaMod = DateTime.Now, TipoMod = "Eliminado"
|
||||
}, transaction);
|
||||
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlDelete, new { Id = id }, transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
using GestionIntegral.Api.Models.Distribucion;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using System.Data;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public interface ICanillaRepository
|
||||
{
|
||||
Task<IEnumerable<(Canilla Canilla, string NombreZona, string NombreEmpresa)>> GetAllAsync(string? nomApeFilter, int? legajoFilter, bool? soloActivos);
|
||||
Task<(Canilla? Canilla, string? NombreZona, string? NombreEmpresa)> GetByIdAsync(int id);
|
||||
Task<Canilla?> GetByIdSimpleAsync(int id); // Para obtener solo la entidad Canilla
|
||||
Task<Canilla?> CreateAsync(Canilla nuevoCanilla, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> UpdateAsync(Canilla canillaAActualizar, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> ToggleBajaAsync(int id, bool darDeBaja, DateTime? fechaBaja, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> ExistsByLegajoAsync(int legajo, int? excludeIdCanilla = null);
|
||||
// IsInUse no es tan directo, ya que las liquidaciones se marcan. Se podría verificar dist_EntradasSalidasCanillas no liquidadas.
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
using GestionIntegral.Api.Models.Distribucion;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using System.Data;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public interface IDistribuidorRepository
|
||||
{
|
||||
Task<IEnumerable<(Distribuidor Distribuidor, string? NombreZona)>> GetAllAsync(string? nombreFilter, string? nroDocFilter);
|
||||
Task<(Distribuidor? Distribuidor, string? NombreZona)> GetByIdAsync(int id);
|
||||
Task<Distribuidor?> GetByIdSimpleAsync(int id); // Para uso interno en el servicio
|
||||
Task<Distribuidor?> CreateAsync(Distribuidor nuevoDistribuidor, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> UpdateAsync(Distribuidor distribuidorAActualizar, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> DeleteAsync(int id, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> ExistsByNroDocAsync(string nroDoc, int? excludeIdDistribuidor = null);
|
||||
Task<bool> ExistsByNameAsync(string nombre, int? excludeIdDistribuidor = null);
|
||||
Task<bool> IsInUseAsync(int id); // Verificar en dist_EntradasSalidas, cue_PagosDistribuidor, dist_PorcPago
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,18 @@
|
||||
using GestionIntegral.Api.Models.Distribucion;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using System.Data;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public interface IOtroDestinoRepository
|
||||
{
|
||||
Task<IEnumerable<OtroDestino>> GetAllAsync(string? nombreFilter);
|
||||
Task<OtroDestino?> GetByIdAsync(int id);
|
||||
Task<OtroDestino?> CreateAsync(OtroDestino nuevoDestino, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> UpdateAsync(OtroDestino destinoAActualizar, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> DeleteAsync(int id, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> ExistsByNameAsync(string nombre, int? excludeId = null);
|
||||
Task<bool> IsInUseAsync(int id); // Verificar si se usa en dist_SalidasOtrosDestinos
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
using System.Data;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public interface IPorcMonCanillaRepository
|
||||
{
|
||||
Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
using System.Data;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public interface IPorcPagoRepository {
|
||||
Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
using GestionIntegral.Api.Models.Distribucion;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using System.Data;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public interface IPrecioRepository
|
||||
{
|
||||
Task<IEnumerable<Precio>> GetByPublicacionIdAsync(int idPublicacion);
|
||||
Task<Precio?> GetByIdAsync(int idPrecio);
|
||||
Task<Precio?> GetActiveByPublicacionAndDateAsync(int idPublicacion, DateTime fecha, IDbTransaction? transaction = null);
|
||||
Task<Precio?> CreateAsync(Precio nuevoPrecio, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> UpdateAsync(Precio precioAActualizar, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> DeleteAsync(int idPrecio, int idUsuario, IDbTransaction transaction);
|
||||
// MODIFICADO: Añadir idUsuarioAuditoria
|
||||
Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction);
|
||||
Task<Precio?> GetPreviousActivePriceAsync(int idPublicacion, DateTime vigenciaDNuevo, IDbTransaction transaction);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
using System.Data;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public interface IPubliSeccionRepository
|
||||
{
|
||||
Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
using GestionIntegral.Api.Models.Distribucion;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using System.Data;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public interface IPublicacionRepository
|
||||
{
|
||||
Task<IEnumerable<(Publicacion Publicacion, string NombreEmpresa)>> GetAllAsync(string? nombreFilter, int? idEmpresaFilter, bool? soloHabilitadas);
|
||||
Task<(Publicacion? Publicacion, string? NombreEmpresa)> GetByIdAsync(int id);
|
||||
Task<Publicacion?> GetByIdSimpleAsync(int id); // Para uso interno del servicio
|
||||
Task<Publicacion?> CreateAsync(Publicacion nuevaPublicacion, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> UpdateAsync(Publicacion publicacionAActualizar, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> DeleteAsync(int id, int idUsuario, IDbTransaction transaction); // Borrado físico con historial
|
||||
Task<bool> ExistsByNameAndEmpresaAsync(string nombre, int idEmpresa, int? excludeIdPublicacion = null);
|
||||
Task<bool> IsInUseAsync(int id);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,10 @@
|
||||
using System.Data;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public interface IRecargoZonaRepository
|
||||
{
|
||||
Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,189 @@
|
||||
using Dapper;
|
||||
using GestionIntegral.Api.Models.Distribucion;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using System.Collections.Generic;
|
||||
using System.Data;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public class OtroDestinoRepository : IOtroDestinoRepository
|
||||
{
|
||||
private readonly DbConnectionFactory _connectionFactory;
|
||||
private readonly ILogger<OtroDestinoRepository> _logger;
|
||||
|
||||
public OtroDestinoRepository(DbConnectionFactory connectionFactory, ILogger<OtroDestinoRepository> logger)
|
||||
{
|
||||
_connectionFactory = connectionFactory;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<OtroDestino>> GetAllAsync(string? nombreFilter)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder("SELECT Id_Destino AS IdDestino, Nombre, Obs FROM dbo.dist_dtOtrosDestinos WHERE 1=1");
|
||||
var parameters = new DynamicParameters();
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(nombreFilter))
|
||||
{
|
||||
sqlBuilder.Append(" AND Nombre LIKE @NombreFilter");
|
||||
parameters.Add("NombreFilter", $"%{nombreFilter}%");
|
||||
}
|
||||
sqlBuilder.Append(" ORDER BY Nombre;");
|
||||
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QueryAsync<OtroDestino>(sqlBuilder.ToString(), parameters);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener todos los Otros Destinos. Filtro: {Nombre}", nombreFilter);
|
||||
return Enumerable.Empty<OtroDestino>();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<OtroDestino?> GetByIdAsync(int id)
|
||||
{
|
||||
const string sql = "SELECT Id_Destino AS IdDestino, Nombre, Obs FROM dbo.dist_dtOtrosDestinos WHERE Id_Destino = @Id";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QuerySingleOrDefaultAsync<OtroDestino>(sql, new { Id = id });
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener Otro Destino por ID: {IdDestino}", id);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> ExistsByNameAsync(string nombre, int? excludeId = null)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.dist_dtOtrosDestinos WHERE Nombre = @Nombre");
|
||||
var parameters = new DynamicParameters();
|
||||
parameters.Add("Nombre", nombre);
|
||||
|
||||
if (excludeId.HasValue)
|
||||
{
|
||||
sqlBuilder.Append(" AND Id_Destino != @ExcludeId");
|
||||
parameters.Add("ExcludeId", excludeId.Value);
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
var count = await connection.ExecuteScalarAsync<int>(sqlBuilder.ToString(), parameters);
|
||||
return count > 0;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error en ExistsByNameAsync para Otro Destino con nombre: {Nombre}", nombre);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> IsInUseAsync(int id)
|
||||
{
|
||||
const string sqlCheckSalidas = "SELECT TOP 1 1 FROM dbo.dist_SalidasOtrosDestinos WHERE Id_Destino = @IdDestino";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
var inUse = await connection.ExecuteScalarAsync<int?>(sqlCheckSalidas, new { IdDestino = id });
|
||||
return inUse.HasValue && inUse.Value == 1;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error en IsInUseAsync para Otro Destino ID: {IdDestino}", id);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<OtroDestino?> CreateAsync(OtroDestino nuevoDestino, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
const string sqlInsert = @"
|
||||
INSERT INTO dbo.dist_dtOtrosDestinos (Nombre, Obs)
|
||||
OUTPUT INSERTED.Id_Destino AS IdDestino, INSERTED.Nombre, INSERTED.Obs
|
||||
VALUES (@Nombre, @Obs);";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_dtOtrosDestinos_H (Id_Destino, Nombre, Obs, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdDestino, @Nombre, @Obs, @IdUsuario, @FechaMod, @TipoMod);";
|
||||
|
||||
var connection = transaction.Connection!;
|
||||
var insertedDestino = await connection.QuerySingleAsync<OtroDestino>(sqlInsert, nuevoDestino, transaction);
|
||||
|
||||
if (insertedDestino == null || insertedDestino.IdDestino <= 0)
|
||||
{
|
||||
throw new DataException("No se pudo obtener el ID del otro destino insertado.");
|
||||
}
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdDestino = insertedDestino.IdDestino,
|
||||
insertedDestino.Nombre,
|
||||
insertedDestino.Obs,
|
||||
IdUsuario = idUsuario,
|
||||
FechaMod = DateTime.Now,
|
||||
TipoMod = "Insertada"
|
||||
}, transaction);
|
||||
return insertedDestino;
|
||||
}
|
||||
|
||||
public async Task<bool> UpdateAsync(OtroDestino destinoAActualizar, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
var destinoActual = await connection.QuerySingleOrDefaultAsync<OtroDestino>(
|
||||
"SELECT Id_Destino AS IdDestino, Nombre, Obs FROM dbo.dist_dtOtrosDestinos WHERE Id_Destino = @Id",
|
||||
new { Id = destinoAActualizar.IdDestino }, transaction);
|
||||
|
||||
if (destinoActual == null) throw new KeyNotFoundException($"Otro Destino con ID {destinoAActualizar.IdDestino} no encontrado.");
|
||||
|
||||
const string sqlUpdate = "UPDATE dbo.dist_dtOtrosDestinos SET Nombre = @Nombre, Obs = @Obs WHERE Id_Destino = @IdDestino;";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_dtOtrosDestinos_H (Id_Destino, Nombre, Obs, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdDestino, @NombreActual, @ObsActual, @IdUsuario, @FechaMod, @TipoMod);";
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdDestino = destinoActual.IdDestino,
|
||||
NombreActual = destinoActual.Nombre,
|
||||
ObsActual = destinoActual.Obs,
|
||||
IdUsuario = idUsuario,
|
||||
FechaMod = DateTime.Now,
|
||||
TipoMod = "Modificada"
|
||||
}, transaction);
|
||||
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, destinoAActualizar, transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
|
||||
public async Task<bool> DeleteAsync(int id, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
var destinoActual = await connection.QuerySingleOrDefaultAsync<OtroDestino>(
|
||||
"SELECT Id_Destino AS IdDestino, Nombre, Obs FROM dbo.dist_dtOtrosDestinos WHERE Id_Destino = @Id",
|
||||
new { Id = id }, transaction);
|
||||
|
||||
if (destinoActual == null) throw new KeyNotFoundException($"Otro Destino con ID {id} no encontrado.");
|
||||
|
||||
const string sqlDelete = "DELETE FROM dbo.dist_dtOtrosDestinos WHERE Id_Destino = @Id";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_dtOtrosDestinos_H (Id_Destino, Nombre, Obs, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdDestino, @Nombre, @Obs, @IdUsuario, @FechaMod, @TipoMod);";
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdDestino = destinoActual.IdDestino,
|
||||
destinoActual.Nombre,
|
||||
destinoActual.Obs,
|
||||
IdUsuario = idUsuario,
|
||||
FechaMod = DateTime.Now,
|
||||
TipoMod = "Eliminada"
|
||||
}, transaction);
|
||||
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlDelete, new { Id = id }, transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,58 @@
|
||||
using Dapper;
|
||||
using System.Data;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using GestionIntegral.Api.Models.Distribucion;
|
||||
using System;
|
||||
using System.Linq;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public class PorcMonCanillaRepository : IPorcMonCanillaRepository
|
||||
{
|
||||
private readonly DbConnectionFactory _cf; private readonly ILogger<PorcMonCanillaRepository> _log;
|
||||
public PorcMonCanillaRepository(DbConnectionFactory cf, ILogger<PorcMonCanillaRepository> log) { _cf = cf; _log = log; }
|
||||
|
||||
public async Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction)
|
||||
{
|
||||
const string selectSql = "SELECT * FROM dbo.dist_PorcMonPagoCanilla WHERE Id_Publicacion = @IdPublicacion";
|
||||
var itemsToDelete = await transaction.Connection!.QueryAsync<PorcMonCanilla>(selectSql, new { IdPublicacion = idPublicacion }, transaction);
|
||||
|
||||
if (itemsToDelete.Any())
|
||||
{
|
||||
const string insertHistoricoSql = @"
|
||||
INSERT INTO dbo.dist_PorcMonPagoCanilla_H (Id_PorcMon, Id_Publicacion, Id_Canilla, VigenciaD, VigenciaH, PorcMon, EsPorcentaje, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@Id_PorcMon, @Id_Publicacion, @Id_Canilla, @VigenciaD, @VigenciaH, @PorcMon, @EsPorcentaje, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
foreach (var item in itemsToDelete)
|
||||
{
|
||||
await transaction.Connection!.ExecuteAsync(insertHistoricoSql, new
|
||||
{
|
||||
Id_PorcMon = item.IdPorcMon, // Mapeo de propiedad a parámetro SQL
|
||||
Id_Publicacion = item.IdPublicacion,
|
||||
Id_Canilla = item.IdCanilla,
|
||||
item.VigenciaD,
|
||||
item.VigenciaH,
|
||||
item.PorcMon,
|
||||
item.EsPorcentaje,
|
||||
Id_Usuario = idUsuarioAuditoria,
|
||||
FechaMod = DateTime.Now,
|
||||
TipoMod = "Eliminado (Cascada)"
|
||||
}, transaction);
|
||||
}
|
||||
}
|
||||
|
||||
const string deleteSql = "DELETE FROM dbo.dist_PorcMonPagoCanilla WHERE Id_Publicacion = @IdPublicacion";
|
||||
try
|
||||
{
|
||||
await transaction.Connection!.ExecuteAsync(deleteSql, new { IdPublicacion = idPublicacion }, transaction);
|
||||
return true;
|
||||
}
|
||||
catch (System.Exception e)
|
||||
{
|
||||
_log.LogError(e, "Error al eliminar PorcMonCanilla por IdPublicacion: {idPublicacion}", idPublicacion);
|
||||
throw;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,56 @@
|
||||
using Dapper; using System.Data;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using GestionIntegral.Api.Models.Distribucion;
|
||||
using System;
|
||||
using System.Linq;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public class PorcPagoRepository : IPorcPagoRepository
|
||||
{
|
||||
private readonly DbConnectionFactory _cf; private readonly ILogger<PorcPagoRepository> _log;
|
||||
public PorcPagoRepository(DbConnectionFactory cf, ILogger<PorcPagoRepository> log) { _cf = cf; _log = log; }
|
||||
|
||||
public async Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction)
|
||||
{
|
||||
const string selectSql = "SELECT * FROM dbo.dist_PorcPago WHERE Id_Publicacion = @IdPublicacion";
|
||||
var itemsToDelete = await transaction.Connection!.QueryAsync<PorcPago>(selectSql, new { IdPublicacion = idPublicacion }, transaction);
|
||||
|
||||
if (itemsToDelete.Any())
|
||||
{
|
||||
const string insertHistoricoSql = @"
|
||||
INSERT INTO dbo.dist_PorcPago_H (Id_Porcentaje, Id_Publicacion, Id_Distribuidor, VigenciaD, VigenciaH, Porcentaje, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPorcentaje, @IdPublicacion, @IdDistribuidor, @VigenciaD, @VigenciaH, @Porcentaje, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
foreach (var item in itemsToDelete)
|
||||
{
|
||||
await transaction.Connection!.ExecuteAsync(insertHistoricoSql, new
|
||||
{
|
||||
item.IdPorcentaje, // Mapea a @Id_Porcentaje si usas nombres con _ en SQL
|
||||
item.IdPublicacion,
|
||||
item.IdDistribuidor,
|
||||
item.VigenciaD,
|
||||
item.VigenciaH,
|
||||
item.Porcentaje,
|
||||
Id_Usuario = idUsuarioAuditoria,
|
||||
FechaMod = DateTime.Now,
|
||||
TipoMod = "Eliminado (Cascada)"
|
||||
}, transaction);
|
||||
}
|
||||
}
|
||||
|
||||
const string deleteSql = "DELETE FROM dbo.dist_PorcPago WHERE Id_Publicacion = @IdPublicacion";
|
||||
try
|
||||
{
|
||||
await transaction.Connection!.ExecuteAsync(deleteSql, new { IdPublicacion = idPublicacion }, transaction);
|
||||
return true;
|
||||
}
|
||||
catch (System.Exception e)
|
||||
{
|
||||
_log.LogError(e, "Error al eliminar PorcPago por IdPublicacion: {idPublicacion}", idPublicacion);
|
||||
throw;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,177 @@
|
||||
using Dapper;
|
||||
using GestionIntegral.Api.Models.Distribucion;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using System.Collections.Generic;
|
||||
using System.Data;
|
||||
using System.Linq;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public class PrecioRepository : IPrecioRepository
|
||||
{
|
||||
private readonly DbConnectionFactory _connectionFactory;
|
||||
private readonly ILogger<PrecioRepository> _logger;
|
||||
|
||||
public PrecioRepository(DbConnectionFactory connectionFactory, ILogger<PrecioRepository> logger)
|
||||
{
|
||||
_connectionFactory = connectionFactory;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<Precio>> GetByPublicacionIdAsync(int idPublicacion)
|
||||
{
|
||||
const string sql = "SELECT * FROM dbo.dist_Precios WHERE Id_Publicacion = @IdPublicacion ORDER BY VigenciaD DESC";
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QueryAsync<Precio>(sql, new { IdPublicacion = idPublicacion });
|
||||
}
|
||||
|
||||
public async Task<Precio?> GetByIdAsync(int idPrecio)
|
||||
{
|
||||
const string sql = "SELECT * FROM dbo.dist_Precios WHERE Id_Precio = @IdPrecio";
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QuerySingleOrDefaultAsync<Precio>(sql, new { IdPrecio = idPrecio });
|
||||
}
|
||||
|
||||
public async Task<Precio?> GetActiveByPublicacionAndDateAsync(int idPublicacion, DateTime fecha, IDbTransaction? transaction = null)
|
||||
{
|
||||
// Obtiene el precio vigente para una publicación en una fecha específica
|
||||
const string sql = @"
|
||||
SELECT TOP 1 * FROM dbo.dist_Precios
|
||||
WHERE Id_Publicacion = @IdPublicacion
|
||||
AND VigenciaD <= @Fecha
|
||||
AND (VigenciaH IS NULL OR VigenciaH >= @Fecha)
|
||||
ORDER BY VigenciaD DESC;"; // Por si hay solapamientos incorrectos, tomar el más reciente
|
||||
|
||||
var cn = transaction?.Connection ?? _connectionFactory.CreateConnection();
|
||||
return await cn.QuerySingleOrDefaultAsync<Precio>(sql, new { IdPublicacion = idPublicacion, Fecha = fecha }, transaction);
|
||||
}
|
||||
|
||||
public async Task<Precio?> GetPreviousActivePriceAsync(int idPublicacion, DateTime vigenciaDNuevo, IDbTransaction transaction)
|
||||
{
|
||||
// Busca el último precio activo antes de la vigenciaD del nuevo precio, que no tenga VigenciaH o cuya VigenciaH sea mayor o igual a la nueva VigenciaD - 1 día
|
||||
// y que no sea el mismo periodo que se está por crear/actualizar (si tuviera un ID).
|
||||
const string sql = @"
|
||||
SELECT TOP 1 *
|
||||
FROM dbo.dist_Precios
|
||||
WHERE Id_Publicacion = @IdPublicacion
|
||||
AND VigenciaD < @VigenciaDNuevo
|
||||
AND VigenciaH IS NULL
|
||||
ORDER BY VigenciaD DESC;";
|
||||
return await transaction.Connection!.QuerySingleOrDefaultAsync<Precio>(sql, new { IdPublicacion = idPublicacion, VigenciaDNuevo = vigenciaDNuevo }, transaction);
|
||||
}
|
||||
|
||||
|
||||
public async Task<Precio?> CreateAsync(Precio nuevoPrecio, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
const string sqlInsert = @"
|
||||
INSERT INTO dbo.dist_Precios (Id_Publicacion, VigenciaD, VigenciaH, Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo)
|
||||
OUTPUT INSERTED.*
|
||||
VALUES (@IdPublicacion, @VigenciaD, @VigenciaH, @Lunes, @Martes, @Miercoles, @Jueves, @Viernes, @Sabado, @Domingo);";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_Precios_H
|
||||
(Id_Precio, Id_Publicacion, VigenciaD, VigenciaH, Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPrecio, @IdPublicacion, @VigenciaD, @VigenciaH, @Lunes, @Martes, @Miercoles, @Jueves, @Viernes, @Sabado, @Domingo, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
var inserted = await transaction.Connection!.QuerySingleAsync<Precio>(sqlInsert, nuevoPrecio, transaction);
|
||||
if (inserted == null) throw new DataException("Error al crear precio.");
|
||||
|
||||
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
inserted.IdPrecio, inserted.IdPublicacion, inserted.VigenciaD, inserted.VigenciaH,
|
||||
inserted.Lunes, inserted.Martes, inserted.Miercoles, inserted.Jueves, inserted.Viernes, inserted.Sabado, inserted.Domingo,
|
||||
Id_Usuario = idUsuario, FechaMod = DateTime.Now, TipoMod = "Creado"
|
||||
}, transaction);
|
||||
return inserted;
|
||||
}
|
||||
|
||||
public async Task<bool> UpdateAsync(Precio precioAActualizar, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<Precio>(
|
||||
"SELECT * FROM dbo.dist_Precios WHERE Id_Precio = @IdPrecio",
|
||||
new { precioAActualizar.IdPrecio }, transaction);
|
||||
if (actual == null) throw new KeyNotFoundException("Precio no encontrado.");
|
||||
|
||||
const string sqlUpdate = @"
|
||||
UPDATE dbo.dist_Precios SET
|
||||
VigenciaH = @VigenciaH, Lunes = @Lunes, Martes = @Martes, Miercoles = @Miercoles,
|
||||
Jueves = @Jueves, Viernes = @Viernes, Sabado = @Sabado, Domingo = @Domingo
|
||||
-- No se permite cambiar IdPublicacion ni VigenciaD de un registro de precio existente
|
||||
WHERE Id_Precio = @IdPrecio;";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_Precios_H
|
||||
(Id_Precio, Id_Publicacion, VigenciaD, VigenciaH, Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPrecio, @IdPublicacion, @VigenciaD, @VigenciaH, @Lunes, @Martes, @Miercoles, @Jueves, @Viernes, @Sabado, @Domingo, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
actual.IdPrecio, actual.IdPublicacion, actual.VigenciaD, // VigenciaD actual para el historial
|
||||
VigenciaH = actual.VigenciaH, // VigenciaH actual para el historial
|
||||
Lunes = actual.Lunes, Martes = actual.Martes, Miercoles = actual.Miercoles, Jueves = actual.Jueves,
|
||||
Viernes = actual.Viernes, Sabado = actual.Sabado, Domingo = actual.Domingo, // Precios actuales para el historial
|
||||
Id_Usuario = idUsuario, FechaMod = DateTime.Now, TipoMod = "Actualizado" // O "Cerrado" si solo se actualiza VigenciaH
|
||||
}, transaction);
|
||||
|
||||
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlUpdate, precioAActualizar, transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
|
||||
public async Task<bool> DeleteAsync(int idPrecio, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var actual = await transaction.Connection!.QuerySingleOrDefaultAsync<Precio>(
|
||||
"SELECT * FROM dbo.dist_Precios WHERE Id_Precio = @IdPrecio", new { IdPrecio = idPrecio }, transaction);
|
||||
if (actual == null) throw new KeyNotFoundException("Precio no encontrado para eliminar.");
|
||||
|
||||
const string sqlDelete = "DELETE FROM dbo.dist_Precios WHERE Id_Precio = @IdPrecio";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_Precios_H
|
||||
(Id_Precio, Id_Publicacion, VigenciaD, VigenciaH, Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPrecio, @IdPublicacion, @VigenciaD, @VigenciaH, @Lunes, @Martes, @Miercoles, @Jueves, @Viernes, @Sabado, @Domingo, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
actual.IdPrecio, actual.IdPublicacion, actual.VigenciaD, actual.VigenciaH,
|
||||
actual.Lunes, actual.Martes, actual.Miercoles, actual.Jueves, actual.Viernes, actual.Sabado, actual.Domingo,
|
||||
Id_Usuario = idUsuario, FechaMod = DateTime.Now, TipoMod = "Eliminado"
|
||||
}, transaction);
|
||||
|
||||
var rowsAffected = await transaction.Connection!.ExecuteAsync(sqlDelete, new { IdPrecio = idPrecio }, transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
|
||||
public async Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction) // MODIFICADO: Recibe idUsuarioAuditoria
|
||||
{
|
||||
const string selectPrecios = "SELECT * FROM dbo.dist_Precios WHERE Id_Publicacion = @IdPublicacion";
|
||||
var preciosAEliminar = await transaction.Connection!.QueryAsync<Precio>(selectPrecios, new { IdPublicacion = idPublicacion }, transaction);
|
||||
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_Precios_H
|
||||
(Id_Precio, Id_Publicacion, VigenciaD, VigenciaH, Lunes, Martes, Miercoles, Jueves, Viernes, Sabado, Domingo, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPrecio, @IdPublicacion, @VigenciaD, @VigenciaH, @Lunes, @Martes, @Miercoles, @Jueves, @Viernes, @Sabado, @Domingo, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
foreach (var precio in preciosAEliminar)
|
||||
{
|
||||
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
precio.IdPrecio, precio.IdPublicacion, precio.VigenciaD, precio.VigenciaH,
|
||||
precio.Lunes, precio.Martes, precio.Miercoles, precio.Jueves, precio.Viernes, precio.Sabado, precio.Domingo,
|
||||
Id_Usuario = idUsuarioAuditoria, // MODIFICADO: Usar el idUsuarioAuditoria pasado
|
||||
FechaMod = DateTime.Now, TipoMod = "Eliminado (Cascada)"
|
||||
}, transaction);
|
||||
}
|
||||
|
||||
const string sql = "DELETE FROM dbo.dist_Precios WHERE Id_Publicacion = @IdPublicacion";
|
||||
try
|
||||
{
|
||||
var rowsAffected = await transaction.Connection!.ExecuteAsync(sql, new { IdPublicacion = idPublicacion }, transaction: transaction);
|
||||
// No necesitamos devolver rowsAffected >= 0 si la lógica del servicio ya valida si debe haber registros
|
||||
return true; // Indica que la operación de borrado (incluyendo 0 filas) se intentó
|
||||
}
|
||||
catch (System.Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al eliminar precios por IdPublicacion: {IdPublicacion}", idPublicacion);
|
||||
throw;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,55 @@
|
||||
using Dapper;
|
||||
using System.Data;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using GestionIntegral.Api.Models.Distribucion;
|
||||
using System;
|
||||
using System.Linq;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public class PubliSeccionRepository : IPubliSeccionRepository
|
||||
{
|
||||
private readonly DbConnectionFactory _cf; private readonly ILogger<PubliSeccionRepository> _log;
|
||||
public PubliSeccionRepository(DbConnectionFactory cf, ILogger<PubliSeccionRepository> log) { _cf = cf; _log = log; }
|
||||
|
||||
public async Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction)
|
||||
{
|
||||
const string selectSql = "SELECT * FROM dbo.dist_dtPubliSecciones WHERE Id_Publicacion = @IdPublicacion";
|
||||
var itemsToDelete = await transaction.Connection!.QueryAsync<PubliSeccion>(selectSql, new { IdPublicacion = idPublicacion }, transaction);
|
||||
|
||||
if (itemsToDelete.Any())
|
||||
{
|
||||
const string insertHistoricoSql = @"
|
||||
INSERT INTO dbo.dist_dtPubliSecciones_H (Id_Seccion, Id_Publicacion, Nombre, Estado, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@Id_Seccion, @Id_Publicacion, @Nombre, @Estado, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
foreach (var item in itemsToDelete)
|
||||
{
|
||||
await transaction.Connection!.ExecuteAsync(insertHistoricoSql, new
|
||||
{
|
||||
Id_Seccion = item.IdSeccion, // Mapeo de propiedad a parámetro SQL
|
||||
Id_Publicacion = item.IdPublicacion,
|
||||
item.Nombre,
|
||||
item.Estado,
|
||||
Id_Usuario = idUsuarioAuditoria,
|
||||
FechaMod = DateTime.Now,
|
||||
TipoMod = "Eliminado (Cascada)"
|
||||
}, transaction);
|
||||
}
|
||||
}
|
||||
|
||||
const string deleteSql = "DELETE FROM dbo.dist_dtPubliSecciones WHERE Id_Publicacion = @IdPublicacion";
|
||||
try
|
||||
{
|
||||
await transaction.Connection!.ExecuteAsync(deleteSql, new { IdPublicacion = idPublicacion }, transaction);
|
||||
return true;
|
||||
}
|
||||
catch (System.Exception e)
|
||||
{
|
||||
_log.LogError(e, "Error al eliminar PubliSecciones por IdPublicacion: {idPublicacion}", idPublicacion);
|
||||
throw;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,219 @@
|
||||
using Dapper;
|
||||
using GestionIntegral.Api.Models.Distribucion;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using System.Collections.Generic;
|
||||
using System.Data;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public class PublicacionRepository : IPublicacionRepository
|
||||
{
|
||||
private readonly DbConnectionFactory _connectionFactory;
|
||||
private readonly ILogger<PublicacionRepository> _logger;
|
||||
|
||||
public PublicacionRepository(DbConnectionFactory connectionFactory, ILogger<PublicacionRepository> logger)
|
||||
{
|
||||
_connectionFactory = connectionFactory;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<(Publicacion Publicacion, string NombreEmpresa)>> GetAllAsync(string? nombreFilter, int? idEmpresaFilter, bool? soloHabilitadas)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder(@"
|
||||
SELECT p.*, e.Nombre AS NombreEmpresa
|
||||
FROM dbo.dist_dtPublicaciones p
|
||||
INNER JOIN dbo.dist_dtEmpresas e ON p.Id_Empresa = e.Id_Empresa
|
||||
WHERE 1=1");
|
||||
var parameters = new DynamicParameters();
|
||||
|
||||
if (soloHabilitadas.HasValue)
|
||||
{
|
||||
sqlBuilder.Append(soloHabilitadas.Value ? " AND p.Habilitada = 1" : " AND (p.Habilitada = 0 OR p.Habilitada IS NULL)");
|
||||
}
|
||||
if (!string.IsNullOrWhiteSpace(nombreFilter))
|
||||
{
|
||||
sqlBuilder.Append(" AND p.Nombre LIKE @Nombre");
|
||||
parameters.Add("Nombre", $"%{nombreFilter}%");
|
||||
}
|
||||
if (idEmpresaFilter.HasValue && idEmpresaFilter > 0)
|
||||
{
|
||||
sqlBuilder.Append(" AND p.Id_Empresa = @IdEmpresa");
|
||||
parameters.Add("IdEmpresa", idEmpresaFilter.Value);
|
||||
}
|
||||
sqlBuilder.Append(" ORDER BY p.Nombre;");
|
||||
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QueryAsync<Publicacion, string, (Publicacion, string)>(
|
||||
sqlBuilder.ToString(),
|
||||
(pub, empNombre) => (pub, empNombre),
|
||||
parameters,
|
||||
splitOn: "NombreEmpresa"
|
||||
);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener todas las Publicaciones.");
|
||||
return Enumerable.Empty<(Publicacion, string)>();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<(Publicacion? Publicacion, string? NombreEmpresa)> GetByIdAsync(int id)
|
||||
{
|
||||
const string sql = @"
|
||||
SELECT p.*, e.Nombre AS NombreEmpresa
|
||||
FROM dbo.dist_dtPublicaciones p
|
||||
INNER JOIN dbo.dist_dtEmpresas e ON p.Id_Empresa = e.Id_Empresa
|
||||
WHERE p.Id_Publicacion = @Id";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
var result = await connection.QueryAsync<Publicacion, string, (Publicacion, string)>(
|
||||
sql,
|
||||
(pub, empNombre) => (pub, empNombre),
|
||||
new { Id = id },
|
||||
splitOn: "NombreEmpresa"
|
||||
);
|
||||
return result.SingleOrDefault();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener Publicación por ID: {IdPublicacion}", id);
|
||||
return (null, null);
|
||||
}
|
||||
}
|
||||
public async Task<Publicacion?> GetByIdSimpleAsync(int id)
|
||||
{
|
||||
const string sql = "SELECT * FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @Id";
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QuerySingleOrDefaultAsync<Publicacion>(sql, new { Id = id });
|
||||
}
|
||||
|
||||
|
||||
public async Task<bool> ExistsByNameAndEmpresaAsync(string nombre, int idEmpresa, int? excludeIdPublicacion = null)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.dist_dtPublicaciones WHERE Nombre = @Nombre AND Id_Empresa = @IdEmpresa");
|
||||
var parameters = new DynamicParameters();
|
||||
parameters.Add("Nombre", nombre);
|
||||
parameters.Add("IdEmpresa", idEmpresa);
|
||||
if (excludeIdPublicacion.HasValue)
|
||||
{
|
||||
sqlBuilder.Append(" AND Id_Publicacion != @ExcludeId");
|
||||
parameters.Add("ExcludeId", excludeIdPublicacion.Value);
|
||||
}
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.ExecuteScalarAsync<bool>(sqlBuilder.ToString(), parameters);
|
||||
}
|
||||
|
||||
public async Task<bool> IsInUseAsync(int id)
|
||||
{
|
||||
// Verificar en tablas relacionadas: dist_EntradasSalidas, dist_EntradasSalidasCanillas,
|
||||
// dist_Precios, dist_RecargoZona, dist_PorcPago, dist_PorcMonPagoCanilla, dist_dtPubliSecciones,
|
||||
// bob_RegPublicaciones, bob_StockBobinas (donde Id_Publicacion se usa)
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
string[] checkQueries = {
|
||||
"SELECT TOP 1 1 FROM dbo.dist_EntradasSalidas WHERE Id_Publicacion = @Id",
|
||||
"SELECT TOP 1 1 FROM dbo.dist_EntradasSalidasCanillas WHERE Id_Publicacion = @Id",
|
||||
"SELECT TOP 1 1 FROM dbo.dist_Precios WHERE Id_Publicacion = @Id",
|
||||
"SELECT TOP 1 1 FROM dbo.dist_RecargoZona WHERE Id_Publicacion = @Id",
|
||||
"SELECT TOP 1 1 FROM dbo.dist_PorcPago WHERE Id_Publicacion = @Id",
|
||||
"SELECT TOP 1 1 FROM dbo.dist_PorcMonPagoCanilla WHERE Id_Publicacion = @Id",
|
||||
"SELECT TOP 1 1 FROM dbo.dist_dtPubliSecciones WHERE Id_Publicacion = @Id",
|
||||
"SELECT TOP 1 1 FROM dbo.bob_RegPublicaciones WHERE Id_Publicacion = @Id",
|
||||
"SELECT TOP 1 1 FROM dbo.bob_StockBobinas WHERE Id_Publicacion = @Id"
|
||||
};
|
||||
foreach (var query in checkQueries)
|
||||
{
|
||||
if (await connection.ExecuteScalarAsync<int?>(query, new { Id = id }) == 1) return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
public async Task<Publicacion?> CreateAsync(Publicacion nuevaPublicacion, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
// Habilitada por defecto es true si es null en el modelo
|
||||
nuevaPublicacion.Habilitada ??= true;
|
||||
|
||||
const string sqlInsert = @"
|
||||
INSERT INTO dbo.dist_dtPublicaciones (Nombre, Observacion, Id_Empresa, CtrlDevoluciones, Habilitada)
|
||||
OUTPUT INSERTED.*
|
||||
VALUES (@Nombre, @Observacion, @IdEmpresa, @CtrlDevoluciones, @Habilitada);";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_dtPublicaciones_H
|
||||
(Id_Publicacion, Nombre, Observacion, Id_Empresa, Habilitada, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPublicacion, @Nombre, @Observacion, @IdEmpresa, @Habilitada, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
var connection = transaction.Connection!;
|
||||
var inserted = await connection.QuerySingleAsync<Publicacion>(sqlInsert, nuevaPublicacion, transaction);
|
||||
if (inserted == null) throw new DataException("Error al crear la publicación.");
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
inserted.IdPublicacion, inserted.Nombre, inserted.Observacion, inserted.IdEmpresa,
|
||||
Habilitada = inserted.Habilitada ?? true, // Asegurar que no sea null para el historial
|
||||
Id_Usuario = idUsuario, FechaMod = DateTime.Now, TipoMod = "Creada"
|
||||
}, transaction);
|
||||
return inserted;
|
||||
}
|
||||
|
||||
public async Task<bool> UpdateAsync(Publicacion publicacionAActualizar, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
var actual = await connection.QuerySingleOrDefaultAsync<Publicacion>(
|
||||
"SELECT * FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @IdPublicacion",
|
||||
new { publicacionAActualizar.IdPublicacion }, transaction);
|
||||
if (actual == null) throw new KeyNotFoundException("Publicación no encontrada.");
|
||||
|
||||
publicacionAActualizar.Habilitada ??= true; // Asegurar que no sea null
|
||||
|
||||
const string sqlUpdate = @"
|
||||
UPDATE dbo.dist_dtPublicaciones SET
|
||||
Nombre = @Nombre, Observacion = @Observacion, Id_Empresa = @IdEmpresa,
|
||||
CtrlDevoluciones = @CtrlDevoluciones, Habilitada = @Habilitada
|
||||
WHERE Id_Publicacion = @IdPublicacion;";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_dtPublicaciones_H
|
||||
(Id_Publicacion, Nombre, Observacion, Id_Empresa, Habilitada, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPublicacion, @Nombre, @Observacion, @IdEmpresa, @Habilitada, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdPublicacion = actual.IdPublicacion, Nombre = actual.Nombre, Observacion = actual.Observacion,
|
||||
IdEmpresa = actual.IdEmpresa, Habilitada = actual.Habilitada ?? true,
|
||||
Id_Usuario = idUsuario, FechaMod = DateTime.Now, TipoMod = "Actualizada"
|
||||
}, transaction);
|
||||
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, publicacionAActualizar, transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
|
||||
public async Task<bool> DeleteAsync(int id, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
var actual = await connection.QuerySingleOrDefaultAsync<Publicacion>(
|
||||
"SELECT * FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @Id", new { Id = id }, transaction);
|
||||
if (actual == null) throw new KeyNotFoundException("Publicación no encontrada.");
|
||||
|
||||
const string sqlDelete = "DELETE FROM dbo.dist_dtPublicaciones WHERE Id_Publicacion = @Id";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_dtPublicaciones_H
|
||||
(Id_Publicacion, Nombre, Observacion, Id_Empresa, Habilitada, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPublicacion, @Nombre, @Observacion, @IdEmpresa, @Habilitada, @Id_Usuario, @FechaMod, @TipoMod);";
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdPublicacion = actual.IdPublicacion, actual.Nombre, actual.Observacion, actual.IdEmpresa,
|
||||
Habilitada = actual.Habilitada ?? true,
|
||||
Id_Usuario = idUsuario, FechaMod = DateTime.Now, TipoMod = "Eliminada"
|
||||
}, transaction);
|
||||
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlDelete, new { Id = id }, transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,64 @@
|
||||
// src/Data/Repositories/RecargoZonaRepository.cs
|
||||
using Dapper;
|
||||
using System.Data;
|
||||
using System.Threading.Tasks;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using GestionIntegral.Api.Models.Distribucion; // Asegúrate que esta directiva using esté presente
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Distribucion
|
||||
{
|
||||
public class RecargoZonaRepository : IRecargoZonaRepository
|
||||
{
|
||||
private readonly DbConnectionFactory _connectionFactory; // _cf
|
||||
private readonly ILogger<RecargoZonaRepository> _logger; // _log
|
||||
|
||||
public RecargoZonaRepository(DbConnectionFactory connectionFactory, ILogger<RecargoZonaRepository> logger)
|
||||
{
|
||||
_connectionFactory = connectionFactory;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<bool> DeleteByPublicacionIdAsync(int idPublicacion, int idUsuarioAuditoria, IDbTransaction transaction)
|
||||
{
|
||||
// Obtener recargos para el historial
|
||||
const string selectRecargos = "SELECT * FROM dbo.dist_RecargoZona WHERE Id_Publicacion = @IdPublicacion";
|
||||
var recargosAEliminar = await transaction.Connection!.QueryAsync<RecargoZona>(selectRecargos, new { IdPublicacion = idPublicacion }, transaction);
|
||||
|
||||
// Asume que tienes una tabla dist_RecargoZona_H y un modelo RecargoZonaHistorico
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.dist_RecargoZona_H (Id_Recargo, Id_Publicacion, Id_Zona, VigenciaD, VigenciaH, Valor, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdRecargo, @IdPublicacion, @IdZona, @VigenciaD, @VigenciaH, @Valor, @Id_Usuario, @FechaMod, @TipoMod);"; // Nombres de parámetros corregidos
|
||||
|
||||
foreach (var recargo in recargosAEliminar)
|
||||
{
|
||||
await transaction.Connection!.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
// Mapear los campos de 'recargo' a los parámetros de sqlInsertHistorico
|
||||
recargo.IdRecargo, // Usar las propiedades del modelo RecargoZona
|
||||
recargo.IdPublicacion,
|
||||
recargo.IdZona,
|
||||
recargo.VigenciaD,
|
||||
recargo.VigenciaH,
|
||||
recargo.Valor,
|
||||
Id_Usuario = idUsuarioAuditoria, // Este es el parámetro esperado por la query
|
||||
FechaMod = DateTime.Now,
|
||||
TipoMod = "Eliminado (Cascada)"
|
||||
}, transaction);
|
||||
}
|
||||
|
||||
const string sql = "DELETE FROM dbo.dist_RecargoZona WHERE Id_Publicacion = @IdPublicacion";
|
||||
try
|
||||
{
|
||||
await transaction.Connection!.ExecuteAsync(sql, new { IdPublicacion = idPublicacion }, transaction: transaction);
|
||||
return true; // Se intentó la operación
|
||||
}
|
||||
catch (System.Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al eliminar RecargosZona por IdPublicacion: {IdPublicacion}", idPublicacion);
|
||||
throw; // Re-lanzar para que la transacción padre haga rollback
|
||||
}
|
||||
}
|
||||
// Aquí irían otros métodos CRUD para RecargoZona si se gestionan individualmente.
|
||||
// Por ejemplo, GetByPublicacionId, Create, Update, Delete (para un recargo específico).
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,113 @@
|
||||
using Dapper;
|
||||
using GestionIntegral.Api.Models.Usuarios;
|
||||
using System.Data;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Usuarios
|
||||
{
|
||||
public class AuthRepository : IAuthRepository
|
||||
{
|
||||
private readonly DbConnectionFactory _connectionFactory;
|
||||
private readonly ILogger<AuthRepository> _logger;
|
||||
|
||||
public AuthRepository(DbConnectionFactory connectionFactory, ILogger<AuthRepository> logger)
|
||||
{
|
||||
_connectionFactory = connectionFactory;
|
||||
_logger = logger;
|
||||
|
||||
}
|
||||
|
||||
public async Task<Usuario?> GetUserByUsernameAsync(string username)
|
||||
{
|
||||
var sql = @"SELECT Id, [User], ClaveHash, ClaveSalt, Habilitada,
|
||||
SupAdmin, Nombre, Apellido, IdPerfil, VerLog, DebeCambiarClave
|
||||
FROM gral_Usuarios
|
||||
WHERE [User] = @Username";
|
||||
|
||||
try
|
||||
{
|
||||
using (var connection = _connectionFactory.CreateConnection())
|
||||
{
|
||||
var user = await connection.QuerySingleOrDefaultAsync<Usuario>(sql, new { Username = username });
|
||||
return user;
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
Console.WriteLine($"Error fetching user by username: {ex.Message}");
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<Usuario?> GetUserByIdAsync(int userId)
|
||||
{
|
||||
var sql = @"SELECT Id, [User], ClaveHash, ClaveSalt, Habilitada,
|
||||
SupAdmin, Nombre, Apellido, IdPerfil, VerLog, DebeCambiarClave
|
||||
FROM gral_Usuarios
|
||||
WHERE Id = @UserId";
|
||||
try
|
||||
{
|
||||
using (var connection = _connectionFactory.CreateConnection())
|
||||
{
|
||||
var user = await connection.QuerySingleOrDefaultAsync<Usuario>(sql, new { UserId = userId });
|
||||
Console.WriteLine($"Repo - User {user?.Id} - DebeCambiarClave leído de BD: {user?.DebeCambiarClave}");
|
||||
return user;
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
Console.WriteLine($"Error fetching user by ID: {ex.Message}");
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> UpdatePasswordAsync(int userId, string newHash, string newSalt)
|
||||
{
|
||||
// Actualiza hash, salt y pone DebeCambiarClave a 0 (false)
|
||||
var sql = @"UPDATE dbo.gral_Usuarios
|
||||
SET ClaveHash = @HashedPassword, ClaveSalt = @Salt, DebeCambiarClave = 0
|
||||
WHERE Id = @UserId";
|
||||
|
||||
try
|
||||
{
|
||||
using (var connection = _connectionFactory.CreateConnection())
|
||||
{
|
||||
var parameters = new
|
||||
{
|
||||
HashedPassword = newHash,
|
||||
Salt = newSalt,
|
||||
UserId = userId
|
||||
};
|
||||
int rowsAffected = await connection.ExecuteAsync(sql, parameters);
|
||||
return rowsAffected == 1; // Devuelve true si se actualizó exactamente una fila
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
Console.WriteLine($"Error updating password for user {userId}: {ex.Message}");
|
||||
return false;
|
||||
}
|
||||
}
|
||||
public async Task<IEnumerable<string>> GetPermisosCodAccByPerfilIdAsync(int idPerfil)
|
||||
{
|
||||
// Esta consulta es similar a la que tenías en gestion.vb -> verPermisosPerfil
|
||||
var sql = @"
|
||||
SELECT p.codAcc
|
||||
FROM dbo.gral_Perfiles pf
|
||||
INNER JOIN dbo.gral_PermisosPerfiles pp ON pf.id = pp.idPerfil
|
||||
INNER JOIN dbo.gral_Permisos p ON pp.idPermiso = p.id
|
||||
WHERE pf.id = @IdPerfil;";
|
||||
try
|
||||
{
|
||||
using (var connection = _connectionFactory.CreateConnection())
|
||||
{
|
||||
return await connection.QueryAsync<string>(sql, new { IdPerfil = idPerfil });
|
||||
}
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener códigos de acceso para el perfil ID: {IdPerfil}", idPerfil); // Asumiendo que tienes _logger en AuthRepository
|
||||
return Enumerable.Empty<string>();
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,12 @@
|
||||
using GestionIntegral.Api.Models.Usuarios;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Usuarios
|
||||
{
|
||||
public interface IAuthRepository
|
||||
{
|
||||
Task<Usuario?> GetUserByUsernameAsync(string username);
|
||||
Task<bool> UpdatePasswordAsync(int userId, string newHash, string newSalt);
|
||||
Task<Usuario?> GetUserByIdAsync(int userId); // Método útil para cambio de clav
|
||||
Task<IEnumerable<string>> GetPermisosCodAccByPerfilIdAsync(int idPerfil);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,20 @@
|
||||
using GestionIntegral.Api.Models.Usuarios;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using System.Data; // Para IDbTransaction
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Usuarios
|
||||
{
|
||||
public interface IPerfilRepository
|
||||
{
|
||||
Task<IEnumerable<Perfil>> GetAllAsync(string? nombreFilter);
|
||||
Task<Perfil?> GetByIdAsync(int id);
|
||||
Task<Perfil?> CreateAsync(Perfil nuevoPerfil, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> UpdateAsync(Perfil perfilAActualizar, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> DeleteAsync(int id, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> ExistsByNameAsync(string nombrePerfil, int? excludeId = null);
|
||||
Task<bool> IsInUseAsync(int id);
|
||||
Task<IEnumerable<int>> GetPermisoIdsByPerfilIdAsync(int idPerfil);
|
||||
Task UpdatePermisosByPerfilIdAsync(int idPerfil, IEnumerable<int> nuevosPermisosIds, IDbTransaction transaction);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,19 @@
|
||||
using GestionIntegral.Api.Models.Usuarios;
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using System.Data;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Usuarios
|
||||
{
|
||||
public interface IPermisoRepository
|
||||
{
|
||||
Task<IEnumerable<Permiso>> GetAllAsync(string? moduloFilter, string? codAccFilter);
|
||||
Task<Permiso?> GetByIdAsync(int id);
|
||||
Task<Permiso?> CreateAsync(Permiso nuevoPermiso, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> UpdateAsync(Permiso permisoAActualizar, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> DeleteAsync(int id, int idUsuario, IDbTransaction transaction);
|
||||
Task<bool> ExistsByCodAccAsync(string codAcc, int? excludeId = null);
|
||||
Task<bool> IsInUseAsync(int id);
|
||||
Task<IEnumerable<Permiso>> GetPermisosByIdsAsync(IEnumerable<int> ids);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
using GestionIntegral.Api.Models.Usuarios; // Para Usuario
|
||||
using System.Collections.Generic;
|
||||
using System.Threading.Tasks;
|
||||
using System.Data;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Usuarios
|
||||
{
|
||||
public interface IUsuarioRepository
|
||||
{
|
||||
Task<IEnumerable<Usuario>> GetAllAsync(string? userFilter, string? nombreFilter);
|
||||
Task<Usuario?> GetByIdAsync(int id);
|
||||
Task<Usuario?> GetByUsernameAsync(string username); // Ya existe en IAuthRepository, pero lo duplicamos para cohesión del CRUD
|
||||
Task<Usuario?> CreateAsync(Usuario nuevoUsuario, int idUsuarioCreador, IDbTransaction transaction);
|
||||
Task<bool> UpdateAsync(Usuario usuarioAActualizar, int idUsuarioModificador, IDbTransaction transaction);
|
||||
// DeleteAsync no es común para usuarios, se suelen deshabilitar.
|
||||
// Task<bool> DeleteAsync(int id, int idUsuarioModificador, IDbTransaction transaction);
|
||||
Task<bool> SetPasswordAsync(int userId, string newHash, string newSalt, bool debeCambiarClave, int idUsuarioModificador, IDbTransaction transaction);
|
||||
Task<bool> UserExistsAsync(string username, int? excludeId = null);
|
||||
|
||||
// Para el DTO de listado
|
||||
Task<IEnumerable<(Usuario Usuario, string NombrePerfil)>> GetAllWithProfileNameAsync(string? userFilter, string? nombreFilter);
|
||||
Task<(Usuario? Usuario, string? NombrePerfil)> GetByIdWithProfileNameAsync(int id);
|
||||
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,250 @@
|
||||
using Dapper;
|
||||
using GestionIntegral.Api.Models.Usuarios;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using System.Collections.Generic;
|
||||
using System.Data;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Usuarios
|
||||
{
|
||||
public class PerfilRepository : IPerfilRepository
|
||||
{
|
||||
private readonly DbConnectionFactory _connectionFactory;
|
||||
private readonly ILogger<PerfilRepository> _logger;
|
||||
|
||||
public PerfilRepository(DbConnectionFactory connectionFactory, ILogger<PerfilRepository> logger)
|
||||
{
|
||||
_connectionFactory = connectionFactory;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<Perfil>> GetAllAsync(string? nombreFilter)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder("SELECT id AS Id, perfil AS NombrePerfil, descPerfil AS Descripcion FROM dbo.gral_Perfiles WHERE 1=1");
|
||||
var parameters = new DynamicParameters();
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(nombreFilter))
|
||||
{
|
||||
sqlBuilder.Append(" AND perfil LIKE @NombreFilter");
|
||||
parameters.Add("NombreFilter", $"%{nombreFilter}%");
|
||||
}
|
||||
sqlBuilder.Append(" ORDER BY perfil;");
|
||||
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QueryAsync<Perfil>(sqlBuilder.ToString(), parameters);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener todos los Perfiles. Filtro: {NombreFilter}", nombreFilter);
|
||||
return Enumerable.Empty<Perfil>();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<Perfil?> GetByIdAsync(int id)
|
||||
{
|
||||
const string sql = "SELECT id AS Id, perfil AS NombrePerfil, descPerfil AS Descripcion FROM dbo.gral_Perfiles WHERE id = @Id";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QuerySingleOrDefaultAsync<Perfil>(sql, new { Id = id });
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener Perfil por ID: {IdPerfil}", id);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> ExistsByNameAsync(string nombrePerfil, int? excludeId = null)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.gral_Perfiles WHERE perfil = @NombrePerfil");
|
||||
var parameters = new DynamicParameters();
|
||||
parameters.Add("NombrePerfil", nombrePerfil);
|
||||
|
||||
if (excludeId.HasValue)
|
||||
{
|
||||
sqlBuilder.Append(" AND id != @ExcludeId");
|
||||
parameters.Add("ExcludeId", excludeId.Value);
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
var count = await connection.ExecuteScalarAsync<int>(sqlBuilder.ToString(), parameters);
|
||||
return count > 0;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error en ExistsByNameAsync para Perfil con nombre: {NombrePerfil}", nombrePerfil);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> IsInUseAsync(int id)
|
||||
{
|
||||
const string sqlCheckUsuarios = "SELECT TOP 1 1 FROM dbo.gral_Usuarios WHERE IdPerfil = @IdPerfil";
|
||||
const string sqlCheckPermisos = "SELECT TOP 1 1 FROM dbo.gral_PermisosPerfiles WHERE idPerfil = @IdPerfil";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
var inUsuarios = await connection.ExecuteScalarAsync<int?>(sqlCheckUsuarios, new { IdPerfil = id });
|
||||
if (inUsuarios.HasValue && inUsuarios.Value == 1) return true;
|
||||
|
||||
var inPermisos = await connection.ExecuteScalarAsync<int?>(sqlCheckPermisos, new { IdPerfil = id });
|
||||
return inPermisos.HasValue && inPermisos.Value == 1;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error en IsInUseAsync para Perfil ID: {IdPerfil}", id);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<Perfil?> CreateAsync(Perfil nuevoPerfil, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
const string sqlInsert = @"
|
||||
INSERT INTO dbo.gral_Perfiles (perfil, descPerfil)
|
||||
OUTPUT INSERTED.id AS Id, INSERTED.perfil AS NombrePerfil, INSERTED.descPerfil AS Descripcion
|
||||
VALUES (@NombrePerfil, @Descripcion);";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.gral_Perfiles_H (idPerfil, perfil, descPerfil, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPerfilHist, @NombrePerfilHist, @DescripcionHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
|
||||
|
||||
var connection = transaction.Connection!; // La conexión debe venir de la transacción
|
||||
|
||||
var insertedPerfil = await connection.QuerySingleAsync<Perfil>(
|
||||
sqlInsert,
|
||||
new { nuevoPerfil.NombrePerfil, nuevoPerfil.Descripcion },
|
||||
transaction: transaction);
|
||||
|
||||
if (insertedPerfil == null || insertedPerfil.Id <= 0)
|
||||
{
|
||||
throw new DataException("No se pudo obtener el ID del perfil insertado.");
|
||||
}
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdPerfilHist = insertedPerfil.Id, // Correcto
|
||||
NombrePerfilHist = insertedPerfil.NombrePerfil,
|
||||
DescripcionHist = insertedPerfil.Descripcion,
|
||||
IdUsuarioHist = idUsuario,
|
||||
FechaModHist = DateTime.Now,
|
||||
TipoModHist = "Insertada"
|
||||
}, transaction: transaction);
|
||||
|
||||
return insertedPerfil;
|
||||
}
|
||||
|
||||
public async Task<bool> UpdateAsync(Perfil perfilAActualizar, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
// Obtener el estado actual PARA EL HISTORIAL DENTRO DE LA MISMA TRANSACCIÓN
|
||||
var perfilActual = await connection.QuerySingleOrDefaultAsync<Perfil>(
|
||||
"SELECT id AS Id, perfil AS NombrePerfil, descPerfil AS Descripcion FROM dbo.gral_Perfiles WHERE id = @Id",
|
||||
new { Id = perfilAActualizar.Id },
|
||||
transaction);
|
||||
|
||||
if (perfilActual == null)
|
||||
{
|
||||
// Esto no debería pasar si el servicio verifica la existencia antes, pero es una salvaguarda.
|
||||
throw new KeyNotFoundException($"Perfil con ID {perfilAActualizar.Id} no encontrado para actualizar.");
|
||||
}
|
||||
|
||||
const string sqlUpdate = "UPDATE dbo.gral_Perfiles SET perfil = @NombrePerfil, descPerfil = @Descripcion WHERE id = @Id;";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.gral_Perfiles_H (idPerfil, perfil, descPerfil, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPerfilHist, @NombrePerfilHist, @DescripcionHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
|
||||
|
||||
// Insertar en historial con los valores ANTES de la modificación
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdPerfilHist = perfilActual.Id,
|
||||
NombrePerfilHist = perfilActual.NombrePerfil,
|
||||
DescripcionHist = perfilActual.Descripcion,
|
||||
IdUsuarioHist = idUsuario,
|
||||
FechaModHist = DateTime.Now,
|
||||
TipoModHist = "Modificada"
|
||||
}, transaction: transaction);
|
||||
|
||||
// Actualizar la tabla principal
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, perfilAActualizar, transaction: transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
|
||||
public async Task<bool> DeleteAsync(int id, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
// Obtener el estado actual PARA EL HISTORIAL DENTRO DE LA MISMA TRANSACCIÓN
|
||||
var perfilActual = await connection.QuerySingleOrDefaultAsync<Perfil>(
|
||||
"SELECT id AS Id, perfil AS NombrePerfil, descPerfil AS Descripcion FROM dbo.gral_Perfiles WHERE id = @Id",
|
||||
new { Id = id },
|
||||
transaction);
|
||||
|
||||
if (perfilActual == null)
|
||||
{
|
||||
throw new KeyNotFoundException($"Perfil con ID {id} no encontrado para eliminar.");
|
||||
}
|
||||
|
||||
const string sqlDelete = "DELETE FROM dbo.gral_Perfiles WHERE id = @Id";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.gral_Perfiles_H (idPerfil, perfil, descPerfil, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPerfilHist, @NombrePerfilHist, @DescripcionHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
|
||||
|
||||
// Insertar en historial con los valores ANTES de la eliminación
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdPerfilHist = perfilActual.Id,
|
||||
NombrePerfilHist = perfilActual.NombrePerfil,
|
||||
DescripcionHist = perfilActual.Descripcion,
|
||||
IdUsuarioHist = idUsuario,
|
||||
FechaModHist = DateTime.Now,
|
||||
TipoModHist = "Eliminada"
|
||||
}, transaction: transaction);
|
||||
|
||||
// Eliminar de la tabla principal
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlDelete, new { Id = id }, transaction: transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
public async Task<IEnumerable<int>> GetPermisoIdsByPerfilIdAsync(int idPerfil)
|
||||
{
|
||||
const string sql = "SELECT idPermiso FROM dbo.gral_PermisosPerfiles WHERE idPerfil = @IdPerfil";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QueryAsync<int>(sql, new { IdPerfil = idPerfil });
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener IDs de permisos para el Perfil ID: {IdPerfil}", idPerfil);
|
||||
return Enumerable.Empty<int>();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task UpdatePermisosByPerfilIdAsync(int idPerfil, IEnumerable<int> nuevosPermisosIds, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
|
||||
// 1. Eliminar todos los permisos existentes para este perfil (dentro de la transacción)
|
||||
const string sqlDelete = "DELETE FROM dbo.gral_PermisosPerfiles WHERE idPerfil = @IdPerfil";
|
||||
await connection.ExecuteAsync(sqlDelete, new { IdPerfil = idPerfil }, transaction: transaction);
|
||||
|
||||
// 2. Insertar los nuevos permisos (si hay alguno)
|
||||
if (nuevosPermisosIds != null && nuevosPermisosIds.Any())
|
||||
{
|
||||
const string sqlInsert = "INSERT INTO dbo.gral_PermisosPerfiles (idPerfil, idPermiso) VALUES (@IdPerfil, @IdPermiso)";
|
||||
// Dapper puede manejar una lista de objetos para inserciones múltiples
|
||||
var permisosParaInsertar = nuevosPermisosIds.Select(idPermiso => new { IdPerfil = idPerfil, IdPermiso = idPermiso });
|
||||
await connection.ExecuteAsync(sqlInsert, permisosParaInsertar, transaction: transaction);
|
||||
}
|
||||
// No hay tabla _H para gral_PermisosPerfiles directamente en este diseño.
|
||||
// La auditoría de qué usuario cambió los permisos de un perfil se podría registrar
|
||||
// en una tabla de log de acciones más general si fuera necesario, o deducir
|
||||
// indirectamente si la interfaz de usuario solo permite a SuperAdmin hacer esto.
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@@ -0,0 +1,231 @@
|
||||
using Dapper;
|
||||
using GestionIntegral.Api.Models.Usuarios;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using System.Collections.Generic;
|
||||
using System.Data;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Usuarios
|
||||
{
|
||||
public class PermisoRepository : IPermisoRepository
|
||||
{
|
||||
private readonly DbConnectionFactory _connectionFactory;
|
||||
private readonly ILogger<PermisoRepository> _logger;
|
||||
|
||||
public PermisoRepository(DbConnectionFactory connectionFactory, ILogger<PermisoRepository> logger)
|
||||
{
|
||||
_connectionFactory = connectionFactory;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<Permiso>> GetAllAsync(string? moduloFilter, string? codAccFilter)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder("SELECT id AS Id, modulo, descPermiso, codAcc FROM dbo.gral_Permisos WHERE 1=1");
|
||||
var parameters = new DynamicParameters();
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(moduloFilter))
|
||||
{
|
||||
sqlBuilder.Append(" AND modulo LIKE @ModuloFilter");
|
||||
parameters.Add("ModuloFilter", $"%{moduloFilter}%");
|
||||
}
|
||||
if (!string.IsNullOrWhiteSpace(codAccFilter))
|
||||
{
|
||||
sqlBuilder.Append(" AND codAcc LIKE @CodAccFilter");
|
||||
parameters.Add("CodAccFilter", $"%{codAccFilter}%");
|
||||
}
|
||||
sqlBuilder.Append(" ORDER BY modulo, codAcc;");
|
||||
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QueryAsync<Permiso>(sqlBuilder.ToString(), parameters);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener todos los Permisos. Filtros: Modulo={Modulo}, CodAcc={CodAcc}", moduloFilter, codAccFilter);
|
||||
return Enumerable.Empty<Permiso>();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<Permiso?> GetByIdAsync(int id)
|
||||
{
|
||||
const string sql = "SELECT id AS Id, modulo, descPermiso, codAcc FROM dbo.gral_Permisos WHERE id = @Id";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QuerySingleOrDefaultAsync<Permiso>(sql, new { Id = id });
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener Permiso por ID: {IdPermiso}", id);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> ExistsByCodAccAsync(string codAcc, int? excludeId = null)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.gral_Permisos WHERE codAcc = @CodAcc");
|
||||
var parameters = new DynamicParameters();
|
||||
parameters.Add("CodAcc", codAcc);
|
||||
|
||||
if (excludeId.HasValue)
|
||||
{
|
||||
sqlBuilder.Append(" AND id != @ExcludeId");
|
||||
parameters.Add("ExcludeId", excludeId.Value);
|
||||
}
|
||||
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
var count = await connection.ExecuteScalarAsync<int>(sqlBuilder.ToString(), parameters);
|
||||
return count > 0;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error en ExistsByCodAccAsync para Permiso con codAcc: {CodAcc}", codAcc);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> IsInUseAsync(int id)
|
||||
{
|
||||
const string sqlCheckPermisosPerfiles = "SELECT TOP 1 1 FROM dbo.gral_PermisosPerfiles WHERE idPermiso = @IdPermiso";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
var inUse = await connection.ExecuteScalarAsync<int?>(sqlCheckPermisosPerfiles, new { IdPermiso = id });
|
||||
return inUse.HasValue && inUse.Value == 1;
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error en IsInUseAsync para Permiso ID: {IdPermiso}", id);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<Permiso>> GetPermisosByIdsAsync(IEnumerable<int> ids)
|
||||
{
|
||||
if (ids == null || !ids.Any())
|
||||
{
|
||||
return Enumerable.Empty<Permiso>();
|
||||
}
|
||||
const string sql = "SELECT id AS Id, modulo, descPermiso, codAcc FROM dbo.gral_Permisos WHERE id IN @Ids;";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QueryAsync<Permiso>(sql, new { Ids = ids });
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener permisos por IDs.");
|
||||
return Enumerable.Empty<Permiso>();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public async Task<Permiso?> CreateAsync(Permiso nuevoPermiso, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
const string sqlInsert = @"
|
||||
INSERT INTO dbo.gral_Permisos (modulo, descPermiso, codAcc)
|
||||
OUTPUT INSERTED.id AS Id, INSERTED.modulo, INSERTED.descPermiso, INSERTED.codAcc
|
||||
VALUES (@Modulo, @DescPermiso, @CodAcc);";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.gral_Permisos_H (idPermiso, modulo, descPermiso, codAcc, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPermisoHist, @ModuloHist, @DescPermisoHist, @CodAccHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
|
||||
|
||||
var connection = transaction.Connection!;
|
||||
var insertedPermiso = await connection.QuerySingleAsync<Permiso>(
|
||||
sqlInsert,
|
||||
nuevoPermiso,
|
||||
transaction: transaction);
|
||||
|
||||
if (insertedPermiso == null || insertedPermiso.Id <= 0)
|
||||
{
|
||||
throw new DataException("No se pudo obtener el ID del permiso insertado.");
|
||||
}
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdPermisoHist = insertedPermiso.Id,
|
||||
ModuloHist = insertedPermiso.Modulo,
|
||||
DescPermisoHist = insertedPermiso.DescPermiso,
|
||||
CodAccHist = insertedPermiso.CodAcc,
|
||||
IdUsuarioHist = idUsuario,
|
||||
FechaModHist = DateTime.Now,
|
||||
TipoModHist = "Insertada"
|
||||
}, transaction: transaction);
|
||||
|
||||
return insertedPermiso;
|
||||
}
|
||||
|
||||
public async Task<bool> UpdateAsync(Permiso permisoAActualizar, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
var permisoActual = await connection.QuerySingleOrDefaultAsync<Permiso>(
|
||||
"SELECT id AS Id, modulo, descPermiso, codAcc FROM dbo.gral_Permisos WHERE id = @Id",
|
||||
new { Id = permisoAActualizar.Id },
|
||||
transaction);
|
||||
|
||||
if (permisoActual == null)
|
||||
{
|
||||
throw new KeyNotFoundException($"Permiso con ID {permisoAActualizar.Id} no encontrado para actualizar.");
|
||||
}
|
||||
|
||||
const string sqlUpdate = @"UPDATE dbo.gral_Permisos
|
||||
SET modulo = @Modulo, descPermiso = @DescPermiso, codAcc = @CodAcc
|
||||
WHERE id = @Id;";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.gral_Permisos_H (idPermiso, modulo, descPermiso, codAcc, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPermisoHist, @ModuloHist, @DescPermisoHist, @CodAccHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdPermisoHist = permisoActual.Id,
|
||||
ModuloHist = permisoActual.Modulo,
|
||||
DescPermisoHist = permisoActual.DescPermiso,
|
||||
CodAccHist = permisoActual.CodAcc,
|
||||
IdUsuarioHist = idUsuario,
|
||||
FechaModHist = DateTime.Now,
|
||||
TipoModHist = "Modificada"
|
||||
}, transaction: transaction);
|
||||
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, permisoAActualizar, transaction: transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
|
||||
public async Task<bool> DeleteAsync(int id, int idUsuario, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
var permisoActual = await connection.QuerySingleOrDefaultAsync<Permiso>(
|
||||
"SELECT id AS Id, modulo, descPermiso, codAcc FROM dbo.gral_Permisos WHERE id = @Id",
|
||||
new { Id = id },
|
||||
transaction);
|
||||
|
||||
if (permisoActual == null)
|
||||
{
|
||||
throw new KeyNotFoundException($"Permiso con ID {id} no encontrado para eliminar.");
|
||||
}
|
||||
|
||||
const string sqlDelete = "DELETE FROM dbo.gral_Permisos WHERE id = @Id";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.gral_Permisos_H (idPermiso, modulo, descPermiso, codAcc, Id_Usuario, FechaMod, TipoMod)
|
||||
VALUES (@IdPermisoHist, @ModuloHist, @DescPermisoHist, @CodAccHist, @IdUsuarioHist, @FechaModHist, @TipoModHist);";
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdPermisoHist = permisoActual.Id,
|
||||
ModuloHist = permisoActual.Modulo,
|
||||
DescPermisoHist = permisoActual.DescPermiso,
|
||||
CodAccHist = permisoActual.CodAcc,
|
||||
IdUsuarioHist = idUsuario,
|
||||
FechaModHist = DateTime.Now,
|
||||
TipoModHist = "Eliminada"
|
||||
}, transaction: transaction);
|
||||
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlDelete, new { Id = id }, transaction: transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,293 @@
|
||||
using Dapper;
|
||||
using GestionIntegral.Api.Models.Usuarios;
|
||||
using Microsoft.Extensions.Logging;
|
||||
using System.Collections.Generic;
|
||||
using System.Data;
|
||||
using System.Linq;
|
||||
using System.Text;
|
||||
using System.Threading.Tasks;
|
||||
|
||||
namespace GestionIntegral.Api.Data.Repositories.Usuarios
|
||||
{
|
||||
public class UsuarioRepository : IUsuarioRepository
|
||||
{
|
||||
private readonly DbConnectionFactory _connectionFactory;
|
||||
private readonly ILogger<UsuarioRepository> _logger;
|
||||
|
||||
public UsuarioRepository(DbConnectionFactory connectionFactory, ILogger<UsuarioRepository> logger)
|
||||
{
|
||||
_connectionFactory = connectionFactory;
|
||||
_logger = logger;
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<Usuario>> GetAllAsync(string? userFilter, string? nombreFilter)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder("SELECT * FROM dbo.gral_Usuarios WHERE 1=1");
|
||||
var parameters = new DynamicParameters();
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(userFilter))
|
||||
{
|
||||
sqlBuilder.Append(" AND [User] LIKE @UserParam");
|
||||
parameters.Add("UserParam", $"%{userFilter}%");
|
||||
}
|
||||
if (!string.IsNullOrWhiteSpace(nombreFilter))
|
||||
{
|
||||
sqlBuilder.Append(" AND (Nombre LIKE @NombreParam OR Apellido LIKE @NombreParam)");
|
||||
parameters.Add("NombreParam", $"%{nombreFilter}%");
|
||||
}
|
||||
sqlBuilder.Append(" ORDER BY [User];");
|
||||
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QueryAsync<Usuario>(sqlBuilder.ToString(), parameters);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener todos los Usuarios.");
|
||||
return Enumerable.Empty<Usuario>();
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<IEnumerable<(Usuario Usuario, string NombrePerfil)>> GetAllWithProfileNameAsync(string? userFilter, string? nombreFilter)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder(@"
|
||||
SELECT u.*, p.perfil AS NombrePerfil
|
||||
FROM dbo.gral_Usuarios u
|
||||
INNER JOIN dbo.gral_Perfiles p ON u.IdPerfil = p.id
|
||||
WHERE 1=1");
|
||||
var parameters = new DynamicParameters();
|
||||
|
||||
if (!string.IsNullOrWhiteSpace(userFilter))
|
||||
{
|
||||
sqlBuilder.Append(" AND u.[User] LIKE @UserParam");
|
||||
parameters.Add("UserParam", $"%{userFilter}%");
|
||||
}
|
||||
if (!string.IsNullOrWhiteSpace(nombreFilter))
|
||||
{
|
||||
sqlBuilder.Append(" AND (u.Nombre LIKE @NombreParam OR u.Apellido LIKE @NombreParam)");
|
||||
parameters.Add("NombreParam", $"%{nombreFilter}%");
|
||||
}
|
||||
sqlBuilder.Append(" ORDER BY u.[User];");
|
||||
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QueryAsync<Usuario, string, (Usuario, string)>(
|
||||
sqlBuilder.ToString(),
|
||||
(usuario, nombrePerfil) => (usuario, nombrePerfil),
|
||||
parameters,
|
||||
splitOn: "NombrePerfil"
|
||||
);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener todos los Usuarios con nombre de perfil.");
|
||||
return Enumerable.Empty<(Usuario, string)>();
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public async Task<Usuario?> GetByIdAsync(int id)
|
||||
{
|
||||
const string sql = "SELECT * FROM dbo.gral_Usuarios WHERE Id = @Id";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QuerySingleOrDefaultAsync<Usuario>(sql, new { Id = id });
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener Usuario por ID: {UsuarioId}", id);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
public async Task<(Usuario? Usuario, string? NombrePerfil)> GetByIdWithProfileNameAsync(int id)
|
||||
{
|
||||
const string sql = @"
|
||||
SELECT u.*, p.perfil AS NombrePerfil
|
||||
FROM dbo.gral_Usuarios u
|
||||
INNER JOIN dbo.gral_Perfiles p ON u.IdPerfil = p.id
|
||||
WHERE u.Id = @Id";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
var result = await connection.QueryAsync<Usuario, string, (Usuario Usuario, string NombrePerfil)>(
|
||||
sql,
|
||||
(usuario, nombrePerfil) => (usuario, nombrePerfil),
|
||||
new { Id = id },
|
||||
splitOn: "NombrePerfil"
|
||||
);
|
||||
return result.SingleOrDefault();
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener Usuario por ID con nombre de perfil: {UsuarioId}", id);
|
||||
return (null, null);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
public async Task<Usuario?> GetByUsernameAsync(string username)
|
||||
{
|
||||
// Esta es la misma que en AuthRepository, si se unifican, se puede eliminar una.
|
||||
const string sql = "SELECT * FROM dbo.gral_Usuarios WHERE [User] = @Username";
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.QuerySingleOrDefaultAsync<Usuario>(sql, new { Username = username });
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error al obtener Usuario por Username: {Username}", username);
|
||||
return null;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<bool> UserExistsAsync(string username, int? excludeId = null)
|
||||
{
|
||||
var sqlBuilder = new StringBuilder("SELECT COUNT(1) FROM dbo.gral_Usuarios WHERE [User] = @Username");
|
||||
var parameters = new DynamicParameters();
|
||||
parameters.Add("Username", username);
|
||||
|
||||
if (excludeId.HasValue)
|
||||
{
|
||||
sqlBuilder.Append(" AND Id != @ExcludeId");
|
||||
parameters.Add("ExcludeId", excludeId.Value);
|
||||
}
|
||||
try
|
||||
{
|
||||
using var connection = _connectionFactory.CreateConnection();
|
||||
return await connection.ExecuteScalarAsync<bool>(sqlBuilder.ToString(), parameters);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
_logger.LogError(ex, "Error en UserExistsAsync para username: {Username}", username);
|
||||
return true; // Asumir que existe para prevenir duplicados
|
||||
}
|
||||
}
|
||||
|
||||
public async Task<Usuario?> CreateAsync(Usuario nuevoUsuario, int idUsuarioCreador, IDbTransaction transaction)
|
||||
{
|
||||
const string sqlInsert = @"
|
||||
INSERT INTO dbo.gral_Usuarios ([User], ClaveHash, ClaveSalt, Habilitada, SupAdmin, Nombre, Apellido, IdPerfil, VerLog, DebeCambiarClave)
|
||||
OUTPUT INSERTED.*
|
||||
VALUES (@User, @ClaveHash, @ClaveSalt, @Habilitada, @SupAdmin, @Nombre, @Apellido, @IdPerfil, @VerLog, @DebeCambiarClave);";
|
||||
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.gral_Usuarios_H
|
||||
(IdUsuario, UserNvo, HabilitadaNva, SupAdminNvo, NombreNvo, ApellidoNvo, IdPerfilNvo, DebeCambiarClaveNva, Id_UsuarioMod, FechaMod, TipoMod)
|
||||
VALUES (@IdUsuarioHist, @UserNvoHist, @HabilitadaNvaHist, @SupAdminNvoHist, @NombreNvoHist, @ApellidoNvoHist, @IdPerfilNvoHist, @DebeCambiarClaveNvaHist, @IdUsuarioModHist, @FechaModHist, @TipoModHist);";
|
||||
|
||||
var connection = transaction.Connection!;
|
||||
var insertedUsuario = await connection.QuerySingleAsync<Usuario>(sqlInsert, nuevoUsuario, transaction);
|
||||
|
||||
if (insertedUsuario == null) throw new DataException("No se pudo crear el usuario.");
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdUsuarioHist = insertedUsuario.Id,
|
||||
UserNvoHist = insertedUsuario.User,
|
||||
HabilitadaNvaHist = insertedUsuario.Habilitada,
|
||||
SupAdminNvoHist = insertedUsuario.SupAdmin,
|
||||
NombreNvoHist = insertedUsuario.Nombre,
|
||||
ApellidoNvoHist = insertedUsuario.Apellido,
|
||||
IdPerfilNvoHist = insertedUsuario.IdPerfil,
|
||||
DebeCambiarClaveNvaHist = insertedUsuario.DebeCambiarClave,
|
||||
IdUsuarioModHist = idUsuarioCreador,
|
||||
FechaModHist = DateTime.Now,
|
||||
TipoModHist = "Creado"
|
||||
}, transaction);
|
||||
|
||||
return insertedUsuario;
|
||||
}
|
||||
|
||||
public async Task<bool> UpdateAsync(Usuario usuarioAActualizar, int idUsuarioModificador, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
var usuarioActual = await connection.QuerySingleOrDefaultAsync<Usuario>(
|
||||
"SELECT * FROM dbo.gral_Usuarios WHERE Id = @Id", new { usuarioAActualizar.Id }, transaction);
|
||||
|
||||
if (usuarioActual == null) throw new KeyNotFoundException("Usuario no encontrado para actualizar.");
|
||||
|
||||
// User (nombre de usuario) no se actualiza aquí
|
||||
const string sqlUpdate = @"
|
||||
UPDATE dbo.gral_Usuarios SET
|
||||
Habilitada = @Habilitada, SupAdmin = @SupAdmin, Nombre = @Nombre, Apellido = @Apellido,
|
||||
IdPerfil = @IdPerfil, VerLog = @VerLog, DebeCambiarClave = @DebeCambiarClave
|
||||
WHERE Id = @Id;";
|
||||
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.gral_Usuarios_H
|
||||
(IdUsuario, UserAnt, UserNvo, HabilitadaAnt, HabilitadaNva, SupAdminAnt, SupAdminNvo,
|
||||
NombreAnt, NombreNvo, ApellidoAnt, ApellidoNvo, IdPerfilAnt, IdPerfilNvo,
|
||||
DebeCambiarClaveAnt, DebeCambiarClaveNva, Id_UsuarioMod, FechaMod, TipoMod)
|
||||
VALUES (@IdUsuarioHist, @UserAntHist, @UserNvoHist, @HabilitadaAntHist, @HabilitadaNvaHist, @SupAdminAntHist, @SupAdminNvoHist,
|
||||
@NombreAntHist, @NombreNvoHist, @ApellidoAntHist, @ApellidoNvoHist, @IdPerfilAntHist, @IdPerfilNvoHist,
|
||||
@DebeCambiarClaveAntHist, @DebeCambiarClaveNvaHist, @IdUsuarioModHist, @FechaModHist, @TipoModHist);";
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdUsuarioHist = usuarioActual.Id,
|
||||
UserAntHist = usuarioActual.User, UserNvoHist = usuarioAActualizar.User, // Aunque no cambiemos User, lo registramos
|
||||
HabilitadaAntHist = usuarioActual.Habilitada, HabilitadaNvaHist = usuarioAActualizar.Habilitada,
|
||||
SupAdminAntHist = usuarioActual.SupAdmin, SupAdminNvoHist = usuarioAActualizar.SupAdmin,
|
||||
NombreAntHist = usuarioActual.Nombre, NombreNvoHist = usuarioAActualizar.Nombre,
|
||||
ApellidoAntHist = usuarioActual.Apellido, ApellidoNvoHist = usuarioAActualizar.Apellido,
|
||||
IdPerfilAntHist = usuarioActual.IdPerfil, IdPerfilNvoHist = usuarioAActualizar.IdPerfil,
|
||||
DebeCambiarClaveAntHist = usuarioActual.DebeCambiarClave, DebeCambiarClaveNvaHist = usuarioAActualizar.DebeCambiarClave,
|
||||
IdUsuarioModHist = idUsuarioModificador,
|
||||
FechaModHist = DateTime.Now,
|
||||
TipoModHist = "Actualizado"
|
||||
}, transaction);
|
||||
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, usuarioAActualizar, transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
|
||||
public async Task<bool> SetPasswordAsync(int userId, string newHash, string newSalt, bool debeCambiarClave, int idUsuarioModificador, IDbTransaction transaction)
|
||||
{
|
||||
var connection = transaction.Connection!;
|
||||
var usuarioActual = await connection.QuerySingleOrDefaultAsync<Usuario>(
|
||||
"SELECT * FROM dbo.gral_Usuarios WHERE Id = @Id", new { Id = userId }, transaction);
|
||||
|
||||
if (usuarioActual == null) throw new KeyNotFoundException("Usuario no encontrado para cambiar contraseña.");
|
||||
|
||||
const string sqlUpdate = @"UPDATE dbo.gral_Usuarios
|
||||
SET ClaveHash = @ClaveHash, ClaveSalt = @ClaveSalt, DebeCambiarClave = @DebeCambiarClave
|
||||
WHERE Id = @UserId";
|
||||
const string sqlInsertHistorico = @"
|
||||
INSERT INTO dbo.gral_Usuarios_H
|
||||
(IdUsuario, UserNvo, HabilitadaNva, SupAdminNvo, NombreNvo, ApellidoNvo, IdPerfilNvo,
|
||||
DebeCambiarClaveAnt, DebeCambiarClaveNva, Id_UsuarioMod, FechaMod, TipoMod)
|
||||
VALUES (@IdUsuarioHist, @UserNvoHist, @HabilitadaNvaHist, @SupAdminNvoHist, @NombreNvoHist, @ApellidoNvoHist, @IdPerfilNvoHist,
|
||||
@DebeCambiarClaveAntHist, @DebeCambiarClaveNvaHist, @IdUsuarioModHist, @FechaModHist, @TipoModHist);";
|
||||
|
||||
|
||||
await connection.ExecuteAsync(sqlInsertHistorico, new
|
||||
{
|
||||
IdUsuarioHist = usuarioActual.Id,
|
||||
UserNvoHist = usuarioActual.User, // No cambia el user
|
||||
HabilitadaNvaHist = usuarioActual.Habilitada,
|
||||
SupAdminNvoHist = usuarioActual.SupAdmin,
|
||||
NombreNvoHist = usuarioActual.Nombre,
|
||||
ApellidoNvoHist = usuarioActual.Apellido,
|
||||
IdPerfilNvoHist = usuarioActual.IdPerfil,
|
||||
DebeCambiarClaveAntHist = usuarioActual.DebeCambiarClave, // Estado anterior de este flag
|
||||
DebeCambiarClaveNvaHist = debeCambiarClave, // Nuevo estado de este flag
|
||||
IdUsuarioModHist = idUsuarioModificador,
|
||||
FechaModHist = DateTime.Now,
|
||||
TipoModHist = "Clave Cambiada" // O "Clave Reseteada"
|
||||
}, transaction);
|
||||
|
||||
var rowsAffected = await connection.ExecuteAsync(sqlUpdate, new
|
||||
{
|
||||
ClaveHash = newHash,
|
||||
ClaveSalt = newSalt,
|
||||
DebeCambiarClave = debeCambiarClave,
|
||||
UserId = userId
|
||||
}, transaction);
|
||||
return rowsAffected == 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user